small-fish-gui 1.5.0__py3-none-any.whl → 1.7.0__py3-none-any.whl

small_fish_gui/__init__.py

@@ -38,4 +38,4 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 """
-__version__ = "1.5.0"
+__version__ = "1.7.0"

small_fish_gui/__main__.py

@@ -1,6 +1,8 @@
 import sys, subprocess
 import PySimpleGUI as sg
 
+from small_fish_gui import __version__
+
 def main():
     import small_fish_gui.pipeline.main
 
@@ -10,9 +12,7 @@ def is_last_version() :
     latest_version = latest_version[:latest_version.find(')')]
     latest_version = latest_version.replace(' ','').split(',')[-1]
 
-    current_version = str(subprocess.run([sys.executable, '-m', 'pip', 'show', '{}'.format('small_fish_gui')], capture_output=True, text=True))
-    current_version = current_version[current_version.find('Version:')+8:]
-    current_version = current_version[:current_version.find('\\n')].replace(' ','')
+    current_version = __version__
 
     return current_version == latest_version
 

small_fish_gui/gui/_napari_widgets.py

@@ -0,0 +1,93 @@
+"""
+Submodule containing custom class for napari widgets
+"""
+import numpy as np
+from napari.layers import Labels
+from magicgui import magicgui
+
+class cell_label_eraser :
+    """
+    Must be instanced within Napari Viewer definition range for update connection to work, cell deletion works fine anyway.
+    """
+    def __init__(self, label_list: 'list[Labels]'):
+        self.widget = self._create_eraser(label_list)
+        for label_layer in label_list :
+            label_layer.events.selected_label.connect((self, 'update'))
+
+    def update(self, event) :
+        layer : Labels = event.source
+        new_label = layer.selected_label
+        self.widget.label_number.value = new_label
+        self.widget.update()
+    
+    def _create_eraser(self, label_list: 'list[Labels]') :
+        @magicgui(
+                call_button="Delete cell",
+                auto_call=False
+                )
+        def label_eraser(label_number: int) -> None :
+
+            for i, label in enumerate(label_list) :
+                label_list[i].data[label.data == label_number] = 0
+                label.refresh()
+
+        return label_eraser
+
+
+
+class free_label_picker :
+    def __init__(self, label_list):
+        self.widget = self._create_free_label_picker(label_list)
+    
+    def _create_free_label_picker(self, label_list : 'list[Labels]') :
+        @magicgui(
+            call_button="Pick free label",
+            auto_call=False
+        )
+        def label_pick()->None :
+            max_list = [label_layer.data.max() for label_layer in label_list]
+            new_label = max(max_list) + 1
+            for label_layer in label_list :
+                label_layer.selected_label = new_label
+                label_layer.refresh()
+
+        return label_pick
+
+
+class segmentation_reseter :
+    def __init__(self, label_list):
+        self.save = self._get_save(label_list)
+        self.widget = self._create_widget(label_list)
+        
+    
+    def _get_save(self, label_list : 'list[Labels]') :
+        return [label.data.copy() for label in label_list]
+
+    def _create_widget(self, label_list: 'list[Labels]') :
+        @magicgui(
+            call_button= 'Reset segmentation',
+            auto_call=False,
+        )
+        def reset_segmentation() -> None:
+            for save_data, layer in zip(self.save, label_list) :
+                layer.data = save_data.copy()
+                layer.refresh()
+
+        return reset_segmentation
+
+class changes_propagater :
+    def __init__(self, label_list):
+        self.widget = self._create_widget(label_list)
+
+    def _create_widget(self, label_list: 'list[Labels]') :
+        @magicgui(
+            call_button='Apply changes',
+            auto_call=False,
+        )
+        def apply_changes() -> None:
+            for layer in label_list :
+                slices = layer.data.shape[0]
+                layer_2D = np.max(layer.data, axis=0)
+                layer.data = np.repeat(layer_2D[np.newaxis], slices, axis=0)
+                layer.refresh()
+        return apply_changes

small_fish_gui/{pipeline/_napari_wrapper.py → gui/napari.py}

@@ -7,13 +7,21 @@ import napari.types
 import numpy as np
 import napari
 
+from napari.layers import Labels
+
+from magicgui import widgets
+from magicgui import magicgui
+
 from bigfish.stack import check_parameter
+from ._napari_widgets import cell_label_eraser, segmentation_reseter, changes_propagater, free_label_picker
 from ..utils import compute_anisotropy_coef
-from ._colocalisation import spots_multicolocalisation
+from ..pipeline._colocalisation import spots_multicolocalisation
+
+#Post detection
 
-def _update_clusters(new_clusters: np.ndarray, spots: np.ndarray, voxel_size, cluster_size, min_spot_number, shape) :
+def _update_clusters(new_clusters: np.ndarray, spots: np.ndarray, voxel_size, cluster_size, shape) :
     if len(new_clusters) == 0 : return new_clusters
-    if len(spots) == 0 : return new_clusters
+    if len(spots) == 0 : return np.empty(shape=(0,2+len(voxel_size)))
 
     if len(new_clusters[0]) in [2,3] :
         new_clusters = np.concatenate([
@@ -25,13 +33,10 @@ def _update_clusters(new_clusters: np.ndarray, spots: np.ndarray, voxel_size, cl
     assert len(new_clusters[0]) == 4 or len(new_clusters[0]) == 5, "Wrong number of coordinates for clusters should not happen."
     
     # Update spots clusters
-    if len(voxel_size) == 3 :
-        new_clusters[:,-2] = spots_multicolocalisation(new_clusters[:,:3], spots, radius_nm= cluster_size, voxel_size=voxel_size, image_shape=shape)
-    elif len(voxel_size) == 2 :
-        new_clusters[:,-2] = spots_multicolocalisation(new_clusters[:,:2], spots, radius_nm= cluster_size, voxel_size=voxel_size, image_shape=shape)
+    new_clusters[:,-2] = spots_multicolocalisation(new_clusters[:,:-2], spots, radius_nm= cluster_size, voxel_size=voxel_size, image_shape=shape)
 
     # delete too small clusters
-        new_clusters = np.delete(new_clusters, new_clusters[:,-2] < min_spot_number, 0)
+    new_clusters = np.delete(new_clusters, new_clusters[:,-2] == 0, 0)
 
     return new_clusters
 
@@ -98,13 +103,16 @@ def correct_spots(image, spots, voxel_size= (1,1,1), clusters= None, cluster_siz
     new_spots = np.array(Viewer.layers['single spots'].data, dtype= int)
 
     if type(clusters) != type(None) :
-        if len(clusters) > 0 : 
-            new_clusters = np.array(Viewer.layers['foci'].data, dtype= int)
-            new_clusters = _update_clusters(new_clusters, new_spots, voxel_size=voxel_size, cluster_size=cluster_size, min_spot_number=min_spot_number, shape=image.shape)
+        new_clusters = np.array(Viewer.layers['foci'].data, dtype= int)
+        new_clusters = _update_clusters(new_clusters, new_spots, voxel_size=voxel_size, cluster_size=cluster_size, shape=image.shape)
     else : new_clusters = None
 
     return new_spots, new_clusters
 
+# Segmentation
+    
+
+
 def show_segmentation(
         nuc_image : np.ndarray,
         nuc_label : np.ndarray,
@@ -135,26 +143,40 @@ def show_segmentation(
             )
 
     #Init Napari viewer
-    Viewer = napari.Viewer(ndisplay=2, title= 'Show segmentation', axis_labels=['z','y','x'] if dim == 3 else ['y', 'x'], show= False)
+    Viewer = napari.Viewer(ndisplay=2, title= 'Show segmentation', axis_labels=['z','y','x'] if dim == 3 else ['y', 'x'])
     
-    # Adding channels
+    # Adding nuclei
     nuc_signal_layer = Viewer.add_image(nuc_image, name= "nucleus signal", blending= 'additive', colormap='blue', contrast_limits=[nuc_image.min(), nuc_image.max()])
-    nuc_label_layer = Viewer.add_labels(nuc_label, opacity= 0.5, blending= 'additive', name= 'nucleus_label',)
+    nuc_label_layer = Viewer.add_labels(nuc_label, opacity= 0.6, name= 'nucleus_label',)
     nuc_label_layer.preserve_labels = True
+    labels_layer_list = [nuc_label_layer]
     
-    #Adding labels
-    if type(cyto_image) != type(None) : Viewer.add_image(cyto_image, name= "cytoplasm signal", blending= 'additive', colormap='red', contrast_limits=[cyto_image.min(), cyto_image.max()])
+    #Adding cytoplasm
     if (type(cyto_label) != type(None) and not np.array_equal(cyto_label, nuc_label) ) or (type(cyto_label) != type(None) and cyto_label.max() == 0): 
-        cyto_label_layer = Viewer.add_labels(cyto_label, opacity= 0.4, blending= 'additive', name= 'cytoplasm_label')
+        Viewer.add_image(cyto_image, name= "cytoplasm signal", blending= 'additive', colormap='red', contrast_limits=[cyto_image.min(), cyto_image.max()])
+        cyto_label_layer = Viewer.add_labels(cyto_label, opacity= 0.6, name= 'cytoplasm_label')
         cyto_label_layer.preserve_labels = True
-    
+        labels_layer_list += [cyto_label_layer]
+
+    #Adding widget
+    label_eraser = cell_label_eraser(labels_layer_list)
+    label_picker = free_label_picker(labels_layer_list)
+    label_reseter = segmentation_reseter(labels_layer_list)
+    changes_applier = changes_propagater(labels_layer_list)
+
+    buttons_container = widgets.Container(widgets=[label_picker.widget, changes_applier.widget, label_reseter.widget], labels=False, layout='horizontal')
+    tools_container = widgets.Container(
+        widgets = [buttons_container, label_eraser.widget],
+        labels=False,
+    )
+    Viewer.window.add_dock_widget(tools_container, name='SmallFish', area='left')
+
     #Launch Napari
-    Viewer.show(block=False)
     napari.run()
 
-
     new_nuc_label = Viewer.layers['nucleus_label'].data
-    if type(cyto_label) != type(None) and not np.array_equal(cyto_label, nuc_label) : new_cyto_label = Viewer.layers['cytoplasm_label'].data
+    if 'cytoplasm_label' in Viewer.layers : 
+        new_cyto_label = Viewer.layers['cytoplasm_label'].data
     else : new_cyto_label = new_nuc_label
 
     return new_nuc_label, new_cyto_label

small_fish_gui/gui/prompts.py

@@ -136,8 +136,8 @@ def output_image_prompt(filename) :
         excel_filename = values['filename'] + ".xlsx"
         feather_filename = values['filename'] + ".feather"
 
-        if not values['Excel'] and not values['Feather'] :
-            sg.popup("Please check at least one box : Excel/Feather")
+        if not values['Excel'] and not values['Feather'] and not values['csv'] :
+            sg.popup("Please check at least one box : Excel/Feather/csv")
             relaunch = True
         elif not os.path.isdir(values['folder']) :
             sg.popup("Incorrect folder")
@@ -280,7 +280,7 @@ def _warning_popup(warning:str) :
 
 def _sumup_df(results: pd.DataFrame) :
 
-    COLUMNS = ['acquisition_id','threshold', 'spot_number', 'cell_number', 'filename', 'channel to compute']
+    COLUMNS = ['acquisition_id','name','threshold', 'spot_number', 'cell_number', 'filename', 'channel to compute']
 
     if len(results) > 0 :
         if 'channel to compute' not in results : results['channel to compute'] = np.NaN
@@ -303,7 +303,7 @@ def hub_prompt(fov_results, do_segmentation=False) :
         [sg.Text('RESULTS', font= 'bold 13')],
         [sg.Table(values= list(sumup_df.values), headings= list(sumup_df.columns), row_height=20, num_rows= 5, vertical_scroll_only=False, key= "result_table"), segmentation_object],
         [sg.Button('Add detection'), sg.Button('Compute colocalisation'), sg.Button('Batch detection')],
-        [sg.Button('Save results', button_color= 'green'), sg.Button('Delete acquisitions',button_color= 'gray'), sg.Button('Reset segmentation',button_color= 'gray'), sg.Button('Reset results',button_color= 'gray')]
+        [sg.Button('Rename acquisition', button_color= 'green'), sg.Button('Save results', button_color= 'green'), sg.Button('Delete acquisitions',button_color= 'gray'), sg.Button('Reset segmentation',button_color= 'gray'), sg.Button('Reset results',button_color= 'gray')]
         # [sg.Button('Save results', button_color= 'green'), sg.Button('Reset results',button_color= 'gray')]
     ]
 
@@ -318,16 +318,20 @@ def hub_prompt(fov_results, do_segmentation=False) :
             return event, values
 
 def coloc_prompt() :
-    layout = [
-        [parameters_layout(['colocalisation distance'], header= 'Colocalisation', default_values= 0)]
-    ]
-
+    layout = parameters_layout(['colocalisation distance'], unit= 'nm', header= 'Colocalisation', default_values= 0)
     event, values = prompt_with_help(layout)
 
     if event == 'Ok' :
         return values['colocalisation distance']
     else : return False
 
+def rename_prompt() :
+    layout = parameters_layout(['name'], header= "Rename acquisitions", size=12)
+    event, values = prompt_with_help(layout)
+    if event == 'Ok' :
+        return values['name']
+    else : return False
+
 def ask_detection_confirmation(used_threshold) :
     layout = [
         [sg.Text("Proceed with current detection ?", font= 'bold 10')],

small_fish_gui/interface/output.py

@@ -10,11 +10,9 @@ def _cast_spot_to_tuple(spot) :
 def _cast_spots_to_tuple(spots) :
     return tuple(list(map(_cast_spot_to_tuple, spots)))
 
-def write_results(dataframe: pd.DataFrame, path:str, filename:str, do_excel= True, do_feather= False, do_csv=False, overwrite=False) :
+def write_results(dataframe: pd.DataFrame, path:str, filename:str, do_excel= True, do_feather= False, do_csv=False, overwrite=False, reset_index=True) :
     check_parameter(dataframe= pd.DataFrame, path= str, filename = str, do_excel = bool, do_feather = bool)
 
-    dataframe.columns = dataframe.columns.astype(str) # assert columns header are string for feather
-
     if len(dataframe) == 0 : return True
     if not do_excel and not do_feather and not do_csv : 
         return False
@@ -22,6 +20,14 @@ def write_results(dataframe: pd.DataFrame, path:str, filename:str, do_excel= Tru
     if not path.endswith('/') : path +='/'
     assert os.path.isdir(path)
 
+    #Casting cols name to str for feather format
+    index_dim = dataframe.columns.nlevels
+    if index_dim == 1 :
+        dataframe.columns = dataframe.columns.astype(str)
+    else :
+        casted_cols = [dataframe.columns.get_level_values(level).astype(str) for level in range(index_dim)]
+        casted_cols = zip(*casted_cols)
+        dataframe.columns = pd.MultiIndex.from_tuples(casted_cols)
 
     new_filename = filename
     i= 1
@@ -31,23 +37,21 @@ def write_results(dataframe: pd.DataFrame, path:str, filename:str, do_excel= Tru
             new_filename = filename + '_{0}'.format(i)
             i+=1
 
-    if 'image' in dataframe.columns :
-        dataframe = dataframe.drop(['image'], axis=1)
+    COLUMNS_TO_DROP = ['image', 'spots', 'clusters', 'rna_coords', 'cluster_coords']
+    for col in COLUMNS_TO_DROP :
+        dataframe = dataframe.drop(columns=col)
 
-    if 'spots' in dataframe.columns : 
-        dataframe = dataframe.drop(['spots'], axis= 1)
-        
-    if 'clusters' in dataframe.columns : 
-        dataframe = dataframe.drop(['clusters'], axis= 1)
+    if reset_index : dataframe = dataframe.reset_index(drop=True)
 
-    if do_feather : dataframe.reset_index(drop=True).to_feather(path + new_filename + '.feather')
-    if do_csv : dataframe.reset_index(drop=True).to_csv(path + new_filename + '.csv', sep=";")
+    if do_csv : dataframe.to_csv(path + new_filename + '.csv', sep=";")
     if do_excel : 
         if len(dataframe) < MAX_LEN_EXCEL :
-            dataframe.reset_index(drop=True).to_excel(path + new_filename + '.xlsx')
+            dataframe.to_excel(path + new_filename + '.xlsx')
         else : 
             print("Error : Table too big to be saved in excel format.")
             return False
     
+    if do_feather : 
+        dataframe.to_parquet(path + new_filename + '.parquet')
 
-    return True
+    return True

small_fish_gui/pipeline/_colocalisation.py

@@ -79,7 +79,7 @@ def spots_multicolocalisation(spots_list, anchor_list, radius_nm, image_shape, v
     Example in 2D
     --------
 
-    >>> Anchors         Spots           Radius (2px)    Count
+    >>> Anchors         spots           Radius (2px)    Count
     >>> 0 0 0 0 0 0     0 X 0 0 X 0       1             0 1 0 0 0 0
     >>> 0 X 0 0 0 0     X 0 0 X 0 0     1 1 1           1 0 0 0 0 0
     >>> 0 X 0 0 0 0     X X 0 0 0 0       1             1 2 0 0 0 0     --> 5
@@ -116,7 +116,7 @@ def spots_multicolocalisation(spots_list, anchor_list, radius_nm, image_shape, v
 
     return res
 
-def spots_colocalisation(image_shape, spot_list1:list, spot_list2:list, distance: float, voxel_size)-> int :
+def spots_colocalisation(spot_list1:list, spot_list2:list, distance: float, voxel_size)-> int :
     """
     Return number of spots from spot_list1 located closer(large) than distance to at least one spot of spot_list2.
 
