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

small_fish_gui/pipeline/segmentation.py

@@ -14,6 +14,8 @@ from ._preprocess import ask_input_parameters
 from ._preprocess import map_channels, reorder_shape, reorder_image_stack
 from matplotlib.colors import ListedColormap
 
+import small_fish_gui.default_values as default
+
 import matplotlib as mpl
 import cellpose.models as models
 import numpy as np
@@ -55,19 +57,26 @@ def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cyt
 
     while True : # Loop if show_segmentation 
         #Default parameters
-        cyto_model_name = segmentation_parameters.setdefault('cyto_model_name', 'cyto3')
-        cyto_size = segmentation_parameters.setdefault('cytoplasm diameter', 180)
-        cytoplasm_channel = segmentation_parameters.setdefault('cytoplasm channel', 0)
-        nucleus_model_name = segmentation_parameters.setdefault('nucleus_model_name', 'nuclei')
-        nucleus_size = segmentation_parameters.setdefault('nucleus diameter', 130)
-        nucleus_channel = segmentation_parameters.setdefault('nucleus channel', 0)
+        cyto_model_name = segmentation_parameters.setdefault('cyto_model_name', default.CYTO_MODEL)
+        cyto_size = segmentation_parameters.setdefault('cytoplasm_diameter', default.CYTO_DIAMETER)
+        cytoplasm_channel = segmentation_parameters.setdefault('cytoplasm_channel', default.CHANNEL)
+        nucleus_model_name = segmentation_parameters.setdefault('nucleus_model_name', default.NUC_MODEL)
+        nucleus_size = segmentation_parameters.setdefault('nucleus_diameter', default.NUC_DIAMETER)
+        nucleus_channel = segmentation_parameters.setdefault('nucleus_channel', default.CHANNEL)
         other_nucleus_image = segmentation_parameters.setdefault('other_nucleus_image',None)
         path = os.getcwd()
-        show_segmentation = segmentation_parameters.setdefault('show segmentation', False)
-        segment_only_nuclei = segmentation_parameters.setdefault('Segment only nuclei', False)
+        show_segmentation = segmentation_parameters.setdefault('show_segmentation', default.SHOW_SEGMENTATION)
+        save_segmentation_visual = segmentation_parameters.setdefault('save_segmentation_visual', default.SAVE_SEGMENTATION_VISUAL)
+        segment_only_nuclei = segmentation_parameters.setdefault('segment_only_nuclei', default.SEGMENT_ONLY_NUCLEI)
+        multichannel = segmentation_parameters.setdefault('is_multichannel', default.IS_MULTICHANNEL)
+        is_3D_stack = segmentation_parameters.setdefault('is_3D_stack', default.IS_3D_STACK)
+        anisotropy = segmentation_parameters.setdefault('anisotropy', default.ANISOTROPY)
+        cytoplasm_segmentation_3D = segmentation_parameters.setdefault('cytoplasm_segmentation_3D', default.DO_3D_SEMGENTATION)
+        nucleus_segmentation_3D = segmentation_parameters.setdefault('nucleus_segmentation_3D', default.DO_3D_SEMGENTATION)
+        flow_threshold = segmentation_parameters.setdefault("flow_threshold",0.4)
+        cellprob_threshold = segmentation_parameters.setdefault("cellprob_threshold",0)
         filename = segmentation_parameters['filename']
         available_channels = list(range(image.shape[0]))
-        multichannel = segmentation_parameters.get('is_multichannel')
 
 
     #Ask user for parameters
@@ -82,10 +91,17 @@ def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cyt
                 nucleus_diameter_preset= nucleus_size,
                 other_nucleus_image_preset=other_nucleus_image,
                 saving_path_preset= path,
+                save_segmentation_visual_preset=save_segmentation_visual,
                 show_segmentation_preset=show_segmentation,
                 segment_only_nuclei_preset=segment_only_nuclei,
                 filename_preset=filename,
                 multichannel=multichannel,
