small-fish-gui 1.8.0__py3-none-any.whl → 1.9.0__py3-none-any.whl

small_fish_gui/pipeline/_colocalisation.py

@@ -226,10 +226,10 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
         fraction_spots1_coloc_spots2 = np.NaN
         fraction_spots2_coloc_spots1 = np.NaN
 
-    if 'clusters' in acquisition1.index :
+    if 'clusters' in acquisition1.columns :
         try : 
-            clusters1 = acquisition1.iloc[0].at['clusters'][:,:len(voxel_size)]
-            fraction_spots2_coloc_cluster1 = spots_colocalisation(spot_list1=spots2, spot_list2=clusters1, distance= colocalisation_distance, voxel_size=voxel_size) / spot2_total
+            clusters_id_1 = acquisition1.iloc[0].at['spots_cluster_id']
+            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))
             fraction_spots2_coloc_cluster1 = np.NaN
@@ -239,10 +239,10 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
 
     else : fraction_spots2_coloc_cluster1 = np.NaN
 
-    if 'clusters' in acquisition2.index :
+    if 'clusters' in acquisition2.columns :
         try :
-            clusters2 = acquisition2.iloc[0].at['clusters'][:,:len(voxel_size)]
-            fraction_spots1_coloc_cluster2 = spots_colocalisation(spot_list1=spots1, spot_list2=clusters2, distance= colocalisation_distance, voxel_size=voxel_size) / spot1_total
+            clusters_id_2 = acquisition2.iloc[0].at['spots_cluster_id']
+            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))
             fraction_spots1_coloc_cluster2 = np.NaN
@@ -252,6 +252,25 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
 
     else : fraction_spots1_coloc_cluster2 = np.NaN
 
+    if 'clusters' in acquisition2.columns and 'clusters' in acquisition1.columns :
+        try :
+            total_clustered_spots1 = len(spots1[clusters_id_1 != -1])
+            total_clustered_spots2 = len(spots2[clusters_id_2 != -1])
+            fraction_cluster1_coloc_cluster2 = spots_colocalisation(spot_list1=spots1[clusters_id_1 != -1], spot_list2=spots2[clusters_id_2 != -1], distance= colocalisation_distance, voxel_size=voxel_size) / total_clustered_spots1
+            fraction_cluster2_coloc_cluster1 = spots_colocalisation(spot_list1=spots2[clusters_id_2 != -1], spot_list2=spots1[clusters_id_1 != -1], distance= colocalisation_distance, voxel_size=voxel_size) / total_clustered_spots2
+        except MissMatchError as e :# clusters not computed
+            sg.popup(str(e))
+            fraction_cluster1_coloc_cluster2 = np.NaN
+            fraction_cluster2_coloc_cluster1 = np.NaN
+        except TypeError :
+            fraction_cluster1_coloc_cluster2 = np.NaN
+            fraction_cluster2_coloc_cluster1 = np.NaN
+
+    else :
+        fraction_cluster1_coloc_cluster2 = np.NaN
+        fraction_cluster2_coloc_cluster1 = np.NaN
+        
+
     coloc_df = pd.DataFrame({
         "acquisition_couple" : [acquisition_couple],
         "acquisition_id_1" : [acquisition_couple[0]],
@@ -263,6 +282,8 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
         'fraction_spots2_coloc_spots1' : [fraction_spots2_coloc_spots1],
         'fraction_spots2_coloc_cluster1' : [fraction_spots2_coloc_cluster1],
         'fraction_spots1_coloc_cluster2' : [fraction_spots1_coloc_cluster2],
+        'fraction_cluster1_coloc_cluster2' : [fraction_cluster1_coloc_cluster2],
+        'fraction_cluster2_coloc_cluster1' : [fraction_cluster2_coloc_cluster1],
     })
 
     coloc_df['fraction_spots1_coloc_free2'] = coloc_df['fraction_spots1_coloc_spots2'] - coloc_df['fraction_spots1_coloc_cluster2']
