small-fish-gui 1.3.4__py3-none-any.whl → 1.4.0__py3-none-any.whl

small_fish_gui/batch/values.txt

@@ -0,0 +1,65 @@
+List of keys for batch 'values' dict instance :
+
+Batch_folder 
+0
+image path 
+3D stack 
+multichannel 
+Dense regions deconvolution 
+Cluster computation 
+Segmentation 
+Napari correction 
+x 
+y 
+z 
+c 
+t 
+cyto_model_name 
+cytoplasm channel 
+cytoplasm diameter 
+nucleus_model_name 
+nucleus channel 
+nucleus diameter 
+Segment only nuclei 
+show segmentation 
+saving path 
+filename 
+threshold 
+threshold penalty 
+channel to compute 
+voxel_size_z 
+voxel_size_y 
+voxel_size_x 
+spot_size_z 
+spot_size_y 
+spot_size_x 
+log_kernel_size_z 
+log_kernel_size_y 
+log_kernel_size_x 
+minimum_distance_z 
+minimum_distance_y 
+minimum_distance_x 
+nucleus channel signal 
+alpha 
+beta 
+gamma 
+deconvolution_kernel_z 
+deconvolution_kernel_y 
+deconvolution_kernel_x 
+cluster size 
+min number of spots 
+Interactive threshold selector 
+spots_extraction_folder 
+spots_filename 
+do_spots_csv 
+do_spots_excel 
+do_spots_feather 
+output_folder 
+batch_name 
+save segmentation 
+save detection 
+extract spots 
+csv 
+xlsx 
+feather 
+2

small_fish_gui/gui/__init__.py

@@ -10,7 +10,6 @@ from .prompts import input_image_prompt
 from .prompts import hub_prompt
 from .prompts import detection_parameters_promt
 from .prompts import coloc_prompt
-from .prompts import post_analysis_prompt
 from .prompts import output_image_prompt
 from .prompts import ask_cancel_detection
 from .prompts import ask_cancel_segmentation
@@ -21,7 +20,7 @@ from .prompts import ask_detection_confirmation
 from .layout import parameters_layout 
 from .layout import bool_layout
 from .layout import path_layout
-from .layout import combo_layout
+from .layout import combo_elmt
 from .layout import tuple_layout
 from .layout import radio_layout
 from .layout import add_header

small_fish_gui/gui/animation.py

@@ -10,21 +10,30 @@ WAITING_TEXT = [
 
 def add_default_loading(funct) :
     def inner(*args,**kwargs) :
-        random_text = np.random.randint(0,len(WAITING_TEXT))
-        waiting_layout = [
-        [sg.Text(WAITING_TEXT[random_text], font= '10')]
-        ]
-        window = sg.Window(
-        title= 'small_fish',
-        layout= waiting_layout,
-        grab_anywhere= True,
-        finalize=True
-    )
-
-        window.read(timeout= 30, close= False)
-        try :
+
+        hide_loading = kwargs.get("hide_loading")
+        if 'hide_loading' in kwargs : del kwargs['hide_loading']
+
+        if not hide_loading :
+            random_text = np.random.randint(0,len(WAITING_TEXT))
+            waiting_layout = [
+            [sg.Text(WAITING_TEXT[random_text], font= '10')]
+            ]
+            window = sg.Window(
+            title= 'small_fish',
+            layout= waiting_layout,
+            grab_anywhere= True,
+            finalize=True
+        )
+
+            window.read(timeout= 30, close= False)
+            try :
+                return funct(*args, **kwargs)
+            finally :
+                window.close()
+
+        else : 
             return funct(*args, **kwargs)
-        finally :
-            window.close()
+
     return inner
 

small_fish_gui/gui/layout.py

@@ -7,9 +7,10 @@ from cellpose.core import use_gpu
 sg.theme('DarkAmber')
 
 
-def add_header(header_text, layout) :
-    header = [[sg.Text('\n{0}'.format(header_text), size= (len(header_text),3), font= 'bold 15')]]
-    return header + layout
+def add_header(header_text) :
+    """Returns [elmnt] not layout"""
+    header = [sg.Text('\n{0}'.format(header_text), size= (len(header_text),3), font= 'bold 15')]
+    return header
 
 
 def pad_right(string, length, pad_char) :
@@ -50,7 +51,7 @@ def parameters_layout(parameters:'list[str]' = [], unit=None, header= None, defa
             layout[line_id] += [sg.Text('{0}'.format(unit))]
     
     if isinstance(header, str) :
-        layout = add_header(header, layout)
+        layout = [add_header(header)] + layout
     return layout
 
 def tuple_layout(opt=None, default_dict={}, unit:dict={}, **tuples) :
@@ -97,7 +98,7 @@ def path_layout(keys= [],look_for_dir = False, header=None, preset=os.getcwd())
         [sg.Text(pad_right(name, max_length, ' ')), Browse(key= name, initial_folder= preset)] for name in keys
         ]
     if isinstance(header, str) :
-        layout = add_header(header, layout=layout)
+        layout = [add_header(header)] + layout
     return layout
 
 def bool_layout(parameters= [], header=None, preset=None) :
@@ -118,10 +119,10 @@ def bool_layout(parameters= [], header=None, preset=None) :
         [sg.Checkbox(pad_right(name, max_length, ' '), key= name, default=box_preset)] for name, box_preset in zip(parameters,preset)
     ]
     if isinstance(header, str) :