+                is_3D_stack=is_3D_stack,
+                cytoplasm_segmentation_3D=cytoplasm_segmentation_3D,
+                nucleus_segmentation_3D=nucleus_segmentation_3D,
+                anisotropy=anisotropy,
+                flow_threshold=flow_threshold,
+                cellprob_threshold=cellprob_threshold,
             )
 
             event, values = prompt(layout)
@@ -98,56 +114,98 @@ def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cyt
                     continue
 
             #Extract parameters
-            values = _cast_segmentation_parameters(values)
-            do_only_nuc = values['Segment only nuclei']
+            values : pipeline_parameters = _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']
+            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']
+            nucleus_size = values['nucleus_diameter']
+            nucleus_channel = values['nucleus_channel']
             other_nucleus_image = values['other_nucleus_image']
             path = values['saving path'] if values['saving path'] != '' else None
-            show_segmentation = values['show segmentation']
+            save_segmentation_visual = values['save_segmentation_visual']
+            show_segmentation = values['show_segmentation']
             filename = values['filename'] if type(path) != type(None) else None
             channels = [cytoplasm_channel, nucleus_channel] if multichannel else [...,...]
+            nucleus_segmentation_3D = values['nucleus_segmentation_3D']
+            cytoplasm_segmentation_3D = values['cytoplasm_segmentation_3D']
+            anisotropy = values['anisotropy']
+            cellprob_threshold_cyto = values['cellprob_threshold_cyto']
+            cellprob_threshold_nuc = values['cellprob_threshold_nuc']
+            flow_threshold_cyto = values['flow_threshold_cyto']
+            flow_threshold_nuc = values['flow_threshold_nuc']
 
             relaunch= False
             #Checking integrity of parameters
+
+            #flow thresholds
+            if type(flow_threshold_nuc) != float : 
+                sg.popup('Invalid value for flow threshold in nuc parameters, must be a float between 0 and 1.')
+                values['flow_threshold_nuc'] = user_parameters.setdefault('flow_threshold_nuc',default.FLOW_THRESHOLD)
+                relaunch= True
+            if type(flow_threshold_cyto) != float : 
+                sg.popup('Invalid value for flow threshold in cyto parameters, must be a float between 0 and 1.')
+                values['flow_threshold_cyto'] = user_parameters.setdefault('flow_threshold_cyto',default.FLOW_THRESHOLD)
+                relaunch= True
+            
+            #cellprob thresholds
+            if type(flow_threshold_nuc) != float : 
+                sg.popup('Invalid value for cellprob threshold in nuc parameters, must be a float between -3 and +3.')
+                values['flow_threshold_nuc'] = user_parameters.setdefault('flow_threshold_nuc',default.FLOW_THRESHOLD)
+                relaunch= True
+            if type(flow_threshold_cyto) != float : 
+                sg.popup('Invalid value for cellprob threshold in cyto parameters, must be a float between -3 and +3.')
+                values['flow_threshold_cyto'] = user_parameters.setdefault('flow_threshold_cyto',default.FLOW_THRESHOLD)
+                relaunch= True
+
+            
+            #Models
             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')
+                values['cyto_model_name'] = user_parameters.setdefault('cyto_model_name', default.CYTO_MODEL)
                 relaunch= True
             if multichannel :
                 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))
+                    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)
+                    values['cytoplasm_channel'] = user_parameters.setdefault('cytoplasm_channel',default.CHANNEL)
             else :
                 cytoplasm_channel = ...
 
+            if is_3D_stack :
+                try :
+                    float(anisotropy)
+                    if anisotropy <0 : raise ValueError()
+
+                except ValueError :
+                    sg.popup("Anisotropy must be a positive float.")
+                    relaunch = True
+                    values['anisotropy'] = user_parameters.setdefault('anisotropy', default.ANISOTROPY)
+
             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)
+                values['cytoplasm_diameter'] = user_parameters.setdefault('cytoplasm_diameter', default.CYTO_DIAMETER)
 
             if type(nucleus_model_name) != str :
                 sg.popup('Invalid nucleus model name.')
-                values['nucleus_model_name'] = user_parameters.setdefault('nucleus_model_name', 'nuclei')
+                values['nucleus_model_name'] = user_parameters.setdefault('nucleus_model_name', default.NUC_MODEL)
                 relaunch= True
             
             if multichannel :
                 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)