@@ -289,10 +310,9 @@ def _cell_coloc(
 
     acquisition_name_id1 = acquisition1['name'].iat[0]
     acquisition_name_id2 = acquisition2['name'].iat[0]
-    cluster_radius1 = acquisition1['cluster size'].iat[0]
-    cluster_radius2 = acquisition2['cluster size'].iat[0]
     result_dataframe = result_dataframe.set_index('acquisition_id', drop=False)
-    coloc_name = '{0}nm_{1}{2}_{3}{4}'.format(colocalisation_distance, acquisition_id1,acquisition_name_id1, acquisition_id2,acquisition_name_id2)
+    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'] :
@@ -309,14 +329,15 @@ 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 :
-        pivot_values_columns.extend(['cluster_coords','foci_number'])
+        pivot_values_columns.extend(['clustered_spots_coords','clustered_spot_number'])
+    cell_dataframe['cell_id'] = cell_dataframe['cell_id'].astype(int)
     colocalisation_df = cell_dataframe.pivot(
         columns=['name', 'acquisition_id'],
         values= pivot_values_columns,
         index= 'cell_id'
     )
     #spots _vs spots
-    colocalisation_df[("spots_to_spots_count",coloc_name,"forward")] = colocalisation_df['rna_coords'].apply(
+    colocalisation_df[("spots_with_spots_count",coloc_name_forward,"forward")] = colocalisation_df['rna_coords'].apply(
         lambda x: spots_colocalisation(
             spot_list1= x[(acquisition_name_id1,acquisition_id1)],
             spot_list2= x[(acquisition_name_id2,acquisition_id2)],
@@ -324,9 +345,9 @@ def _cell_coloc(
             voxel_size=voxel_size
             ),axis=1
         )
-    colocalisation_df[("spots_to_spots_fraction",coloc_name,"forward")] = colocalisation_df[("spots_to_spots_count",coloc_name,"forward")].astype(float) / colocalisation_df[('total_rna_number',acquisition_name_id1,acquisition_id1)].astype(float)
+    colocalisation_df[("spots_with_spots_fraction",coloc_name_forward,"forward")] = colocalisation_df[("spots_with_spots_count",coloc_name_forward,"forward")].astype(float) / colocalisation_df[('total_rna_number',acquisition_name_id1,acquisition_id1)].astype(float)
     
-    colocalisation_df[("spots_to_spots_count",coloc_name,"backward")] = colocalisation_df['rna_coords'].apply(
+    colocalisation_df[("spots_with_spots_count",coloc_name_backward,"backward")] = colocalisation_df['rna_coords'].apply(
         lambda x: spots_colocalisation(
             spot_list1= x[(acquisition_name_id2,acquisition_id2)],
             spot_list2= x[(acquisition_name_id1,acquisition_id1)],
@@ -334,66 +355,71 @@ def _cell_coloc(
             voxel_size=voxel_size
             ),axis=1
         )
-    colocalisation_df[("spots_to_spots_fraction",coloc_name,"backward")] = colocalisation_df[("spots_to_spots_count",coloc_name,"backward")].astype(float) / colocalisation_df[('total_rna_number',acquisition_name_id2,acquisition_id2)].astype(float)
+    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 len(acquisition2['clusters'].iat[0]) > 0 :
 
             #spots to clusters
-            colocalisation_df[("spots_to_clusters_count",coloc_name,"forward")] = colocalisation_df.apply(
+            colocalisation_df[("spots_with_clustered_spots_count",coloc_name_forward,"forward")] = colocalisation_df.apply(
                 lambda x: spots_colocalisation(
                     spot_list1= x[('rna_coords',acquisition_name_id1,acquisition_id1)],
-                    spot_list2= x[('cluster_coords',acquisition_name_id2,acquisition_id2)][:,:len(voxel_size)],
-                    distance=colocalisation_distance + cluster_radius2,
+                    spot_list2= x[('clustered_spots_coords',acquisition_name_id2,acquisition_id2)][:,:len(voxel_size)],
+                    distance=colocalisation_distance,
                     voxel_size=voxel_size
                     ),axis=1
                 )
-            colocalisation_df[("spots_to_clusters_fraction",coloc_name,"forward")] = colocalisation_df[("spots_to_clusters_count",coloc_name,"forward")].astype(float) / colocalisation_df[('total_rna_number',acquisition_name_id1,acquisition_id1)].astype(float)
+            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 len(acquisition1['clusters'].iat[0]) > 0 :
-            colocalisation_df[("spots_to_clusters_count",coloc_name,"backward")] = colocalisation_df.apply(
+            colocalisation_df[("spots_with_clustered_spots_count",coloc_name_backward,"backward")] = colocalisation_df.apply(
                 lambda x: spots_colocalisation(
                     spot_list1= x[('rna_coords',acquisition_name_id2,acquisition_id2)],
-                    spot_list2= x[('cluster_coords',acquisition_name_id1,acquisition_id1)][:,:len(voxel_size)],
-                    distance=colocalisation_distance + cluster_radius1,
+                    spot_list2= x[('clustered_spots_coords',acquisition_name_id1,acquisition_id1)][:,:len(voxel_size)],
+                    distance=colocalisation_distance,
                     voxel_size=voxel_size
                     ),axis=1
                 )
-            colocalisation_df[("spots_to_clusters_fraction",coloc_name,"backward")] = colocalisation_df[("spots_to_clusters_count",coloc_name,"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] :
+            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 len(acquisition1['clusters'].iat[0]) > 0 and len(acquisition2['clusters'].iat[0]) > 0 :
             #clusters to clusters 
-            colocalisation_df[("clusters_to_clusters_count",coloc_name,"forward")] = colocalisation_df.apply(
+            colocalisation_df[("clustered_spots_with_clustered_spots_count",coloc_name_forward,"forward")] = colocalisation_df.apply(
                 lambda x: spots_colocalisation(
-                    spot_list1= x[('cluster_coords',acquisition_name_id1,acquisition_id1)][:,:len(voxel_size)],
-                    spot_list2= x[('cluster_coords',acquisition_name_id2,acquisition_id2)][:,:len(voxel_size)],
-                    distance=colocalisation_distance + cluster_radius1 + cluster_radius2, 
+                    spot_list1= x[('clustered_spots_coords',acquisition_name_id1,acquisition_id1)][:,:len(voxel_size)],
+                    spot_list2= x[('clustered_spots_coords',acquisition_name_id2,acquisition_id2)][:,:len(voxel_size)],
+                    distance=colocalisation_distance, 
                     voxel_size=voxel_size 
                     ),axis=1
             )
-            colocalisation_df[("clusters_to_clusters_fraction",coloc_name,"forward")] = colocalisation_df[("clusters_to_clusters_count",coloc_name,"forward")].astype(float) / colocalisation_df[('foci_number',acquisition_name_id1,acquisition_id1)].astype(float)
+            colocalisation_df[("clustered_spots_with_clustered_spots_fraction",coloc_name_forward,"forward")] = colocalisation_df[("clustered_spots_with_clustered_spots_count",coloc_name_forward,"forward")].astype(float) / colocalisation_df[('clustered_spot_number',acquisition_name_id1,acquisition_id1)].astype(float)
 
-            colocalisation_df[("clusters_to_clusters_count",coloc_name,"backward")] = colocalisation_df.apply(
+            colocalisation_df[("clustered_spots_with_clustered_spots_count",coloc_name_backward,"backward")] = colocalisation_df.apply(
                 lambda x: spots_colocalisation(
-                    spot_list1= x[('cluster_coords',acquisition_name_id2,acquisition_id2)][:,:len(voxel_size)],
-                    spot_list2= x[('cluster_coords',acquisition_name_id1,acquisition_id1)][:,:len(voxel_size)],
-                    distance=colocalisation_distance + cluster_radius1 + cluster_radius2, 
+                    spot_list1= x[('clustered_spots_coords',acquisition_name_id2,acquisition_id2)][:,:len(voxel_size)],
+                    spot_list2= x[('clustered_spots_coords',acquisition_name_id1,acquisition_id1)][:,:len(voxel_size)],
+                    distance=colocalisation_distance, 
                     voxel_size=voxel_size 
                     ),axis=1
             )
-            colocalisation_df[("clusters_to_clusters_fraction",coloc_name,"backward")] = colocalisation_df[("clusters_to_clusters_count",coloc_name,"backward")].astype(float) / colocalisation_df[('foci_number',acquisition_name_id2,acquisition_id2)].astype(float)
+            colocalisation_df[("clustered_spots_with_clustered_spots_fraction",coloc_name_backward,"backward")] = colocalisation_df[("clustered_spots_with_clustered_spots_count",coloc_name_backward,"backward")].astype(float) / colocalisation_df[('clustered_spot_number',acquisition_name_id2,acquisition_id2)].astype(float)
 
     colocalisation_df = colocalisation_df.sort_index(axis=0).sort_index(axis=1, level=0)
 
-    if 'cluster_coords' in cell_dataframe.columns : colocalisation_df = colocalisation_df.drop('cluster_coords', axis=1)
+    if 'clustered_spots_coords' in cell_dataframe.columns : colocalisation_df = colocalisation_df.drop('clustered_spots_coords', axis=1)
     colocalisation_df = colocalisation_df.drop('rna_coords', axis=1)
+    colocalisation_df['voxel_size'] = [voxel_size]*len(colocalisation_df)
+    colocalisation_df['pair_name'] = [(acquisition_name_id1, acquisition_name_id2)] * len(colocalisation_df)
+    colocalisation_df['pair_acquisition_id'] = [(acquisition_id1, acquisition_id2)] * len(colocalisation_df)
+    colocalisation_df['colocalisation_distance'] = colocalisation_distance
 
     return colocalisation_df
 
 @add_default_loading
-def launch_colocalisation(result_tables, result_dataframe, cell_result_dataframe, colocalisation_distance, global_coloc_df, cell_coloc_df: pd.DataFrame) :
+def launch_colocalisation(result_tables, 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]]
@@ -409,12 +435,11 @@ def launch_colocalisation(result_tables, result_dataframe, cell_result_dataframe
             cell_dataframe=cell_result_dataframe,
             colocalisation_distance=colocalisation_distance
         )
-        cell_coloc_df = pd.concat([
-            cell_coloc_df,
-            new_coloc,
-        ], axis=1).sort_index(axis=1, level=0)
-
-        cell_coloc_df.index = cell_coloc_df.index.rename('cell_id')
+        
+        index = 0
+        while (acquisition_id1, acquisition_id2, index) in cell_coloc_df.keys() :
+            index +=1
+        cell_coloc_df [(acquisition_id1,acquisition_id2, index)] = new_coloc
 
 
     else :

small_fish_gui/pipeline/actions.py

@@ -6,7 +6,7 @@ from ..gui.prompts import output_image_prompt, prompt_save_segmentation, prompt_
 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 write_results, write_list_of_results
 from ..interface.inoutput import input_segmentation, output_segmentation
 
 from ._preprocess import map_channels
@@ -49,9 +49,6 @@ def segment_cells(user_parameters : pipeline_parameters, nucleus_label, cytoplas
     return nucleus_label, cytoplasm_label, user_parameters
 
 def add_detection(user_parameters : pipeline_parameters, acquisition_id, cytoplasm_label, nucleus_label) :
-    """
-    #TODO : Separate segmentation from detection in pipeline.
-    """
 
     new_results_df = pd.DataFrame()
     new_cell_results_df = pd.DataFrame()
@@ -89,7 +86,7 @@ def add_detection(user_parameters : pipeline_parameters, acquisition_id, cytopla
         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(
+            user_parameters, frame_result, spots, clusters, spots_cluster_id = launch_detection(
                 image,
                 other_image,
                 user_parameters,
@@ -105,7 +102,7 @@ def add_detection(user_parameters : pipeline_parameters, acquisition_id, cytopla
                 raise(error)
 
 
-        if user_parameters['show_napari_corrector'] :
+        if user_parameters['show_napari_corrector'] or user_parameters['show_interactive_threshold_selector']:
             if ask_detection_confirmation(user_parameters.get('threshold')) : break
         else :
             break
@@ -118,6 +115,7 @@ def add_detection(user_parameters : pipeline_parameters, acquisition_id, cytopla
                     user_parameters=user_parameters,
                     image=image,
                     spots=spots,
+                    cluster_id= spots_cluster_id,
                     nucleus_label= nucleus_label,
                     cell_label= cytoplasm_label,
                 )
@@ -129,6 +127,7 @@ def add_detection(user_parameters : pipeline_parameters, acquisition_id, cytopla
     nucleus_signal = nucleus_signal,
     spots=spots,
     clusters=clusters,
+    spots_cluster_id = spots_cluster_id,
     nucleus_label = nucleus_label,
     cell_label= cytoplasm_label,
     user_parameters=user_parameters,
@@ -222,7 +221,12 @@ def load_segmentation(nucleus_label, cytoplasm_label, segmentation_done) :
 
     return nucleus_label, cytoplasm_label, segmentation_done
 
-def save_results(result_df, cell_result_df, global_coloc_df, cell_coloc_df) :
+def save_results(
+        result_df : pd.DataFrame, 
+        cell_result_df : pd.DataFrame, 
+        global_coloc_df : pd.DataFrame, 
+        cell_coloc_df : dict, #TODO : Rename to cell_coloc_dict
+        ) :
     if len(result_df) != 0 :
         dic = output_image_prompt(filename=result_df.iloc[0].at['filename'])
 
@@ -238,7 +242,7 @@ def save_results(result_df, cell_result_df, global_coloc_df, cell_coloc_df) :
             sucess1 = write_results(result_df, path= path, filename=filename, do_excel= do_excel, do_feather= do_feather, do_csv=do_csv)
             sucess2 = write_results(cell_result_df, path= path, filename=filename + '_cell_result', do_excel= do_excel, do_feather= do_feather, do_csv=do_csv)
             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_results(cell_coloc_df, path= path, filename=filename + 'cell2cell_coloc_result', do_excel= do_excel, do_feather= do_feather, do_csv=do_csv, reset_index=False)
+            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))
 
     else :
@@ -266,7 +270,7 @@ def delete_acquisitions(selected_acquisitions : pd.DataFrame,
                         result_df : pd.DataFrame, 
                         cell_result_df : pd.DataFrame, 
                         global_coloc_df : pd.DataFrame,
-                        cell_coloc_df : pd.DataFrame,
+                        cell_coloc_df : dict,
                         ) :
     
     if len(result_df) == 0 :
@@ -291,11 +295,14 @@ def delete_acquisitions(selected_acquisitions : pd.DataFrame,
             global_coloc_df = global_coloc_df.drop(coloc_df_drop_idx, axis=0)
         
         if len(cell_coloc_df) > 0 :
+            keys_to_delete = []
             for acquisition_id in acquisition_ids :
-                cell_coloc_df = cell_coloc_df.drop(acquisition_id, axis=1, level=2) #Delete spot number and foci number
-                coloc_columns = cell_coloc_df.columns.get_level_values(1)
-                coloc_columns = coloc_columns[coloc_columns.str.contains(str(acquisition_id))]
-                cell_coloc_df = cell_coloc_df.drop(labels=coloc_columns, axis=1, level=1)
+                for coloc_key in cell_coloc_df.keys() :
+                    if acquisition_id in coloc_key :
+                        keys_to_delete.append(coloc_key) 
+
+            for key in keys_to_delete : 
+                if key in cell_coloc_df.keys() : cell_coloc_df.pop(key)
 
         result_df = result_df.drop(result_drop_idx, axis=0)
 
@@ -306,7 +313,7 @@ def rename_acquisitions(
         result_df : pd.DataFrame, 
         cell_result_df : pd.DataFrame, 
         global_coloc_df : pd.DataFrame,
-        cell_coloc_df : pd.DataFrame,
+        cell_coloc_df : dict,
         ) :
     
     if len(result_df) == 0 :
@@ -331,16 +338,19 @@ def rename_acquisitions(
             global_coloc_df.loc[global_coloc_df['acquisition_id_1'].isin(acquisition_ids), ['name1']] = name
             global_coloc_df.loc[global_coloc_df['acquisition_id_2'].isin(acquisition_ids), ['name2']] = name
         if len(cell_coloc_df) > 0 :
-            target_columns = cell_coloc_df.columns.get_level_values(1)
-            for old_name in old_names : #Note list was ordered by elmt len (decs) to avoid conflict when one name is contained by another one. if the shorter is processed first then the longer will not be able to be properly renamed.
-                target_columns = target_columns.str.replace(old_name, name)
-            
-            new_columns = zip(
-                cell_coloc_df.columns.get_level_values(0),
-                target_columns,
-                cell_coloc_df.columns.get_level_values(2),
-            )
+            for key in cell_coloc_df.keys() :
+                df = cell_coloc_df[key]
+                target_columns = df.columns.get_level_values(1)
+                for old_name in old_names : #Note list was ordered by elmt len (decs) to avoid conflict when one name is contained by another one. if the shorter is processed first then the longer will not be able to be properly renamed.
+                    target_columns = target_columns.str.replace(old_name, name)
+
+                new_columns = zip(
+                    df.columns.get_level_values(0),
+                    target_columns,
+                    df.columns.get_level_values(2),
+                )
 
-            cell_coloc_df.columns = pd.MultiIndex.from_tuples(new_columns)
+                df.columns = pd.MultiIndex.from_tuples(new_columns)
+                cell_coloc_df[key] = df
 
     return result_df, cell_result_df, global_coloc_df, cell_coloc_df

small_fish_gui/pipeline/detection.py

@@ -7,7 +7,7 @@ from ..hints import pipeline_parameters
 from ._preprocess import ParameterInputError
 from ._preprocess import check_integrity, convert_parameters_types
 
-from ..gui.napari import correct_spots, _update_clusters, threshold_selection
+from ..gui.napari_visualiser import correct_spots, threshold_selection
 from ..gui import add_default_loading
 from ..gui import detection_parameters_promt
 
@@ -388,14 +388,36 @@ 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 : pipeline_parameters) :
+def launch_cell_extraction(
+    acquisition_id, 
+    spots, 
+    clusters, 
+    spots_cluster_id,
+    image, 
+    nucleus_signal, 
+    cell_label, 
+    nucleus_label, 
+    user_parameters : pipeline_parameters
+    ) :
 
     #Extract parameters
     dim = user_parameters['dim']
     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
+    if do_clustering :
+        if len(clusters) > 0 :
+
+            free_spots = spots[spots_cluster_id == -1]
+            clustered_spots = spots[spots_cluster_id != -1]
+
+            other_coords = {
+                'clusters_coords' : clusters,
+                'clustered_spots' : clustered_spots,
+                'free_spots' : free_spots,
+                }
+        else :
+            other_coords = None
     else : other_coords = None
     if do_clustering : do_clustering = len(clusters) > 0
 
@@ -429,7 +451,8 @@ def launch_cell_extraction(acquisition_id, spots, clusters, image, nucleus_signa
     features_names += ['nucleus_mean_signal', 'nucleus_median_signal', 'nucleus_max_signal', 'nucleus_min_signal']
     features_names += ['snr_mean', 'snr_median', 'snr_std']
     features_names += ['cell_center_coord','foci_number','foci_in_nuc_number']
-    features_names += ['rna_coords','cluster_coords']
+    features_names += ['rna_coords','cluster_coords', 'clustered_spots_coords', 'free_spots_coords']
+    features_names += ['clustered_spot_number', 'free_spot_number']
 
     result_frame = pd.DataFrame()
 
@@ -444,6 +467,8 @@ def launch_cell_extraction(acquisition_id, spots, clusters, image, nucleus_signa
         nuc_signal = nucleus_signal[min_y:max_y, min_x:max_x]
         rna_coords = cell['rna_coord']
         foci_coords = cell.get('clusters_coords')
+        clustered_spots_coords = cell.get('clustered_spots')
+        free_spots_coords = cell.get('free_spots')
         signal = cell['image']
 
         with np.errstate(divide= 'ignore', invalid= 'ignore') :
@@ -509,7 +534,8 @@ def launch_cell_extraction(acquisition_id, spots, clusters, image, nucleus_signa
         features += [cell_center, foci_number, foci_in_nuc_number]
 
         features = [acquisition_id, cell_id, cell_bbox] + features
-        features += [rna_coords, foci_coords]
+        features += [rna_coords, foci_coords, clustered_spots_coords, free_spots_coords]
+        features += [len(clustered_spots_coords), len(free_spots_coords)]
         
         result_frame = pd.concat([
             result_frame,
@@ -527,20 +553,23 @@ def launch_clustering(spots, user_parameters : pipeline_parameters):
     nb_min_spots = user_parameters['min number of spots']
     cluster_size = user_parameters['cluster size']
 
-    clusters = cluster_detection(
+    cluster_result_dict = cluster_detection(
         spots=spots,
         voxel_size=voxel_size,
         radius=cluster_size,
         nb_min_spots=nb_min_spots,
-        keys_to_compute= 'clusters'
-    )['clusters']
+        keys_to_compute= ['clusters','clustered_spots']
+    )
+
+    clusters = cluster_result_dict['clusters']
+    clustered_spots = cluster_result_dict['clustered_spots']
 
-    return clusters
+    return clusters, clustered_spots
 
 def launch_detection(
         image,
         other_image,
-        user_parameters,
+        user_parameters : pipeline_parameters,
         cell_label= None,
         nucleus_label = None,
         hide_loading=False,
@@ -575,10 +604,12 @@ def launch_detection(
         spots = launch_dense_region_deconvolution(image, spots, user_parameters, hide_loading = hide_loading)
         
     if do_clustering : 
-        clusters = launch_clustering(spots, user_parameters, hide_loading = hide_loading) #012 are coordinates #3 is number of spots per cluster, #4 is cluster index
-        clusters = _update_clusters(clusters, spots, voxel_size=user_parameters['voxel_size'], cluster_size=user_parameters['cluster size'], shape=image.shape)
+        clusters, clustered_spots = launch_clustering(spots, user_parameters, hide_loading = hide_loading) #012 are coordinates #3 is number of spots per cluster, #4 is cluster index
+        spots, spots_cluster_id = clustered_spots[:,:-1], clustered_spots[:,-1]
 
-    else : clusters = None
+    else : 
+        clusters = None
+        spots_cluster_id = None
 
     user_parameters['threshold'] = threshold
 
@@ -589,19 +620,37 @@ def launch_detection(
             spots, 
             user_parameters['voxel_size'],
             clusters=clusters,
+            spot_cluster_id = spots_cluster_id,
             cluster_size= user_parameters.get('cluster size'),
             min_spot_number= user_parameters.setdefault('min number of spots', 0),
             cell_label=cell_label,
             nucleus_label=nucleus_label,
             other_images=other_image
             )
+        
+        if do_clustering :
+            spots, spots_cluster_id = spots[:,:-1], spots[:,-1]
+        else :
+            spots_cluster_id = None
+
     post_detection_dict = launch_post_detection(image, spots, user_parameters, hide_loading = hide_loading)
     fov_result.update(post_detection_dict)
     
-    return user_parameters, fov_result, spots, clusters
+    return user_parameters, fov_result, spots, clusters, spots_cluster_id
             
 
-def launch_features_computation(acquisition_id, image, nucleus_signal, spots, clusters, nucleus_label, cell_label, user_parameters :pipeline_parameters, frame_results) :
+def launch_features_computation(
+        acquisition_id, 
+        image, 
+        nucleus_signal, 
+        spots, 
+        clusters, 
+        spots_cluster_id, 
+        nucleus_label, 
+        cell_label, 
+        user_parameters : pipeline_parameters, 
+        frame_results
+        ) :
 
     dim = image.ndim
     if user_parameters['do_cluster_computation'] : 
@@ -618,6 +667,7 @@ def launch_features_computation(acquisition_id, image, nucleus_signal, spots, cl
                 acquisition_id=acquisition_id,
                 spots=spots,
                 clusters=clusters,
+                spots_cluster_id = spots_cluster_id,
                 image=image,
                 nucleus_signal=nucleus_signal,
                 cell_label= cell_label,
@@ -638,6 +688,7 @@ def launch_features_computation(acquisition_id, image, nucleus_signal, spots, cl
         frame_results['cell_number'] = NaN
     frame_results['spots'] = spots
     frame_results['clusters'] = clusters
+    frame_results['spots_cluster_id'] = spots_cluster_id
     frame_results.update(user_parameters)
     frame_results['threshold'] = user_parameters['threshold']
 

small_fish_gui/pipeline/main.py

@@ -16,13 +16,13 @@ acquisition_id = -1
 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()
+cell_coloc_df = dict()
 cytoplasm_label = None
 nucleus_label = None
 
 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' :
@@ -34,8 +34,8 @@ while True : #Break this loop to close small_fish
                 cytoplasm_label = cytoplasm_label,
                 nucleus_label = nucleus_label,
                 )
-            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)
+            result_df = pd.concat([result_df, new_result_df], axis=0).reset_index(drop=True)
+            cell_result_df = pd.concat([cell_result_df, new_cell_result_df], axis=0).reset_index(drop=True)
 
         elif event == 'Segment cells' :
             nucleus_label, cytoplasm_label, user_parameters = segment_cells(
@@ -73,10 +73,10 @@ while True : #Break this loop to close small_fish
             )
 
         elif event == "Reset all" :
-            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()
+            cell_coloc_df = dict()
             acquisition_id = -1
             user_parameters['segmentation_done'] = False
             cytoplasm_label = None

small_fish_gui/pipeline/segmentation.py

@@ -8,7 +8,7 @@ from ..hints import pipeline_parameters
 from ..gui.layout import _segmentation_layout
 from ..gui import prompt, prompt_with_help, ask_cancel_segmentation
 from ..interface import open_image
-from ..gui.napari import show_segmentation as napari_show_segmentation
+from ..gui.napari_visualiser import show_segmentation as napari_show_segmentation
 from .utils import from_label_get_centeroidscoords
 from ._preprocess import ask_input_parameters
 from ._preprocess import map_channels, reorder_shape, reorder_image_stack

small_fish_gui/pipeline/spots.py

@@ -12,6 +12,7 @@ def launch_spots_extraction(
         user_parameters,
         image,
         spots,
+        cluster_id,
         nucleus_label,
         cell_label,
 ) :
@@ -19,6 +20,7 @@ def launch_spots_extraction(
         acquisition_id=acquisition_id,
         image=image,
         spots=spots,
+        cluster_id= cluster_id,
         nucleus_label=nucleus_label,
         cell_label=cell_label,
     )
@@ -38,6 +40,7 @@ def compute_Spots(
         acquisition_id : int,
         image : np.ndarray,
         spots : np.ndarray,
+        cluster_id : np.ndarray,
         nucleus_label = None,
         cell_label = None,
 ) :
@@ -45,6 +48,9 @@ def compute_Spots(
     if len(spots) == 0 :
         return pd.DataFrame()
 
+    if type(cluster_id) == type(None) : #When user doesn't select cluster
+        cluster_id = [np.NaN]*len(spots)
+
     index = list(zip(*spots))
     index = tuple(index)
     spot_intensities_list = list(image[index])
@@ -67,6 +73,7 @@ def compute_Spots(
         'cell_label' : cell_label_list,
         'in_nucleus' : in_nuc_list,
         'coordinates' : coord_list,
+        'cluster_id' : cluster_id,
     })
 
     return Spots