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

small_fish_gui/interface/__init__.py

@@ -7,4 +7,4 @@ from .image import get_filename
 from .image import check_format
 from .image import FormatError
 
-from .output import write_results
+from .inoutput import write_results

small_fish_gui/interface/image.py

@@ -19,10 +19,10 @@ def open_image(full_path:str) :
     return im
 
 
-def check_format(image, is_3D, is_time_stack, is_multichannel) :
+def check_format(image, is_3D, is_multichannel) :
     shape = list(image.shape)
     dim = image.ndim - (shape[image.ndim - 1] == 1)
-    if not dim == (2 + is_3D + is_time_stack + is_multichannel) :
+    if not dim == (2 + is_3D  + is_multichannel) :
         raise FormatError("Inconsistency in image format and parameters.")
 
 

small_fish_gui/interface/{output.py → inoutput.py}

@@ -1,6 +1,8 @@
 import os
 import pandas as pd
+import numpy as np
 from bigfish.stack import check_parameter
+from typing import Literal
 
 MAX_LEN_EXCEL = 1048576
 
@@ -33,13 +35,13 @@ def write_results(dataframe: pd.DataFrame, path:str, filename:str, do_excel= Tru
     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
 
     COLUMNS_TO_DROP = ['image', 'spots', 'clusters', 'rna_coords', 'cluster_coords']
     for col in COLUMNS_TO_DROP :
-        dataframe = dataframe.drop(columns=col)
+        if col in dataframe.columns : dataframe = dataframe.drop(columns=col)
 
     if reset_index : dataframe = dataframe.reset_index(drop=True)
 
@@ -55,3 +57,40 @@ def write_results(dataframe: pd.DataFrame, path:str, filename:str, do_excel= Tru
         dataframe.to_parquet(path + new_filename + '.parquet')
 
     return True
+
+def input_segmentation(
+        nucleus_path : str,
+        cytoplasm_path : str,
+) :
+    nucleus_label = np.load(nucleus_path)
+
+    if cytoplasm_path != '' :
+        cytoplasm_label = np.load(cytoplasm_path)
+    else : 
+        cytoplasm_label = nucleus_label
+
+    return nucleus_label, cytoplasm_label
+
+def output_segmentation(
+        path : str,
+        extension : Literal['npy', 'npz_uncompressed', 'npz_compressed'],
+        nucleus_label : np.ndarray,
+        cytoplasm_label : np.ndarray = None,
+) :
+    
+    saved = False
+    if extension == 'npy' :
+        save = np.save
+    elif extension == 'npz_uncompressed' :
+        save = np.savez
+    elif extension == 'npz_compressed' :
+        save = np.savez_compressed
+
+    if type(nucleus_label) != type(None) :
+        save(path + "_nucleus_segmentation", nucleus_label)
+        saved = True
+    
+    if type(cytoplasm_label) != type(None) :
+        save(path + "_cytoplasm_segmentation", cytoplasm_label)
+
+    return saved

small_fish_gui/interface/testing.py

@@ -1,8 +1,12 @@
-import imageio.v3 as iio
+import PySimpleGUI as sg
 
-path = '/home/flo/Documents/IGH projects/SohaQuantif/SCC/input/230723 n1 b-cat bac APC IF fitc ires neo smfish cy3 without puromycin-01.tif'
+layout = [
+    [sg.Radio(['A',], key='button', group_id=0, key='test1'),sg.Radio(['B'], key='button', group_id=0, key='test2'), sg.Radio(['C'], key='button', group_id=0, key='test3')],
+    [sg.Radio(['D',], key='button', group_id=1, key='test4')],
+    [sg.Button('Ok')]
+    ]
 
-props = iio.improps(path)
-meta = iio.immeta(path)
-print(props)
-print(meta['channels'], meta['slices'], meta['unit'], meta['hyperstack'], meta['spacing'])
+window = sg.Window(title= 'test', layout=layout)
+event, values = window.read()
+
+print(values)

small_fish_gui/pipeline/__init__.py

@@ -7,10 +7,10 @@ from ._preprocess import reorder_image_stack
 from ._preprocess import prepare_image_detection
 from ._preprocess import convert_parameters_types
 
-from ._segmentation import launch_segmentation
-from ._segmentation import _cast_segmentation_parameters
-from ._segmentation import cell_segmentation
-from ._segmentation import plot_segmentation
+from .segmentation import launch_segmentation
+from .segmentation import _cast_segmentation_parameters
+from .segmentation import cell_segmentation
+from .segmentation import plot_segmentation
 
 from .detection import launch_detection
 from .detection import launch_features_computation

small_fish_gui/pipeline/_colocalisation.py

@@ -191,12 +191,15 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
     acquisition1 = result_dataframe.loc[result_dataframe['acquisition_id'] == acquisition_id1]
     acquisition2 = result_dataframe.loc[result_dataframe['acquisition_id'] == acquisition_id2]
 
+    assert len(acquisition1) == 1
+    assert len(acquisition2) == 1
+
     acquisition_couple = (acquisition_id1,acquisition_id2)
 
-    voxel_size1 = acquisition1.at['voxel_size']
-    voxel_size2 = acquisition2.at['voxel_size']
-    shape1 = acquisition1.at['reordered_shape']
-    shape2 = acquisition2.at['reordered_shape']
+    voxel_size1 = acquisition1.iloc[0].at['voxel_size']
+    voxel_size2 = acquisition2.iloc[0].at['voxel_size']
+    shape1 = acquisition1.iloc[0].at['reordered_shape']
+    shape2 = acquisition2.iloc[0].at['reordered_shape']
 
     if voxel_size1 != voxel_size2 : 
         raise MissMatchError("voxel size 1 different than voxel size 2")
@@ -209,8 +212,8 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
         shape = shape1
 
 
-    spots1 = acquisition1['spots']
-    spots2 = acquisition2['spots']
+    spots1 = acquisition1.iloc[0].at['spots']
+    spots2 = acquisition2.iloc[0].at['spots']
 
     spot1_total = len(spots1)
     spot2_total = len(spots2)
@@ -225,7 +228,7 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
 
     if 'clusters' in acquisition1.index :
         try : 
-            clusters1 = acquisition1['clusters'][:,:len(voxel_size)]
+            clusters1 = acquisition1.iloc[0].at['clusters'][:,:len(voxel_size)]
             fraction_spots2_coloc_cluster1 = spots_colocalisation(spot_list1=spots2, spot_list2=clusters1, distance= colocalisation_distance, voxel_size=voxel_size) / spot2_total
         except MissMatchError as e :
             sg.popup(str(e))
@@ -238,7 +241,7 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
 
     if 'clusters' in acquisition2.index :
         try :
-            clusters2 = acquisition2['clusters'][:,:len(voxel_size)]
+            clusters2 = acquisition2.iloc[0].at['clusters'][:,:len(voxel_size)]
             fraction_spots1_coloc_cluster2 = spots_colocalisation(spot_list1=spots1, spot_list2=clusters2, distance= colocalisation_distance, voxel_size=voxel_size) / spot1_total
         except MissMatchError as e :# clusters not computed
             sg.popup(str(e))
@@ -267,8 +270,8 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
 
     #Add names
     coloc_df_col = list(coloc_df.columns)
-    coloc_df['name1'] = acquisition1.at['name']
-    coloc_df['name2'] = acquisition2.at['name']
+    coloc_df['name1'] = acquisition1.iloc[0].at['name']
+    coloc_df['name2'] = acquisition2.iloc[0].at['name']
     coloc_df = coloc_df.loc[:,['name1','name2'] + coloc_df_col]
 
     return coloc_df
@@ -333,7 +336,7 @@ def _cell_coloc(
         )
     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 acquisition2['do_cluster_computation'].iat[0] :
         if len(acquisition2['clusters'].iat[0]) > 0 :
 
             #spots to clusters
@@ -347,7 +350,7 @@ def _cell_coloc(
                 )
             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 acquisition1['do_cluster_computation'].iat[0] :
         if len(acquisition1['clusters'].iat[0]) > 0 :
             colocalisation_df[("spots_to_clusters_count",coloc_name,"backward")] = colocalisation_df.apply(
                 lambda x: spots_colocalisation(
@@ -359,7 +362,7 @@ def _cell_coloc(
                 )
             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 acquisition2['do_cluster_computation'].iat[0]  and acquisition1['do_cluster_computation'].iat[0] :
         if len(acquisition1['clusters'].iat[0]) > 0 and len(acquisition2['clusters'].iat[0]) > 0 :
             #clusters to clusters 
             colocalisation_df[("clusters_to_clusters_count",coloc_name,"forward")] = colocalisation_df.apply(
@@ -397,7 +400,7 @@ def launch_colocalisation(result_tables, result_dataframe, cell_result_dataframe
 
     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'] :
+    if acquisition_id1 in list(cell_result_dataframe['acquisition_id']) and acquisition_id2 in list(cell_result_dataframe['acquisition_id']) :
         print("Launching cell to cell colocalisation.")
         new_coloc = _cell_coloc(
             acquisition_id1 = acquisition_id1,
@@ -411,6 +414,8 @@ def launch_colocalisation(result_tables, result_dataframe, cell_result_dataframe
             new_coloc,
         ], axis=1).sort_index(axis=1, level=0)
 
+        cell_coloc_df.index = cell_coloc_df.index.rename('cell_id')
+
 
     else :
         print("Launching global colocalisation.")

small_fish_gui/pipeline/_preprocess.py

@@ -2,6 +2,7 @@ import numpy as np
 import os
 import PySimpleGUI as sg
 from ..gui import _error_popup, _warning_popup, parameters_layout, add_header, prompt, prompt_with_help
+from ..gui.prompts import input_image_prompt
 
 class ParameterInputError(Exception) :
     """
@@ -13,24 +14,24 @@ class MappingError(ValueError) :
     """
     Raised when user inputs an incorrect image mapping.
     """
-    def __init__(self, map ,*args: object) -> None:
+    def __init__(self, map_ ,*args: object) -> None:
         super().__init__(*args)
-        self.map = map
+        self.map_ = map_
 
     def get_map(self) :
-        return self.map
+        return self.map_
 
-def prepare_image_detection(map, user_parameters) :
+def prepare_image_detection(map_, user_parameters) :
     """
     Return monochannel image for ready for spot detection; 
     if image is already monochannel, nothing happens.
     else : image is the image on which detection is performed, other_image are the other layer to show in Napari Viewer.
     """
-    image = reorder_image_stack(map, user_parameters)
+    image = reorder_image_stack(map_, user_parameters['image'])
     assert len(image.shape) != 5 , "Time stack not supported, should never be True"
     
-    if user_parameters['multichannel'] :
-        channel_to_compute = user_parameters['channel to compute']
+    if user_parameters['is_multichannel'] :
+        channel_to_compute = user_parameters['channel_to_compute']
         other_image = image.copy()
         other_image = np.delete(other_image, channel_to_compute, axis=0)
         other_image = [layer for layer in other_image]
@@ -41,13 +42,12 @@ def prepare_image_detection(map, user_parameters) :
 
     return image, other_image
 
-def reorder_image_stack(map, user_parameters) :
-    image_stack = user_parameters['image']
-    x = (int(map['x']),)
-    y = (int(map['y']),)
-    z = (int(map['z']),) if type(map.get('z')) != type(None) else ()
-    c = (int(map['c']),) if type(map.get('c')) != type(None) else ()
-    t = (int(map['t']),) if type(map.get('t')) != type(None) else ()
+def reorder_image_stack(map_, image_stack) :
+    x = (int(map_['x']),)
+    y = (int(map_['y']),)
+    z = (int(map_['z']),) if type(map_.get('z')) != type(None) else ()
+    c = (int(map_['c']),) if type(map_.get('c')) != type(None) else ()
+    t = (int(map_['t']),) if type(map_.get('t')) != type(None) else ()
 
     source = t+c+z+y+x
 
@@ -62,20 +62,20 @@ def reorder_image_stack(map, user_parameters) :
 def map_channels(user_parameters) :
     
     image = user_parameters['image']
-    is_3D_stack = user_parameters['3D stack']
-    is_time_stack = user_parameters['time stack']
-    multichannel = user_parameters['multichannel']
+    is_3D_stack = user_parameters['is_3D_stack']
+    is_time_stack = False
+    multichannel = user_parameters['is_multichannel']
 
     try : 
-        map = _auto_map_channels(is_3D_stack, is_time_stack, multichannel, image=image)
+        map_ = _auto_map_channels(is_3D_stack, is_time_stack, multichannel, image=image)
     except MappingError as e :
         sg.popup("Automatic dimension mapping went wrong. Please indicate dimensions positions in the array.")
-        map = _ask_channel_map(image.shape, is_3D_stack, is_time_stack, multichannel, preset_map= e.get_map())
+        map_ = _ask_channel_map(image.shape, is_3D_stack, is_time_stack, multichannel, preset_map= e.get_map())
 
     else :
-        map = _show_mapping(image.shape, map, is_3D_stack, is_time_stack, multichannel,)
+        map_ = _show_mapping(image.shape, map_, is_3D_stack, is_time_stack, multichannel,)
 
-    return map
+    return map_
 
 def _auto_map_channels(is_3D_stack, is_time_stack, multichannel, image: np.ndarray=None, shape=None) :
     if type(shape) == type(None) :
@@ -85,7 +85,7 @@ def _auto_map_channels(is_3D_stack, is_time_stack, multichannel, image: np.ndarr
     #Set the biggest dimension to y
     y_val = max(reducing_list)
     y_idx = shape.index(y_val)
-    map = {'y' : y_idx}
+    map_ = {'y' : y_idx}
 
     #2nd biggest set to x
     reducing_list[y_idx] = -1
@@ -93,7 +93,7 @@ def _auto_map_channels(is_3D_stack, is_time_stack, multichannel, image: np.ndarr
     x_idx = reducing_list.index(x_val)
     reducing_list[y_idx] = y_val
 
-    map['x'] = x_idx
+    map_['x'] = x_idx
     reducing_list.remove(y_val)
     reducing_list.remove(x_val)
 
@@ -101,26 +101,26 @@ def _auto_map_channels(is_3D_stack, is_time_stack, multichannel, image: np.ndarr
     if multichannel :
         c_val = min(reducing_list)
         c_idx = shape.index(c_val)
-        map['c'] = c_idx
+        map_['c'] = c_idx
         reducing_list.remove(c_val)
 
     if is_time_stack :
         t_val = reducing_list[0]
         t_idx = shape.index(t_val)
-        map['t'] = t_idx
+        map_['t'] = t_idx
         reducing_list.remove(t_val)
     
     if is_3D_stack :
         z_val = reducing_list[0]
         z_idx = shape.index(z_val)
-        map['z'] = z_idx
+        map_['z'] = z_idx
 
-    total_channels = len(map)
-    unique_channel = len(np.unique(list(map.values())))
+    total_channels = len(map_)
+    unique_channel = len(np.unique(list(map_.values())))
 
-    if total_channels != unique_channel : raise MappingError(map,"{0} channel(s) are not uniquely mapped.".format(total_channels - unique_channel))
+    if total_channels != unique_channel : raise MappingError(map_,"{0} channel(s) are not uniquely mapped.".format(total_channels - unique_channel))
 
-    return map
+    return map_
 
 def _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map: dict= {}) :
     while True :
@@ -158,13 +158,13 @@ def _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map
 
     return preset_map
 
-def _show_mapping(shape, map, is_3D_stack, is_time_stack, multichannel) :
+def _show_mapping(shape, map_, is_3D_stack, is_time_stack, multichannel) :
     while True : 
         layout = [
             [sg.Text("Image shape : {0}".format(shape))],
             [sg.Text('Dimensions mapping was set to :')],
             [sg.Text('x : {0} \ny : {1} \nz : {2} \nc : {3} \nt : {4}'.format(
-                map['x'], map['y'], map.get('z'), map.get("c"), map.get('t')
+                map_['x'], map_['y'], map_.get('z'), map_.get("c"), map_.get('t')
             ))],
             [sg.Button('Change mapping')]
         ]
@@ -172,9 +172,9 @@ def _show_mapping(shape, map, is_3D_stack, is_time_stack, multichannel) :
         event, values = prompt_with_help(layout, help='mapping', add_scrollbar=False)
 
         if event == 'Ok' :
-            return map
+            return map_
         elif event == 'Change mapping':
-            map = _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map=map)
+            map_ = _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map=map_)
         elif event == 'Cancel' : 
             return None
         else : raise AssertionError('Unforseen event')
@@ -194,12 +194,12 @@ def convert_parameters_types(values:dict) :
     for tuple_parameter in tuples_list :
         try :
             tuple_values = tuple([float(values.get(tuple_parameter + '_{0}'.format(dimension))) for dimension in dim_tuple])
-        except Exception : #execption when str cannot be converted to float or no parameter was given.
+        except Exception as e : #execption when str cannot be converted to float or no parameter was given.
             values[tuple_parameter] = None
         else : values[tuple_parameter] = tuple_values
 
     #Parameters
-    int_list = ['threshold', 'channel_to_compute', 'channel to compute', 'min number of spots', 'cluster size','nucleus channel signal']
+    int_list = ['threshold', 'channel_to_compute', 'channel_to_compute', 'min number of spots', 'cluster size','nucleus channel signal']
     float_list = ['alpha', 'beta', 'gamma', 'threshold penalty']
 
     for parameter in int_list :
@@ -224,7 +224,7 @@ def check_integrity(
         do_clustering, 
         multichannel,
         segmentation_done, 
-        map, 
+        map_, 
         shape
         ):
     """
@@ -232,7 +232,9 @@ def check_integrity(
     """
 
     #voxel_size
-    if type(values['voxel_size']) == type(None) : raise ParameterInputError('Incorrect voxel size parameter.')
+    if type(values['voxel_size']) == type(None) : 
+        print(values['voxel_size'])
+        raise ParameterInputError('Incorrect voxel size parameter.')
     
     #detection integrity :
     if not isinstance(values['spot_size'], (tuple, list)) and not(isinstance(values['minimum_distance'], (tuple, list)) and isinstance(values['log_kernel_size'], (tuple, list))) :
@@ -257,7 +259,7 @@ def check_integrity(
 
     #channel
     if multichannel :
-        ch_len = shape[int(map['c'])]
+        ch_len = shape[int(map_['c'])]
 
         if type(segmentation_done) == type(None) :
             pass
@@ -270,12 +272,12 @@ def check_integrity(
             values['nucleus channel signal'] = nuc_signal_ch
 
         try :
-            ch = int(values['channel to compute'])
+            ch = int(values['channel_to_compute'])
         except Exception :
-            raise ParameterInputError("Incorrect channel to compute parameter.")
+            raise ParameterInputError("Incorrect channel_to_compute parameter.")
         if ch >= ch_len :
-            raise ParameterInputError("Channel to compute is out of range for image.\nPlease select from {0}".format(list(range(ch_len))))
-        values['channel to compute'] = ch
+            raise ParameterInputError("channel_to_compute is out of range for image.\nPlease select from {0}".format(list(range(ch_len))))
+        values['channel_to_compute'] = ch
 
     #Spot extraction
     if not os.path.isdir(values['spots_extraction_folder']) and values['spots_extraction_folder'] != '':
@@ -284,12 +286,12 @@ def check_integrity(
 
     return values
 
-def reorder_shape(shape, map) :
-    x = [int(map['x']),]
-    y = [int(map['y']),]
-    z = [int(map['z']),] if type(map.get('z')) != type(None) else []
-    c = [int(map['c']),] if type(map.get('c')) != type(None) else []
-    t = [int(map['t']),] if type(map.get('t')) != type(None) else []
+def reorder_shape(shape, map_) :
+    x = [int(map_['x']),]
+    y = [int(map_['y']),]
+    z = [int(map_['z']),] if type(map_.get('z')) != type(None) else []
+    c = [int(map_['c']),] if type(map_.get('c')) != type(None) else []
+    t = [int(map_['t']),] if type(map_.get('t')) != type(None) else []
 
     source = t + c + z + y + x
 
@@ -343,4 +345,50 @@ def clean_unused_parameters_cache(user_parameters: dict) :
             if type(user_parameters[parameter]) == type(None) :
                 del user_parameters[parameter]
     
-    return user_parameters
+    return user_parameters
+
+def ask_input_parameters(ask_for_segmentation=True) :
+    """
+    Prompt user with interface allowing parameters setting for bigFish detection / deconvolution.
+    """
+    
+    values = {}
+    image_input_values = {}
+    while True :
+        is_3D_preset = image_input_values.setdefault('is_3D_stack', False)
+        is_time_preset = image_input_values.setdefault('time stack', False)
+        is_multichannel_preset = image_input_values.setdefault('is_multichannel', False)
+        denseregion_preset = image_input_values.setdefault('do_dense_regions_deconvolution', False)
+        do_clustering_preset = image_input_values.setdefault('do_cluster_computation', False)
+        do_napari_preset = image_input_values.setdefault('show_napari_corrector', False)
+
+        if ask_for_segmentation :
+            image_input_values = input_image_prompt(
+                is_3D_stack_preset=is_3D_preset,
+                multichannel_preset=is_multichannel_preset,
+                do_dense_regions_deconvolution_preset=None,
+                do_clustering_preset= None,
+                do_Napari_correction=None,
+            )
+        else :
+            image_input_values = input_image_prompt(
+                is_3D_stack_preset=is_3D_preset,
+                multichannel_preset=is_multichannel_preset,
+                do_dense_regions_deconvolution_preset=denseregion_preset,
+                do_clustering_preset= do_clustering_preset,
+                do_Napari_correction=do_napari_preset,
+            )
+
+        if type(image_input_values) == type(None) :
+            return image_input_values
+
+        if 'image' in image_input_values.keys() :
+            image_input_values['shape'] = image_input_values['image'].shape 
+            break
+
+
+    values.update(image_input_values)
+    values['dim'] = 3 if values['is_3D_stack'] else 2
+    values['filename'] = os.path.basename(values['image path'])
+    
+    return values