+                    values['nucleus_channel'] = user_parameters.setdefault('nucleus_channel', default.CHANNEL)
             else : 
                 nucleus_channel = ...
 
             if type(nucleus_size) not in [int, float] :
                 sg.popup("Incorrect nucleus size.")
                 relaunch= True
-                values['nucleus diameter'] = user_parameters.setdefault('nucleus diameter', 30)
+                values['nucleus_diameter'] = user_parameters.setdefault('nucleus_diameter', default.NUC_DIAMETER)
+
             if other_nucleus_image != '' :
                 if not os.path.isfile(other_nucleus_image) :
                     sg.popup("Nucleus image is not a file.")
@@ -202,7 +260,6 @@ def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cyt
                 nuc_path = None
                 cyto_path = None
 
-
             cytoplasm_label, nucleus_label = cell_segmentation(
                 image,
                 cyto_model_name= cyto_model_name,
@@ -212,6 +269,14 @@ def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cyt
                 channels=channels,
                 do_only_nuc=do_only_nuc,
                 external_nucleus_image = nucleus_image,
+                anisotropy=anisotropy,
+                nucleus_3D_segmentation=nucleus_segmentation_3D,
+                cyto_3D_segmentation=cytoplasm_segmentation_3D,
+                cellprob_threshold_cyto=cellprob_threshold_cyto,
+                cellprob_threshold_nuc=cellprob_threshold_nuc,
+                flow_threshold_cyto=flow_threshold_cyto,
+                flow_threshold_nuc=flow_threshold_nuc,
+
                 )
 
         finally  : window.close()
@@ -222,6 +287,7 @@ def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cyt
                 nuc_label= nucleus_label,
                 cyto_image=image[cytoplasm_channel],
                 cyto_label=cytoplasm_label,
+                anisotrpy=anisotropy,
             )
 
             if nucleus_label.ndim == 3 : nucleus_label = np.max(nucleus_label, axis=0)
@@ -236,20 +302,29 @@ def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cyt
             if event == "No" :
                 continue
 
-        if type(output_path) != type(None) :
+        if type(output_path) != type(None) and save_segmentation_visual:
             
             #Get backgrounds
             nuc_proj = image[nucleus_channel]
             im_proj = image[cytoplasm_channel]
             if im_proj.ndim == 3 :
-                im_proj = stack.maximum_projection(im_proj)
+                im_proj = stack.mean_projection(im_proj)
             if nuc_proj.ndim == 3 :
-                nuc_proj = stack.maximum_projection(nuc_proj)
+                nuc_proj = stack.mean_projection(nuc_proj)
+            if nucleus_label.ndim == 3 :
+                nucleus_label_proj = np.max(nucleus_channel,axis=0)
+            else : 
+                nucleus_label_proj = nucleus_label
+            if cytoplasm_label.ndim == 3 :
+                cytoplasm_label_proj = np.max(cytoplasm_label,axis=0)
+            else : 
+                cytoplasm_label_proj = cytoplasm_label
+
             
             #Call plots
-            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,)
+            plot.plot_segmentation_boundary(nuc_proj, cytoplasm_label_proj, nucleus_label_proj, 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=False, path_output=cyto_path, title="Cytoplasm Segmentation (red)", remove_frame=True)
+                plot.plot_segmentation_boundary(im_proj, cytoplasm_label_proj, nucleus_label_proj, boundary_size=2, contrast=True, show=False, path_output=cyto_path, title="Cytoplasm Segmentation (red)", remove_frame=True)
             plot_labels(
                 nucleus_label,
                 path_output=output_path + "_nucleus_label_map.png",
@@ -257,7 +332,7 @@ def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cyt
                 )
             if not do_only_nuc : 
                 plot_labels(
-                    cytoplasm_label,
+                    cytoplasm_label_proj,
                     path_output=output_path + "_cytoplasm_label_map.png",
                     show=False
                     )