@@ -134,10 +134,9 @@ def spots_colocalisation(image_shape, spot_list1:list, spot_list2:list, distance
     if len(spot_list1[0]) != len(spot_list2[0]) : 
         raise MissMatchError("dimensionalities of spots 1 and spots 2 don't match.")
     
-    if len(voxel_size) == 3 :
-        image_shape = image_shape[-3:]
-    else : 
-        image_shape = image_shape[-2:]
+    shape1 = np.max(spot_list1,axis=0)
+    shape2 = np.max(spot_list2,axis=0)
+    image_shape = np.max([shape1, shape2],axis=0) + 1
 
     signal2 = reconstruct_boolean_signal(image_shape, spot_list2)
     mask = np.logical_not(signal2)
@@ -173,8 +172,7 @@ def initiate_colocalisation(result_tables) :
                 break
         return colocalisation_distance
 
-@add_default_loading
-def launch_colocalisation(result_tables, result_dataframe, colocalisation_distance) :
+def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisation_distance) :
     """
 
     Target :
@@ -190,8 +188,10 @@ def launch_colocalisation(result_tables, result_dataframe, colocalisation_distan
 
     """
 
-    acquisition1 = result_dataframe.iloc[result_tables[0]]
-    acquisition2 = result_dataframe.iloc[result_tables[1]]
+    acquisition1 = result_dataframe.loc[result_dataframe['acquisition_id'] == acquisition_id1]
+    acquisition2 = result_dataframe.loc[result_dataframe['acquisition_id'] == acquisition_id2]
+
+    acquisition_couple = (acquisition_id1,acquisition_id2)
 
     voxel_size1 = acquisition1.at['voxel_size']
     voxel_size2 = acquisition2.at['voxel_size']
