small-fish-gui 1.6.0__py3-none-any.whl → 1.7.1__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.6.0"
+__version__ = "1.7.1"

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,11 +7,19 @@ 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 np.empty(shape=(0,2+len(voxel_size)))
 
@@ -28,7 +36,7 @@ def _update_clusters(new_clusters: np.ndarray, spots: np.ndarray, voxel_size, cl
     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
 
@@ -96,11 +104,15 @@ def correct_spots(image, spots, voxel_size= (1,1,1), clusters= None, cluster_siz
 
     if type(clusters) != type(None) :
         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 = _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,
@@ -131,21 +143,35 @@ 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

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")

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,32 +20,38 @@ 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
 
     if not overwrite :
-        while new_filename + '.xlsx' in os.listdir(path) or new_filename + '.feather' in os.listdir(path) or new_filename + '.csv' in os.listdir(path) :
+        while new_filename + '.xlsx' in os.listdir(path) or new_filename + '.parquet' in os.listdir(path) or new_filename + '.csv' in os.listdir(path) :
             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 :
+        if col in dataframe.columns : 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 :
@@ -272,4 +271,159 @@ def launch_colocalisation(result_tables, result_dataframe, colocalisation_distan
     coloc_df['name2'] = acquisition2.at['name']
     coloc_df = coloc_df.loc[:,['name1','name2'] + coloc_df_col]
 
-    return coloc_df
+    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

@@ -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,40 +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, 
-        coloc_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, 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 rename.")
 
     else :
         name = rename_prompt()
-        print("entered : ",name)
-        if not name : return result_df, cell_result_df, coloc_df #User didn't put a name or canceled
+        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(coloc_df) > 0 : 
-            coloc_df.loc[coloc_df['acquisition_id_1'].isin(acquisition_ids), ['name1']] = name
-            coloc_df.loc[coloc_df['acquisition_id_2'].isin(acquisition_ids), ['name2']] = 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, coloc_df
+    return result_df, cell_result_df, global_coloc_df, cell_coloc_df

small_fish_gui/pipeline/detection.py

@@ -5,7 +5,7 @@ Contains code to handle detection as well as bigfish wrappers related to spot de
 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
@@ -487,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()
 
@@ -566,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,
@@ -632,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
 
@@ -702,6 +704,7 @@ def launch_features_computation(acquisition_id, image, nucleus_signal, spots, cl
     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

@@ -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(
@@ -86,10 +103,16 @@ while True : #Break this loop to close small_fish
         
         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, coloc_df = rename_acquisitions(selected_acquisitions, result_df, cell_result_df, coloc_df)
+            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.6.0.dist-info → small_fish_gui-1.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: small_fish_gui
-Version: 1.6.0
+Version: 1.7.1
 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.6.0.dist-info → small_fish_gui-1.7.1.dist-info}/RECORD

@@ -2,7 +2,7 @@ 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=5p-W0XXzvadf_q5TZCbYLXaSLIBLOBlhwt7rTtg760w,1941
+small_fish_gui/__init__.py,sha256=a5xjNERakIQns7eLzivIHcpSK_YbhUvicolmTosN_ic,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
@@ -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=rdO2X_whpBgMzCrysFoJEUWfZwbC7mZOp_DYctftNT0,13634
+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=eMz9QXBf6LIWuNGvd6Z3Yswuz-Jg9pezUN3OJSb_MIg,2090
 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=pWyObNoACWNW04OYzKf7bgq2OezWpEWh7Vl5DShTI1A,10118
+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=Yjpo-uXQxLfLESsWr4kIBZgQNVXJtcTFcrsvS9sk4No,7832
 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=YGW7IFwtRksf0nktl5C2uVLP-Z-7vVznIBxIdJGZJZw,9447
-small_fish_gui/pipeline/detection.py,sha256=rnA0qMqr0dNUAUPd1ANYZ7dyfllsDQrihO_gjEpenvA,34817
-small_fish_gui/pipeline/main.py,sha256=7iBHO8xNEvdONaUo78jkShBkHFuwgGryMoI4YwP4coI,3817
+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.6.0.dist-info/METADATA,sha256=lNNHwO008d4nmzHaYpeNKi9DFptJ56O0GxfmxWiRxI4,2567
-small_fish_gui-1.6.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-small_fish_gui-1.6.0.dist-info/licenses/LICENSE,sha256=-iFy8VGBYs5VsHglKpk4D-hxqQ2jMJaqmfq_ulIzDks,1303
-small_fish_gui-1.6.0.dist-info/RECORD,,
+small_fish_gui-1.7.1.dist-info/METADATA,sha256=6RAZQN04nvJvaJkLSx3Hquu7YVuozCna6Qg60fmSb4w,2567
+small_fish_gui-1.7.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+small_fish_gui-1.7.1.dist-info/licenses/LICENSE,sha256=-iFy8VGBYs5VsHglKpk4D-hxqQ2jMJaqmfq_ulIzDks,1303
+small_fish_gui-1.7.1.dist-info/RECORD,,