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

small_fish_gui/__init__.py

@@ -37,8 +37,14 @@ 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__ = "2.0.1"
+__version__ = "2.0.3"
 __wiki__ = "https://github.com/2Echoes/small_fish_gui/wiki"
 
-import os
-os.environ["QT_QPA_PLATFORM"] = "xcb"
+import os, platform
+system_type = platform.system()
+
+if system_type == "Linux" :
+  try :
+    os.environ["QT_QPA_PLATFORM"] = "xcb"
+  except Exception :
+    pass

small_fish_gui/batch/integrity.py

@@ -124,7 +124,7 @@ def check_detection_parameters(
             values=values,
             do_dense_region_deconvolution=do_dense_region_deconvolution,
             do_clustering=do_clustering,
-            multichannel=is_multichannel,
+            is_multichannel=is_multichannel,
             segmentation_done= values['do_segmentation'],
             map_=map_,
             shape=shape
@@ -156,7 +156,7 @@ def check_output_parameters(values) :
     if len(values['batch_name']) == 0 : is_output_ok = False
 
     #extension
-    if values['csv'] or values['xlsx'] or values['feather'] :
+    if values['csv'] or values['xlsx'] :
         pass
     else :
         sg.popup("Select at least one data format for output.")

small_fish_gui/batch/pipeline.py

@@ -6,6 +6,7 @@ import os, traceback
 import pandas as pd
 import FreeSimpleGUI as sg
 import numpy as np
+from AF_eraser import remove_autofluorescence_RANSACfit
 
 from ..hints import pipeline_parameters
 
@@ -101,8 +102,8 @@ def batch_pipeline(
                 parameters = _cast_segmentation_parameters(parameters)
                 cytoplasm_label, nucleus_label = cell_segmentation(
                     im_seg,
-                    cyto_model_name= parameters['cyto_model_name'],
-                    cyto_diameter= parameters['cytoplasm_diameter'],
+                    cytoplasm_model_name= parameters['cytoplasm_model_name'],
+                    cytoplasm_diameter= parameters['cytoplasm_diameter'],
                     nucleus_model_name= parameters['nucleus_model_name'],
                     nucleus_diameter= parameters['nucleus_diameter'],
                     channels=[parameters['cytoplasm_channel'], parameters['nucleus_channel']],
@@ -110,10 +111,11 @@ def batch_pipeline(
                     nucleus_3D_segmentation=parameters['nucleus_segmentation_3D'],
                     cyto_3D_segmentation= parameters['cytoplasm_segmentation_3D'],
                     do_only_nuc=parameters['segment_only_nuclei'],
-                    flow_threshold_cyto=parameters['flow_threshold_cyto'],
-                    flow_threshold_nuc=parameters['flow_threshold_cyto'],
-                    cellprob_threshold_cyto=parameters['cellprob_threshold_cyto'],
-                    cellprob_threshold_nuc=parameters['cellprob_threshold_nuc'],
+                    cytoplasm_flow_threshold=parameters['cytoplasm_flow_threshold'],
+                    nucleus_flow_threshold=parameters['cytoplasm_flow_threshold'],
+                    cytoplasm_cellprob_threshold=parameters['cytoplasm_cellprob_threshold'],
+                    nucleus_cellprob_threshold=parameters['nucleus_cellprob_threshold'],
+                    **parameters
                     )
 
                 parameters['segmentation_done'] = True
@@ -146,13 +148,38 @@ def batch_pipeline(
                 cytoplasm_label, nucleus_label = None,None
                 parameters['segmentation_done'] = False
 
+            #2.5 Background removal (opt)
+            print("do_background_removal : ", parameters['do_background_removal'])
+            print("is_multichannel : ", parameters['is_multichannel'])
+            if parameters["do_background_removal"] and parameters["is_multichannel"] :
+                window_print(batch_window, "Removing background....")
+                
+                _, other_image = prepare_image_detection(map_, parameters) 
+                image_stack = reorder_image_stack(map_, image)
+                signal_channel = int(parameters['channel_to_compute'])
+                background_channel = int(parameters["background_channel"])
+                
+                image= image_stack[signal_channel]
+                background = image_stack[background_channel]
+
+                result, score = remove_autofluorescence_RANSACfit(
+                    signal=image,
+                    background=background,
+                    max_trials=100
+                )
+
+
+                print("\rBackground substraction done.")
+            else :
+                image, other_image = prepare_image_detection(map_, parameters) 
+
+
             #3. Detection, deconvolution, clusterisation
             window_print(batch_window,"Detecting spots...")
             parameters = convert_parameters_types(parameters)
-            image, other_image = prepare_image_detection(map_, parameters) 
             nucleus_signal = get_nucleus_signal(image, other_image, parameters)
             try : # Catch error raised if user enter a spot size too small compare to voxel size
-                parameters, frame_result, spots, clusters, spot_cluster_id = launch_detection(
+                parameters, frame_result, spots, clusters, spot_cluster_id,_ = launch_detection(
                     image,
                     other_image,
                     parameters,
@@ -204,15 +231,23 @@ def batch_pipeline(
 
             #5. Features computation
             window_print(batch_window,"computing features...")
+
+            if do_segmentation :
+                nucleus_label = nucleus_label if nucleus_label.ndim == 2 else np.max(nucleus_label,axis=0),
+                cytoplasm_label= cytoplasm_label if cytoplasm_label.ndim == 2 else np.max(cytoplasm_label, axis=0),
+            else :
+                nucleus_label = None
+                cell_label = None
+
             new_results_df, new_cell_results_df = launch_features_computation(
             acquisition_id=acquisition_id + last_acquisition_id,
             image=image,
             nucleus_signal = nucleus_signal,
             spots=spots,
             clusters=clusters,
-            spots_cluster_id=spot_cluster_id,
-            nucleus_label = nucleus_label if nucleus_label.ndim == 2 else np.max(nucleus_label,axis=0),
-            cell_label= cytoplasm_label if cytoplasm_label.ndim == 2 else np.max(cytoplasm_label, axis=0),
+            spots_cluster_id=spot_cluster_id,            
+            nucleus_label=nucleus_label,
+            cell_label=cytoplasm_label,
             user_parameters=parameters,
             frame_results=frame_result,
             )

small_fish_gui/batch/prompt.py

@@ -4,25 +4,34 @@ Submodule with main function to call to launch batch mode.
 
 import os
 import FreeSimpleGUI as sg
-import small_fish_gui.default_values as default
+
 
 from .utils import get_elmt_from_key, create_map, call_auto_map
 from .pipeline import batch_pipeline
-from .update import update_detection_tab, update_map_tab, update_master_parameters, update_segmentation_tab, update_output_tab
+from .update import (
+    update_detection_tab, 
+    update_map_tab, 
+    update_master_parameters, 
+    update_segmentation_tab, 
+    update_output_tab,
+    update_background_removing_tab,
+    )
 from .input import load, extract_files
 from .integrity import sanity_check, check_channel_map_integrity, check_detection_parameters, check_segmentation_parameters, check_output_parameters
 from ..gui.layout import _segmentation_layout, _detection_layout, _input_parameters_layout, _ask_channel_map_layout
-
+from ..gui.tooltips import REMOVE_BACKGROUND_TOOLTIP
+from ..interface import get_settings
+from ..hints import pipeline_parameters
 
 def batch_promp(
         results_df,
         cell_results_df,
         acquisition_id,
-        preset: dict={},
-) :
+        preset: pipeline_parameters,
+    ) :
 
     files_values = [[]]
-
+    default = get_settings()
 
     #LOAD FILES
     files_table = sg.Table(
@@ -46,21 +55,21 @@ def batch_promp(
     sanity_header = sg.Text("Dimension sanity", font=('bold',15), pad=(0,10))
     dimension_number_text = sg.Text("Dimension number : unknown")
     
-#LAYOUT INIT
-#########################################
-#####   COLUMNS
-#########################################
-
-#####   Tabs
+    #LAYOUT INIT
+    #########################################
+    #####   COLUMNS
+    #########################################
+    
+    #####   Tabs
 
     #Input tab
     input_layout = _input_parameters_layout(
         ask_for_segmentation=True,
-        is_3D_stack_preset= preset.setdefault("is_3D_stack" ,default.IS_3D_STACK),
+        is_3D_stack_preset= preset.setdefault("is_3D_stack" ,default.stack_3D),
         time_stack_preset=False,
-        multichannel_preset=preset.setdefault("is_multichannel" ,default.IS_MULTICHANNEL),
-        do_dense_regions_deconvolution_preset=preset.setdefault("do_dense_regions_deconvolution", default.DO_DENSE_REGIONS_DECONVOLUTION),
-        do_clustering_preset= preset.setdefault("do_cluster_computation", default.DO_CLUSTER_COMPUTATION),
+        multichannel_preset=preset.setdefault("is_multichannel" ,default.multichannel_stack),
+        do_dense_regions_deconvolution_preset=preset.setdefault("do_dense_regions_deconvolution", default.do_dense_regions_deconvolution),
+        do_clustering_preset= preset.setdefault("do_cluster_computation", default.do_cluster),
         do_Napari_correction=False,
         do_segmentation_preset= preset.setdefault("segmentation_done", False),
     )
@@ -74,7 +83,7 @@ def batch_promp(
         shape=(0,1,2,3,4),
         is_3D_stack=True,
         is_time_stack=True,
-        multichannel=True,
+        is_multichannel=True,
     )
     last_shape_read = sg.Text("Last shape read : None")
     auto_map = sg.Button("auto-map", disabled=True, pad=(10,0))
@@ -83,22 +92,30 @@ def batch_promp(
     map_layout += [[auto_map, apply_map_button]]
     map_tab = sg.Tab("Map", map_layout)
 
+
+    preset["is_3D_stack"] = True
+    preset["is_multichannel"] = True
+    preset.setdefault("cytoplasm_channel", preset["detection_channel"])
+    preset.setdefault("cytoplasm_segmentation_3D", preset["do_3D_segmentation"])
+    preset.setdefault("nucleus_segmentation_3D", preset["do_3D_segmentation"])
+    preset["filename"] =  ""
+    preset["other_nucleus_image"] =  ""
+    preset["saving_path"] =  ""
+    preset["reordered_shape"] =  None
+    preset.setdefault("filename", "")
     #Segmentation tab
-    segmentation_layout = _segmentation_layout(
-        multichannel=True,
-        is_3D_stack=True, 
-        cytoplasm_model_preset=preset.setdefault("cyto_model_name",default.CYTO_MODEL),
-        cytoplasm_channel_preset=preset.setdefault("cytoplasm_channel",default.CHANNEL),
-        cyto_diameter_preset=preset.setdefault("cytoplasm_diameter",default.CYTO_DIAMETER),
-        nucleus_model_preset=preset.setdefault("nucleus_model_name",default.NUC_MODEL),
-        nucleus_channel_preset=preset.setdefault("nucleus channel",default.CHANNEL),
-        nucleus_diameter_preset=preset.setdefault("nucleus_diameter",default.NUC_DIAMETER),
-        segment_only_nuclei_preset=preset.setdefault("segment_only_nuclei",default.SEGMENT_ONLY_NUCLEI),
+    preset.setdefault("other_nucleus_image", default.working_directory)
+    preset.setdefault("cytoplasm_channel", default.detection_channel)
+    preset.setdefault("cytoplasm_segmentation_3D", default.do_3D_segmentation)
+    preset.setdefault("nucleus_segmentation_3D", default.do_3D_segmentation)
+    
+    segmentation_layout, segmentation_event_dict = _segmentation_layout(
+        **preset
         )
     
     apply_segmentation_button = sg.Button('apply', key='apply-segmentation')
     segmentation_layout += [[apply_segmentation_button]]
-    seg_keys_to_hide = ['show_segmentation', 'saving path', 'filename', 'other_nucleus_image', 'save_segmentation_visual', 'saving path_browse']
+    seg_keys_to_hide = ['show_segmentation', 'seg_control_saving_path', 'filename', 'other_nucleus_image', 'save_segmentation_visuals', 'seg_control_saving_path_browse']
     segmentation_tab = sg.Tab("Segmentation", segmentation_layout, visible=False)
 
     #Detection tab
@@ -115,18 +132,21 @@ def batch_promp(
     detection_keys_to_hide = ['do_spots_csv', 'do_spots_excel', 'spots_filename','spots_extraction_folder', 'spots_extraction_folder_browse']
     detection_tab = sg.Tab("Detection", detection_layout, visible=False)
 
+    #Remove background tab
+    background_removing_tab, background_removing_event_dict = create_background_removing_tab()
+
     #Output tab
     show_batch_folder_text = sg.Text('', key= 'batch_folder_text')
     apply_output_button = sg.Button('apply', key='apply-output')
     save_segmentation_visual_box = sg.Checkbox("save segmentation", disabled=True, key='save segmentation', tooltip= "Save png files illustrating segmentation borders.")
     save_segmentation_masks_box = sg.Check("save labels",  disabled=True, key="save_masks", tooltip= "Save segmentation labels as .npy files.")
-    save_detection_box = sg.Checkbox("create spot detection visuals", key= 'save detection', tooltip="Create multichannel tiff with raw spot signal and detected spots.\nWarning if processing a lot of files make sure you have enough free space on your hard drive.")
+    save_detection_box = sg.Checkbox("create spot detection visuals", key= 'save detection', tooltip="Create is_multichannel tiff with raw spot signal and detected spots.\nWarning if processing a lot of files make sure you have enough free space on your hard drive.")
     extract_spots_box = sg.Checkbox("extract spots", key='extract spots')
     batch_name_input = sg.InputText(size=25, key='batch_name')
     output_layout=[
         [sg.Text("Output folder", font=('bold',15), pad=(0,10))],
         [show_batch_folder_text],
-        [sg.Text("Select a folder : "), sg.FolderBrowse(initial_folder=os.getcwd(), key='output_folder', target=(1,-1))],
+        [sg.Text("Select a folder : "), sg.FolderBrowse(initial_folder=default.working_directory, key='output_folder', target=(1,-1))],
         [sg.Text("Name for batch : "), batch_name_input],
         [save_detection_box],
         [extract_spots_box],
@@ -141,7 +161,7 @@ def batch_promp(
     output_tab = sg.Tab("Output", output_layout, visible=True)
 
     ##TAB GROUP
-    _tab_group = sg.TabGroup([[input_tab, map_tab, segmentation_tab, detection_tab, output_tab]], enable_events=True)
+    _tab_group = sg.TabGroup([[input_tab, map_tab, segmentation_tab, detection_tab, background_removing_tab, output_tab]], enable_events=True)
     tab_col = sg.Column( #Allow the tab to be scrollable
         [[_tab_group]],
         scrollable=True,
@@ -156,6 +176,7 @@ def batch_promp(
         "Segmentation" : segmentation_tab,
         "Detection" : detection_tab,
         "Map" : map_tab,
+        "background_removing" : background_removing_tab,
         "Output" : output_tab
     }
     
@@ -192,12 +213,12 @@ def batch_promp(
     stream_output = sg.Output(size=(100,10), pad=(30,10), visible=True, expand_x=True, expand_y=True)
     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')],
+        [sg.Text("Select a folder : "), sg.FolderBrowse(initial_folder=preset["working_directory"], key='Batch_folder'), sg.Button('Load')],
         [files_table],
         [sanity_header, sanity_check_button, sanity_progress],
         [dimension_number_text],
         [tab_col, sg.Push(), launch_col, sg.Push()],
-        [stream_output],
+        # [stream_output],
     ]
 
     window = sg.Window("small fish", layout=layout, size= (800,800), auto_size_buttons=True, auto_size_text=True, resizable=True)
@@ -217,7 +238,6 @@ def batch_promp(
         '_is_output_correct' : output_ok_text,
 
     }
-    loop = 0
     timeout = 1
     last_shape = None
     talk=True
@@ -232,19 +252,25 @@ def batch_promp(
     get_elmt_from_key(tab_dict['Input'], key= 'image_path').update(disabled=True)
     for key in seg_keys_to_hide : get_elmt_from_key(tab_dict['Segmentation'], key=key).update(disabled=True)
     for key in detection_keys_to_hide : get_elmt_from_key(tab_dict['Detection'], key=key).update(disabled=True)
-    
+    first_loop = True
+
     while True : 
         try :
-            loop +=1
             window = window.refresh()
             event, values = window.read(timeout=timeout)
 
+            if event != sg.TIMEOUT_KEY :
+                stream_output.restore_stderr()
+                stream_output.restore_stdout()
+
+
             #Welcome message
-            if loop == 1 : 
+            if first_loop : 
                 timeout = 500
                 print("Welcome to small fish batch analysis. Please start by loading some files and setting parameters.")
+                first_loop = False
 
-            if values is None : return results_df, cell_results_df, acquisition_id, preset, False, None,None
+            if values is None : return results_df, cell_results_df, acquisition_id, preset, bool(preset.get("segmentation_done")), None,None
             
             batch_folder = values.get('Batch_folder')
             is_multichanel = values.get('is_multichannel')
@@ -379,7 +405,8 @@ def batch_promp(
                 stream_output.restore_stdout()
 
                 window.close()
-                return results_df, cell_results_df, acquisition_id, values, False, None,None #Segmentation done : False, cell label : None, Nucleus label : None
+                preset.update(values)
+                return results_df, cell_results_df, acquisition_id, preset, False, None,None #Segmentation done : False, cell label : None, Nucleus label : None
 
 
             #End of loop
@@ -406,7 +433,8 @@ def batch_promp(
                 do_segmentation=do_segmentation,
                 is_multichannel=is_multichanel,
                 is_3D=is_3D,
-                is_mapping_ok=Master_parameters_dict['_is_mapping_correct']
+                is_mapping_ok=Master_parameters_dict['_is_mapping_correct'],
+                segmentation_event_dict=segmentation_event_dict,
             )
 
             update_detection_tab(
@@ -419,6 +447,13 @@ def batch_promp(
                 do_segmentation=do_segmentation,
             )
 
+            update_background_removing_tab(
+                is_multichanel=is_multichanel,
+                background_removing_tab=background_removing_tab,
+                event_dict=background_removing_event_dict,
+                channel_number= None if not is_multichanel else 100
+            )
+
             update_output_tab(
                 tab_elmt=tab_dict['Output'],
                 do_segmentation=do_segmentation,
@@ -443,4 +478,30 @@ def batch_promp(
             stream_output.restore_stderr()
             stream_output.restore_stdout()
             window.close()
-            raise e
+            raise e
+
+
+
+def create_background_removing_tab() :
+    settings = get_settings()
+    
+    remove_background_bool = sg.Checkbox("Remove background", default=settings.do_background_removal, key="do_background_removal", tooltip=REMOVE_BACKGROUND_TOOLTIP)
+    channel_select = sg.Spin(initial_value=settings.background_channel, values=list(range(1000)), key= "background_channel")
+    max_trial_select = sg.Spin(initial_value=100, values=list(range(1000)), key= "background_max_trial")
+    apply_button = sg.Button("Apply", key = "apply-background_removing")
+
+    layout = [
+        [remove_background_bool],
+        [sg.Text("background channel"), channel_select],
+        [sg.Text("Max trial"), max_trial_select],
+        [apply_button]
+    ]
+
+    tab_layout = sg.Tab("Background removing", layout=layout, disabled=True)
+
+    event_dict = {
+        'remove_background_bool' : remove_background_bool,
+        'background_channel' : channel_select,
+    }
+
+    return tab_layout, event_dict

small_fish_gui/batch/update.py

@@ -54,7 +54,7 @@ def update_detection_tab(
     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')
     
-    #segmentation and multichannel
+    #segmentation and is_multichannel
     nucleus_channel_signal = get_elmt_from_key(tab_elmt, key= 'nucleus channel signal')
     
     #disable
@@ -93,20 +93,25 @@ def update_segmentation_tab(
         do_segmentation : bool, 
         is_multichannel : bool, 
         is_3D : bool, 
-        is_mapping_ok: bool
+        is_mapping_ok: bool,
+        segmentation_event_dict : dict,
         ) : 
-    
-    #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')
-    do_nucleus_3D_elmt = get_elmt_from_key(tab_elmt, key= "nucleus_segmentation_3D")
-    do_cytoplasm_3D_elmt = get_elmt_from_key(tab_elmt, key= "cytoplasm_segmentation_3D")
-    
+
     #Update values
-    cytoplasm_channel_elmt.update(disabled = not is_multichannel)
-    nucleus_channel_elmt.update(disabled = not is_multichannel)
-    do_nucleus_3D_elmt.update(disabled = not is_3D)
-    do_cytoplasm_3D_elmt.update(disabled = not is_3D)
+    for object_key in ["cytoplasm", "nucleus"] :
+        segmentation_event_dict[object_key + "_channel"].update(disabled = not is_multichannel)
+        if segmentation_event_dict[object_key + "_radio_2D_seg"].get() :
+            for elmnt in segmentation_event_dict[object_key + "_radio_2D"] : elmnt.update(disabled= False)
+            for elmnt in segmentation_event_dict[object_key + "_radio_3D"] : elmnt.update(disabled= True)
+        else :
+            for elmnt in segmentation_event_dict[object_key + "_radio_2D"] : elmnt.update(disabled= True)
+            for elmnt in segmentation_event_dict[object_key + "_radio_3D"] : elmnt.update(disabled= False)
+
+    if segmentation_event_dict["segment_only_nuclei"].get() :
+        segmentation_event_dict["cytoplasm_column"].update(visible=False)
+    else :
+        segmentation_event_dict["cytoplasm_column"].update(visible=True)
+
     segmentation_correct_text.update(visible= do_segmentation)
 
     tab_elmt.update(visible=is_mapping_ok and do_segmentation)
@@ -132,6 +137,14 @@ def update_map_tab(
     automap_element.update(disabled=type(last_shape) == type(None))
     apply_element.update(disabled=type(last_shape) == type(None))
 
+def update_background_removing_tab(
+    background_removing_tab : sg.Tab,
+    event_dict : dict,
+    is_multichanel : bool,
+    channel_number : None | int
+) : 
+    background_removing_tab.update(visible= is_multichanel, disabled= not is_multichanel)
+
 def update_output_tab(
         tab_elmt : sg.Tab,
         do_segmentation,

small_fish_gui/batch/utils.py

@@ -24,7 +24,7 @@ def call_auto_map(
         map_ = _auto_map_channels(
             is_3D_stack=is_3D,
             is_time_stack=False,
-            multichannel=is_multichannel,
+            is_multichannel=is_multichannel,
             image=None,
             shape=shape
             )

small_fish_gui/gui/__init__.py

@@ -14,6 +14,7 @@ from .prompts import ask_cancel_detection
 from .prompts import ask_cancel_segmentation
 from .prompts import ask_detection_confirmation
 from .prompts import prompt_restore_main_menu
+from .prompts import segmentation_prompt
 
 #Helpers to build windows
 from .layout import parameters_layout