small-fish-gui 1.3.4__tar.gz → 1.3.5__tar.gz

{small_fish_gui-1.3.4 → small_fish_gui-1.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: small_fish_gui
-Version: 1.3.4
+Version: 1.3.5
 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.3.4 → small_fish_gui-1.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "small_fish_gui"
-version = "1.3.4"
+version = "1.3.5"
 authors = [
   { name="Slimani Floric", email="floric.slimani@live.com" },
 ]

{small_fish_gui-1.3.4 → small_fish_gui-1.3.5}/src/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.3.4"
+__version__ = "1.3.5"

{small_fish_gui-1.3.4 → small_fish_gui-1.3.5}/src/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-1.3.5/src/small_fish_gui/gui/batch.py

@@ -0,0 +1,312 @@
+import os
+import numpy as np
+import PySimpleGUI as sg
+import bigfish.stack as stack
+import czifile as czi
+
+from .layout import _segmentation_layout, _detection_layout, _input_parameters_layout, _ask_channel_map_layout
+
+
+from time import sleep
+
+def get_images(filename:str) :
+    """returns filename if is image else return None"""
+
+    supported_types = ('.tiff', '.tif', '.png', '.czi')
+    if filename.endswith(supported_types) : 
+        return [filename]
+    else :
+        return None
+
+
+def get_files(path) :
+
+    filelist = os.listdir(path)
+    filelist = list(map(get_images,filelist))
+
+    while None in filelist : filelist.remove(None)
+
+    return filelist
+
+def extract_files(filenames: list) :
+    return sum(filenames,[])
+
+def check_file(filename:str) :
+
+    if filename.endswith('.czi') :
+        image = czi.imread(filename)
+    else :
+        image = stack.read_image(filename)
+
+    image = np.squeeze(image)
+
+    return image.shape
+
+def sanity_check(
+        filename_list: list, 
+        batch_folder : str,
+        window : sg.Window, 
+        progress_bar: sg.ProgressBar,
+        ) :
+    
+    filenumber = len(filename_list)
+    if filenumber == 0 :
+        print("No file to check")
+        progress_bar.update(current_count= 0, bar_color=('gray','gray'))
+        return None
+    else :
+        print("{0} files to check".format(filenumber))
+        progress_bar.update(current_count=0, max= filenumber)
+        ref_shape = check_file(batch_folder + '/' + filename_list[0])
+
+        print("Starting sanity check. This could take some time...")
+        for i, file in enumerate(filename_list) :
+            progress_bar.update(current_count= i+1, bar_color=('green','gray'))
+            shape = check_file(batch_folder + '/' + file)
+
+            if len(shape) != len(ref_shape) : #then dimension missmatch
+                print("Different number of dimensions found : {0}, {1}".format(len(ref_shape), len(shape)))
+                progress_bar.update(current_count=filenumber, bar_color=('red','black'))
+                window= window.refresh()
+                break
+
+            window= window.refresh()
+
+        print("Sanity check completed.")
+        return None if len(shape) != len(ref_shape) else shape
+
+
+def get_elmt_from_key(Tab_elmt:sg.Tab, key) -> sg.Element:
+    elmt_list = sum(Tab_elmt.Rows,[])
+    for elmt in elmt_list :
+        if elmt.Key == key : return elmt
+    raise KeyError("{0} key not found amongst {1}.".format(key, [elmt.Key for elmt in elmt_list]))
+
+def update_detection_tab(
+        tab_elmt:sg.Tab, 
+        is_multichannel, 
+        is_3D, 
+        do_dense_region_deconvolution,
+        do_clustering
+        ) :
+    
+    #Acess elements
+    ##Detection
+    channel_to_compute = get_elmt_from_key(tab_elmt, key= 'channel to compute')
+    voxel_size_z = get_elmt_from_key(tab_elmt, key= 'voxel_size_z')
+    spot_size_z = get_elmt_from_key(tab_elmt, key= 'spot_size_z')
+    log_kernel_size_z = get_elmt_from_key(tab_elmt, key= 'log_kernel_size_z')
+    minimum_distance_z = get_elmt_from_key(tab_elmt, key= 'minimum_distance_z')
+
+    ##Dense regions deconvolution
+    alpha = get_elmt_from_key(tab_elmt, key= 'alpha')
+    beta = get_elmt_from_key(tab_elmt, key= 'beta')
+    gamma = get_elmt_from_key(tab_elmt, key= 'gamma')
+    deconvolution_kernel_z = get_elmt_from_key(tab_elmt, key= 'deconvolution_kernel_z')
+    cluster_size = get_elmt_from_key(tab_elmt, key= 'cluster size')
+    min_number_of_spot = get_elmt_from_key(tab_elmt, key= 'min number of spots')
+    nucleus_channel_signal = get_elmt_from_key(tab_elmt, key= 'nucleus channel signal')
+    interactive_threshold_selector = get_elmt_from_key(tab_elmt, key= 'Interactive threshold selector')
+
+    update_dict={
+        'is_3D' : is_3D,
+        'is_multichannel' : is_multichannel,
+        'do_dense_region_deconvolution' : do_dense_region_deconvolution,
+        'do_clustering' : do_clustering,
+        'always_hidden' : False
+    }
+
+    list_dict={
+        'is_3D' : [voxel_size_z, spot_size_z, log_kernel_size_z, minimum_distance_z, deconvolution_kernel_z],
+        'is_multichannel' : [channel_to_compute, nucleus_channel_signal],
+        'do_dense_region_deconvolution' : [alpha,beta,gamma],
+        'do_clustering' : [cluster_size, min_number_of_spot],
+        'always_hidden' : [interactive_threshold_selector]
+        
+    }
+
+    for key, enabled in update_dict.items() :
+        for elmt in list_dict.get(key) :
+            elmt.update(disabled=not enabled)
+    
+
+
+def update_segmentation_tab(tab_elmt : sg.Tab, do_segmentation, is_multichannel) : #TODO
+    
+    #Access elements
+    cytoplasm_channel_elmt = get_elmt_from_key(tab_elmt, key= 'cytoplasm channel')
+    nucleus_channel_elmt = get_elmt_from_key(tab_elmt, key= 'nucleus channel')
+    
+    #Update values
+    tab_elmt.update(visible=do_segmentation)
+    cytoplasm_channel_elmt.update(disabled = not is_multichannel)
+    nucleus_channel_elmt.update(disabled = not is_multichannel)
+
+def update_map_tab() :
+    #TODO
+    pass
+
+def batch_promp() :
+
+    files_values = [[]]
+
+
+    #LOAD FILES
+    files_table = sg.Table(values=files_values, headings=['Filenames'], col_widths=100, max_col_width= 200, def_col_width=100, num_rows= 10, auto_size_columns=False)
+
+    #Start&Stop
+    start_button =sg.Button('Start', button_color= 'green', disabled= True)
+    stop_button = sg.Button('Cancel', button_color= 'red')
+
+    #DIMENSION SANITY
+    sanity_progress = sg.ProgressBar(10, size_px=(500,10))
+    sanity_check_button = sg.Button(
+        'Check', 
+        tooltip= "Will check that all files loaded have the same dimension number and that small fish is able to open them.", 
+        pad=(10,0))
+    sanity_header = sg.Text("Dimension sanity", font=('bold',15), pad=(0,10))
+    dimension_number_text = sg.Text("Dimension number : unknown")
+
+    #Input tab
+    input_layout = _input_parameters_layout(
+        ask_for_segmentation=True,
+        is_3D_stack_preset=False,
+        time_stack_preset=False,
+        multichannel_preset=False,
+        do_dense_regions_deconvolution_preset=False,
+        do_clustering_preset=False,
+        do_Napari_correction=False,
+        do_segmentation_preset=False,
+    )
+    input_layout += [[sg.Button('Ok')]]
+    input_tab = sg.Tab("Input", input_layout)
+
+    #Maptab
+    map_layout = _ask_channel_map_layout(
+        shape=(0,1,2,3,4),
+        is_3D_stack=True,
+        is_time_stack=True,
+        multichannel=True,
+    )
+    last_shape_read = sg.Text("Last shape read : None")
+    auto_map = sg.Button("auto-map", disabled=True, pad=(10,0))
+    map_layout += [[last_shape_read, auto_map]]
+    map_tab = sg.Tab("Map", map_layout)
+
+    #Segmentation tab
+    segmentation_layout = _segmentation_layout(multichannel=True, cytoplasm_model_preset='cyto3')
+    segmentation_tab = sg.Tab("Segmentation", segmentation_layout, visible=False)
+
+    #Detection tab
+    detection_layout = _detection_layout(
+        is_3D_stack=True,
+        is_multichannel=True,
+        do_clustering=True,
+        do_dense_region_deconvolution=True,
+        do_segmentation=True,
+    )
+
+
+    detection_tab = sg.Tab("Detection", detection_layout)
+    
+        
+
+    #TABS
+    _tab_group = sg.TabGroup([[input_tab, map_tab, segmentation_tab, detection_tab]], enable_events=True)
+    tab_group = sg.Column( #Allow the tab to be scrollable
+        [[_tab_group]],
+        scrollable=True,
+        vertical_scroll_only=True,
+        pad=(150,5)
+        )
+    tab_dict= {
+        "Input" : input_tab,
+        "Segmentation" : segmentation_tab,
+        "Detection" : detection_tab,
+        "Map" : map_tab,
+    }
+
+    layout = [
+        [sg.Text("Batch Processing", font=('bold',20), pad=((300,0),(0,2)))],
+        [sg.Text("Select a folder : "), sg.FolderBrowse(initial_folder=os.getcwd(), key='Batch_folder'), sg.Button('Load')],
+        [files_table],
+        [sanity_header, sanity_check_button, sanity_progress],
+        [dimension_number_text],
+        [tab_group],
+        [sg.Output(size=(100,10), pad=(30,10))],
+        [start_button, stop_button],
+    ]
+
+    window = sg.Window("small fish", layout=layout, size= (800,800), auto_size_buttons=True, auto_size_text=True)
+    loop = 0
+    timeout = 1
+    while True :
+        loop +=1
+        window = window.refresh()
+        event, values = window.read(timeout=timeout)
+        
+        #Welcome message
+        if loop == 1 : 
+            timeout = None
+            print("Welcome to small fish batch analysis. Please start by loading some files and setting parameters.")
+        
+        batch_folder = values.get('Batch_folder')
+        is_multichanel = values.get('multichannel')
+        is_3D = values.get('3D stack')
+        do_segmentation = values.get('Segmentation')
+        do_dense_regions_deconvolution = values.get('Dense regions deconvolution')
+        do_clustering = values.get('Cluster computation')
+
+        if type(batch_folder) != type(None)  and event == 'Load':
+            if not os.path.isdir(batch_folder) :
+                print("Can't open {0}".format(batch_folder))
+            else :
+                files_values = get_files(batch_folder)
+                files_table.update(values=files_values)
+
+        elif event == 'Check' :
+            filename_list = extract_files(files_values)
+            last_shape = sanity_check(
+                filename_list=filename_list,
+                batch_folder=batch_folder,
+                window=window,
+                progress_bar=sanity_progress
+            )
+            if isinstance(last_shape,(tuple,list)) :
+                dim_number = len(last_shape)
+                dimension_number_text.update("Dimension number : {0}".format(dim_number))
+                auto_map.update(disabled=False)
+            else :
+                dimension_number_text.update("Dimension number : unknown")
+                auto_map.update(disabled=True)
+
+            last_shape_read.update("Last shape read : {0}".format(last_shape))
+           
+        
+        elif event == _tab_group.key or event == 'Ok': #Tab switch in parameters
+            update_segmentation_tab(
+                tab_elmt=tab_dict.get("Segmentation"),
+                do_segmentation=do_segmentation,
+                is_multichannel=is_multichanel,
+            )
+
+            update_detection_tab(
+                tab_elmt=tab_dict.get("Detection"),
+                is_multichannel=is_multichanel,
+                is_3D=is_3D,
+                do_dense_region_deconvolution=do_dense_regions_deconvolution,
+                do_clustering=do_clustering,
+            )
+
+        elif event == 'auto-map' :
+            #TODO
+            pass
+
+        # elif event == 'apply' (map) #TODO
+
+        # elif event == 'check parameters' -> un/lock start #TODO
+            
+        elif event == "Cancel" :
+            print(values)
+        elif event == None :
+            quit()

small_fish_gui-1.3.5/src/small_fish_gui/gui/layout.py

@@ -0,0 +1,307 @@
+import PySimpleGUI as sg
+import os
+from ..utils import check_parameter
+import cellpose.models as models
+from cellpose.core import use_gpu
+
+sg.theme('DarkAmber')
+
+
+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) :
+    if len(string) >= length : return string
+    else : return string + pad_char* (length - len(string))
+    
+
+def parameters_layout(parameters:'list[str]' = [], unit=None, header= None, default_values=None, size=5, opt=None) :
+
+    if len(parameters) == 0 : return []
+    check_parameter(parameters= list, header = (str, type(None)))
+    for key in parameters : check_parameter(key = str)
+    max_length = len(max(parameters, key=len))
+
+    if type(opt) == type(None) :
+        opt = [False] * len(parameters)
+    else :
+        if len(opt) != len(parameters) : raise ValueError("Parameters and opt must be of same length.")
+
+    if isinstance(default_values, (list, tuple)) :
+        if len(default_values) != len(parameters) : raise ValueError("if default values specified it must be of equal length as parameters.")
+        layout= [
+            [sg.Text("{0}".format(pad_right(parameter, max_length, ' ')), text_color= 'green' if option else None), 
+             sg.InputText(size= size, key= parameter, default_text= value)
+             
+             ] for parameter,value, option in zip(parameters,default_values, opt)
+        ]
+    else :
+        layout= [
+            [sg.Text("{0}".format(pad_right(parameter, max_length, ' ')), text_color= 'green' if option else None), 
+             sg.InputText(size= size, key= parameter)
+             
+             ] for parameter, option in zip(parameters, opt)
+        ]
+    
+    if type(unit) == str :
+        for line_id, line in enumerate(layout) :
+            layout[line_id] += [sg.Text('{0}'.format(unit))]
+    
+    if isinstance(header, str) :
+        layout = [add_header(header)] + layout
+    return layout
+
+def tuple_layout(opt=None, default_dict={}, unit:dict={}, **tuples) :
+    """
+    tuples example : voxel_size = ['z','y','x']; will ask a tuple with 3 element default to 'z', 'y' 'x'.
+    """
+    if type(tuples) == type(None) : return []
+    if len(tuples.keys()) == 0 : return []
+
+    if type(opt) != type(None) :
+        if not isinstance(opt, dict) : raise TypeError("opt parameter should be either None or dict type.")
+        if not opt.keys() == tuples.keys() : raise ValueError("If opt is passed it is expected to have same keys as tuples dict.")
+    else : 
+        opt = tuples.copy()
+        for key in opt.keys() :
+            opt[key] = False
+
+    for tup in tuples : 
+        if not isinstance(tuples[tup], (list,tuple)) : raise TypeError()
+
+    max_size = len(max(tuples.keys(), key=len))
+    
+    layout = [
+        [sg.Text(pad_right(tup, max_size, ' '), text_color= 'green' if opt[option] else None)] 
+        + [sg.InputText(default_text=default_dict.setdefault('{0}_{1}'.format(tup,elmnt), elmnt),key= '{0}_{1}'.format(tup, elmnt), size= 5) for elmnt in tuples[tup]]
+        + [sg.Text(unit.setdefault(tup,''))] 
+        for tup,option, in zip(tuples,opt)
+    ]
+
+    return layout
+
+def path_layout(keys= [],look_for_dir = False, header=None, preset=os.getcwd()) :
+    """
+    If not look for dir then looks for file.
+    """
+    if len(keys) == 0 : return []
+    check_parameter(keys= list, header = (str, type(None)))
+    for key in keys : check_parameter(key = str)
+    if look_for_dir : Browse = sg.FolderBrowse
+    else : Browse = sg.FileBrowse
+
+    max_length = len(max(keys, key=len))
+    layout = [
+        [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
+    return layout
+
+def bool_layout(parameters= [], header=None, preset=None) :
+    if len(parameters) == 0 : return []
+    check_parameter(parameters= list, header= (str, type(None)), preset=(type(None), list, tuple, bool))
+    for key in parameters : check_parameter(key = str)
+    if type(preset) == type(None) :
+        preset = [False] * len(parameters)
+    elif type(preset) == bool :
+        preset = [preset] * len(parameters)
+    else : 
+        for key in preset : check_parameter(key = bool)
+
+
+
+    max_length = len(max(parameters, key=len))
+    layout = [
+        [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
+    return layout
+
+def combo_elmt(values, key, header=None, read_only=True, default_value=None) :
+    """
+    drop-down list
+    """
+    if len(values) == 0 : return []
+    check_parameter(values= list, header= (str, type(None)))
+    if type(default_value) == type(None) :
+        default_value = values[0]
+    elif default_value not in values :
+        default_value = values[0]
+    layout = [
+        sg.Combo(values, default_value=default_value, readonly=read_only, key=key)
+    ]
+    if isinstance(header, str) :
+        layout = add_header(header) + layout
+    return layout
+
+def radio_layout(values, header=None) :
+    """
+    Single choice buttons.
+    """
+    if len(values) == 0 : return []
+    check_parameter(values= list, header= (str, type(None)))
+    layout = [
+        [sg.Radio(value, group_id= 0) for value in values]
+    ]
+    if isinstance(header, str) :
+        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',) :
+    
+    USE_GPU = use_gpu()
+
+    models_list = models.get_user_models() + models.MODEL_NAMES
+    if len(models_list) == 0 : models_list = ['no model found']
+    
+    #Header : GPU availabality
+    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_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])
+    #Nucleus parameters
+    layout += [
+            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)
+    
+    #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)
+
+    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)
+
+    #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)])
+
+    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 += parameters_layout(['nucleus channel signal'], default_values=default_segmentation) + [[sg.Text(" channel from which signal will be measured for nucleus features.")]]
+
+    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-1.3.4 → small_fish_gui-1.3.5}/src/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 = [
@@ -354,4 +351,5 @@ def ask_cancel_detection() :
     if event == 'No' :
         return False
     else :
-        return True
+        return True
+

small_fish_gui-1.3.5/src/small_fish_gui/gui/test.py

@@ -0,0 +1,5 @@
+import PySimpleGUI as sg
+import small_fish_gui.gui.batch as prompt
+
+prompt.batch_promp()
+print('end')

{small_fish_gui-1.3.4 → small_fish_gui-1.3.5}/src/small_fish_gui/pipeline/_preprocess.py

@@ -122,14 +122,13 @@ def _auto_map_channels(image: np.ndarray, is_3D_stack, is_time_stack, multichann
     return map
 
 def _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map: dict= {}) :
-    map = preset_map
     while True :
         relaunch = False
-        x = map.setdefault('x',0)
-        y = map.setdefault('y',0)
-        z = map.setdefault('z',0)
-        c = map.setdefault('c',0)
-        t = map.setdefault('t',0)
+        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))])
@@ -139,12 +138,12 @@ def _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map
         if multichannel : layout += [parameters_layout(['c'], default_values=[c])]
         if is_time_stack : layout += [parameters_layout(['t'], default_values=[t])]
 
