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

small_fish_gui/interface/user_settings.py

@@ -0,0 +1,96 @@
+"""
+Submodule to handle Small Fish settings.
+"""
+
+import os
+import json
+from .default_settings import get_default_settings
+from pydantic import BaseModel, ValidationError
+from typing import Tuple, Optional
+
+class SettingsDict(BaseModel) :
+    working_directory : str
+    do_background_removal : bool
+    background_channel : int
+    multichannel_stack : bool
+    stack_3D : bool
+    detection_channel : int
+    nucleus_channel : int
+    anisotropy : float
+    flow_threshold : float
+    cellprob_threshold : float
+    cytoplasm_diameter : int
+    cytoplasm_min_size : int
+    cytoplasm_max_proj : bool
+    cytoplasm_mean_proj : bool
+    cytoplasm_select_slice : bool
+    cytoplasm_selected_slice : int
+    nucleus_diameter : int
+    cytoplasm_model : str
+    nucleus_model : str
+    nucleus_min_size : int
+    nucleus_max_proj : bool
+    nucleus_mean_proj : bool
+    nucleus_select_slice : bool
+    nucleus_selected_slice : int
+    show_segmentation : bool
+    segment_only_nuclei : bool
+    do_3D_segmentation : bool
+    save_segmentation_visuals : bool
+    threshold : Optional[int]
+    threshold_penalty : float
+    do_dense_regions_deconvolution : bool
+    do_cluster : bool
+    show_napari_corrector : bool
+    interactive_threshold_selector : bool
+    alpha : float
+    beta : float
+    gamma : float
+    cluster_size : int
+    min_spot : int
+    coloc_range : int
+    do_csv : bool
+    do_excel : bool
+    spot_extraction_folder : str
+    voxel_size : tuple
+    
+
+
+def get_settings() -> SettingsDict :
+
+    setting_path = get_settings_path()
+
+    if os.path.isfile(setting_path) :
+        return _load_settings()
+    else :
+        settings = _init_settings()
+        write_settings(settings)
+        return settings
+
+def _load_settings() :
+    settings_path = get_settings_path()
+    with open(settings_path, "r") as f:
+        settings = json.load(f)
+    
+    try : settings = SettingsDict(**settings)
+
+    except ValidationError as e :
+        print(f"Incorrect settings, using default settings \n{e}")
+        settings = _init_settings()
+    
+    return settings
+
+def _init_settings() :
+    default_settings = get_default_settings()
+    return SettingsDict(**default_settings)
+
+def get_settings_path() :
+    return os.path.join(os.path.dirname(__file__) , "settings.json")
+
+def write_settings(settings : SettingsDict) :
+    if not isinstance(settings, SettingsDict) :
+        raise TypeError("Expected SettingsDict type, got {}".format(type(settings)))
+    else :
+        settings_path = get_settings_path()
+        with open(settings_path, mode="w") as f:
+             json.dump(settings.dict(), f, indent=4)

small_fish_gui/main_menu.py

@@ -13,14 +13,17 @@ from .pipeline.actions import compute_colocalisation
 from .pipeline.actions import delete_acquisitions, rename_acquisitions 
 from .pipeline.actions import save_segmentation, load_segmentation, segment_cells
 from .pipeline.actions import open_wiki
-
+from .pipeline.actions import open_settings
 from .pipeline._preprocess import clean_unused_parameters_cache
+
+from .interface import get_settings
 from .batch import batch_promp
 from .gui import hub_prompt, prompt_restore_main_menu, default_theme
 from .hints import pipeline_parameters
 
 #'Global' parameters
 user_parameters = pipeline_parameters({'segmentation_done' : False}) #TypedDict
+user_parameters.update(get_settings())
 acquisition_id = -1
 result_df = pd.DataFrame(columns=['acquisition_id', 'name'])
 cell_result_df = pd.DataFrame(columns=['acquisition_id'])