@@ -284,91 +359,140 @@ def cell_segmentation(
         image, cyto_model_name, 
         nucleus_model_name, 
         channels, cyto_diameter, 
-        nucleus_diameter, 
+        nucleus_diameter,
+        nucleus_3D_segmentation=False,
+        cyto_3D_segmentation=False,
+        anisotropy = 1,
+        flow_threshold_nuc = 0.4,
+        flow_threshold_cyto = 0.4,
+        cellprob_threshold_nuc = 0.,
+        cellprob_threshold_cyto = 0.,
         do_only_nuc=False,
         external_nucleus_image = None,
         ) :
 
     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 type(external_nucleus_image) != type(None) :
         nuc = external_nucleus_image
     else :
         nuc = image[nuc_channel]
 
-    if nuc.ndim >= 3 :
-        nuc = stack.maximum_projection(nuc)
+    if nuc.ndim >= 3 and not nucleus_3D_segmentation:
+        nuc = stack.mean_projection(nuc)
+    nuc_label = _segmentate_object(
+        nuc, 
+        nucleus_model_name, 
+        nucleus_diameter, 
+        do_3D=nucleus_3D_segmentation, 
+        anisotropy=anisotropy,
+        flow_threshold= flow_threshold_nuc,
+        cellprob_threshold=cellprob_threshold_nuc
+        )
     
-    if not do_only_nuc :
+    if not do_only_nuc : 
+        cyto_channel = channels[0]
+        nuc = image[nuc_channel] if type(external_nucleus_image) == type(None) else external_nucleus_image
+
+        if image[cyto_channel].ndim >= 3 and not cyto_3D_segmentation:
+            cyto = stack.mean_projection(image[cyto_channel])
+        else : 
+            cyto = image[cyto_channel]
+        if nuc.ndim >= 3 and not cyto_3D_segmentation:
+            nuc = stack.mean_projection(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))
+        source = list(range(image.ndim))
+        dest = source[-1:] + source[:-1]
+        image = np.moveaxis(image, source=range(image.ndim), destination= dest)
+
+        cytoplasm_label = _segmentate_object(
+            image, 
+            cyto_model_name, 
+            cyto_diameter, 
+            do_3D=cyto_3D_segmentation, 
+            anisotropy=anisotropy,
+            flow_threshold=flow_threshold_cyto,
+            cellprob_threshold=cellprob_threshold_cyto,
+            )
+
+        if cytoplasm_label.ndim == 3 and nuc_label.ndim == 2 :
+            nuc_label = np.repeat(nuc_label[np.newaxis], len(cytoplasm_label), axis= 0)
+        if nuc_label.ndim == 3 and cytoplasm_label.ndim == 2 :
+            cytoplasm_label = np.repeat(cytoplasm_label[np.newaxis], len(nuc_label), axis= 0)
 
-    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]) :
+def _segmentate_object(
+        im : np.ndarray, 
+        model_name : str, 
+        object_size_px : int, 
+        do_3D = False, 
+        anisotropy : float = 1.0,
+        flow_threshold : float = 0.4,
+        cellprob_threshold : float = 0, 
+        ) :
 
     model = models.CellposeModel(
         gpu= use_gpu(),
-        model_type= model_name,
+        pretrained_model= model_name,
     )
 
-    label = model.eval(
+    label, flow, style = model.eval(
         im,
         diameter= object_size_px,
-        channels= channels,
-        do_3D= False,
-        )[0]
+        do_3D= do_3D,
+        z_axis=0 if do_3D else None,
+        channel_axis= im.ndim -1 if im.ndim == 3+ do_3D else None,
+        anisotropy=anisotropy,
+        flow_threshold=flow_threshold,
+        cellprob_threshold=cellprob_threshold,
+        )
+    
     label = np.array(label, dtype= np.int64)
-    label = remove_disjoint(label)
+    if not do_3D : label = remove_disjoint(label) # Too much time consuming in 3D
+    else : pass #TODO : filter too litle regions
     
     return label
 
 def _cast_segmentation_parameters(values:dict) :
 