-        event, map = prompt_with_help(layout,help= 'mapping')
+        event, preset_map = prompt_with_help(layout,help= 'mapping', add_scrollbar=False)
         if event == 'Cancel' : quit()
 
         #Check integrity
-        channels_values = np.array(list(map.values()), dtype= int)
-        total_channels = len(map)
+        channels_values = np.array(list(preset_map.values()), dtype= int)
+        total_channels = len(preset_map)
         unique_channel = len(np.unique(channels_values))
         if total_channels != unique_channel :
             sg.popup("{0} channel(s) are not uniquely mapped.".format(total_channels - unique_channel))
@@ -154,7 +153,7 @@ def _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map
             relaunch= True
         if not relaunch : break
 
-    return map
+    return preset_map
 
 def _show_mapping(shape, map, is_3D_stack, is_time_stack, multichannel) :
     layout = [
@@ -166,7 +165,7 @@ def _show_mapping(shape, map, is_3D_stack, is_time_stack, multichannel) :
         [sg.Button('Change mapping')]
     ]
 
-    event, values = prompt_with_help(layout, help='mapping')
+    event, values = prompt_with_help(layout, help='mapping', add_scrollbar=False)
 
     if event == 'Ok' :
         return map

{small_fish_gui-1.3.4 → small_fish_gui-1.3.5}/src/small_fish_gui/pipeline/_segmentation.py