@@ -116,6 +119,15 @@ while True : #Break this loop to close small_fish
         elif event == "wiki" :
             open_wiki()
 
+        elif event == "settings" :
+            open_settings()
+            user_parameters.update(get_settings())
+
+        elif event == sg.WINDOW_CLOSE_ATTEMPTED_EVENT :
+            answ  = sg.popup_ok_cancel("Do you want to close Small Fish ?")
+            if answ == "OK" : break
+            else : continue
+
         else :
             break
         

small_fish_gui/pipeline/{_signaltonoise.py → _bigfish_wrapers.py}

@@ -1,14 +1,23 @@
 """
-Signal to noise wrapper from BigFish code.
+Wrappers from BigFish code.
 """
 
-
-# ### SNR ###
-import bigfish.stack as stack
 import numpy as np
-from bigfish.detection.utils import get_object_radius_pixel, get_spot_volume, get_spot_surface
+import bigfish.stack as stack
+import bigfish.detection as detection
+from bigfish.detection.utils import (
+    get_object_radius_pixel, 
+    get_spot_volume, 
+    get_spot_surface,
+    get_object_radius_pixel
+    )
 
-def compute_snr_spots(image, spots, voxel_size, spot_radius):
+def compute_snr_spots(
+    image : np.ndarray, 
+    spots : np.ndarray, 
+    voxel_size : tuple[int,int,int], 
+    spot_radius : int
+    ):
     """
     Modified version of bigfish.detection.utils compute_snr_spots : 
     # Author: Arthur Imbert <arthur.imbert.pro@gmail.com>
@@ -216,4 +225,47 @@ def compute_snr_spots(image, spots, voxel_size, spot_radius):
             'cell_stdbackground_std' : np.std(std_background_list)
         }
 
-    return res
+    return res
+
+def _apply_log_filter(
+        image: np.ndarray,
+        voxel_size : tuple,
+        spot_radius : tuple,
+        log_kernel_size : tuple[int] | int,
+
+) :
+    """
+    Apply spot detection steps until local maxima step (just before final threshold).
+    Return filtered image.
+    """
+    
+    ndim = image.ndim
+
+    if type(log_kernel_size) == type(None) :
+        log_kernel_size = get_object_radius_pixel(
+                voxel_size_nm=voxel_size,
+                object_radius_nm=spot_radius,
+                ndim=ndim)
+    
+    
+    image_filtered = stack.log_filter(image, log_kernel_size)
+    
+    return image_filtered
+    
+def _local_maxima_mask(
+    image_filtered: np.ndarray,
+    voxel_size : tuple,
+    spot_radius : tuple,
+    minimum_distance : int,
+    ) : 
+
+    ndim = image_filtered.ndim
+
+    if type(minimum_distance) == type(None) :
+        minimum_distance = get_object_radius_pixel(
+            voxel_size_nm=voxel_size,
+            object_radius_nm=spot_radius,
+            ndim=ndim)
+    mask_local_max = detection.local_maximum_detection(image_filtered, minimum_distance)
+    
+    return mask_local_max.astype(bool)

small_fish_gui/pipeline/_colocalisation.py

@@ -1,5 +1,6 @@
 from ._custom_errors import MissMatchError
 from ..gui import coloc_prompt, add_default_loading
+from ..interface import get_settings
 
 import os
 import numpy as np
@@ -136,7 +137,7 @@ def spots_colocalisation(
         voxel_size : (z,y,x) tuple
     """
 
-    if len(spot_list1) == 0 or len(spot_list2) == 0 : return np.NaN
+    if len(spot_list1) == 0 or len(spot_list2) == 0 : return np.nan
     if len(spot_list1[0]) != len(spot_list2[0]) : 
         raise MissMatchError("dimensionalities of spots 1 and spots 2 don't match.")
 
