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

small_fish_gui/gui/tooltips.py

@@ -0,0 +1,15 @@
+
+CELLPROB_TOOLTIP = """ (float) from -6. to +6.
+The network predicts 3 outputs: flows in X, flows in Y, and cell “probability”. 
+The predictions the network makes of the probability are the inputs to a sigmoid centered at zero (1 / (1 + e^-x)), so they vary from around -6 to +6. 
+The pixels greater than the cellprob_threshold are used to run dynamics and determine ROIs. 
+The default is cellprob_threshold=0.0. 
+Decrease this threshold if cellpose is not returning as many ROIs as you’d expect. 
+Similarly, increase this threshold if cellpose is returning too ROIs particularly from dim areas.
+""" #Cellpose 4.0.6 doc
+
+FLOW_THRESHOLD_TOOLTIP = """ (float) from 0. to 1.
+The flow_threshold parameter is the maximum allowed error of the flows for each mask. 
+Increase this threshold if cellpose is not returning as many ROIs as you’d expect. 
+Similarly, decrease this threshold if cellpose is returning too many ill-shaped ROIs.
+""" #Cellpose 4.0.6 doc

small_fish_gui/hints.py

@@ -9,9 +9,16 @@ class pipeline_parameters(TypedDict) :
             At run time is a regular dict instance, this class is used for keys hinting
             """
             alpha : float
+            anisotropy : float
             beta : float
             channel_to_compute : int
+            cellprob_threshold_cyto : float
+            cellprob_threshold_nuc : float
+            cytoplasm_segmentation_3D : bool
             cluster_size : int
+            cyto_model_name : str
+            cytoplasm_diameter : int
+            cytoplasm_channel : int
             do_cluster_computation : bool
             do_dense_regions_deconvolution : bool
             do_spots_excel : bool
@@ -19,10 +26,11 @@ class pipeline_parameters(TypedDict) :
             do_spots_csv : bool
             dim : int
             filename : str
+            flow_threshold_cyto : int
+            flow_threshold_nuc : int
             gamma : float
             image_path : str
             image : ndarray
-            show_interactive_threshold_selector : bool
             log_kernel_size : Tuple[float,float,float]
             log_kernel_size_x : float
             log_kernel_size_y : float
@@ -34,18 +42,29 @@ class pipeline_parameters(TypedDict) :
             minimum_distance_z : float
             is_3D_stack : bool
             is_multichannel : bool
-            show_napari_corrector : bool
             nucleus_channel_signal : int
-            reodered_shape : Tuple[int,int,int,int,int]
+            nucleus_segmentation_3D : bool
+            nucleus_diameter : int
+            nucleus_model_name : str
+            nucleus_channel : int
+            other_nucleus_image : str
+            reordered_shape : Tuple[int,int,int,int,int]
             do_segmentation : bool
-            segmentation_done : bool
             shape : Tuple[int,int,int,int,int]
+            save_segmentation_visual : bool
+            segmentation_done : bool
+            show_interactive_threshold_selector : bool
             spots_extraction_folder : str
             spots_filename : str
             spot_size : Tuple[int,int,int]
             spot_size_x : int
             spot_size_y : int
             spot_size_z : int
+            segment_only_nuclei : bool
+            cytoplasm_segmentation_3D : bool
+            nucleus_segmentation_3D : bool
+            show_napari_corrector : bool
+            show_segmentation : bool
             threshold : int
             threshold_penalty : int
             time_stack : None

small_fish_gui/{pipeline/main.py → main_menu.py}

@@ -7,31 +7,33 @@ from small_fish_gui import __version__
 import pandas as pd
 import FreeSimpleGUI as sg
 
-from .actions import add_detection 
-from . actions import save_results 
-from . actions import compute_colocalisation 
-from . actions import delete_acquisitions, rename_acquisitions 
-from . actions import save_segmentation, load_segmentation, segment_cells
-from .actions import open_wiki
-
-from ._preprocess import clean_unused_parameters_cache
-from ..batch import batch_promp
-from ..gui import hub_prompt, prompt_restore_main_menu
-from ..hints import pipeline_parameters
+from .pipeline.actions import add_detection 
+from .pipeline.actions import save_results 
+from .pipeline.actions import compute_colocalisation 
+from .pipeline.actions import delete_acquisitions, rename_acquisitions 
+from .pipeline.actions import save_segmentation, load_segmentation, segment_cells
+from .pipeline.actions import open_wiki
+
+from .pipeline._preprocess import clean_unused_parameters_cache
+from .batch import batch_promp
+from .gui import hub_prompt, prompt_restore_main_menu, default_theme
+from .hints import pipeline_parameters
 
 #'Global' parameters
 user_parameters = pipeline_parameters({'segmentation_done' : False}) #TypedDict
 acquisition_id = -1
-result_df = pd.DataFrame(columns=['acquisition_id'])
+result_df = pd.DataFrame(columns=['acquisition_id', 'name'])
 cell_result_df = pd.DataFrame(columns=['acquisition_id'])
 global_coloc_df = pd.DataFrame()
 cell_coloc_df = dict()
 cytoplasm_label = None
 nucleus_label = None
 
+default_theme()
 while True : #Break this loop to close small_fish
     try :
         result_df = result_df.reset_index(drop=True)
+
         event, values = hub_prompt(result_df, user_parameters['segmentation_done'])
 
         if event == 'Add detection' :
@@ -71,14 +73,13 @@ while True : #Break this loop to close small_fish
             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.
 
-            global_coloc_df, cell_coloc_df = compute_colocalisation(
-                result_tables,
+            global_coloc_df, cell_coloc_df, acquisition_id = compute_colocalisation(
                 result_dataframe=result_df,
                 cell_result_dataframe=cell_result_df,
                 global_coloc_df=global_coloc_df,
                 cell_coloc_df=cell_coloc_df,
+                max_id=acquisition_id,
             )
 
         elif event == "Reset all" :

small_fish_gui/pipeline/_colocalisation.py

@@ -1,6 +1,7 @@
 from ._custom_errors import MissMatchError
 from ..gui import coloc_prompt, add_default_loading
 
+import os
 import numpy as np
 import pandas as pd
 import FreeSimpleGUI as sg
@@ -116,7 +117,12 @@ def spots_multicolocalisation(spots_list, anchor_list, radius_nm, image_shape, v
 
     return res
 
-def spots_colocalisation(spot_list1:list, spot_list2:list, distance: float, voxel_size)-> int :
+def spots_colocalisation(
+        spot_list1:np.ndarray, 
+        spot_list2:np.ndarray, 
+        distance: int, 
+        voxel_size : tuple
+        )-> int :
     """
     Return number of spots from spot_list1 located closer(large) than distance to at least one spot of spot_list2.
 