@@ -208,7 +208,6 @@ def launch_colocalisation(result_tables, result_dataframe, colocalisation_distan
     else :
         shape = shape1
 
-    acquisition_couple = (acquisition1.at['acquisition_id'], acquisition2.at['acquisition_id'])
 
     spots1 = acquisition1['spots']
     spots2 = acquisition2['spots']
@@ -217,8 +216,8 @@ def launch_colocalisation(result_tables, result_dataframe, colocalisation_distan
     spot2_total = len(spots2)
 
     try :
-        fraction_spots1_coloc_spots2 = spots_colocalisation(image_shape=shape, spot_list1=spots1, spot_list2=spots2, distance= colocalisation_distance, voxel_size=voxel_size) / spot1_total
-        fraction_spots2_coloc_spots1 = spots_colocalisation(image_shape=shape, spot_list1=spots2, spot_list2=spots1, distance= colocalisation_distance, voxel_size=voxel_size) / spot2_total
+        fraction_spots1_coloc_spots2 = spots_colocalisation(spot_list1=spots1, spot_list2=spots2, distance= colocalisation_distance, voxel_size=voxel_size) / spot1_total
+        fraction_spots2_coloc_spots1 = spots_colocalisation(spot_list1=spots2, spot_list2=spots1, distance= colocalisation_distance, voxel_size=voxel_size) / spot2_total
     except MissMatchError as e :
         sg.popup(str(e))
         fraction_spots1_coloc_spots2 = np.NaN
@@ -227,11 +226,11 @@ def launch_colocalisation(result_tables, result_dataframe, colocalisation_distan
     if 'clusters' in acquisition1.index :
         try : 
             clusters1 = acquisition1['clusters'][:,:len(voxel_size)]
-            fraction_spots2_coloc_cluster1 = spots_colocalisation(image_shape=shape, spot_list1=spots2, spot_list2=clusters1, distance= colocalisation_distance, voxel_size=voxel_size) / spot2_total
+            fraction_spots2_coloc_cluster1 = spots_colocalisation(spot_list1=spots2, spot_list2=clusters1, distance= colocalisation_distance, voxel_size=voxel_size) / spot2_total
         except MissMatchError as e :
             sg.popup(str(e))
             fraction_spots2_coloc_cluster1 = np.NaN
-        except TypeError : # Clusters not computed
+        except TypeError : # clusters not computed
             fraction_spots2_coloc_cluster1 = np.NaN
 
 
@@ -240,8 +239,8 @@ def launch_colocalisation(result_tables, result_dataframe, colocalisation_distan
     if 'clusters' in acquisition2.index :
         try :
             clusters2 = acquisition2['clusters'][:,:len(voxel_size)]
-            fraction_spots1_coloc_cluster2 = spots_colocalisation(image_shape=shape, spot_list1=spots1, spot_list2=clusters2, distance= colocalisation_distance, voxel_size=voxel_size) / spot1_total
-        except MissMatchError as e :# Clusters not computed
+            fraction_spots1_coloc_cluster2 = spots_colocalisation(spot_list1=spots1, spot_list2=clusters2, 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
         except TypeError :
@@ -263,4 +262,168 @@ def launch_colocalisation(result_tables, result_dataframe, colocalisation_distan
         'fraction_spots1_coloc_cluster2' : [fraction_spots1_coloc_cluster2],
     })
 
-    return coloc_df
+    coloc_df['fraction_spots1_coloc_free2'] = coloc_df['fraction_spots1_coloc_spots2'] - coloc_df['fraction_spots1_coloc_cluster2']
+    coloc_df['fraction_spots2_coloc_free1'] = coloc_df['fraction_spots2_coloc_spots1'] - coloc_df['fraction_spots2_coloc_cluster1']
+
+    #Add names
+    coloc_df_col = list(coloc_df.columns)
+    coloc_df['name1'] = acquisition1.at['name']
+    coloc_df['name2'] = acquisition2.at['name']
+    coloc_df = coloc_df.loc[:,['name1','name2'] + coloc_df_col]
+
+    return coloc_df
+
+def _cell_coloc(
+        acquisition_id1: int,
+        acquisition_id2: int,
+        result_dataframe : pd.DataFrame, 
+        cell_dataframe : pd.DataFrame, 
+        colocalisation_distance : float,
+        ) :
+    
+    acquisition1 = result_dataframe.loc[result_dataframe['acquisition_id'] == acquisition_id1]
+    acquisition2 = result_dataframe.loc[result_dataframe['acquisition_id'] == acquisition_id2]
+
+    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)
+
+    #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.")
+    voxel_size = result_dataframe.at[acquisition_id1, 'voxel_size']
+
+    #Selecting relevant cells in Cell table
+    cell_dataframe = cell_dataframe.loc[(cell_dataframe['acquisition_id'] == acquisition_id1)|(cell_dataframe['acquisition_id'] == acquisition_id2)]
+
+    #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'])
+    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(
+        lambda x: spots_colocalisation(
+            spot_list1= x[(acquisition_name_id1,acquisition_id1)],
+            spot_list2= x[(acquisition_name_id2,acquisition_id2)],
+            distance=colocalisation_distance,
+            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_to_spots_count",coloc_name,"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)],
+            distance=colocalisation_distance,
+            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)
+
+    if acquisition2['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(
+                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,
+                    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)
+        
+    if acquisition1['Cluster computation'].iat[0] :
+        if len(acquisition1['clusters'].iat[0]) > 0 :
+            colocalisation_df[("spots_to_clusters_count",coloc_name,"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,
+                    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['Cluster computation'].iat[0]  and acquisition1['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(
+                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, 
+                    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[("clusters_to_clusters_count",coloc_name,"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, 
+                    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 = 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)
+    colocalisation_df = colocalisation_df.drop('rna_coords', axis=1)
+
+    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) :
+    
+    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 cell_result_dataframe['acquisition_id'] and acquisition_id2 in cell_result_dataframe['acquisition_id'] :
+        print("Launching cell to cell colocalisation.")
+        new_coloc = _cell_coloc(
+            acquisition_id1 = acquisition_id1,
+            acquisition_id2 = acquisition_id2,
+            result_dataframe = 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)
+
+
+    else :
+        print("Launching global colocalisation.")
+        new_coloc = _global_coloc(
+            acquisition_id1=acquisition_id1,
+            acquisition_id2=acquisition_id2,
+            result_dataframe=result_dataframe,
+            colocalisation_distance=colocalisation_distance,
+        )
+        global_coloc_df = pd.concat([
+            global_coloc_df,
+            new_coloc,
+        ], axis=0).reset_index(drop=True)
+
+
+    return global_coloc_df, cell_coloc_df

small_fish_gui/pipeline/_segmentation.py

@@ -7,7 +7,7 @@ from skimage.measure import label
 from ..gui.layout import _segmentation_layout
 from ..gui import prompt, prompt_with_help, ask_cancel_segmentation
 from ..interface import open_image
-from ._napari_wrapper import show_segmentation as napari_show_segmentation
+from ..gui.napari import show_segmentation as napari_show_segmentation
 from .utils import from_label_get_centeroidscoords
 from matplotlib.colors import ListedColormap
 
@@ -149,7 +149,7 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
                             relaunch=True
                             values['other_nucleus_image'] = user_parameters.setdefault('other_nucleus_image', None)
                         
-                        elif nucleus_image.shape != image[cytoplasm_channel] :
+                        elif nucleus_image.shape != image[cytoplasm_channel].shape :
                             sg.popup("Nucleus image shape missmatched. Expected same shape as cytoplasm_image \ncytoplasm shape : {0}, nucleus shape : {1}".format(image[cytoplasm_channel].shape, nucleus_image.shape))
                             nucleus_image = None
                             relaunch=True

small_fish_gui/pipeline/actions.py

@@ -2,7 +2,7 @@
 This submodule groups all the possible actions of the user in the main windows. It is the start of each action the user can do.
 """
 
-from ..gui.prompts import output_image_prompt, ask_detection_confirmation, ask_cancel_detection
+from ..gui.prompts import output_image_prompt, ask_detection_confirmation, ask_cancel_detection, rename_prompt
 from ..interface.output import write_results
 from ._preprocess import map_channels, prepare_image_detection, reorder_shape, reorder_image_stack
 from .detection import ask_input_parameters, initiate_detection, launch_detection, launch_features_computation, get_nucleus_signal
@@ -118,7 +118,7 @@ def add_detection(user_parameters, segmentation_done, acquisition_id, cytoplasm_
     )
     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) :
+def save_results(result_df, cell_result_df, global_coloc_df, cell_coloc_df) :
     if len(result_df) != 0 :
         dic = output_image_prompt(filename=result_df.iloc[0].at['filename'])
 
@@ -128,34 +128,46 @@ def save_results(result_df, cell_result_df, coloc_df) :
             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')
+
             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(coloc_df, path= path, filename=filename + '_coloc_result', do_excel= do_excel, do_feather= do_feather, do_csv=do_csv)
-            if sucess1 and sucess2 and sucess3 : sg.popup("Sucessfully saved at {0}.".format(path))
+            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)
+            if all([sucess1,sucess2, 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) :
+def compute_colocalisation(result_tables, result_dataframe, cell_result_dataframe, global_coloc_df, cell_coloc_df) :
     colocalisation_distance = initiate_colocalisation(result_tables)
 
     if colocalisation_distance == False :
-        res_coloc = pd.DataFrame() # popup handled in initiate_colocalisation
+        pass
     else :
-        res_coloc = launch_colocalisation(result_tables, result_dataframe=result_dataframe, colocalisation_distance=colocalisation_distance)
+        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,
+            )
 
-    return res_coloc
+    return global_coloc_df, cell_coloc_df
 
 def delete_acquisitions(selected_acquisitions : pd.DataFrame, 
                         result_df : pd.DataFrame, 
                         cell_result_df : pd.DataFrame, 
-                        coloc_df : pd.DataFrame
+                        global_coloc_df : pd.DataFrame,
+                        cell_coloc_df : pd.DataFrame,
                         ) :
     
     if len(result_df) == 0 :
         sg.popup("No acquisition to delete.")
-        return result_df, cell_result_df, coloc_df
+        return result_df, cell_result_df, global_coloc_df
 
     if len(selected_acquisitions) == 0 :
         sg.popup("Please select the acquisitions you would like to delete.")
@@ -169,11 +181,62 @@ def delete_acquisitions(selected_acquisitions : pd.DataFrame,
             print("{0} cells deleted.".format(len(cell_result_df_drop_idx)))
             cell_result_df = cell_result_df.drop(cell_result_df_drop_idx, axis=0)
         
-        if len(coloc_df) > 0 :
-            coloc_df_drop_idx = coloc_df[(coloc_df["acquisition_id_1"].isin(acquisition_ids)) | (coloc_df['acquisition_id_2'].isin(acquisition_ids))].index
+        if len(global_coloc_df) > 0 :
+            coloc_df_drop_idx = global_coloc_df[(global_coloc_df["acquisition_id_1"].isin(acquisition_ids)) | (global_coloc_df['acquisition_id_2'].isin(acquisition_ids))].index
             print("{0} coloc measurement deleted.".format(len(coloc_df_drop_idx)))
-            coloc_df = coloc_df.drop(coloc_df_drop_idx, axis=0)
+            global_coloc_df = global_coloc_df.drop(coloc_df_drop_idx, axis=0)
+        
+        if len(cell_coloc_df) > 0 :
+            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)
 
         result_df = result_df.drop(result_drop_idx, axis=0)
 
-    return result_df, cell_result_df, coloc_df
+    return result_df, cell_result_df, global_coloc_df, cell_coloc_df
+
+def rename_acquisitions(
+        selected_acquisitions : pd.DataFrame, 
+        result_df : pd.DataFrame, 
+        cell_result_df : pd.DataFrame, 
+        global_coloc_df : pd.DataFrame,
+        cell_coloc_df : pd.DataFrame,
+        ) :
+    
+    if len(result_df) == 0 :
+        sg.popup("No acquisition to rename.")
+        return result_df, cell_result_df, global_coloc_df
+    
+    if len(selected_acquisitions) == 0 :
+        sg.popup("Please select the acquisitions you would like to rename.")
+
+    else :
+        name = rename_prompt()
+        if not name : return result_df, cell_result_df, global_coloc_df #User didn't put a name or canceled
+        name : str = name.replace(' ','_')
+        acquisition_ids = list(result_df.iloc[list(selected_acquisitions)]['acquisition_id'])
+        old_names = list(result_df.loc[result_df['acquisition_id'].isin(acquisition_ids)]['name'])
+        old_names.sort(key=len) #We order this list by elmt length
+        old_names.reverse() #From longer to smaller
+
+        result_df.loc[result_df['acquisition_id'].isin(acquisition_ids),['name']] = name
+        if len(cell_result_df) > 0 : cell_result_df.loc[cell_result_df['acquisition_id'].isin(acquisition_ids),['name']] = name
+        if len(global_coloc_df) > 0 : 
+            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),
+            )
+
+            cell_coloc_df.columns = pd.MultiIndex.from_tuples(new_columns)
+
+    return result_df, cell_result_df, global_coloc_df, cell_coloc_df

small_fish_gui/pipeline/detection.py

@@ -1,10 +1,11 @@
 """
 Contains code to handle detection as well as bigfish wrappers related to spot detection.
 """
+
 from ._preprocess import ParameterInputError
 from ._preprocess import check_integrity, convert_parameters_types
 from ._signaltonoise import compute_snr_spots
-from ._napari_wrapper import correct_spots, _update_clusters, threshold_selection
+from ..gui.napari import correct_spots, _update_clusters, threshold_selection
 from ..gui import add_default_loading
 from ..gui import detection_parameters_promt, input_image_prompt
 from ..utils import compute_anisotropy_coef
@@ -486,6 +487,7 @@ 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']
 
     result_frame = pd.DataFrame()
 
@@ -565,6 +567,7 @@ 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]
         
         result_frame = pd.concat([
             result_frame,
@@ -575,8 +578,6 @@ def launch_cell_extraction(acquisition_id, spots, clusters, image, nucleus_signa
     
     return result_frame
 
-
-
 @add_default_loading
 def launch_clustering(spots, user_parameters): 
 
@@ -633,7 +634,7 @@ def launch_detection(
         
     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'], min_spot_number= user_parameters['min number of spots'], shape=image.shape)
+        clusters = _update_clusters(clusters, spots, voxel_size=user_parameters['voxel_size'], cluster_size=user_parameters['cluster size'], shape=image.shape)
 
     else : clusters = None
 
@@ -694,6 +695,16 @@ def launch_features_computation(acquisition_id, image, nucleus_signal, spots, cl
     frame_results['threshold'] = user_parameters['threshold']
 
     frame_results = pd.DataFrame(columns= frame_results.keys(), data= (frame_results.values(),))
+
+    #Adding name column
+    result_col = list(frame_results.columns)
+    cell_result_col = list(cell_result_dframe.columns)
+    name = "acquisition_{0}".format(acquisition_id)
+    frame_results['name'] = name
+    cell_result_dframe['name'] = name
+    frame_results = frame_results.loc[:,['name'] + result_col]
+    cell_result_dframe = cell_result_dframe.loc[:,['name'] + cell_result_col]
+    cell_result_dframe['total_rna_number'] = cell_result_dframe['nb_rna_in_nuc'] + cell_result_dframe['nb_rna_out_nuc']
         
     return frame_results, cell_result_dframe
 

small_fish_gui/pipeline/main.py

@@ -5,7 +5,7 @@ This script is called when software starts; it is the main loop.
 import pandas as pd
 import PySimpleGUI as sg
 from ..gui import hub_prompt
-from .actions import add_detection, save_results, compute_colocalisation, delete_acquisitions
+from .actions import add_detection, save_results, compute_colocalisation, delete_acquisitions, rename_acquisitions
 from ._preprocess import clean_unused_parameters_cache
 from ..batch import batch_promp
 
@@ -14,15 +14,31 @@ user_parameters = dict() # Very important instance containg all choice from user
 acquisition_id = -1
 result_df = pd.DataFrame()
 cell_result_df = pd.DataFrame()
-coloc_df = pd.DataFrame()
+global_coloc_df = pd.DataFrame()
+cell_coloc_df = pd.DataFrame()
 segmentation_done = False
 cytoplasm_label = None
 nucleus_label = None
 
+#Use for dev purpose
+MAKE_NEW_SAVE = False
+PATH = "/home/floricslimani/Documents/small_fish_workshop/save"
+LOAD_SAVE = False
+
 while True : #Break this loop to close small_fish
-    result_df = result_df.reset_index(drop=True)
-    cell_result_df = cell_result_df.reset_index(drop=True)
-    coloc_df = coloc_df.reset_index(drop=True)
+
+    if LOAD_SAVE :
+        result_df = pd.read_csv(PATH + "/result.csv", sep='|')
+        cell_result_df = pd.read_csv(PATH + "/cell_result_df.csv", sep='|')
+        global_coloc_df = pd.read_csv(PATH + "/global_coloc_df.csv", sep='|')
+        cell_coloc_df = pd.read_csv(PATH + "/cell_coloc_df.csv", sep='|')
+
+
+    else :
+        result_df = result_df.reset_index(drop=True)
+        cell_result_df = cell_result_df.reset_index(drop=True)
+        global_coloc_df = global_coloc_df.reset_index(drop=True)
+        cell_coloc_df = cell_coloc_df.reset_index(drop=True)
     try :
         event, values = hub_prompt(result_df, segmentation_done)
 
@@ -43,25 +59,26 @@ while True : #Break this loop to close small_fish
             save_results(
                 result_df=result_df,
                 cell_result_df=cell_result_df,
-                coloc_df=coloc_df
+                global_coloc_df=global_coloc_df,
+                cell_coloc_df = cell_coloc_df,
             )
             
         elif event == 'Compute colocalisation' :
             result_tables = values.setdefault('result_table', []) #Contains the lines selected by the user on the sum-up array.
 
-            res_coloc= compute_colocalisation(
+            global_coloc_df, cell_coloc_df = compute_colocalisation(
                 result_tables,
-                result_dataframe=result_df
+                result_dataframe=result_df,
+                cell_result_dataframe=cell_result_df,
+                global_coloc_df=global_coloc_df,
+                cell_coloc_df=cell_coloc_df,
             )
 
-            coloc_df = pd.concat(
-                [coloc_df,res_coloc],
-                axis= 0)
-
         elif event == "Reset results" :
             result_df = pd.DataFrame()
             cell_result_df = pd.DataFrame()
-            coloc_df = pd.DataFrame()
+            global_coloc_df = pd.DataFrame()
+            cell_coloc_df = pd.DataFrame()
             acquisition_id = -1
             segmentation_done = False
             cytoplasm_label = None
@@ -74,7 +91,7 @@ while True : #Break this loop to close small_fish
 
         elif event == "Delete acquisitions" :
             selected_acquisitions = values.setdefault('result_table', []) #Contains the lines selected by the user on the sum-up array.
-            result_df, cell_result_df, coloc_df = delete_acquisitions(selected_acquisitions, result_df, cell_result_df, coloc_df)
+            result_df, cell_result_df, global_coloc_df, cell_coloc_df = delete_acquisitions(selected_acquisitions, result_df, cell_result_df, global_coloc_df, cell_coloc_df)
 
         elif event == "Batch detection" :
             result_df, cell_result_df, acquisition_id, user_parameters, segmentation_done, cytoplasm_label,nucleus_label = batch_promp(
@@ -84,8 +101,18 @@ while True : #Break this loop to close small_fish
                 preset=user_parameters,
             )
         
+        elif event == "Rename acquisition" :
+            selected_acquisitions = values.setdefault('result_table', []) #Contains the lines selected by the user on the sum-up array.
+            result_df, cell_result_df, global_coloc_df, cell_coloc_df = rename_acquisitions(selected_acquisitions, result_df, cell_result_df, global_coloc_df, cell_coloc_df)
+
         else :
             break
+        
+        if MAKE_NEW_SAVE :
+            result_df.reset_index(drop=True).to_csv(PATH + "/result.csv", sep='|')
+            cell_result_df.reset_index(drop=True).to_csv(PATH + "/cell_result_df.csv", sep='|')
+            cell_coloc_df.reset_index(drop=True).to_csv(PATH + "/cell_coloc_df.csv", sep='|')
+            global_coloc_df.reset_index(drop=True).to_csv(PATH + "/global_coloc_df.csv", sep='|')
 
     except Exception as error :
         sg.popup(str(error))

{small_fish_gui-1.5.0.dist-info → small_fish_gui-1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: small_fish_gui
-Version: 1.5.0
+Version: 1.7.0
 Summary: Small Fish is a python application for the analysis of smFish images. It provides a ready to use graphical interface to combine famous python packages for cell analysis without any need for coding.
 Project-URL: Homepage, https://github.com/2Echoes/small_fish
 Project-URL: Issues, https://github.com/2Echoes/small_fish/issues

{small_fish_gui-1.5.0.dist-info → small_fish_gui-1.7.0.dist-info}/RECORD

@@ -2,8 +2,8 @@ small_fish_gui/.readthedocs.yaml,sha256=r2T0e_In8X8l0_ZwgPvuoWQ9c0PE9bSpFzV2W6Ez
 small_fish_gui/LICENSE,sha256=-iFy8VGBYs5VsHglKpk4D-hxqQ2jMJaqmfq_ulIzDks,1303
 small_fish_gui/README.md,sha256=4RpEXKZW5vH6sUWeZb88yr1TLLPi20PqOk7KdA9O9Hk,4234
 small_fish_gui/Segmentation example.jpg,sha256=opfiSbjmfF6z8kBs08sg_FNR2Om0AcMPU5sSwSLHdoQ,215038
-small_fish_gui/__init__.py,sha256=odndmnYjkNSVx0dzWpIehR8-0L2wqayHUx20vUHm-kg,1941
-small_fish_gui/__main__.py,sha256=EzSCoJ7jpSdK-QbzUwQLGZeQWjybNeq8VnCBucA8MZw,1372
+small_fish_gui/__init__.py,sha256=LrR2v63vron8S_9kBcwoaenFnNYVYCOplKKCph3b-ks,1941
+small_fish_gui/__main__.py,sha256=jjFNnf-l4jCJI16epq2KOaKmgtUAe9lSNdPj5fpxrDk,1143
 small_fish_gui/napari_detection_example.png,sha256=l5EZlrbXemLiGqb5inSVsD6Kko1Opz528-go-fBfrw8,977350
 small_fish_gui/requirements.txt,sha256=9OMfUAnLdHevq6w_fVoDmVmkSMJeFofkOK_86_fu9C0,321
 small_fish_gui/utils.py,sha256=LM6QW2ono_LIRv7JXIIq7ZxxbDXqBtZ5uR9gjKJfwM8,1903
@@ -21,32 +21,33 @@ small_fish_gui/batch/values.py,sha256=C1hRlCpTIDsg89DMKIIW5NUxeK876ODRUuJ2D-mJv6
 small_fish_gui/batch/values.txt,sha256=PVxzIaaF6DGFRx_CMaStXZI6OrbjNub1-jR3pklXVjc,991
 small_fish_gui/docs/conf.py,sha256=6YU8UEpTenKGMiz7H4aG42Of72_n4uLadDfHJvziqRk,16
 small_fish_gui/gui/__init__.py,sha256=xQ_BfYcnQmKZtx_0leO4OmbkLNLv49ZPqEu_UXMgmDc,867
+small_fish_gui/gui/_napari_widgets.py,sha256=8IMppaPZU37ANdZwTZOhwqCEly0hokzYL7UIVIixGns,3022
 small_fish_gui/gui/animation.py,sha256=rnNP5FPp06Hu-R33c4AVTCknALBbxT2YlsKFCXHAp9k,981
 small_fish_gui/gui/general_help_screenshot.png,sha256=X4E6Td5f04K-pBUPDaBJRAE3D5b8fuEdiAUKhkIDr-0,54210
 small_fish_gui/gui/help_module.py,sha256=PmgkkDs7bZ2-po83A_PK9uldQcHjehYmqre21nYb6DQ,9600
 small_fish_gui/gui/layout.py,sha256=oB8Kg6s0rCA8yB4WM8JQY8BpjoPiBqTGb6YoOKDqEA8,13855
 small_fish_gui/gui/mapping_help_screenshot.png,sha256=HcuRh5TYciUogUasza5vZ_QSshaiHsskQK23mh9vQS8,34735
-small_fish_gui/gui/prompts.py,sha256=4QeYIqENmfffLv7255wVhG3N1tsOvRk33_r0prY11uY,13352
+small_fish_gui/gui/napari.py,sha256=XiahTyq7QEQAuF6EK3-e--3-A8yBPVn0oaVZZyJo0qo,8607
+small_fish_gui/gui/prompts.py,sha256=CONXMmSa0a-l93fyXAPz7h1skql0BEZtLzWJMVepPQ0,13660
 small_fish_gui/gui/segmentation_help_screenshot.png,sha256=rbSgIydT0gZtfMh1qk4mdMbEIyCaakvHmxa2eOrLwO0,118944
 small_fish_gui/interface/__init__.py,sha256=PB86R4Y9kV80aGZ-vP0ZW2KeaCwGbBbCtFCmbN2yl28,275
 small_fish_gui/interface/image.py,sha256=X1L7S5svxUwdoDcI3QM1PbN-c4Nz5w30hixq3IgqSn8,1130
-small_fish_gui/interface/output.py,sha256=5jC37tobgXgsiVJYx3RWaES09I-YFmbXKk65lHflTHc,1867
+small_fish_gui/interface/output.py,sha256=6dJuTZwFM1nZzAT8evif0tCnJZIJmtLyodQzSoA7Q_w,2060
 small_fish_gui/interface/parameters.py,sha256=lUugD-4W2TZyJF3TH1q70TlktEYhhPtcPCrvxm5Dk50,36
 small_fish_gui/interface/testing.py,sha256=MY5-GcPOUHagcrwR8A7QOjAmjZIDVC8Wz3NibLe3KQw,321
 small_fish_gui/pipeline/__init__.py,sha256=_Ey20GG8fJtqZvixbXNNYX6wTWMnCUArmARPqsNEhuQ,743
-small_fish_gui/pipeline/_colocalisation.py,sha256=peBw2Qz5m6wSejDkDz240UgvWl8ohNelrnmEgznbEsw,9635
+small_fish_gui/pipeline/_colocalisation.py,sha256=vVHDOvAfqaRFUuX-8HBtDLVrXgoSeUOxa19hmm7lllo,18978
 small_fish_gui/pipeline/_custom_errors.py,sha256=tQ-AUhgzIFpK30AZiQQrtHCHyGVRDdAoIjzL0Fk-1pA,43
-small_fish_gui/pipeline/_napari_wrapper.py,sha256=42c_PvKF8D_NW_CWysS4nZ2_Qp5vP9voaAH0bFJjJpc,8099
 small_fish_gui/pipeline/_preprocess.py,sha256=ddocTXwc0vYq2VGUbWYaN9eUiHPyfiCuBpYQ2p6rQ8g,13084
-small_fish_gui/pipeline/_segmentation.py,sha256=gcanidUOC9nULF6UffWLFmfIup-EOMxeckBz7Xldp3I,18852
+small_fish_gui/pipeline/_segmentation.py,sha256=bB7U_EhebFAssyZcGimnz706aNLbajVMOUj6nbVflwA,18854
 small_fish_gui/pipeline/_signaltonoise.py,sha256=7A9t7xu7zghI6cr201Ldm-LjJ5NOuP56VSeJ8KIzcUo,8497
-small_fish_gui/pipeline/actions.py,sha256=_egZlClWAeq6z2sEp2o031dL80ecmmGVDKwnouKTxkU,8185
-small_fish_gui/pipeline/detection.py,sha256=JpT6IDiwyzbMzi2CcBu96RWWwdNbwlXgkVWI4fSr_Mw,34429
-small_fish_gui/pipeline/main.py,sha256=igBR8cQ2H5xmpI2Q0w3DcAHt92wZSYxA0m217a7OG2c,3484
+small_fish_gui/pipeline/actions.py,sha256=JqcEYtVf3rr-YB_C8SF9U0dpoBktjUhm_Ko0FxZbxy4,11636
+small_fish_gui/pipeline/detection.py,sha256=ORs3OR7MYIz4l1GX3Ayjzpxp2poRnTHhoicJdF7XL_E,34976
+small_fish_gui/pipeline/main.py,sha256=0DrN9dXZJTqLOD0tZaHTVFE1oolzLPU1w5LNgWC3iuU,5072
 small_fish_gui/pipeline/spots.py,sha256=yHvqf1eD25UltELpzcouYXhLkxiXI_mOL1ANSzXK5pw,1907
 small_fish_gui/pipeline/test.py,sha256=w4ZMGDmUDXxVgWTlZ2TKw19W8q5gcE9gLMKe0SWnRrw,2827
 small_fish_gui/pipeline/utils.py,sha256=run6qtqCAe_mFnE3o1CnmF1xBBmK3ydgc8-jOV9P-_w,448
-small_fish_gui-1.5.0.dist-info/METADATA,sha256=TdTS-eCK_0wDVkBxz7RPNSUp2F9eYzoGwDIJpWawugY,2567
-small_fish_gui-1.5.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-small_fish_gui-1.5.0.dist-info/licenses/LICENSE,sha256=-iFy8VGBYs5VsHglKpk4D-hxqQ2jMJaqmfq_ulIzDks,1303
-small_fish_gui-1.5.0.dist-info/RECORD,,
+small_fish_gui-1.7.0.dist-info/METADATA,sha256=b8ALR98CI1iIaTsDQKGEQ-9Yu3hOAEekdYmOFUDzCQE,2567
+small_fish_gui-1.7.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+small_fish_gui-1.7.0.dist-info/licenses/LICENSE,sha256=-iFy8VGBYs5VsHglKpk4D-hxqQ2jMJaqmfq_ulIzDks,1303
+small_fish_gui-1.7.0.dist-info/RECORD,,