-        layout = add_header(header, layout=layout)
+        layout = [add_header(header)] + layout
     return layout
 
-def combo_layout(values, key, header=None, read_only=True, default_value=None) :
+def combo_elmt(values, key, header=None, read_only=True, default_value=None) :
     """
     drop-down list
     """
@@ -135,7 +136,7 @@ def combo_layout(values, key, header=None, read_only=True, default_value=None) :
         sg.Combo(values, default_value=default_value, readonly=read_only, key=key)
     ]
     if isinstance(header, str) :
-        layout = add_header(header, layout=layout)
+        layout = add_header(header) + layout
     return layout
 
 def radio_layout(values, header=None) :
@@ -148,7 +149,7 @@ def radio_layout(values, header=None) :
         [sg.Radio(value, group_id= 0) for value in values]
     ]
     if isinstance(header, str) :
-        layout = add_header(header, layout=layout)
+        layout = [add_header(header)] + layout
     return layout
 
 def _segmentation_layout(multichannel, cytoplasm_model_preset= 'cyto2', nucleus_model_preset= 'nuclei', cytoplasm_channel_preset=0, nucleus_channel_preset=0, cyto_diameter_preset=30, nucleus_diameter_preset= 30, show_segmentation_preset= False, segment_only_nuclei_preset=False, saving_path_preset=os.getcwd(), filename_preset='cell_segmentation.png',) :