@@ -133,9 +139,15 @@ def spots_colocalisation(spot_list1:list, spot_list2:list, distance: float, voxe
     if len(spot_list1) == 0 or len(spot_list2) == 0 : return np.NaN
     if len(spot_list1[0]) != len(spot_list2[0]) : 
         raise MissMatchError("dimensionalities of spots 1 and spots 2 don't match.")
-    
+
+    spot_list1 = np.array([spot for spot in spot_list1], dtype=int)
+    spot_list2 = np.array([spot for spot in spot_list2], dtype=int)
+
     shape1 = np.max(spot_list1,axis=0)
     shape2 = np.max(spot_list2,axis=0)
+
+    Z,Y,X = list(zip(*spot_list2))
+
     image_shape = np.max([shape1, shape2],axis=0) + 1
 
     signal2 = reconstruct_boolean_signal(image_shape, spot_list2)
@@ -152,25 +164,48 @@ def spots_colocalisation(spot_list1:list, spot_list2:list, distance: float, voxe
     return count
 
 
-   
+def initiate_colocalisation(
+        result_tables : pd.DataFrame,
+        ) :
 
+    result_tables = result_tables.set_index('acquisition_id', drop=False)
+    available_spots = dict(zip(result_tables['acquisition_id'].astype(str).str.cat(result_tables['name'],sep='-'), result_tables.index))
 
+    while True :
+        try : 
+            colocalisation_distance, voxel_size, spots1_key, spots2_key = coloc_prompt(list(available_spots.keys()))
+            if colocalisation_distance is None :
+                return None,None, None,None
+            colocalisation_distance = int(colocalisation_distance)
 
-def initiate_colocalisation(result_tables) :
-    if len(result_tables) != 2 : 
-        sg.popup("Please select 2 acquisitions for colocalisation (Ctrl + click in the table)")
-        return False
-    else : 
-        while True :
-            colocalisation_distance = coloc_prompt()
-            if colocalisation_distance == False : return False
-            try : 
-                colocalisation_distance = int(colocalisation_distance)
-            except Exception :
-                sg.popup("Incorrect colocalisation distance")
+            if spots1_key in available_spots.keys() :
+                spots1_key = available_spots[spots1_key]
+            elif os.path.isfile(spots1_key) :
+                pass
+
+            else :
+                raise ValueError("Incorrect value for spots1")
+            
+            if spots2_key in available_spots.keys() :
+                spots2_key = available_spots[spots2_key]
+            elif os.path.isfile(spots2_key) :
+                pass
             else :
-                break
-        return colocalisation_distance
+                raise ValueError("Incorrect value for spots1")
+
+        except ValueError as e :
+            
+            if str(e) == "Incorrect value for spots1" :
+                sg.popup(str(e))
+
+            elif str(e) == "Incorrect value for spots2" :
+                sg.popup(str(e))
+
+            else :
+                sg.popup("Incorrect colocalisation distance")
+        else :
+            break
+    return colocalisation_distance, voxel_size, spots1_key, spots2_key
 
 def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisation_distance) :
     """
@@ -198,20 +233,12 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
 
     voxel_size1 = acquisition1.iloc[0].at['voxel_size']
     voxel_size2 = acquisition2.iloc[0].at['voxel_size']
-    shape1 = acquisition1.iloc[0].at['reordered_shape']
-    shape2 = acquisition2.iloc[0].at['reordered_shape']
 
     if voxel_size1 != voxel_size2 : 
         raise MissMatchError("voxel size 1 different than voxel size 2")
     else :
         voxel_size = voxel_size1
 
-    if shape1 != shape2 :
-        raise MissMatchError("shape 1 different than shape 2")
-    else :
-        shape = shape1
-
-
     spots1 = acquisition1.iloc[0].at['spots']
     spots2 = acquisition2.iloc[0].at['spots']
 
@@ -228,7 +255,7 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
 
     if 'clusters' in acquisition1.columns :
         try : 
-            clusters_id_1 = acquisition1.iloc[0].at['spots_cluster_id']
+            clusters_id_1 = np.array(acquisition1.iloc[0].at['spots_cluster_id'], dtype=int)
             fraction_spots2_coloc_cluster1 = spots_colocalisation(spot_list1=spots2, spot_list2=spots1[clusters_id_1 != -1], distance= colocalisation_distance, voxel_size=voxel_size) / spot2_total
         except MissMatchError as e :
             sg.popup(str(e))
@@ -241,7 +268,7 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
 
     if 'clusters' in acquisition2.columns :
         try :
-            clusters_id_2 = acquisition2.iloc[0].at['spots_cluster_id']
+            clusters_id_2 = np.array(acquisition2.iloc[0].at['spots_cluster_id'], dtype=int)
             fraction_spots1_coloc_cluster2 = spots_colocalisation(spot_list1=spots1, spot_list2=spots2[clusters_id_2 != -1], distance= colocalisation_distance, voxel_size=voxel_size) / spot1_total
         except MissMatchError as e :# clusters not computed
             sg.popup(str(e))
@@ -314,10 +341,6 @@ def _cell_coloc(
     coloc_name_forward = '{0} -> {1}'.format(acquisition_name_id1, acquisition_name_id2)
     coloc_name_backward = '{1} -> {0}'.format(acquisition_name_id1, acquisition_name_id2)
 
-    #Getting shape
-    if not result_dataframe.at[acquisition_id1, 'reordered_shape'] == result_dataframe.at[acquisition_id2, 'reordered_shape'] :
-        raise ValueError("Selected acquisitions have different shapes. Most likely they don't belong to the same fov.")
-
     #Getting voxel_size
     if not result_dataframe.at[acquisition_id1, 'voxel_size'] == result_dataframe.at[acquisition_id2, 'voxel_size'] :
         raise ValueError("Selected acquisitions have different voxel_size. Most likely they don't belong to the same fov.")
@@ -328,9 +351,9 @@ def _cell_coloc(
 
     #Putting spots lists in 2 cols for corresponding cells
     pivot_values_columns = ['rna_coords', 'total_rna_number']
-    if 'clusters' in acquisition2.columns or 'clusters' in acquisition1.columns :
+    if 'clusters' in acquisition2.columns or 'clusters' in acquisition1.columns:
         pivot_values_columns.extend(['clustered_spots_coords','clustered_spot_number'])
-    cell_dataframe['cell_id'] = cell_dataframe['cell_id'].astype(int)
+    cell_dataframe.loc[:,['cell_id']] = cell_dataframe['cell_id'].astype(int)
     colocalisation_df = cell_dataframe.pivot(
         columns=['name', 'acquisition_id'],
         values= pivot_values_columns,
@@ -357,7 +380,7 @@ def _cell_coloc(
         )
     colocalisation_df[("spots_with_spots_fraction",coloc_name_backward,"backward")] = colocalisation_df[("spots_with_spots_count",coloc_name_backward,"backward")].astype(float) / colocalisation_df[('total_rna_number',acquisition_name_id2,acquisition_id2)].astype(float)
 
-    if acquisition2['do_cluster_computation'].iat[0] :
+    if 'clusters' in acquisition2.columns:
         if len(acquisition2['clusters'].iat[0]) > 0 :
 
             #spots to clusters
@@ -371,7 +394,7 @@ def _cell_coloc(
                 )
             colocalisation_df[("spots_with_clustered_spots_fraction",coloc_name_forward,"forward")] = colocalisation_df[("spots_with_clustered_spots_count",coloc_name_forward,"forward")].astype(float) / colocalisation_df[('total_rna_number',acquisition_name_id1,acquisition_id1)].astype(float)
         
-    if acquisition1['do_cluster_computation'].iat[0] :
+    if 'clusters' in acquisition1.columns:
         if len(acquisition1['clusters'].iat[0]) > 0 :
             colocalisation_df[("spots_with_clustered_spots_count",coloc_name_backward,"backward")] = colocalisation_df.apply(
                 lambda x: spots_colocalisation(
@@ -384,7 +407,7 @@ def _cell_coloc(
 
             colocalisation_df[("spots_with_clustered_spots_fraction",coloc_name_backward,"backward")] = colocalisation_df[("spots_with_clustered_spots_count",coloc_name_backward,"backward")].astype(float) / colocalisation_df[('total_rna_number',acquisition_name_id2,acquisition_id2)].astype(float)
 
-    if acquisition2['do_cluster_computation'].iat[0] and acquisition1['do_cluster_computation'].iat[0] :
+    if 'clusters' in acquisition2.columns and 'clusters' in acquisition1.columns:
         if len(acquisition1['clusters'].iat[0]) > 0 and len(acquisition2['clusters'].iat[0]) > 0 :
             #clusters to clusters 
             colocalisation_df[("clustered_spots_with_clustered_spots_count",coloc_name_forward,"forward")] = colocalisation_df.apply(
@@ -420,12 +443,8 @@ def _cell_coloc(
     return colocalisation_df
 
 @add_default_loading
-def launch_colocalisation(result_tables, result_dataframe, cell_result_dataframe, colocalisation_distance, global_coloc_df, cell_coloc_df: dict) :
+def launch_colocalisation(acquisition_id1, acquisition_id2, result_dataframe, cell_result_dataframe, colocalisation_distance, global_coloc_df, cell_coloc_df: dict) :
     
-    acquisition1 = result_dataframe.iloc[result_tables[0]]
-    acquisition2 = result_dataframe.iloc[result_tables[1]]
-
-    acquisition_id1, acquisition_id2 = (acquisition1.at['acquisition_id'], acquisition2.at['acquisition_id'])
 
     if acquisition_id1 in list(cell_result_dataframe['acquisition_id']) and acquisition_id2 in list(cell_result_dataframe['acquisition_id']) :
         print("Launching cell to cell colocalisation.")

small_fish_gui/pipeline/_preprocess.py

@@ -4,6 +4,8 @@ import FreeSimpleGUI as sg
 from ..gui import _error_popup, _warning_popup, parameters_layout, add_header
 from ..gui.prompts import input_image_prompt, prompt
 
+import small_fish_gui.default_values as default
+
 class ParameterInputError(Exception) :
     """
     Raised when user inputs an incorrect parameter.
@@ -314,19 +316,19 @@ def _check_segmentation_parameters(
 ) :
 
     available_channels = list(range(len(shape)))
-    do_only_nuc = user_parameters['Segment only nuclei']
+    do_only_nuc = user_parameters['segment_only_nuclei']
     cyto_model_name = user_parameters['cyto_model_name']
-    cyto_size = user_parameters['cytoplasm diameter']
-    cytoplasm_channel = user_parameters['cytoplasm channel']
+    cyto_size = user_parameters['cytoplasm_diameter']
+    cytoplasm_channel = user_parameters['cytoplasm_channel']
     nucleus_model_name = user_parameters['nucleus_model_name']
-    nucleus_size = user_parameters['nucleus diameter']
-    nucleus_channel = user_parameters['nucleus channel']
+    nucleus_size = user_parameters['nucleus_diameter']
+    nucleus_channel = user_parameters['nucleus_channel']
    
 
     if type(cyto_model_name) != str  and not do_only_nuc:
         raise ParameterInputError('Invalid cytoplasm model name.')
     if cytoplasm_channel not in available_channels and not do_only_nuc and is_multichannel:
-        raise ParameterInputError('For given input image please select channel in {0}\ncytoplasm channel : {1}'.format(available_channels, cytoplasm_channel))
+        raise ParameterInputError('For given input image please select channel in {0}\ncytoplasm_channel : {1}'.format(available_channels, cytoplasm_channel))
 
     if type(cyto_size) not in [int, float] and not do_only_nuc:
         raise ParameterInputError("Incorrect cytoplasm size.")
@@ -361,12 +363,11 @@ def ask_input_parameters(ask_for_segmentation=True) :
     values = {}
     image_input_values = {}
     while True :
-        is_3D_preset = image_input_values.setdefault('is_3D_stack', False)
-        is_time_preset = image_input_values.setdefault('time stack', False)
-        is_multichannel_preset = image_input_values.setdefault('is_multichannel', False)
-        denseregion_preset = image_input_values.setdefault('do_dense_regions_deconvolution', False)
-        do_clustering_preset = image_input_values.setdefault('do_cluster_computation', False)
-        do_napari_preset = image_input_values.setdefault('show_napari_corrector', False)
+        is_3D_preset = image_input_values.setdefault('is_3D_stack', default.IS_3D_STACK)
+        is_multichannel_preset = image_input_values.setdefault('is_multichannel', default.IS_MULTICHANNEL)
+        denseregion_preset = image_input_values.setdefault('do_dense_regions_deconvolution', default.DO_DENSE_REGIONS_DECONVOLUTION)
+        do_clustering_preset = image_input_values.setdefault('do_cluster_computation', default.DO_CLUSTER_COMPUTATION)
+        do_napari_preset = image_input_values.setdefault('show_napari_corrector', default.SHOW_NAPARI_CORRECTOR)
 
         if ask_for_segmentation :
             image_input_values = input_image_prompt(

small_fish_gui/pipeline/actions.py

@@ -17,6 +17,7 @@ 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 .spots import load_spots, reconstruct_acquisition_data, reconstruct_cell_data
 
 from .segmentation import launch_segmentation
 from ._colocalisation import initiate_colocalisation, launch_colocalisation
@@ -115,7 +116,7 @@ def add_detection(user_parameters : pipeline_parameters, acquisition_id, cytopla
 
     if user_parameters['spots_extraction_folder'] != '' and type(user_parameters['spots_extraction_folder']) != type(None) :
         if user_parameters['spots_filename'] != '' and type(user_parameters['spots_filename']) != type(None) :
-            if any((user_parameters['do_spots_excel'], user_parameters['do_spots_csv'], user_parameters['do_spots_feather'])) :
+            if any([user_parameters['do_spots_excel'], user_parameters['do_spots_csv']]) :
                 launch_spots_extraction(
                     acquisition_id=acquisition_id,
                     user_parameters=user_parameters,
@@ -242,9 +243,11 @@ def save_results(
         global_coloc_df : pd.DataFrame, 
         cell_coloc_df : dict, #TODO : Rename to cell_coloc_dict
         ) :
-    if len(result_df) != 0 :
+    if len(result_df) != 0  :
         dic = output_image_prompt(filename=result_df.iloc[0].at['filename'])
 
+        if dic is None : return None
+
         if isinstance(dic, dict) :
             path = dic['folder']
             filename = dic['filename']
@@ -260,26 +263,111 @@ def save_results(
             sucess4 = write_list_of_results(cell_coloc_df.values(), path= path, filename=filename + 'cell2cell_coloc_result', do_excel= do_excel, do_feather= do_feather, do_csv=do_csv)
             if all([sucess1,sucess2, sucess3, sucess4,]) : sg.popup("Sucessfully saved at {0}.".format(path))
 
+    elif len(global_coloc_df) !=0 or len(cell_coloc_df) !=0 :
+        dic = output_image_prompt(filename="loaded_spots_coloc")
+        if dic is None : return None
+        if isinstance(dic, dict) :
+            path = dic['folder']
+            filename = dic['filename']
+            do_excel = dic['Excel']
+            do_feather = dic['Feather']
+            do_csv = dic['csv']
+
+            if 'rna_coords' in cell_result_df.columns : cell_result_df = cell_result_df.drop(columns='rna_coords')
+
+            sucess3 = write_results(global_coloc_df, path= path, filename=filename + 'global_coloc_result', do_excel= do_excel, do_feather= do_feather, do_csv=do_csv)
+            sucess4 = write_list_of_results(cell_coloc_df.values(), path= path, filename=filename + 'cell2cell_coloc_result', do_excel= do_excel, do_feather= do_feather, do_csv=do_csv)
+            if all([sucess3, sucess4,]) : sg.popup("Sucessfully saved at {0}.".format(path))
+
+
     else :
         dic = None
         sg.popup('No results to save.') 
 
-def compute_colocalisation(result_tables, result_dataframe, cell_result_dataframe, global_coloc_df, cell_coloc_df) :
-    colocalisation_distance = initiate_colocalisation(result_tables)
+def compute_colocalisation(
+        result_dataframe, 
+        cell_result_dataframe, 
+        global_coloc_df, 
+        cell_coloc_df,
+        max_id,
+        ) :
+    
+    colocalisation_distance, voxel_size, spots1_key, spots2_key = initiate_colocalisation(result_dataframe)
+    if colocalisation_distance is None :
+        return global_coloc_df, cell_coloc_df, max_id
+
+    if os.path.isfile(spots1_key) :
+        Spots1 = load_spots(spots1_key)
+        fake_acquisition = reconstruct_acquisition_data(
+            Spots=Spots1,
+            max_id=max_id,
+            filename= os.path.basename(spots1_key),
+            voxel_size = voxel_size
+        )
+        result_dataframe = pd.concat([
+            result_dataframe,
+            fake_acquisition
+        ], axis=0)
+
+        if not Spots1['cell_label'].isna().all() :
+            fake_cells = reconstruct_cell_data(
+                Spots=Spots1,
+                max_id=max_id,
+            )
+
+            cell_result_dataframe = pd.concat([
+                cell_result_dataframe,
+                fake_cells
+            ], axis=0)
+
+        max_id +=1
+        acquisition_id1 = fake_acquisition.iloc[0].at['acquisition_id']
 
-    if colocalisation_distance == False :
-        pass
     else :
-        global_coloc_df, cell_coloc_df = launch_colocalisation(
-            result_tables, 
-            result_dataframe=result_dataframe, 
-            cell_result_dataframe=cell_result_dataframe,
-            colocalisation_distance=colocalisation_distance,
-            global_coloc_df=global_coloc_df,
-            cell_coloc_df=cell_coloc_df,
+        acquisition_id1 = spots1_key
+    
+    if os.path.isfile(spots2_key) :
+        Spots2 = load_spots(spots2_key)
+        fake_acquisition = reconstruct_acquisition_data(
+            Spots=Spots2,
+            max_id=max_id,
+            filename= os.path.basename(spots2_key),
+            voxel_size = voxel_size
+        )
+        result_dataframe = pd.concat([
+            result_dataframe,
+            fake_acquisition
+        ], axis=0)
+
+        if not Spots2['cell_label'].isna().all() :
+            fake_cells = reconstruct_cell_data(
+                Spots=Spots2,
+                max_id=max_id,
             )
 
-    return global_coloc_df, cell_coloc_df
+            cell_result_dataframe = pd.concat([
+                cell_result_dataframe,
+                fake_cells
+            ], axis=0)
+
+        max_id +=1
+        acquisition_id2 = fake_acquisition.iloc[0].at['acquisition_id']
+
+    else :
+        acquisition_id2 = spots2_key
+
+
+    global_coloc_df, cell_coloc_df = launch_colocalisation(
+        acquisition_id1 = acquisition_id1,
+        acquisition_id2 = acquisition_id2,
+        result_dataframe=result_dataframe, 
+        cell_result_dataframe=cell_result_dataframe,
+        colocalisation_distance=colocalisation_distance,
+        global_coloc_df=global_coloc_df,
+        cell_coloc_df=cell_coloc_df,
+        )
+
+    return global_coloc_df, cell_coloc_df, max_id
 
 def delete_acquisitions(selected_acquisitions : pd.DataFrame, 
                         result_df : pd.DataFrame, 

small_fish_gui/pipeline/detection.py

@@ -443,7 +443,11 @@ def launch_cell_extraction(
         image = stack.maximum_projection(image)
     if nucleus_signal.ndim == 3 :
         nucleus_signal = stack.maximum_projection(nucleus_signal)
-    
+    if cell_label.ndim == 3 :
+        cell_label = stack.maximum_projection(nucleus_signal)
+    if nucleus_label.ndim == 3 :
+        nucleus_label = stack.maximum_projection(nucleus_signal)
+
     cells_results = multistack.extract_cell(
         cell_label=cell_label,
         ndim=dim,