@@ -170,7 +170,7 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
                 [sg.Button("Yes"), sg.Button("No")]
             ]
             
-            event, values = prompt(layout=layout, add_ok_cancel=False)
+            event, values = prompt(layout=layout, add_ok_cancel=False, add_scrollbar=False)
             if event == "No" :
                 continue
 

{small_fish_gui-1.3.4 → small_fish_gui-1.3.5}/src/small_fish_gui/pipeline/detection.py

@@ -8,6 +8,7 @@ from ._signaltonoise import compute_snr_spots
 from ._napari_wrapper 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
 from .spots import compute_Spots
 from magicgui import magicgui
 from napari.layers import Image, Points
@@ -766,9 +767,11 @@ def _create_threshold_slider(
             threshold=threshold
         )[0]
 
+        scale = compute_anisotropy_coef(voxel_size)
+
         layer_args = {
             'size': 5, 
-            'scale' : voxel_size, 
+            'scale' : scale, 
             'face_color' : 'transparent', 
             'edge_color' : 'blue', 
             'symbol' : 'ring', 

small_fish_gui-1.3.4/src/small_fish_gui/gui/layout.py

@@ -1,184 +0,0 @@
-import PySimpleGUI as sg
-import os
-from ..utils import check_parameter
-import cellpose.models as models
-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 pad_right(string, length, pad_char) :
-    if len(string) >= length : return string
-    else : return string + pad_char* (length - len(string))
-    
-
-def parameters_layout(parameters:'list[str]' = [], unit=None, header= None, default_values=None, size=5, opt=None) :
-
-    if len(parameters) == 0 : return []
-    check_parameter(parameters= list, header = (str, type(None)))
-    for key in parameters : check_parameter(key = str)
-    max_length = len(max(parameters, key=len))
-
-    if type(opt) == type(None) :
-        opt = [False] * len(parameters)
-    else :
-        if len(opt) != len(parameters) : raise ValueError("Parameters and opt must be of same length.")
-
-    if isinstance(default_values, (list, tuple)) :
-        if len(default_values) != len(parameters) : raise ValueError("if default values specified it must be of equal length as parameters.")
-        layout= [
-            [sg.Text("{0}".format(pad_right(parameter, max_length, ' ')), text_color= 'green' if option else None), 
-             sg.InputText(size= size, key= parameter, default_text= value)
-             
-             ] for parameter,value, option in zip(parameters,default_values, opt)
-        ]
-    else :
-        layout= [
-            [sg.Text("{0}".format(pad_right(parameter, max_length, ' ')), text_color= 'green' if option else None), 
-             sg.InputText(size= size, key= parameter)
-             
-             ] for parameter, option in zip(parameters, opt)
-        ]
-    
-    if type(unit) == str :
-        for line_id, line in enumerate(layout) :
-            layout[line_id] += [sg.Text('{0}'.format(unit))]
-    
-    if isinstance(header, str) :
-        layout = add_header(header, layout)
-    return layout
-
-def tuple_layout(opt=None, default_dict={}, unit:dict={}, **tuples) :
-    """
-    tuples example : voxel_size = ['z','y','x']; will ask a tuple with 3 element default to 'z', 'y' 'x'.
-    """
-    if type(tuples) == type(None) : return []
-    if len(tuples.keys()) == 0 : return []
-
-    if type(opt) != type(None) :
-        if not isinstance(opt, dict) : raise TypeError("opt parameter should be either None or dict type.")
-        if not opt.keys() == tuples.keys() : raise ValueError("If opt is passed it is expected to have same keys as tuples dict.")
-    else : 
-        opt = tuples.copy()
-        for key in opt.keys() :
-            opt[key] = False
-
-    for tup in tuples : 
-        if not isinstance(tuples[tup], (list,tuple)) : raise TypeError()
-
-    max_size = len(max(tuples.keys(), key=len))
-    
-    layout = [
-        [sg.Text(pad_right(tup, max_size, ' '), text_color= 'green' if opt[option] else None)] 
-        + [sg.InputText(default_text=default_dict.setdefault('{0}_{1}'.format(tup,elmnt), elmnt),key= '{0}_{1}'.format(tup, elmnt), size= 5) for elmnt in tuples[tup]]
-        + [sg.Text(unit.setdefault(tup,''))] 
-        for tup,option, in zip(tuples,opt)
-    ]
-
-    return layout
-
-def path_layout(keys= [],look_for_dir = False, header=None, preset=os.getcwd()) :
-    """
-    If not look for dir then looks for file.
-    """
-    if len(keys) == 0 : return []
-    check_parameter(keys= list, header = (str, type(None)))
-    for key in keys : check_parameter(key = str)
-    if look_for_dir : Browse = sg.FolderBrowse
-    else : Browse = sg.FileBrowse
-
-    max_length = len(max(keys, key=len))
-    layout = [
-        [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)
-    return layout
-
-def bool_layout(parameters= [], header=None, preset=None) :
-    if len(parameters) == 0 : return []
-    check_parameter(parameters= list, header= (str, type(None)), preset=(type(None), list, tuple, bool))
-    for key in parameters : check_parameter(key = str)
-    if type(preset) == type(None) :
-        preset = [False] * len(parameters)
-    elif type(preset) == bool :
-        preset = [preset] * len(parameters)
-    else : 
-        for key in preset : check_parameter(key = bool)
-
-
-
-    max_length = len(max(parameters, key=len))
-    layout = [
-        [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)
-    return layout
-
-def combo_layout(values, key, header=None, read_only=True, default_value=None) :
-    """
-    drop-down list
-    """
-    if len(values) == 0 : return []
-    check_parameter(values= list, header= (str, type(None)))
-    if type(default_value) == type(None) :
-        default_value = values[0]
-    elif default_value not in values :
-        default_value = values[0]
-    layout = [
-        sg.Combo(values, default_value=default_value, readonly=read_only, key=key)
-    ]
-    if isinstance(header, str) :
-        layout = add_header(header, layout=layout)
-    return layout
-
-def radio_layout(values, header=None) :
-    """
-    Single choice buttons.
-    """
-    if len(values) == 0 : return []
-    check_parameter(values= list, header= (str, type(None)))
-    layout = [
-        [sg.Radio(value, group_id= 0) for value in values]
-    ]
-    if isinstance(header, str) :
-        layout = add_header(header, layout=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',) :
-    
-    USE_GPU = use_gpu()
-
-    models_list = models.get_user_models() + models.MODEL_NAMES
-    if len(models_list) == 0 : models_list = ['no model found']
-    
-    #Header : GPU availabality
-    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)]
-                        ]
-    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)
-                ]
-    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)]
-
-    return layout

small_fish_gui-1.3.4/src/small_fish_gui/gui/test.py

@@ -1,4 +0,0 @@
-import PySimpleGUI as sg
-import small_fish.gui.prompts as p
-
-p.hub_prompt([{},{},{"cell_number" : 100, "spot_number" : 1000},{},{},{'cell_number' : 10},{}])