@@ -162,23 +163,148 @@ def _segmentation_layout(multichannel, cytoplasm_model_preset= 'cyto2', nucleus_
     layout = [[sg.Text("GPU is currently "), sg.Text('ON', text_color= 'green') if USE_GPU else sg.Text('OFF', text_color= 'red')]]
     
     #cytoplasm parameters
-    layout += [add_header("Cell Segmentation", [sg.Text("Choose cellpose model for cytoplasm: \n")]),
-              [combo_layout(models_list, key='cyto_model_name', default_value= cytoplasm_model_preset)]
+    layout += [
+        add_header("Cell Segmentation"),
+        [sg.Text("Choose cellpose model for cytoplasm: \n")],
+        combo_elmt(models_list, key='cyto_model_name', default_value= cytoplasm_model_preset)
                         ]
-    if multichannel : layout += [parameters_layout(['cytoplasm channel'],default_values= [cytoplasm_channel_preset])]
-    layout += [parameters_layout(['cytoplasm diameter'], unit= "px", default_values= [cyto_diameter_preset])]
+                        
+    if multichannel : layout += parameters_layout(['cytoplasm channel'],default_values= [cytoplasm_channel_preset])
+    layout += parameters_layout(['cytoplasm diameter'], unit= "px", default_values= [cyto_diameter_preset])
     #Nucleus parameters
     layout += [
-            add_header("Nucleus segmentation",[sg.Text("Choose cellpose model for nucleus: \n")]),
-              combo_layout(models_list, key='nucleus_model_name', default_value= nucleus_model_preset)
+            add_header("Nucleus segmentation"),
+            [sg.Text("Choose cellpose model for nucleus: \n")],
+              combo_elmt(models_list, key='nucleus_model_name', default_value= nucleus_model_preset)
                 ]
-    if multichannel : layout += [parameters_layout(['nucleus channel'], default_values= [nucleus_channel_preset])]
-    layout += [parameters_layout([ 'nucleus diameter'],unit= "px", default_values= [nucleus_diameter_preset])]
-    layout += [bool_layout(["Segment only nuclei"], preset=segment_only_nuclei_preset)]
+    
+    if multichannel : layout += parameters_layout(['nucleus channel'], default_values= [nucleus_channel_preset])
+    layout += parameters_layout([ 'nucleus diameter'],unit= "px", default_values= [nucleus_diameter_preset])
+    layout += bool_layout(["Segment only nuclei"], preset=segment_only_nuclei_preset)
     
     #Control plots
-    layout += [bool_layout(['show segmentation'], header= 'Segmentation plots', preset= show_segmentation_preset)]
-    layout += [path_layout(['saving path'], look_for_dir=True, preset=saving_path_preset)]
-    layout += [parameters_layout(['filename'], default_values=[filename_preset], size= 25)]
+    layout += bool_layout(['show segmentation'], header= 'Segmentation plots', preset= show_segmentation_preset)
+    layout += path_layout(['saving path'], look_for_dir=True, preset=saving_path_preset)
+    layout += parameters_layout(['filename'], default_values=[filename_preset], size= 25)
+
+    return layout
+
+def _input_parameters_layout(
+        ask_for_segmentation,
+        is_3D_stack_preset,
+        time_stack_preset,
+        multichannel_preset,
+        do_dense_regions_deconvolution_preset,
+        do_clustering_preset,
+        do_segmentation_preset,
+        do_Napari_correction
+
+) :
+    layout_image_path = path_layout(['image path'], header= "Image")
+    layout_image_path += bool_layout(['3D stack', 'multichannel'], preset= [is_3D_stack_preset, time_stack_preset, multichannel_preset])
+    
+    if ask_for_segmentation : 
+        layout_image_path += bool_layout(
+            ['Dense regions deconvolution', 'Cluster computation', 'Segmentation', 'Napari correction'], 
+            preset= [do_dense_regions_deconvolution_preset, do_clustering_preset, do_segmentation_preset, do_Napari_correction], 
+            header= "Pipeline settings")
+    else : 
+        layout_image_path += bool_layout(
+            ['Dense regions deconvolution', 'Cluster computation', 'Napari correction'], 
+            preset= [do_dense_regions_deconvolution_preset, do_clustering_preset, do_Napari_correction], 
+            header= "Pipeline settings")
+
+    return layout_image_path
+
+def _detection_layout(
+        is_3D_stack,
+        is_multichannel,
+        do_dense_region_deconvolution,
+        do_clustering,
+        do_segmentation,
+        segmentation_done=False,
+        default_dict={},
+) :
+    if is_3D_stack : dim = 3
+    else : dim = 2
+
+    #Detection
+    detection_parameters = ['threshold', 'threshold penalty']
+    default_detection = [default_dict.setdefault('threshold',''), default_dict.setdefault('threshold penalty', '1')]
+    opt= [True, True]
+    if is_multichannel : 
+        detection_parameters += ['channel to compute']
+        opt += [False]
+        default_detection += [default_dict.setdefault('channel to compute', '')]
+    
+    layout = [[sg.Text("Green parameters", text_color= 'green'), sg.Text(" are optional parameters.")]]
+    layout += parameters_layout(detection_parameters, header= 'Detection', opt=opt, default_values=default_detection)
+    
+    if dim == 2 : tuple_shape = ('y','x')
+    else : tuple_shape = ('z','y','x')
+    opt = {'voxel_size' : False, 'spot_size' : False, 'log_kernel_size' : True, 'minimum_distance' : True}
+    unit = {'voxel_size' : 'nm', 'minimum_distance' : 'nm', 'spot_size' : 'radius(nm)', 'log_kernel_size' : 'px'}
+
+    layout += tuple_layout(opt=opt, unit=unit, default_dict=default_dict, voxel_size= tuple_shape, spot_size= tuple_shape, log_kernel_size= tuple_shape, minimum_distance= tuple_shape)
+    
+    if (do_segmentation and is_multichannel) or (is_multichannel and segmentation_done):
+        default_segmentation = [default_dict.setdefault('nucleus channel signal', default_dict.setdefault('nucleus channel',0))]
+        layout += [[sg.Text("nucleus channel signal "), sg.InputText(default_text=default_segmentation, key= "nucleus channel signal", size= 5, tooltip= "Channel from which signal will be measured for nucleus features, \nallowing you to measure signal from a different channel than the one used for segmentation.")]]
+        # layout += parameters_layout(['nucleus channel signal'], default_values=default_segmentation) + [[sg.Text("Channel from which signal will be measured for nucleus features, allowing you to measure signal from a different channel than the one used for segmentation.")]]
+    
+    #Deconvolution
+    if do_dense_region_deconvolution :
+        default_dense_regions_deconvolution = [default_dict.setdefault('alpha',0.5), default_dict.setdefault('beta',1)]
+        layout += parameters_layout(['alpha', 'beta',], default_values= default_dense_regions_deconvolution, header= 'Dense regions deconvolution')
+        layout += parameters_layout(['gamma'], unit= 'px', default_values= [default_dict.setdefault('gamma',5)])
+        layout += tuple_layout(opt= {"deconvolution_kernel" : True}, unit= {"deconvolution_kernel" : 'px'}, default_dict=default_dict, deconvolution_kernel = tuple_shape)
+    
+    #Clustering
+    if do_clustering :
+        layout += parameters_layout(['cluster size'], unit="radius(nm)", default_values=[default_dict.setdefault('cluster size',400)])
+        layout += parameters_layout(['min number of spots'], default_values=[default_dict.setdefault('min number of spots', 5)])
+
+    
+
+    layout += bool_layout(['Interactive threshold selector'], preset=[False])
+    layout += path_layout(
+        keys=['spots_extraction_folder'],
+        look_for_dir=True,
+        header= "Individual spot extraction",
+        preset= default_dict.setdefault('spots_extraction_folder', '')
+    )
+    layout += parameters_layout(
+        parameters=['spots_filename'],
+        default_values=[default_dict.setdefault('spots_filename','spots_extraction')],
+        size= 13
+    )
+    layout += bool_layout(
+        parameters= ['do_spots_csv', 'do_spots_excel', 'do_spots_feather'],
+        preset= [default_dict.setdefault('do_spots_csv',False), default_dict.setdefault('do_spots_excel',False),default_dict.setdefault('do_spots_feather',False)]
+    )
+
+    return layout
+
+def _ask_channel_map_layout(
+        shape,
+        is_3D_stack,
+        multichannel,
+        is_time_stack,
+        preset_map={},
+) :
+    
+    x = preset_map.setdefault('x',0)
+    y = preset_map.setdefault('y',0)
+    z = preset_map.setdefault('z',0)
+    c = preset_map.setdefault('c',0)
+    t = preset_map.setdefault('t',0)
+
+    layout = [
+            add_header("Dimensions mapping"), [sg.Text("Image shape : {0}".format(shape))]
+        ]
+    layout += parameters_layout(['x','y'], default_values=[x,y])
+    if is_3D_stack : layout += parameters_layout(['z'], default_values=[z])
+    if multichannel : layout += parameters_layout(['c'], default_values=[c])
+    if is_time_stack : layout += parameters_layout(['t'], default_values=[t])
 
     return layout

small_fish_gui/gui/prompts.py

@@ -2,18 +2,24 @@ import PySimpleGUI as sg
 import pandas as pd
 import os
 import numpy as np
-from .layout import path_layout, parameters_layout, bool_layout, tuple_layout, combo_layout, add_header, path_layout
+from .layout import path_layout, parameters_layout, bool_layout, tuple_layout, combo_elmt, add_header, path_layout
 from ..interface import open_image, check_format, FormatError
 from .help_module import ask_help
 
-def prompt(layout, add_ok_cancel=True, timeout=None, timeout_key='TIMEOUT_KEY') :
+def prompt(layout, add_ok_cancel=True, timeout=None, timeout_key='TIMEOUT_KEY', add_scrollbar=True) :
     """
     Default event : 'Ok', 'Cancel'
     """
     if add_ok_cancel : layout += [[sg.Button('Ok'), sg.Button('Cancel')]]
 
+    if add_scrollbar :
+        size = (400,500)
+        col_elmt = sg.Column(layout, scrollable=True, vertical_scroll_only=True, size=size)
+        layout = [[col_elmt]]
+    else :
+        size = (None,None)
     
-    window = sg.Window('small fish', layout=layout, margins=(10,10))
+    window = sg.Window('small fish', layout=layout, margins=(10,10), size=size, resizable=True)
     event, values = window.read(timeout=timeout, timeout_key=timeout_key)
     if event == None : 
         window.close()
@@ -26,12 +32,19 @@ def prompt(layout, add_ok_cancel=True, timeout=None, timeout_key='TIMEOUT_KEY')
         window.close()
         return event, values
 
-def prompt_with_help(layout, help =None) :
+def prompt_with_help(layout, help =None, add_scrollbar=True) :
     layout += [[]]
     layout += [[sg.Button('Help')]]
     layout += [[sg.Button('Ok'), sg.Button('Cancel')]]
     
-    window = sg.Window('small fish', layout=layout)
+    if add_scrollbar :
+        size = (400,500)
+        col_elmt = sg.Column(layout, scrollable=True, vertical_scroll_only=True, size=size)
+        layout = [[col_elmt]]
+    else :
+        size = (None,None)
+
+    window = sg.Window('small fish', layout=layout, size=size, resizable=True)
     while True :
         event, values = window.read()
         if event == None :
@@ -79,7 +92,7 @@ def input_image_prompt(
     else : 
         layout_image_path += bool_layout(['Dense regions deconvolution', 'Cluster computation', 'Napari correction'], preset= [do_dense_regions_deconvolution_preset, do_clustering_preset, do_Napari_correction], header= "Pipeline settings")
     
-    event, values = prompt_with_help(layout_image_path, help= 'general')
+    event, values = prompt_with_help(layout_image_path, help= 'general', add_scrollbar=False)
 
     if event == 'Cancel' :
         return None
@@ -227,22 +240,6 @@ def detection_parameters_promt(is_3D_stack, is_multichannel, do_dense_region_dec
     else : values['dim'] = 2
     return values
 
-def post_analysis_prompt() :
-    answer = events(['Save results','add_detection', 'colocalisation', 'open results in napari'])
-
-    return answer
-
-def events(event_list) :
-    """
-    Return event chose from user
-    """
-    
-    layout = [
-        [sg.Button(event) for event in event_list]
-    ]
-
-    event, values = prompt(layout, add_ok_cancel= False)
-    return event
 
 def ask_replace_file(filename:str) :
     layout = [
@@ -303,7 +300,7 @@ def hub_prompt(fov_results, do_segmentation=False) :
     layout = [
         [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('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('Save results', button_color= 'green'), sg.Button('Reset results',button_color= 'gray')]
     ]
@@ -336,7 +333,7 @@ def ask_detection_confirmation(used_threshold) :
         [sg.Button("Ok"), sg.Button("Restart detection")]
     ]
 
-    event, value = prompt(layout, add_ok_cancel=False)
+    event, value = prompt(layout, add_ok_cancel=False, add_scrollbar=False)
 
     if event == 'Restart detection' :
         return False
@@ -349,9 +346,10 @@ def ask_cancel_detection() :
         [sg.Button("Yes"), sg.Button("No")]
     ]
 
-    event, value = prompt(layout, add_ok_cancel=False)
+    event, value = prompt(layout, add_ok_cancel=False, add_scrollbar=False)
 
     if event == 'No' :
         return False
     else :
-        return True
+        return True
+

small_fish_gui/interface/output.py

@@ -10,9 +10,11 @@ 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) :
+def write_results(dataframe: pd.DataFrame, path:str, filename:str, do_excel= True, do_feather= False, do_csv=False, overwrite=False) :
     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
@@ -23,9 +25,11 @@ def write_results(dataframe: pd.DataFrame, path:str, filename:str, do_excel= Tru
 
     new_filename = filename
     i= 1
-    while new_filename + '.xlsx' in os.listdir(path) or new_filename + '.feather' in os.listdir(path) or new_filename + '.csv' in os.listdir(path) :
-        new_filename = filename + '_{0}'.format(i)
-        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) :
+            new_filename = filename + '_{0}'.format(i)
+            i+=1
 
     if 'image' in dataframe.columns :
         dataframe = dataframe.drop(['image'], axis=1)

small_fish_gui/pipeline/__init__.py

@@ -0,0 +1,21 @@
+"""
+Module containing main pipeline for user mode as well as calls for pipeline functions.
+"""
+
+from ._preprocess import reorder_shape
+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 .detection import launch_detection
+from .detection import launch_features_computation
+from .detection import launch_cell_extraction
+from .detection import get_nucleus_signal
+from .detection import output_spot_tiffvisual
+
+from .spots import launch_spots_extraction