-    values.setdefault('cytoplasm channel',0)
-    values.setdefault('nucleus channel',0)
+    values.setdefault('cytoplasm_channel',0)
+    values.setdefault('nucleus_channel',0)
 
+    cast_rules = {
+        'cytoplasm_diameter' : int,
+        'nucleus_diameter' : int,
+        'cytoplasm_channel' : int,
+        'nucleus_channel' : int,
+        'anisotropy' : float,
+        'flow_threshold_cyto' : float,
+        'cellprob_threshold_cyto' : float,
+        'flow_threshold_nuc' : float,
+        'cellprob_threshold_nuc' : float,
+
+    }    
+
+    for key, constructor in cast_rules.items() :
+        try :
+            if key in values.keys() : values[key] = constructor(values[key])
+        except ValueError :
+            pass
+
+    #None if default
     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):
@@ -450,6 +574,15 @@ def plot_segmentation(
     if nuc_image.ndim == 3 :
         nuc_image = np.max(nuc_image,axis=0)
     
+    if cyto_label.ndim == 3 :
+        cyto_label = np.max(cyto_label,axis=0)
+    
+    if nuc_label.ndim == 3 :
+        nuc_label = np.max(nuc_label,axis=0)
+    
+    if cyto_image.ndim == 3 :
+        cyto_image = np.max(cyto_image,axis=0)
+    
     plot.plot_segmentation_boundary(
         image=nuc_image,
         nuc_label= nuc_label,

small_fish_gui/pipeline/spots.py

@@ -31,7 +31,6 @@ def launch_spots_extraction(
         filename= user_parameters['spots_filename'],
         do_excel=user_parameters['do_spots_excel'],
         do_csv=user_parameters['do_spots_csv'],
-        do_feather=user_parameters['do_spots_feather'],
         )
     
     if did_output : print("Individual spots extracted at {0}".format(user_parameters['spots_extraction_folder']))
@@ -41,8 +40,8 @@ def compute_Spots(
         image : np.ndarray,
         spots : np.ndarray,
         cluster_id : np.ndarray,
-        nucleus_label = None,
-        cell_label = None,
+        nucleus_label : np.ndarray = None,
+        cell_label : np.ndarray = None,
 ) :
 
     if len(spots) == 0 :
@@ -55,11 +54,17 @@ def compute_Spots(
     index = tuple(index)
     spot_intensities_list = list(image[index])
     if type(nucleus_label) != type(None) :
-        in_nuc_list = list(nucleus_label.astype(bool)[index[-2:]]) #Only plane coordinates
+        if nucleus_label.ndim == 2 :
+            in_nuc_list = list(nucleus_label.astype(bool)[index[-2:]]) #Only plane coordinates
+        else :
+            in_nuc_list = list(nucleus_label.astype(bool)[index])
     else :
         in_nuc_list = np.NaN
     if type(cell_label) != type(None) :
-        cell_label_list = list(cell_label[index[-2:]]) #Only plane coordinates
+        if cell_label.ndim == 3 :
+            cell_label_list = list(cell_label[index])
+        else :    
+            cell_label_list = list(cell_label[index[-2:]]) #Only plane coordinates
     else :
         cell_label_list = np.NaN
     id_list = np.arange(len(spots))
@@ -78,4 +83,123 @@ def compute_Spots(
 
     return Spots
     
+def load_spots(
+        table_path : str
+        ) -> pd.DataFrame :
+    
+    if table_path.endswith('.csv') :
+        Spots = pd.read_csv(table_path, sep= ";")
+    elif table_path.endswith('.xlsx') or table_path.endswith('.xls') :
+        Spots = pd.read_excel(table_path)
+    elif table_path.endswith('.feather') :
+        Spots = pd.read_feather(table_path)
+    else :
+        raise ValueError("Table format not recognized. Please use .csv, .xlsx or .feather files.")
+    
+    if "coordinates" in Spots.columns :
+        pass
+    elif "y" in Spots.columns and "x" in Spots.columns :
+        if "z" in Spots.columns :
+            pass
+        else :
+            pass
+    else :
+        raise ValueError("Coordinates information not found in table. Please provide a 'coordinates' column with tuples (z,y,x) or (y,x) or 'y' and 'x' columns.")
+
+    return Spots
+
+def reconstruct_acquisition_data(
+        Spots : pd.DataFrame,
+        max_id : int,
+        filename : str,
+        voxel_size : 'tuple[int]'
+        ) -> pd.DataFrame:
+    """
+    Aim : creating a acquisition to add to result_dataframe from loaded spots for co-localization use  
+
+    **Needed keys for colocalization**
+        * acquisition_id
+        * name
+        * spots : np.ndarray[int] (nb_spots, nb_coordinates)
+        * clusters : np.ndarray[int] (nb_cluster, nb_coordinate + 2)
+        * spots_cluster_id : list[int]
+        * voxel_size : tuple[int]
+        * shape : tuple[int]
+        * filename : str
+    """
+    
+    spots = reconstruct_spots(Spots['coordinates'])
+    has_clusters = not Spots['cluster_id'].isna().all()
+    spot_number = len(spots)
+
+    if has_clusters :
+
+        clusters = np.empty(shape=(0,5), dtype=int) #useless for coloc only needded in columns to enable coloc on clusters
+        spot_cluster_id = Spots['cluster_id'].to_numpy().astype(int).tolist()
+
+        new_acquisition = pd.DataFrame({
+            'acquisition_id' : [max_id + 1],
+            'name' : ["loaded_spots_{}".format(max_id + 1)],
+            'threshold' : [0],
+            'spots' : [spots],
+            'clusters' : [clusters],
+            'spots_cluster_id' : [spot_cluster_id],
+            'spot_number' : [spot_number],
+            'filename' : [filename],
+            'voxel_size' : [voxel_size],
+        })
+    else :
+        new_acquisition = pd.DataFrame({
+            'acquisition_id' : [max_id + 1],
+            'name' : ["loaded_spots_{}".format(max_id + 1)],
+            'threshold' : [0],
+            'spots' : [spots],
+            'spot_number' : [spot_number],
+            'filename' : [filename],
+            'voxel_size' : [voxel_size],
+        })
+
+    return new_acquisition
+
+def reconstruct_spots(
+        coordinates_serie : pd.Series
+        ) :
+    spots = coordinates_serie.str.replace('(','').str.replace(')','')
+    spots = spots.str.split(',')
+    spots = spots.apply(np.array)
+    spots = np.array(spots.to_list()).astype(int)
+
+    return spots
+
+
+def reconstruct_cell_data(
+        Spots : pd.DataFrame,
+        max_id : int,
+        ) :
+    
+    has_cluster = not Spots['cluster_id'].isna().all()
+    coordinates = reconstruct_spots(Spots['coordinates'])
+    Spots['coordinates'] = pd.Series(coordinates.tolist(), dtype=object, index= Spots.index)
+
+    cell = Spots.groupby('cell_label')['coordinates'].apply(np.array).rename("rna_coords").reset_index(drop=False)
+    
+    #Handle cells with no spots
+    na_mask =cell[cell['rna_coords'].isna()].index
+    cell.loc[na_mask, ['rna_coords']] = pd.Series([np.empty(shape=(0,3))]*len(na_mask), dtype= object, index=na_mask)
+    
+    cell['total_rna_number'] = cell['rna_coords'].apply(len)
+    
+    if has_cluster :
+        cell['clustered_spots_coords'] = Spots[Spots['cluster_id'] !=-1].groupby('cell_label')['coordinates'].apply(np.array).rename("clustered_spots_coords")
+        
+        #Handle cells with no clusters
+        na_mask =cell[cell['clustered_spots_coords'].isna()].index
+        cell.loc[na_mask, ['clustered_spots_coords']] = pd.Series([np.empty(shape=(0,3))]*len(na_mask), dtype= object, index=na_mask)
+        
+        cell['clustered_spot_number'] = cell['clustered_spots_coords'].apply(len)
+
+    cell['acquisition_id'] = max_id + 1
+    cell['name'] = "loaded_spots_{}".format(max_id + 1)
+    cell = cell.rename(columns={"cell_label": "cell_id"})
 
+    return cell