small-fish-gui 2.0.2__py3-none-any.whl → 2.0.3__py3-none-any.whl

small_fish_gui/gui/napari_visualiser.py

@@ -8,9 +8,12 @@ import napari
 from magicgui import widgets
 
 from bigfish.stack import check_parameter
+from napari.layers import Image, Points
 from ._napari_widgets import CellLabelEraser, SegmentationReseter, ChangesPropagater, FreeLabelPicker
 from ._napari_widgets import ClusterIDSetter, ClusterMerger, ClusterUpdater, ClusterCreator
 from ._napari_widgets import initialize_all_cluster_wizards
+from ._napari_widgets import SpotDetector, DenseRegionDeconvolver, BackgroundRemover
+from ._napari_widgets import NapariWidget
 from ..utils import compute_anisotropy_coef
 
 def correct_spots(
@@ -90,7 +93,7 @@ def correct_spots(
                 "cluster_id" : clusters[:,dim+1],
                 "end" : [True] * len(clusters_coordinates)
                 }, 
-            feature_defaults= {"spot_number" : 0, "cluster_id" : -2, "end" : True} # napari features default will not work with np.NaN passing -2 instead.
+            feature_defaults= {"spot_number" : 0, "cluster_id" : -2, "end" : True} # napari features default will not work with np.nan passing -2 instead.
         )
 
     if type(cell_label) != type(None) and not np.array_equal(nucleus_label, cell_label) : Viewer.add_labels(cell_label, scale=scale, opacity= 0.2, blending= 'additive')
@@ -160,7 +163,7 @@ def show_segmentation(
         cyto_image : np.ndarray = None,
         cyto_label : np.ndarray = None,
         anisotrpy : float = 1,
-) :
+        ) :
     dim = nuc_image.ndim
     
     if type(cyto_image) != type(None) :
