small-fish-gui 1.0.0__py3-none-any.whl

small_fish_gui/__init__.py

@@ -0,0 +1,41 @@
+# Author: Floric Slimani
+
+"""
+Minimal software for spot detection using big-fish.
+
+BigFish
+
+Published work : 
+
+Arthur Imbert, Wei Ouyang, Adham Safieddine, Emeline Coleno, Christophe Zimmer, Edouard Bertrand, Thomas Walter, Florian Mueller. 
+FISH-quant v2: a scalable and modular analysis tool for smFISH image analysis. bioRxiv (2021) https://doi.org/10.1101/2021.07.20.453024
+
+BSD 3-Clause License
+
+Copyright © 2020, Arthur Imbert
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the copyright holder nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+__version__ = "0.5.0"

small_fish_gui/__main__.py

@@ -0,0 +1,15 @@
+import sys
+import os
+import PySimpleGUI as sg
+
+def main():
+    import small_fish.pipeline.main
+
+
+if __name__ == "__main__":
+    try :
+        sys.exit(main())
+    except Exception as error :
+        sg.popup("Sorry. Something went wrong...\nIf you have some time to spare could you please communicate the error you encountered (next window) on :\nhttps://github.com/2Echoes/small_fish/issues.")
+        sg.popup_error_with_traceback(error)
+        raise error

small_fish_gui/gui/__init__.py

@@ -0,0 +1,29 @@
+"""
+This subpackge contains code related to graphical interface
+"""
+
+from .prompts import _error_popup
+from .prompts import _warning_popup 
+from .prompts import prompt
+from .prompts import prompt_with_help
+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
+from .prompts import ask_help
+from .prompts import ask_detection_confirmation
+
+#Helpers to build windows
+from .layout import parameters_layout 
+from .layout import bool_layout
+from .layout import path_layout
+from .layout import combo_layout
+from .layout import tuple_layout
+from .layout import radio_layout
+from .layout import add_header
+
+from .animation import add_default_loading

small_fish_gui/gui/animation.py

@@ -0,0 +1,30 @@
+import PySimpleGUI as sg
+import numpy as np
+
+WAITING_TEXT = [
+    'Running...',
+    'Computing science...',
+    'Preparing some good results...',
+    'A good day for science...'
+]
+
+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 :
+            return funct(*args, **kwargs)
+        finally :
+            window.close()
+    return inner
+

small_fish_gui/gui/help_module.py

@@ -0,0 +1,256 @@
+import PySimpleGUI as sg
+import os
+
+
+def _fake_help() :
+    layout = [
+        [sg.Text("Fake help window")],
+        [sg.Button('Close')]
+    ]
+
+    return layout
+
+def ask_help(chapter= '') :
+    
+    if chapter == 'general' :
+        help_l = _general_help()
+
+    elif chapter == 'segmentation' :
+        help_l= _segmentation_help()
+
+    elif chapter == 'mapping' : 
+        help_l = _mapping_help()
+
+    elif chapter == 'detection' :
+        help_l = _detection_help()
+
+    else : 
+        help_l = _fake_help()
+
+    window = sg.Window('Help (small fish)', layout=help_l, keep_on_top=True, auto_size_text=True)
+    event, values = window.read(timeout= 0.1)
+
+    if event == 'Close' :
+        window.close()
+
+def add_help_button(help_request) :
+    pass
+
+def _general_help() :
+
+    im_path = os.path.dirname(__file__) + '/general_help_screenshot.png'
+
+    help_text = """
+    Pipeline settings :
+
+        Dense regions deconvolution : (Recommanded for cluster computations) Detect dense and bright regions with potential clustered 
+            spots and simulate a more realistic number of spots in these regions.
+            See bigfish documentation : https://big-fish.readthedocs.io/en/stable/detection/dense.html
+
+        Cluster computation :
+            DBScan algorithm is ran by big-fish to detecte clusters of spots. Use is you want to quantify one of the following : 
+            Transcription sites, foci, colocalisation of spots near foci...
+        
+        Segmentation : Perform full cell segmentation in 2D (cytoplasm + nucleus) via cellpose.
+            You can use your own retrained models or out of the box models from cellpose.
+
+        Napari correct :
+            After each detection, opens a Napari viewer, enabling the user to visualise, add or remove spots and clusters.
+    """
+
+    layout = [
+        [sg.Text("Welcome to small fish", font= 'bold 15')],
+        [sg.Image(im_path)],
+        [sg.Text(help_text, font = 'bold 10')]
+    ]
+
+    return layout
+
+def _detection_help() :
+
+    header = """
+    Detection is the main feature we use from big-fish package (usage requires quote).
+    Access fully detailed documentation : 
+    
+        DETECTION : https://big-fish.readthedocs.io/en/stable/detection/spots.html
+        DENSE REGIONS DECONVOLUTION : https://big-fish.readthedocs.io/en/stable/detection/dense.html
+        CLUSTERING : https://big-fish.readthedocs.io/en/stable/detection/cluster.html
+        
+    """
+    detection_header= """
+    
+    DETECTION PARAMETERS
+    """
+    detection_text = """
+    threshold
+        Leave empty for automatic threshold computation (see doc). Or set a manual threshold to apply after LoG filter.
+    
+    threshold penalty
+        Custom feature. Apply a multiplicator to automatic threshold.
+        Leave empty or 1 for no modification of auto threshold.
+        From 0<.<1 values will lower the threshold, increasing the number of spot detected.
+        On the contrary >1 values will increase the threshold, reducing the number of spot detected.
+             
+    voxel_size
+        Size of a voxel, in nanometer. One value per spatial dimension (zyx or yx dimensions). 
+        If it’s a scalar, the same value is applied to every dimensions. Not used if ‘log_kernel_size’ and ‘minimum_distance’ are provided.
+
+    spot_size    
+        Radius of the spot, in nanometer. One value per spatial dimension (zyx or yx dimensions). 
+        If it’s a scalar, the same radius is applied to every dimensions. 
+        Not used if ‘log_kernel_size’ and ‘minimum_distance’ are provided.
+
+    log kernel size
+        Size of the LoG kernel. It equals the standard deviation (in pixels) used for the gaussian kernel 
+        (one for each dimension). One value per spatial dimension (zyx or yx dimensions). If it’s a scalar, 
+        the same standard deviation is applied to every dimensions. 
+        If None, we estimate it with the voxel size and spot radius.
+
+    minimum distance
+        Minimum distance (in pixels) between two spots we want to be able to detect separately. 
+        One value per spatial dimension (zyx or yx dimensions). 
+        If it’s a scalar, the same distance is applied to every dimensions. 
+        If None, we estimate it with the voxel size and spot radius.
+
+    """
+    deconv_header="""    
+    DENSE REGIONS DECONVOLUTION PARAMETERS
+
+    """
+    deconv_text="""
+    alpha
+        Note : Simply put the higher alpha the less spots are added in bright regions.
+
+        Intensity percentile used to compute the reference spot, between 0 and 1. 
+        The higher, the brighter are the spots simulated in the dense regions. 
+        Consequently, a high intensity score reduces the number of spots added. 
+        Default is 0.5, meaning the reference spot considered is the median spot.
+    
+    beta
+        Note : Simply put the higher beta the brighter regions need to be to be deconvoluted.
+
+        Multiplicative factor for the intensity threshold of a dense region. Default is 1. 
+        Threshold is computed with the formula:
+
+                threshold = beta * max(median_spot)
+
+        with median_spot the median value of all detected spot signals.
+    
+    gamma
+        Note : for gamma = 0 no gaussian filter is performed.
+
+        Multiplicative factor use to compute the gaussian kernel size:
+
+                kernel_size = gamma * spot_size / voxel_size
+
+        We perform a large gaussian filter with such scale to estimate image background and remove it from original image. 
+        A large gamma increases the scale of the gaussian filter and smooth the estimated background. 
+        To decompose very large bright areas, a larger gamma should be set.
+
+    kernel_size
+        Standard deviation used for the gaussian kernel (one for each dimension), in pixel. 
+        If it’s a scalar, the same standard deviation is applied to every dimensions. 
+        If None, we estimate the kernel size from ‘spot_radius’, ‘voxel_size’ and ‘gamma’
+
+
+    """
+    clustering_header="""    
+    CLUSTERING PARAMETERS
+
+    """
+    clustering_text="""
+    cluster size
+        The maximum distance between two samples for one to be considered as in the neighborhood of the other. 
+        Radius expressed in nanometer.
+        
+        NOTE : Cluster centroids are computed from bigfish DBScan algorithm. 
+        But the number of spots belonging to those clusters is computed as the number of sptos closer than the cluster_size distance (nanometer).
+        Which can yield a slightly different result than bigfish but allow us to add and delete cluster with the napari correction option.
+
+    min number of spots
+        The number of spots in a neighborhood for a point to be considered as a core point (from which a cluster is expanded). 
+        This includes the point itself.
+
+    """
+
+    quote = """
+    BigFish quote : 
+    Arthur Imbert, Wei Ouyang, Adham Safieddine, Emeline Coleno, Christophe Zimmer, Edouard Bertrand, Thomas Walter, Florian Mueller. 
+    FISH-quant v2: a scalable and modular analysis tool for smFISH image analysis. bioRxiv (2021) 
+    https://doi.org/10.1101/2021.07.20.45302
+
+    """
+
+    layout = [
+        [sg.Text(header, font= "bold 15")],
+        [sg.Column([
+            [sg.Text(detection_header, font= 'bold 13')],
+            [sg.Text(detection_text)],
+            [sg.Text(deconv_header, font= 'bold 13')],
+            [sg.Text(deconv_text)],
+            [sg.Text(clustering_header, font= 'bold 13')],
+            [sg.Text(clustering_text)],
+            ], scrollable=True, vertical_scroll_only=True)],
+        [sg.Text(quote, font= 'italic 8')]
+    ]
+
+    return layout
+
+def _segmentation_help() :
+
+    cellpose1_quote = """Stringer, C., Wang, T., Michaelos, M., & Pachitariu, M. (2021).
+    Cellpose: a generalist algorithm for cellular segmentation. Nature methods, 18(1), 100-106."""
+    cellpose2_quote = """Pachitariu, M. & Stringer, C. (2022).
+    Cellpose 2.0: how to train your own model. Nature methods, 1-8."""
+    im_path = os.path.dirname(__file__) + '/segmentation_help_screenshot.png'
+
+    layout =[
+        [sg.Text("Segmentation is performed using Cellpose 2.0; this is published work that requires citation.\n")],
+        [sg.Text(cellpose1_quote)],
+        [sg.Text(cellpose2_quote)],
+        [sg.Image(im_path)]
+    ]
+
+    return layout
+
+
+def _mapping_help() :
+
+    im_path = os.path.dirname(__file__) + '/mapping_help_screenshot.png'
+
+
+    help_text = """
+    Depending on image format, dimensions (time, channels, spatial dimensions) are not always stored in the same order.
+    An automatic configuration is performed; nonetheless it is recommanded to check it worked properly or your data can
+    get mixed up.
+
+    This window present the shape of your image : example (1080,1080,4)
+    1080x1080 are the xy dimension (pixel resolution); and 4 is the number of channel. Another example a 3D multichannel 
+    stack could be (18,4,1080,1080)...
+    The machine understand the order of the information such as (1080,1080,4) positions are (0,1,2). /!\ It starts from zero! /!\
+    The mapping purpose is to link the position to the type of informations, in this case we want :
+
+            x : 1
+            y : 0
+            z : None
+            c : 2
+            t : None
+
+    The other example from above (18,4,1080,1080) mapping would be :
+
+            x : 3
+            y : 2
+            z : 0
+            c : 1
+            t : None
+    """
+
+    layout = [
+        [sg.Text(help_text)],
+        [sg.Image(im_path)]
+    ]
+
+    return layout
+
+def _small_fish_help() :
+    pass

small_fish_gui/gui/layout.py

@@ -0,0 +1,184 @@
+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(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)]
+                        ]
+    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)
+                ]
+    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