@@ -170,10 +171,15 @@ def initiate_colocalisation(
 
     result_tables = result_tables.set_index('acquisition_id', drop=False)
     available_spots = dict(zip(result_tables['acquisition_id'].astype(str).str.cat(result_tables['name'],sep='-'), result_tables.index))
+    default_values = dict(get_settings())
 
     while True :
         try : 
-            colocalisation_distance, voxel_size, spots1_key, spots2_key = coloc_prompt(list(available_spots.keys()))
+            colocalisation_distance, voxel_size, spots1_key, spots2_key, values = coloc_prompt(
+                list(available_spots.keys()),
+                **default_values
+                )
+            default_values.update(values)
             if colocalisation_distance is None :
                 return None,None, None,None
             colocalisation_distance = int(colocalisation_distance)
@@ -194,15 +200,8 @@ def initiate_colocalisation(
                 raise ValueError("Incorrect value for spots1")
 
         except ValueError as e :
-            
-            if str(e) == "Incorrect value for spots1" :
-                sg.popup(str(e))
-
-            elif str(e) == "Incorrect value for spots2" :
-                sg.popup(str(e))
+            sg.popup(str(e))
 
-            else :
-                sg.popup("Incorrect colocalisation distance")
         else :
             break
     return colocalisation_distance, voxel_size, spots1_key, spots2_key
@@ -250,8 +249,8 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
         fraction_spots2_coloc_spots1 = spots_colocalisation(spot_list1=spots2, spot_list2=spots1, distance= colocalisation_distance, voxel_size=voxel_size) / spot2_total
     except MissMatchError as e :
         sg.popup(str(e))
-        fraction_spots1_coloc_spots2 = np.NaN
-        fraction_spots2_coloc_spots1 = np.NaN
+        fraction_spots1_coloc_spots2 = np.nan
+        fraction_spots2_coloc_spots1 = np.nan
 
     if 'clusters' in acquisition1.columns :
         try : 
@@ -259,12 +258,12 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
             fraction_spots2_coloc_cluster1 = spots_colocalisation(spot_list1=spots2, spot_list2=spots1[clusters_id_1 != -1], distance= colocalisation_distance, voxel_size=voxel_size) / spot2_total
         except MissMatchError as e :
             sg.popup(str(e))
-            fraction_spots2_coloc_cluster1 = np.NaN
+            fraction_spots2_coloc_cluster1 = np.nan
         except TypeError : # clusters not computed
-            fraction_spots2_coloc_cluster1 = np.NaN
+            fraction_spots2_coloc_cluster1 = np.nan
 
 
-    else : fraction_spots2_coloc_cluster1 = np.NaN
+    else : fraction_spots2_coloc_cluster1 = np.nan
 
     if 'clusters' in acquisition2.columns :
         try :
@@ -272,12 +271,12 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
             fraction_spots1_coloc_cluster2 = spots_colocalisation(spot_list1=spots1, spot_list2=spots2[clusters_id_2 != -1], distance= colocalisation_distance, voxel_size=voxel_size) / spot1_total
         except MissMatchError as e :# clusters not computed
             sg.popup(str(e))
-            fraction_spots1_coloc_cluster2 = np.NaN
+            fraction_spots1_coloc_cluster2 = np.nan
         except TypeError :
-            fraction_spots1_coloc_cluster2 = np.NaN
+            fraction_spots1_coloc_cluster2 = np.nan
 
 
-    else : fraction_spots1_coloc_cluster2 = np.NaN
+    else : fraction_spots1_coloc_cluster2 = np.nan
 
     if 'clusters' in acquisition2.columns and 'clusters' in acquisition1.columns :
         try :
@@ -287,15 +286,15 @@ def _global_coloc(acquisition_id1,acquisition_id2, result_dataframe, colocalisat
             fraction_cluster2_coloc_cluster1 = spots_colocalisation(spot_list1=spots2[clusters_id_2 != -1], spot_list2=spots1[clusters_id_1 != -1], distance= colocalisation_distance, voxel_size=voxel_size) / total_clustered_spots2
         except MissMatchError as e :# clusters not computed
             sg.popup(str(e))
-            fraction_cluster1_coloc_cluster2 = np.NaN
-            fraction_cluster2_coloc_cluster1 = np.NaN
+            fraction_cluster1_coloc_cluster2 = np.nan
+            fraction_cluster2_coloc_cluster1 = np.nan
         except TypeError :
-            fraction_cluster1_coloc_cluster2 = np.NaN
-            fraction_cluster2_coloc_cluster1 = np.NaN
+            fraction_cluster1_coloc_cluster2 = np.nan
+            fraction_cluster2_coloc_cluster1 = np.nan
 
     else :
-        fraction_cluster1_coloc_cluster2 = np.NaN
-        fraction_cluster2_coloc_cluster1 = np.NaN
+        fraction_cluster1_coloc_cluster2 = np.nan
+        fraction_cluster2_coloc_cluster1 = np.nan
         
 
     coloc_df = pd.DataFrame({

small_fish_gui/pipeline/_preprocess.py

@@ -3,8 +3,10 @@ import os
 import FreeSimpleGUI as sg
 from ..gui import _error_popup, _warning_popup, parameters_layout, add_header
 from ..gui.prompts import input_image_prompt, prompt
+from ..gui.layout import _ask_channel_map_layout
+from ..interface import get_settings
+from ..hints import pipeline_parameters
 
-import small_fish_gui.default_values as default
 
 class ParameterInputError(Exception) :
     """
@@ -33,10 +35,9 @@ def prepare_image_detection(map_, user_parameters) :
     assert len(image.shape) != 5 , "Time stack not supported, should never be True"
     
     if user_parameters['is_multichannel'] :
-        channel_to_compute = user_parameters['channel_to_compute']
+        channel_to_compute = int(user_parameters['channel_to_compute'])
         other_image = image.copy()
         other_image = np.delete(other_image, channel_to_compute, axis=0)
-        other_image = [layer for layer in other_image]
         image: np.ndarray = image[channel_to_compute]
 
     else :
@@ -66,20 +67,20 @@ def map_channels(user_parameters) :
     image = user_parameters['image']
     is_3D_stack = user_parameters['is_3D_stack']
     is_time_stack = False
-    multichannel = user_parameters['is_multichannel']
+    is_multichannel = user_parameters['is_multichannel']
 
     try : 
-        map_ = _auto_map_channels(is_3D_stack, is_time_stack, multichannel, image=image)
+        map_ = _auto_map_channels(is_3D_stack, is_time_stack, is_multichannel, image=image)
     except MappingError as e :
         sg.popup("Automatic dimension mapping went wrong. Please indicate dimensions positions in the array.")
-        map_ = _ask_channel_map(image.shape, is_3D_stack, is_time_stack, multichannel, preset_map= e.get_map())
+        map_ = _ask_channel_map(image.shape, is_3D_stack, is_time_stack, is_multichannel, preset_map= e.get_map())
 
     else :
-        map_ = _show_mapping(image.shape, map_, is_3D_stack, is_time_stack, multichannel,)
+        map_ = _show_mapping(image.shape, map_, is_3D_stack, is_time_stack, is_multichannel,)
 
     return map_
 
-def _auto_map_channels(is_3D_stack, is_time_stack, multichannel, image: np.ndarray=None, shape=None) :
+def _auto_map_channels(is_3D_stack, is_time_stack, is_multichannel, image: np.ndarray=None, shape=None) :
     if type(shape) == type(None) :
         shape = image.shape
     reducing_list = list(shape)
@@ -100,7 +101,7 @@ def _auto_map_channels(is_3D_stack, is_time_stack, multichannel, image: np.ndarr
     reducing_list.remove(x_val)
 
     #smaller value set to c
-    if multichannel :
+    if is_multichannel :
         c_val = min(reducing_list)
         c_idx = shape.index(c_val)
         map_['c'] = c_idx
@@ -124,7 +125,7 @@ def _auto_map_channels(is_3D_stack, is_time_stack, multichannel, image: np.ndarr
 
     return map_
 
-def _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map: dict= {}) :
+def _ask_channel_map(shape, is_3D_stack, is_time_stack, is_multichannel, preset_map: dict= {}) :
     while True :
         relaunch = False
         save_preset = preset_map.copy()
@@ -135,13 +136,13 @@ def _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map
         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])]
+        layout = _ask_channel_map_layout(
+            is_3D_stack=is_3D_stack,
+            is_time_stack=False,
+            is_multichannel=is_multichannel,
+            shape=shape,
+            preset_map=preset_map
+        )
 
         event, preset_map = prompt(layout, add_scrollbar=False)
         if event == 'Cancel' : return save_preset
@@ -160,7 +161,7 @@ def _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map
 
     return preset_map
 
-def _show_mapping(shape, map_, is_3D_stack, is_time_stack, multichannel) :
+def _show_mapping(shape, map_, is_3D_stack, is_time_stack, is_multichannel) :
     while True : 
         layout = [
             [sg.Text("Image shape : {0}".format(shape))],
@@ -176,7 +177,7 @@ def _show_mapping(shape, map_, is_3D_stack, is_time_stack, multichannel) :
         if event == 'Ok' :
             return map_
         elif event == 'Change mapping':
-            map_ = _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map=map_)
+            map_ = _ask_channel_map(shape, is_3D_stack, is_time_stack, is_multichannel, preset_map=map_)
         elif event == 'Cancel' : 
             return None
         else : raise AssertionError('Unforseen event')
@@ -208,7 +209,7 @@ def convert_parameters_types(values:dict) :
 
     #Parameters
     int_list = ['threshold', 'channel_to_compute', 'channel_to_compute', 'min_number_of_spots', 'cluster_size','nucleus channel signal']
-    float_list = ['alpha', 'beta', 'gamma', 'threshold penalty']
+    float_list = ['alpha', 'beta', 'gamma', 'threshold_penalty']
 
     for parameter in int_list :
         try :
@@ -230,7 +231,7 @@ def check_integrity(
         values: dict, 
         do_dense_region_deconvolution,
         do_clustering, 
-        multichannel,
+        is_multichannel,
         segmentation_done, 
         map_, 
         shape
@@ -241,8 +242,9 @@ def check_integrity(
 
     #voxel_size
     if type(values['voxel_size']) == type(None) : 
-        print(values['voxel_size'])
         raise ParameterInputError('Incorrect voxel size parameter.')
+    elif (np.array(values['voxel_size']) < 1).any() :
+        raise ParameterInputError('Voxel size can be < 1.')
     
     #detection integrity :
     if not isinstance(values['spot_size'], (tuple, list)) and not(isinstance(values['minimum_distance'], (tuple, list)) and isinstance(values['log_kernel_size'], (tuple, list))) :
@@ -266,7 +268,7 @@ def check_integrity(
             raise ParameterInputError("Incorrect cluster size parameter.")
 
     #channel
-    if multichannel :
+    if is_multichannel :
         ch_len = shape[int(map_['c'])]
 
         if type(segmentation_done) == type(None) :
@@ -317,7 +319,7 @@ def _check_segmentation_parameters(
 
     available_channels = list(range(len(shape)))
     do_only_nuc = user_parameters['segment_only_nuclei']
-    cyto_model_name = user_parameters['cyto_model_name']
+    cytoplasm_model_name = user_parameters['cytoplasm_model_name']
     cyto_size = user_parameters['cytoplasm_diameter']
     cytoplasm_channel = user_parameters['cytoplasm_channel']
     nucleus_model_name = user_parameters['nucleus_model_name']
@@ -325,7 +327,7 @@ def _check_segmentation_parameters(
     nucleus_channel = user_parameters['nucleus_channel']
    
 
-    if type(cyto_model_name) != str  and not do_only_nuc:
+    if type(cytoplasm_model_name) != str  and not do_only_nuc:
         raise ParameterInputError('Invalid cytoplasm model name.')
     if cytoplasm_channel not in available_channels and not do_only_nuc and is_multichannel:
         raise ParameterInputError('For given input image please select channel in {0}\ncytoplasm_channel : {1}'.format(available_channels, cytoplasm_channel))
@@ -355,22 +357,33 @@ def clean_unused_parameters_cache(user_parameters: dict) :
     
     return user_parameters
 
-def ask_input_parameters(ask_for_segmentation=True) :
+def ask_input_parameters(image_input_values : pipeline_parameters, ask_for_segmentation=True) :
     """
     Prompt user with interface allowing parameters setting for bigFish detection / deconvolution.
     """
     
     values = {}
-    image_input_values = {}
+    default = get_settings()
     while True :
-        is_3D_preset = image_input_values.setdefault('is_3D_stack', default.IS_3D_STACK)
-        is_multichannel_preset = image_input_values.setdefault('is_multichannel', default.IS_MULTICHANNEL)
-        denseregion_preset = image_input_values.setdefault('do_dense_regions_deconvolution', default.DO_DENSE_REGIONS_DECONVOLUTION)
-        do_clustering_preset = image_input_values.setdefault('do_cluster_computation', default.DO_CLUSTER_COMPUTATION)
-        do_napari_preset = image_input_values.setdefault('show_napari_corrector', default.SHOW_NAPARI_CORRECTOR)
+        filename_preset = image_input_values.setdefault("image_path", default.working_directory)
+
+        if os.path.isfile(filename_preset) :
+            filename_preset = os.path.dirname(filename_preset)
+        elif os.path.isdir(filename_preset) :
+            pass
+        else :
+            filename_preset = default.working_directory
+
+        is_3D_preset = image_input_values.setdefault('is_3D_stack', default.stack_3D)
+        is_multichannel_preset = image_input_values.setdefault('is_multichannel', default.multichannel_stack)
+        denseregion_preset = image_input_values.setdefault('do_dense_regions_deconvolution', default.do_dense_regions_deconvolution)
+        do_clustering_preset = image_input_values.setdefault('do_cluster_computation', default.do_cluster)
+        do_napari_preset = image_input_values.setdefault('show_napari_corrector', default.show_napari_corrector)
+        do_background_removal_preset = image_input_values.setdefault('do_background_removal_preset', default.do_background_removal)
 
         if ask_for_segmentation :
             image_input_values = input_image_prompt(
+                filename_preset= filename_preset,
                 is_3D_stack_preset=is_3D_preset,
                 multichannel_preset=is_multichannel_preset,
                 do_dense_regions_deconvolution_preset=None,
@@ -379,6 +392,7 @@ def ask_input_parameters(ask_for_segmentation=True) :
             )
         else :
             image_input_values = input_image_prompt(
+                filename_preset= filename_preset,
                 is_3D_stack_preset=is_3D_preset,
                 multichannel_preset=is_multichannel_preset,
                 do_dense_regions_deconvolution_preset=denseregion_preset,

small_fish_gui/pipeline/actions.py

@@ -2,12 +2,16 @@
 This submodule groups all the possible actions of the user in the main windows. It is the start of each action the user can do.
 """
 
+from torch import layout
 from ..gui.prompts import output_image_prompt, prompt_save_segmentation, prompt_load_segmentation
 from ..gui.prompts import ask_detection_confirmation, ask_cancel_detection, ask_confirmation
 from ..gui.prompts import rename_prompt
+from ..gui.prompts import prompt
+from ..gui.layout import settings_layout
 
 from ..interface.inoutput import write_results, write_list_of_results
 from ..interface.inoutput import input_segmentation, output_segmentation
+from ..interface import get_settings, SettingsDict, write_settings
 
 from ._preprocess import map_channels
 from ._preprocess import prepare_image_detection
@@ -30,6 +34,7 @@ import pandas as pd
 import FreeSimpleGUI as sg
 import numpy as np
 import webbrowser
+from pydantic import ValidationError
 
 def open_wiki() :
     webbrowser.open_new_tab(__wiki__)
@@ -60,7 +65,7 @@ def add_detection(user_parameters : pipeline_parameters, acquisition_id, cytopla
     new_cell_results_df = pd.DataFrame()
 
     #Ask for image parameters
-    new_parameters = ask_input_parameters(ask_for_segmentation= False) #The image is open and stored inside user_parameters
+    new_parameters = ask_input_parameters(user_parameters, ask_for_segmentation= False) #The image is open and stored inside user_parameters
     if type(new_parameters) == type(None) : #if user clicks 'Cancel'
         return new_results_df, new_cell_results_df, acquisition_id, user_parameters
     else :
@@ -93,7 +98,7 @@ def add_detection(user_parameters : pipeline_parameters, acquisition_id, cytopla
         nucleus_signal = get_nucleus_signal(image, other_image, user_parameters)
         
         try : # Catch error raised if user enter a spot size too small compare to voxel size
-            user_parameters, frame_result, spots, clusters, spots_cluster_id = launch_detection(
+            user_parameters, frame_result, spots, clusters, spots_cluster_id, image = launch_detection(
                 image,
                 other_image,
                 user_parameters,
@@ -252,7 +257,7 @@ def save_results(
             path = dic['folder']
             filename = dic['filename']
             do_excel = dic['Excel']
-            do_feather = dic['Feather']
+            do_feather = False
             do_csv = dic['csv']
 
             if 'rna_coords' in cell_result_df.columns : cell_result_df = cell_result_df.drop(columns='rna_coords')
@@ -270,7 +275,7 @@ def save_results(
             path = dic['folder']
             filename = dic['filename']
             do_excel = dic['Excel']
-            do_feather = dic['Feather']
+            do_feather = False
             do_csv = dic['csv']
 
             if 'rna_coords' in cell_result_df.columns : cell_result_df = cell_result_df.drop(columns='rna_coords')
@@ -456,4 +461,42 @@ def rename_acquisitions(
                 df.columns = pd.MultiIndex.from_tuples(new_columns)
                 cell_coloc_df[key] = df
 
-    return result_df, cell_result_df, global_coloc_df, cell_coloc_df
+    return result_df, cell_result_df, global_coloc_df, cell_coloc_df
+
+
+def open_settings() :
+    settings = get_settings()
+
+    while True :
+        layout = settings_layout(settings)
+        event, values = prompt(layout)
+
+        if event == "Cancel" : 
+            return False
+        else :
+            try :
+                if values['threshold'] == "" : values['threshold'] = None
+                if values["voxel_size_z"] == "z" : values["voxel_size_z"] = 1 
+                if values["voxel_size_y"] == "y" : values["voxel_size_y"] = 1 
+                if values["voxel_size_x"] == "x" : values["voxel_size_x"] = 1 
+                values["voxel_size"] = (int(values['voxel_size_z']), int(values['voxel_size_y']), int(values['voxel_size_x']))
+                new_settings = SettingsDict(**values)
+
+            except ValidationError as e :
+
+                layout = []
+                for error in e.errors() :
+                    layout.append([sg.Text(f"{error['loc']} : {error['msg']}")])
+                layout.append([sg.Button("Close")])
+                prompt(layout, add_ok_cancel=False)
+
+            except ValueError as e :
+                if not "invalid literal" in str(e) :
+                    raise e
+                sg.popup("Incorrect voxel size parameters")
+    
+            else :
+                break
+    
+    write_settings(new_settings)
+    return True