@@ -226,44 +229,126 @@ def show_segmentation(
 
     return new_nuc_label, new_cyto_label
 
-def threshold_selection(
+def interactive_detection(
         image : np.ndarray,
-        filtered_image : np.ndarray,
-        threshold_slider,
+        interactive_threshold : bool,
+        do_background_removal : bool,
+        dense_region_deconvolution : bool,
         voxel_size : tuple,
+        **kwargs
         ) :
     
     """
     To view code for spot selection have a look at magicgui instance created with `detection._create_threshold_slider` which is then passed to this napari wrapper as 'threshold_slider' argument.
+    
+    note : spots,threshold
     """
     
+    assert any([interactive_threshold, do_background_removal, dense_region_deconvolution]), "Wrong code path"
+
+    print("Preparing Napari viewer...")
     Viewer = napari.Viewer(title= "Small fish - Threshold selector", ndisplay=2, show=True)
     scale = compute_anisotropy_coef(voxel_size)
-    Viewer.add_image(
+    image_layer = Viewer.add_image(
         data= image,
-        contrast_limits= [image.min(), image.max()],
         name= "raw signal",
         colormap= 'green',
         scale= scale,
         blending= 'additive'
     )
-    Viewer.add_image(
-        data= filtered_image,
-        contrast_limits= [filtered_image.min(), filtered_image.max()],
-        colormap= 'gray',
-        scale=scale,
-        blending='additive'
-    )
 
-    Viewer.window.add_dock_widget(threshold_slider, name='threshold_selector')
-    threshold_slider() #First occurence with auto or entered threshold.
+    #Background remover
+    background_remover = _interactive_background_removal(image, voxel_size, **kwargs)
+    background_widgets = widgets.Container(widgets=[background_remover.widget, background_remover.reset_widget], labels=False)
+    Viewer.window.add_dock_widget(background_widgets, name='background_remover')
+
+    #Spot detection
+    spot_detector = _interactive_threshold_selection(image, voxel_size, background_remover_instance= background_remover, **kwargs)
+
+    Viewer.window.add_dock_widget(spot_detector.widget, name='threshold_selector')
+    spot_detector.widget() #First occurence with auto or entered threshold.
     
+    spots_layer = Viewer.layers['single spots']
+
+    if dense_region_deconvolution :
+        dense_region_deconvolver = _interactive_spot_decomposition(
+            image_layer, 
+            voxel_size,
+            spots = spots_layer, 
+            **kwargs
+            )
+        Viewer.window.add_dock_widget(dense_region_deconvolver.widget, name='dense_region_deconvolver')
+
     napari.run()
 
-    spots = Viewer.layers['single spots'].data.astype(int)
-    if len(spots) == 0 :
-        pass
-    else :
-        threshold = Viewer.layers['single spots'].properties.get('threshold')[0]
+    updated_parameters = {}
+    updated_parameters.update(spot_detector.get_detection_parameters())
+    if dense_region_deconvolution : updated_parameters.update(dense_region_deconvolver.get_detection_parameters())
+    signal = Viewer.layers['raw signal'].data
+
+    spots = Viewer.layers['single spots'].data.astype(np.int32)
+
+    return spots, signal, updated_parameters
+
+
+
+def _interactive_threshold_selection(image : np.ndarray, voxel_size : tuple, **kwargs) -> NapariWidget :
+
+    key_error = "Missing keys for interactive threshold selection, required keys are : 'default_threshold', 'default_spot_radius','default_kernel_size','default_min_distance',"
+    if not all([key for key in kwargs.keys()]) : raise ValueError(key_error)
+    type_dict = {
+        'default_threshold' : (type(None), int),
+        'default_spot_radius' : (type(None), tuple),
+        'default_kernel_size' : (type(None), tuple),
+        'default_min_distance' : (type(None), tuple),
+        }
+
+    for key, item in type_dict.items() :
+        if not isinstance(kwargs[key], item) : raise TypeError(f"Expected type {item} for {key} argument, got {type(kwargs[key])}") 
+
+    spot_detector = SpotDetector(
+        image=image,
+        default_threshold= kwargs["default_threshold"],
+        default_kernel_size=kwargs["default_kernel_size"],
+        default_min_distance=kwargs["default_min_distance"],
+        default_spot_size=kwargs["default_spot_radius"],
+        voxel_size=voxel_size,
+        background_remover_instance= kwargs['background_remover_instance']
+    )
+
+    return spot_detector
+
+def _interactive_spot_decomposition(image : Image, voxel_size : tuple, **kwargs) -> NapariWidget :
+    key_error = "Missing keys for interactive threshold selection, required keys are : 'spots', 'deconvolution_spot_radius','deconvolution_kernel_size','alpha', 'beta', 'gamma'"
+    if not all([key for key in kwargs.keys()]) : raise ValueError(key_error)
+    type_dict = {
+        'spots' : Points,
+        'deconvolution_spot_radius' : (type(None), tuple),
+        'alpha' : float,
+        'beta' : float,
+        'gamma' : float,
+        'deconvolution_kernel_size' : (type(None), tuple),
+        }
+
+    dense_regions_deconvolver = DenseRegionDeconvolver(
+        image= image,
+        spots= kwargs['spots'],
+        alpha=kwargs['alpha'],
+        beta=kwargs['beta'],
+        gamma=kwargs['gamma'],
+        spot_radius=kwargs['deconvolution_spot_radius'],
+        kernel_size=kwargs['deconvolution_kernel_size'],
+        voxel_size=voxel_size
+    )
+
+    return dense_regions_deconvolver
+
+def _interactive_background_removal(image : np.ndarray, voxel_size : tuple, **kwargs) -> NapariWidget :
+
+    background_remover = BackgroundRemover(
+        signal= image,
+        voxel_size = voxel_size,
+        other_image = kwargs.get('other_image'),
+    )
 
-    return spots, threshold
+    return background_remover

small_fish_gui/gui/prompts.py

@@ -2,7 +2,7 @@ import FreeSimpleGUI as sg
 import pandas as pd
 import os
 import numpy as np
-import small_fish_gui.default_values as default
+
 
 from typing import Literal, Union
 from .layout import (
@@ -13,10 +13,12 @@ from .layout import (
     radio_layout,
     colocalization_layout,
     tuple_layout,
-    _detection_layout
+    _detection_layout,
+    _segmentation_layout
     )
-from ..interface import open_image, check_format, FormatError
+from ..interface import open_image, check_format, FormatError, get_settings
 
+default = get_settings()
 
 def prompt(layout, add_ok_cancel=True, timeout=None, timeout_key='TIMEOUT_KEY', add_scrollbar=True) :
     """
@@ -24,30 +26,38 @@ def prompt(layout, add_ok_cancel=True, timeout=None, timeout_key='TIMEOUT_KEY',
     """
     if add_ok_cancel : layout += [[sg.Button('Ok', bind_return_key=True), sg.Button('Cancel')]]
 
-    size = (400,500)
-    col_elmt = sg.Column(layout, scrollable=True, vertical_scroll_only=True, size=size, expand_x=True, expand_y=True)
+    size = (800,800)
+    col_elmt = sg.Column(layout, scrollable=True, vertical_scroll_only=True, size=size, size_subsample_height=1, expand_x=True, expand_y=True)
     layout = [[col_elmt]]
     
-    window = sg.Window('small fish', layout=layout, margins=(10,10), size=size, resizable=True, location=None)
-    event, values = window.read(timeout=timeout, timeout_key=timeout_key)
-    if event == None : 
-        window.close()
-        quit()
-
-    elif event == 'Cancel' :
-        window.close()
-        return event,{}
-    else : 
-        window.close()
-        return event, values
+    window = sg.Window('small fish', layout=layout, margins=(10,10), size=size, resizable=True, location=None, enable_close_attempted_event=True)
+    
+    while True :
+        event, values = window.read(timeout=timeout, timeout_key=timeout_key)
+        if event == sg.WIN_CLOSE_ATTEMPTED_EVENT : 
+            answ = sg.popup_yes_no("Do you want to close Small Fish ?")
+            if answ == "Yes" : 
+                window.close()
+                quit()
+            else :
+                pass
+
+        elif event == 'Cancel' or event is None :
+            window.close()
+            return event,{}
+        else : 
+            window.close()
+            return event, values
 
 def input_image_prompt(
+        filename_preset : str,
         is_3D_stack_preset=False,
         multichannel_preset = False,
         do_dense_regions_deconvolution_preset= False,
         do_clustering_preset = False,
         do_Napari_correction= False,
-) :
+        do_background_removal_preset = False,
+    ) :
     """
         Keys :
         - 'image_path'
@@ -61,11 +71,17 @@ def input_image_prompt(
     Returns Values
 
     """
-    layout_image_path = path_layout(['image_path'], header= "Image")
-    layout_image_path += bool_layout(['3D stack', 'Multichannel stack'],keys= ['is_3D_stack', 'is_multichannel'], preset= [is_3D_stack_preset, multichannel_preset])
+    layout_image_path = [[sg.Text("Open an image", font="Bold 15")]]
+    layout_image_path += path_layout(['image_path'], preset=filename_preset)
+    layout_image_path += bool_layout(['3D stack', 'Multichannel stack',],keys= ['is_3D_stack', 'is_multichannel'], preset= [is_3D_stack_preset, multichannel_preset])
     
     if type(do_dense_regions_deconvolution_preset) != type(None) and type(do_clustering_preset) != type(None) and type(do_Napari_correction) != type(None): 
-        layout_image_path += bool_layout(['Dense regions deconvolution', 'Compute clusters', 'Open results in Napari'], keys = ['do_dense_regions_deconvolution', 'do_cluster_computation', 'show_napari_corrector'], preset= [do_dense_regions_deconvolution_preset, do_clustering_preset, do_Napari_correction], header= "Pipeline settings")
+        layout_image_path += bool_layout(
+            ['Dense regions deconvolution', 'Compute clusters', 'Open results in Napari',], 
+            keys = ['do_dense_regions_deconvolution', 'do_cluster_computation', 'show_napari_corrector'], 
+            preset= [do_dense_regions_deconvolution_preset, do_clustering_preset, do_Napari_correction], 
+            header= "Pipeline settings"
+            )
     
     event, values = prompt(layout_image_path, add_scrollbar=False)
 
@@ -79,7 +95,7 @@ def input_image_prompt(
     try :
         image = open_image(im_path)
         check_format(image, is_3D_stack, is_multichannel)
-        values.update({'image' : image})
+        values['image'] =  image
     except FormatError as error:
         sg.popup("Inconsistency between image format and options selected.\n Image shape : {0}".format(image.shape))
     except OSError as error :
@@ -95,19 +111,16 @@ def output_image_prompt(filename) :
         relaunch = False
         layout = path_layout(['folder'], look_for_dir= True, header= "Output parameters :")
         layout += parameters_layout(["filename"], default_values= [filename + "_quantification"], size=25)
-        layout += bool_layout(['csv','Excel', 'Feather'])
+        layout += bool_layout(['csv','Excel'])
 
         event,values= prompt(layout)
         if event == ('Cancel') : return None
 
         values['filename'] = values['filename'].replace(".xlsx","")
-        values['filename'] = values['filename'].replace(".feather","")
         excel_filename = values['filename'] + ".xlsx"
-        feather_filename = values['filename'] + ".feather"
-
 
-        if not values['Excel'] and not values['Feather'] and not values['csv'] :
-            sg.popup("Please check at least one box : Excel/Feather/csv")
+        if not values['Excel'] and not values['csv'] :
+            sg.popup("Please check at least one box : Excel/csv")
             relaunch = True
         elif not os.path.isdir(values['folder']) :
             sg.popup("Incorrect folder")
@@ -117,11 +130,6 @@ def output_image_prompt(filename) :
                 pass
             else :
                 relaunch = True
-        elif os.path.isfile(values['folder'] + feather_filename) and values['Feather']:
-            if ask_replace_file(feather_filename) :
-                pass
-            else :
-                relaunch = True
 
         if not relaunch : break
 
@@ -157,6 +165,61 @@ def detection_parameters_promt(
     else : values['dim'] = 2
     return values
 
+def segmentation_prompt(**segmentation_parameters) :
+
+    layout, event_dict = _segmentation_layout(**segmentation_parameters)
+
+    layout += [[sg.Button("Ok", bind_return_key=True), sg.Button("Cancel")]]
+    layout = [[sg.Column(layout, scrollable=True, vertical_scroll_only=True, size_subsample_height=2, expand_x=True, expand_y=True)]]
+
+    window = sg.Window('small fish', layout=layout, margins=(10,10), size=(800,800), resizable=True, location=None, enable_close_attempted_event=True)
+    while True :
+        event, values = window.read(timeout=300, timeout_key="timeout")
+
+        if event == sg.WIN_CLOSE_ATTEMPTED_EVENT : 
+            answ = sg.popup_yes_no("Do you want to close Small Fish ?")
+            if answ == "Yes" : 
+                window.close()
+                quit()
+            else :
+                pass
+
+        elif event == 'Cancel' or event is None :
+            window.close()
+            return event,{}
+
+        elif event == "timeout" :
+            pass
+        
+        elif event == "Ok" : 
+            window.close()
+            return event, values
+
+        elif event == "segment_only_nuclei" :
+            if event_dict['segment_only_nuclei'].get() : #user wants to segment only nuclei
+                event_dict['cytoplasm_column'].update(visible=False)
+            else :
+                event_dict['cytoplasm_column'].update(visible=True)
+
+        elif "_radio_2D" in event :
+            object_key = event.split("_radio_2D")[0]
+
+            for elmnt_to_enable in event_dict[object_key + "_radio_2D"] :
+                elmnt_to_enable.update(disabled=False)
+            for elmnt_to_disable in event_dict[object_key + "_radio_3D"] :
+                elmnt_to_disable.update(disabled=True)
+
+        elif "_radio_3D" in event : 
+            object_key = event.split("_radio_3D")[0]
+
+            for elmnt_to_enable in event_dict[object_key + "_radio_3D"] :
+                elmnt_to_enable.update(disabled=False)
+            for elmnt_to_disable in event_dict[object_key + "_radio_2D"] :
+                elmnt_to_disable.update(disabled=True)
+
+        else : 
+            raise(AssertionError(f"Not supported event : {event} in segmentation prompt."))
+
 def ask_replace_file(filename:str) :
     layout = [
         [sg.Text("{0} already exists, replace ?")],
@@ -199,14 +262,17 @@ def _sumup_df(results: pd.DataFrame) :
     COLUMNS = ['acquisition_id','name','threshold', 'spot_number', 'cell_number', 'filename', 'channel_to_compute']
 
     if len(results) > 0 :
-        if 'channel_to_compute' not in results : results['channel_to_compute'] = np.NaN
+        if 'channel_to_compute' not in results : results['channel_to_compute'] = np.nan
         res = results.loc[:,COLUMNS]
     else :
         res = pd.DataFrame(columns= COLUMNS)
 
     return res
 
-def hub_prompt(fov_results : pd.DataFrame, do_segmentation=False) -> 'Union[Literal["Add detection", "Compute colocalisation", "Batch detection", "Rename acquisition", "Save results", "Delete acquisitions", "Reset segmentation", "Reset results", "Segment cells"], dict[Literal["result_table", ""]]]':
+def hub_prompt(
+    fov_results : pd.DataFrame, 
+    do_segmentation=False
+    ) -> 'Union[Literal["Add detection", "Compute colocalisation", "Batch detection", "Rename acquisition", "Save results", "Delete acquisitions", "Reset segmentation", "Reset results", "Segment cells"], dict[Literal["result_table", ""]]]':
 
     sumup_df = _sumup_df(fov_results)
     
@@ -216,14 +282,14 @@ def hub_prompt(fov_results : pd.DataFrame, do_segmentation=False) -> 'Union[Lite
         segmentation_object = sg.Text('No segmentation in memory', font='8', text_color= 'red')
 
     layout = [
-        [sg.Text('RESULTS', font= 'bold 13')],
+        [sg.Text('RESULTS', font= 'bold 13'), sg.Stretch(), sg.Button('⚙️',font="Arial 15", button_color="gray", key="settings",)],
         [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('Segment cells'), sg.Button('Add detection'), sg.Button('Compute colocalisation'), sg.Button('Batch detection')],
         [sg.Button('Save results', button_color= 'green'), sg.Button('Save segmentation', button_color= 'green'), sg.Button('Load segmentation', button_color= 'green')],
         [sg.Button('Rename acquisition', button_color= 'gray'), sg.Button('Delete acquisitions',button_color= 'gray'), sg.Button('Reset segmentation',button_color= 'gray'), sg.Button('Reset all',button_color= 'gray'), sg.Button('Open wiki',button_color= 'yellow', key='wiki')],
     ]
 
-    window = sg.Window('small fish', layout= layout, margins= (10,10), location=None)
+    window = sg.Window('small fish', layout= layout, margins= (10,10), location=None, enable_close_attempted_event=True)
 
     while True : 
         event, values = window.read()
@@ -232,41 +298,88 @@ def hub_prompt(fov_results : pd.DataFrame, do_segmentation=False) -> 'Union[Lite
             window.close()
             return event, values
 
-def coloc_prompt(spot_list : list) :
-    layout = colocalization_layout(spot_list)
+    
+def coloc_prompt(spot_list : list, **default_values) :
+    layout, element_dict = colocalization_layout(spot_list, **default_values)
 
     layout = [[sg.Col(
         layout,
         expand_x=True,
         expand_y=True,
         vertical_scroll_only=True,
-        scrollable=True
+        scrollable=True,
     )
     ]]
-    window = sg.Window('small fish', layout=layout, margins=(10,10), resizable=True, location=None, auto_size_buttons=True)
+    window = sg.Window('small fish', layout=layout, margins=(10,10), resizable=False, size=(800,800), location=None, auto_size_buttons=True)
     while True : 
         event, values = window.read(timeout=100, timeout_key="timeout")
 
         if event == None : quit()
         elif event == "timeout" : pass
+        elif "radio_spots" in event :
+            spot_id = 1 if "1" in event else 2
+            is_memory = "memory" in event
+            for row in element_dict[f"options_spots{spot_id}_memory"].Rows :
+                for elmnt in row : 
+                    if not isinstance(elmnt, sg.Text): elmnt.update(disabled= not is_memory)
+            for row in element_dict[f"options_spots{spot_id}_load"].Rows :
+                for elmnt in row : 
+                    if not isinstance(elmnt, sg.Text): elmnt.update(disabled= is_memory)
+
         elif event == 'Ok' :
-            
-            if values["spots1_dropdown"] =="" :
+            if element_dict["radio_spots1_load"].get() :
                 spots1 = values["spots1_browse"]
             else :
                 spots1 = values["spots1_dropdown"]
 
-            if values["spots2_dropdown"] =="" :
+            if element_dict["radio_spots2_load"].get() :
                 spots2 = values["spots2_browse"]
             else :
                 spots2 = values["spots2_dropdown"]
-            
 
-            window.close()
-            return values['colocalisation distance'], [values['voxel_size_z'], values['voxel_size_y'], values['voxel_size_x']], spots1, spots2
+            if element_dict["radio_spots1_load"].get() and element_dict["radio_spots2_load"].get() :
+                sucess, voxel_size = _check_voxel_size_equality(
+                    voxel_size_1 =(values[f"z_voxel_size_spot1"], values[f"y_voxel_size_spot1"], values[f"x_voxel_size_spot1"]),
+                    voxel_size_2 =(values[f"z_voxel_size_spot2"], values[f"y_voxel_size_spot2"], values[f"x_voxel_size_spot2"]),
+                )
+            elif element_dict["radio_spots1_load"].get() :
+                sucess, voxel_size = _check_voxel_size_equality(
+                    voxel_size_1 =(values[f"z_voxel_size_spot1"], values[f"y_voxel_size_spot1"], values[f"x_voxel_size_spot1"]),
+                    voxel_size_2 =(values[f"z_voxel_size_spot1"], values[f"y_voxel_size_spot1"], values[f"x_voxel_size_spot1"]),
+                )
+            elif element_dict["radio_spots2_load"].get() :
+                sucess, voxel_size = _check_voxel_size_equality(
+                    voxel_size_1 =(values[f"z_voxel_size_spot2"], values[f"y_voxel_size_spot2"], values[f"x_voxel_size_spot2"]),
+                    voxel_size_2 =(values[f"z_voxel_size_spot2"], values[f"y_voxel_size_spot2"], values[f"x_voxel_size_spot2"]),
+                )
+
+            else :
+                voxel_size = (1,1,1)
+                sucess = True
+
+            if not sucess :
+                pass
+            else :
+                window.close()
+                return values['colocalisation distance'], voxel_size,  spots1, spots2, values
         else : 
             window.close()
-            return None,None,None,None
+            return None,None,None,None, {}
+
+def _check_voxel_size_equality(
+    voxel_size_1 : tuple, 
+    voxel_size_2 : tuple
+    ) :
+    try :
+        voxel_size_1 = tuple([int(voxel) for voxel in voxel_size_1])
+        voxel_size_2 = tuple([int(voxel) for voxel in voxel_size_2])
+        if voxel_size_1 != voxel_size_2 :
+            raise ValueError("voxel sizes must be identical for spots 1 and spots 2.")
+    except ValueError as e :
+        sg.popup(str(e))
+        return False, voxel_size_1
+    else :
+        return True, voxel_size_1
 
 def rename_prompt() :
     layout = parameters_layout(['name'], header= "Rename acquisitions", size=12)