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

small_fish_gui/pipeline/_colocalisation.py

@@ -0,0 +1,266 @@
+from ._custom_errors import MissMatchError
+from ..gui import coloc_prompt, add_default_loading
+
+import numpy as np
+import pandas as pd
+import PySimpleGUI as sg
+from scipy.ndimage import distance_transform_edt
+from scipy.signal import fftconvolve
+
+def reconstruct_boolean_signal(image_shape, spot_list: list):
+    signal = np.zeros(image_shape, dtype= bool)
+    if len(spot_list) == 0 : return signal
+    dim = len(spot_list[0])
+
+    if dim == 3 :
+        Z, Y, X = list(zip(*spot_list))
+        signal[Z,Y,X] = True
+
+    else : 
+        Y, X = list(zip(*spot_list))
+        signal[Y,X] = True
+        
+
+    return signal
+
+def nanometer_to_pixel(value, scale) :
+    if isinstance(scale, (float,int)) : scale = [scale]
+    if isinstance(value, (float,int)) : value = [value]*len(scale)
+    if len(value) != len(scale) : raise ValueError("value and scale must have the same dimensionality")
+
+    return list(np.array(value) / np.array(scale))
+
+def _create_counting_kernel(radius_nm, voxel_size) :
+
+    max_pixel_distance = int(max(nanometer_to_pixel(radius_nm, voxel_size)))
+    kernel = np.ones(shape=[2*max_pixel_distance+1 for i in range(len(voxel_size))]) #always odd number so middle is always at [pixel_radius-1, pixel_radius-1, pixel_radius-1]
+    if len(voxel_size) == 3 :
+        kernel[max_pixel_distance, max_pixel_distance, max_pixel_distance] = 0
+    else :
+        kernel[max_pixel_distance, max_pixel_distance] = 0
+
+    kernel = distance_transform_edt(kernel, sampling= voxel_size) <= radius_nm
+    
+    return kernel.astype(int)
+
+def _spot_count_map(spots_array, radius_px, voxel_size) :
+    """
+    Create a map where each pixel value correspond to the number of spots closer than radius to the position.
+    """
+
+    kernel = _create_counting_kernel(radius_px, voxel_size)
+    map = fftconvolve(spots_array, kernel, mode= 'same')
+
+    return np.round(map).astype(int)
+
+def _reconstruct_spot_signal(image_shape, spot_list: list, dim=3):
+    """
+    Create a map where each pixel value correspond to the number of spots located in this position.
+    """
+    signal = np.zeros(image_shape, dtype= int)
+    unique_list, counts = np.unique(spot_list, return_counts= True, axis=0)
+    if dim == 3 :
+        Z, Y, X = list(zip(*unique_list))
+        signal[Z,Y,X] = counts
+    elif dim == 2 :
+        Y, X = list(zip(*unique_list))
+        signal[Y,X] = counts
+    else : 
+        raise ValueError("Wrong dim passed should be 2 or 3, it is {0}".format(dim))
+
+    return signal
+
+def spots_multicolocalisation(spots_list, anchor_list, radius_nm, image_shape, voxel_size) :
+
+    """
+    Compute the number of spots from spots_list closer than radius to a spot from anchor_list. Each spots_list spots will be counted as many times as there are anchors close enough.
+    Note that the radius in nm is converted to pixel using voxel size, and rounded to the closest int value.
+    
+    Example in 2D
+    --------
+
+    >>> Anchors         Spots           Radius (2px)    Count
+    >>> 0 0 0 0 0 0     0 X 0 0 X 0       1             0 1 0 0 0 0
+    >>> 0 X 0 0 0 0     X 0 0 X 0 0     1 1 1           1 0 0 0 0 0
+    >>> 0 X 0 0 0 0     X X 0 0 0 0       1             1 2 0 0 0 0     --> 5
+    >>> 0 0 0 0 X 0     0 0 X 0 0 0                     0 0 0 0 0 0
+    >>> 0 0 0 0 0 0     0 0 0 X 0 0                     0 0 0 0 0 0
+
+    Parameters
+    ----------
+    spots_list : list
+    anchor_list : list
+    radius_nm : int, float
+    image_shape : tuple (Z, Y, X)
+    voxel_size : tuple (Z, Y, X)
+    
+    Returns
+    -------
+    Returns the list of neighbouring spot number to 'spots_list'.
+    """
+    if len(spots_list) == 0 or len(anchor_list) == 0 : return 0
+    if len(voxel_size) != len(spots_list[0]) : raise ValueError("Dimensions missmatched; voxel_size : {0} spots : {1}".format(len(voxel_size), len(spots_list[0])))
+
+    dim = len(voxel_size)
+
+    anchor_array = _reconstruct_spot_signal(image_shape=image_shape, spot_list=anchor_list, dim=dim)
+    count_map = _spot_count_map(anchor_array, radius_px=radius_nm, voxel_size=voxel_size)
+
+    if dim == 3 :
+        Z,Y,X = list(zip(*spots_list))
+        res = list(count_map[Z,Y,X])
+
+    if dim == 2 :
+        Y,X = list(zip(*spots_list))
+        res = list(count_map[Y,X])
+
+    return res
+
+def spots_colocalisation(image_shape, spot_list1:list, spot_list2:list, distance: float, voxel_size)-> int :
+    """
+    Return number of spots from spot_list1 located closer(large) than distance to at least one spot of spot_list2.
+
+    Parameters
+    ----------
+        image_shape : tuple
+        spot_list1 : list
+        spot_list2 : list
+        distance : nanometer
+            distance in nanometer.
+        voxel_size : (z,y,x) tuple
+    """
+
+    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.")
+    
+    if len(voxel_size) == 3 :
+        image_shape = image_shape[-3:]
+    else : 
+        image_shape = image_shape[-2:]
+
+    signal2 = reconstruct_boolean_signal(image_shape, spot_list2)
+    mask = np.logical_not(signal2)
+    distance_map = distance_transform_edt(mask, sampling= voxel_size)
+
+    if len(voxel_size) == 3 :
+        Z,Y,X = zip(*spot_list1)
+        count = (distance_map[Z,Y,X] <= distance).sum()
+    else :
+        Y,X = zip(*spot_list1)
+        count = (distance_map[Y,X] <= distance).sum()
+
+    return count
+
+
+   
+
+
+
+def initiate_colocalisation(result_tables) :
+    if len(result_tables) != 2 : 
+        sg.popup("Please select 2 acquisitions for colocalisation (Ctrl + click in the table)")
+        return False
+    else : 
+        while True :
+            colocalisation_distance = coloc_prompt()
+            if colocalisation_distance == False : return False
+            try : 
+                colocalisation_distance = int(colocalisation_distance)
+            except Exception :
+                sg.popup("Incorrect colocalisation distance")
+            else :
+                break
+        return colocalisation_distance
+
+@add_default_loading
+def launch_colocalisation(result_tables, result_dataframe, colocalisation_distance) :
+    """
+
+    Target :
+
+    - acquisition_couple
+    - colocalisation_distance
+    - spot1_total
+    - spot2_total
+    - fraction_spot1_coloc_spots
+    - fraction_spot2_coloc_spots
+    - fraction_spot1_coloc_clusters
+    - fraction_spot2_coloc_spots
+
+    """
+
+    acquisition1 = result_dataframe.iloc[result_tables[0]]
+    acquisition2 = result_dataframe.iloc[result_tables[1]]
+
+    voxel_size1 = acquisition1.at['voxel_size']
+    voxel_size2 = acquisition2.at['voxel_size']
+    shape1 = acquisition1.at['reordered_shape']
+    shape2 = acquisition2.at['reordered_shape']
+
+    if voxel_size1 != voxel_size2 : 
+        raise MissMatchError("voxel size 1 different than voxel size 2")
+    else :
+        voxel_size = voxel_size1
+
+    if shape1 != shape2 :
+        print(shape1)
+        print(shape2) 
+        raise MissMatchError("shape 1 different than shape 2")
+    else :
+        shape = shape1
+        print(shape1)
+        print(shape2)
+
+    acquisition_couple = (acquisition1.at['acquisition_id'], acquisition2.at['acquisition_id'])
+
+    spots1 = acquisition1['spots']
+    spots2 = acquisition2['spots']
+
+    spot1_total = len(spots1)
+    spot2_total = len(spots2)
+
+    try :
+        fraction_spots1_coloc_spots2 = spots_colocalisation(image_shape=shape, spot_list1=spots1, spot_list2=spots2, distance= colocalisation_distance, voxel_size=voxel_size) / spot1_total
+        fraction_spots2_coloc_spots1 = spots_colocalisation(image_shape=shape, 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
+
+    if 'clusters' in acquisition1.index :
+        try : 
+            clusters1 = acquisition1['clusters'][:,:len(voxel_size)]
+            fraction_spots2_coloc_cluster1 = spots_colocalisation(image_shape=shape, spot_list1=spots2, spot_list2=clusters1, distance= colocalisation_distance, voxel_size=voxel_size) / spot2_total
+        except MissMatchError as e :
+            sg.popup(str(e))
+            fraction_spots2_coloc_cluster1 = np.NaN
+
+    else : fraction_spots2_coloc_cluster1 = np.NaN
+
+    if 'clusters' in acquisition2.index :
+        try :
+            clusters2 = acquisition2['clusters'][:,:len(voxel_size)]
+            fraction_spots1_coloc_cluster2 = spots_colocalisation(image_shape=shape, spot_list1=spots1, spot_list2=clusters2, distance= colocalisation_distance, voxel_size=voxel_size) / spot1_total
+        except MissMatchError as e :
+            sg.popup(str(e))
+            fraction_spots1_coloc_cluster2 = np.NaN
+
+    else : fraction_spots1_coloc_cluster2 = np.NaN
+
+    coloc_df = pd.DataFrame({
+        "acquisition_couple" : [acquisition_couple],
+        "acquisition_id_1" : [acquisition_couple[0]],
+        "acquisition_id_2" : [acquisition_couple[1]],
+        "colocalisation_distance" : [colocalisation_distance],
+        "spot1_total" : [spot1_total],
+        "spot2_total" : [spot2_total],
+        'fraction_spots1_coloc_spots2' : [fraction_spots1_coloc_spots2],
+        'fraction_spots2_coloc_spots1' : [fraction_spots2_coloc_spots1],
+        'fraction_spots2_coloc_cluster1' : [fraction_spots2_coloc_cluster1],
+        'fraction_spots1_coloc_cluster2' : [fraction_spots1_coloc_cluster2],
+    })
+
+    print(coloc_df.loc[:,['fraction_spots1_coloc_spots2','fraction_spots2_coloc_spots1', 'fraction_spots2_coloc_cluster1', 'fraction_spots1_coloc_cluster2']])
+
+    return coloc_df

small_fish_gui/pipeline/_custom_errors.py

@@ -0,0 +1,2 @@
+class MissMatchError(ValueError) :
+    pass

small_fish_gui/pipeline/_detection_visualisation.py

@@ -0,0 +1,139 @@
+"""
+Contains Napari wrappers to visualise and correct spots/clusters.
+"""
+
+
+import numpy as np
+import scipy.ndimage as ndi
+import napari
+
+from napari.utils.events import Event
+from napari.layers import Points
+from bigfish.stack import check_parameter
+from ..utils import compute_anisotropy_coef
+from ._colocalisation import spots_multicolocalisation
+
+class Points_callback :
+    """
+    Custom class to handle points number evolution during Napari run.
+    """
+    
+    def __init__(self, points, next_id) -> None:
+        self.points = points
+        self.next_id = next_id
+        self._set_callback()
+    
+    def __str__(self) -> str:
+        string = 'Points_callback object state :\ncurrent_points_number : {0}\ncurrnet_id : {1}'.format(self.current_points_number, self.next_id)
+        return string
+    
+    def get_points(self) :
+        return self.points
+    
+    def get_next_id(self) : 
+        return self.next_id
+    
+    def _set_callback(self) :
+        def callback(event:Event) :
+
+            old_points = self.get_points()
+            new_points:Points = event.source.data
+            features = event.source.features
+            
+            current_point_number = len(old_points)
+            next_id = self.get_next_id()
+            new_points_number = len(new_points)
+
+            if new_points_number > current_point_number :
+                features.at[new_points_number - 1, "id"] = next_id
+                self.next_id += 1
+
+            #preparing next callback
+            self.points = new_points
+            self._set_callback()
+        self.callback = callback
+
+def _update_clusters(new_clusters: np.ndarray, spots: np.ndarray, voxel_size, cluster_size, min_spot_number, shape) :
+    if len(new_clusters) == 0 : return new_clusters
+    if len(spots) == 0 : return new_clusters
+    assert len(new_clusters[0]) == 4 or len(new_clusters[0]) == 5, "Wrong number of coordinates for clusters should not happen."
+    
+    # Update spots clusters
+    if len(voxel_size) == 3 :
+        new_clusters[:,-2] = spots_multicolocalisation(new_clusters[:,:3], spots, radius_nm= cluster_size, voxel_size=voxel_size, image_shape=shape)
+    elif len(voxel_size) == 2 :
+        new_clusters[:,-2] = spots_multicolocalisation(new_clusters[:,:2], spots, radius_nm= cluster_size, voxel_size=voxel_size, image_shape=shape)
+
+    # delete too small clusters
+        new_clusters = np.delete(new_clusters, new_clusters[:,-2] < min_spot_number, 0)
+
+    return new_clusters
+
+def correct_spots(image, spots, voxel_size= (1,1,1), clusters= None, cluster_size=None, min_spot_number=0, cell_label= None, nucleus_label= None, other_images =[]):
+    """
+    Open Napari viewer for user to visualize and corrects spots, clusters.
+
+    Returns
+    -------
+        new_spots,new_clusters
+    """
+    check_parameter(image= np.ndarray, voxel_size= (tuple,list))
+    dim = len(voxel_size)
+
+    if dim == 3 and type(cell_label) != type(None) :
+        cell_label = np.repeat(
+            cell_label[np.newaxis],
+            repeats= len(image),
+            axis=0
+        )
+    if dim == 3 and type(nucleus_label) != type(None) :
+        nucleus_label = np.repeat(
+            nucleus_label[np.newaxis],
+            repeats= len(image),
+            axis=0
+        )
+
+    scale = compute_anisotropy_coef(voxel_size)
+    try :
+        Viewer = napari.Viewer(ndisplay=2, title= 'Spot correction', axis_labels=['z','y','x'], show= False)
+        Viewer.add_image(image, scale=scale, name= "rna signal", blending= 'additive', colormap='red')
+        other_colors = ['green', 'blue', 'gray', 'cyan', 'bop orange', 'bop purple'] * ((len(other_images)-1 // 7) + 1)
+        for im, color in zip(other_images, other_colors) : 
+            Viewer.add_image(im, scale=scale, blending='additive', visible=False, colormap=color)
+        layer_offset = len(other_images)
+
+        Viewer.add_points(spots, size = 5, scale=scale, face_color= 'green', opacity= 1, symbol= 'ring', name= 'single spots') # spots
+        if type(clusters) != type(None) : Viewer.add_points(clusters[:,:dim], size = 10, scale=scale, face_color= 'blue', opacity= 0.7, symbol= 'diamond', name= 'foci', features= {"spot_number" : clusters[:,dim], "id" : clusters[:,dim+1]}, feature_defaults= {"spot_number" : 0, "id" : -1}) # cluster
+        if type(cell_label) != type(None) and np.array_equal(nucleus_label, cell_label) : Viewer.add_labels(cell_label, scale=scale, opacity= 0.2, blending= 'additive')
+        if type(nucleus_label) != type(None) : Viewer.add_labels(nucleus_label, scale=scale, opacity= 0.2, blending= 'additive')
+        
+        #prepare cluster update
+        if type(clusters) != type(None) : 
+            next_cluster_id = clusters[-1,-1] + 1 if len(clusters) > 0 else 1
+            _callback = Points_callback(points=clusters[:dim], next_id=next_cluster_id)
+            points_callback = Viewer.layers[2 + layer_offset].events.data.connect((_callback, 'callback'))
+        Viewer.show(block=False)
+        napari.run()
+        
+
+        new_spots = np.array(Viewer.layers[1 + layer_offset].data, dtype= int)
+
+        if type(clusters) != type(None) :
+            if len(clusters) > 0 : 
+                new_clusters = np.concatenate([
+                    np.array(Viewer.layers[2 + layer_offset].data, dtype= int),
+                    np.array(Viewer.layers[2 + layer_offset].features, dtype= int)
+                ],
+                axis= 1)
+
+                new_clusters = _update_clusters(new_clusters, new_spots, voxel_size=voxel_size, cluster_size=cluster_size, min_spot_number=min_spot_number, shape=image.shape)
+        else : new_clusters = None
+
+    except Exception as error :
+        new_spots = spots
+        new_clusters = clusters
+        raise error
+
+    return new_spots, new_clusters
+
+

small_fish_gui/pipeline/_preprocess.py

@@ -0,0 +1,272 @@
+import numpy as np
+import pandas as pd
+import PySimpleGUI as sg
+from ..gui import _error_popup, _warning_popup, parameters_layout, add_header, prompt, prompt_with_help
+
+class ParameterInputError(Exception) :
+    """
+    Raised when user inputs an incorrect parameter.
+    """
+    pass
+
+class MappingError(ValueError) :
+    """
+    Raised when user inputs an incorrect image mapping.
+    """
+    def __init__(self, map ,*args: object) -> None:
+        super().__init__(*args)
+        self.map = map
+
+    def get_map(self) :
+        return self.map
+
+def prepare_image_detection(map, user_parameters) :
+    """
+    Return monochannel image for ready for spot detection; 
+    if image is already monochannel, nothing happens.
+    else : image is the image on which detection is performed, other_image are the other layer to show in Napari Viewer.
+    """
+    image = reorder_image_stack(map, user_parameters)
+    assert len(image.shape) != 5 , "Time stack not supported, should never be True"
+    
+    if user_parameters['multichannel'] :
+        channel_to_compute = 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 :
+        other_image = []
+
+    return image, other_image
+
+def reorder_image_stack(map, user_parameters) :
+    image_stack = user_parameters['image']
+    x = (int(map['x']),)
+    y = (int(map['y']),)
+    z = (int(map['z']),) if type(map.get('z')) != type(None) else ()
+    c = (int(map['c']),) if type(map.get('c')) != type(None) else ()
+    t = (int(map['t']),) if type(map.get('t')) != type(None) else ()
+
+    source = t+c+z+y+x
+
+    image_stack = np.moveaxis(
+        image_stack,
+        source= source,
+        destination= tuple(range(len(source)))
+    )
+
+    return image_stack
+
+def map_channels(user_parameters) :
+    
+    image = user_parameters['image']
+    is_3D_stack = user_parameters['3D stack']
+    is_time_stack = user_parameters['time stack']
+    multichannel = user_parameters['multichannel']
+
+    try : 
+        map = _auto_map_channels(image, is_3D_stack, is_time_stack, multichannel)
+    except MappingError as e :
+        sg.popup("Automatic dimension mapping went wrong. Please indicate manually dimensions positions in the array.")
+        map = _ask_channel_map(image.shape, is_3D_stack, is_time_stack, multichannel, preset_map= e.get_map())
+
+    else :
+        map = _show_mapping(image.shape, map, is_3D_stack, is_time_stack, multichannel,)
+
+    return map
+
+def _auto_map_channels(image: np.ndarray, is_3D_stack, is_time_stack, multichannel) :
+    shape = image.shape
+    reducing_list = list(shape)
+
+    #Set the biggest dimension to y
+    y_val = max(reducing_list)
+    y_idx = shape.index(y_val)
+    map = {'y' : y_idx}
+
+    #2nd biggest set to x
+    reducing_list[y_idx] = -1
+    x_val = max(reducing_list)
+    x_idx = reducing_list.index(x_val)
+    reducing_list[y_idx] = y_val
+
+    map['x'] = x_idx
+    reducing_list.remove(y_val)
+    reducing_list.remove(x_val)
+
+    #smaller value set to c
+    if multichannel :
+        c_val = min(reducing_list)
+        c_idx = shape.index(c_val)
+        map['c'] = c_idx
+        reducing_list.remove(c_val)
+
+    if is_time_stack :
+        t_val = reducing_list[0]
+        t_idx = shape.index(t_val)
+        map['t'] = t_idx
+        reducing_list.remove(t_val)
+    
+    if is_3D_stack :
+        z_val = reducing_list[0]
+        z_idx = shape.index(z_val)
+        map['z'] = z_idx
+
+    total_channels = len(map)
+    unique_channel = len(np.unique(list(map.values())))
+
+    if total_channels != unique_channel : raise MappingError(map,"{0} channel(s) are not uniquely mapped.".format(total_channels - unique_channel))
+
+    return map
+
+def _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map: dict= {}) :
+    map = preset_map
+    while True :
+        relaunch = False
+        x = map.setdefault('x',0)
+        y = map.setdefault('y',0)
+        z = map.setdefault('z',0)
+        c = map.setdefault('c',0)
+        t = map.setdefault('t',0)
+
+        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])]
+
+        event, map = prompt_with_help(layout,help= 'mapping')
+        if event == 'Cancel' : quit()
+
+        #Check integrity
+        channels_values = np.array(list(map.values()), dtype= int)
+        total_channels = len(map)
+        unique_channel = len(np.unique(channels_values))
+        if total_channels != unique_channel :
+            sg.popup("{0} channel(s) are not uniquely mapped.".format(total_channels - unique_channel))
+            relaunch= True
+        if not all(channels_values < len(shape)):
+            sg.popup("Channels values out of range for image dimensions.\nPlease select dimensions from {0}".format(list(range(len(shape)))))
+            relaunch= True
+        if not relaunch : break
+
+    return map
+
+def _show_mapping(shape, map, is_3D_stack, is_time_stack, multichannel) :
+    layout = [
+        [sg.Text("Image shape : {0}".format(shape))],
+        [sg.Text('Dimensions mapping was set to :')],
+        [sg.Text('x : {0} \ny : {1} \nz : {2} \nc : {3} \nt : {4}'.format(
+            map['x'], map['y'], map.get('z'), map.get("c"), map.get('t')
+        ))],
+        [sg.Button('Change mapping')]
+    ]
+
+    event, values = prompt_with_help(layout, help='mapping')
+
+    if event == 'Ok' :
+        return map
+    elif event == 'Change mapping' or event == 'Cancel':
+        map = _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map=map)
+    else : raise AssertionError('Unforseen event')
+
+    return map
+
+def convert_parameters_types(values:dict) :
+    """
+    Convert parameters from `ask_input_parameters` from strings to float, int or tuple type.
+    """
+
+    #Tuples
+    tuples_list = ['voxel_size', 'spot_size', 'log_kernel_size', 'minimum_distance', 'deconvolution_kernel']
+    dim = values['dim']
+    if dim == 3 : dim_tuple = ('z', 'y', 'x')
+    else : dim_tuple = ('y', 'x')
+
+    for tuple_parameter in tuples_list :
+        try :
+            tuple_values = tuple([float(values.get(tuple_parameter + '_{0}'.format(dimension))) for dimension in dim_tuple])
+        except Exception : #execption when str cannot be converted to float or no parameter was given.
+            values[tuple_parameter] = None
+        else : values[tuple_parameter] = tuple_values
+
+    #Parameters
+    int_list = ['threshold', 'channel_to_compute', 'min number of spots', 'cluster size','nucleus channel signal']
+    float_list = ['time_step', 'alpha', 'beta', 'gamma', 'threshold penalty']
+
+    for parameter in int_list :
+        try :
+            parameter_value = int(values[parameter])
+        except Exception :
+            values[parameter] = None
+        else : values[parameter] = parameter_value
+
+    for parameter in float_list :
+        try :
+            parameter_value = float(values[parameter])
+        except Exception :
+            values[parameter] = None
+        else : values[parameter] = parameter_value
+
+    return values
+
+def check_integrity(values: dict, do_dense_region_deconvolution, multichannel,segmentation_done, map, shape):
+    """
+    Checks that parameters given in input by user are fit to be used for bigfish detection.
+    """
+
+    #voxel_size
+    if type(values['voxel_size']) == type(None) : raise ParameterInputError('Incorrect voxel size parameter.')
+    
+    #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))) :
+       raise ParameterInputError("Either minimum_distance and 'log_kernel_size' must be correctly set\n OR 'spot_size' must be correctly set.")
+    
+    #Deconvolution integrity
+    if do_dense_region_deconvolution :
+        if not isinstance(values['alpha'], (float, int)) or not isinstance(values['beta'], (float, int)) :
+            raise ParameterInputError("Incorrect alpha or beta parameters.")
+        if type(values['gamma']) == type(None) and not isinstance(values['deconvolution_kernel'], (list, tuple)):
+            _warning_popup('No gamma found; image will not be denoised before deconvolution.')
+            values['gamma'] = 0
+
+    #channel
+    if multichannel :
+        ch_len = shape[int(map['c'])]
+        if segmentation_done :
+            try : nuc_signal_ch = int(values['nucleus channel signal'])
+            except Exception :
+                raise ParameterInputError("Incorrect channel for nucleus signal measure.")
+            if nuc_signal_ch > ch_len :
+                raise ParameterInputError("Nucleus signal channel is out of range for image.\nPlease select from {0}".format(list(range(ch_len))))
+            values['nucleus channel signal'] = nuc_signal_ch
+
+        try :
+            ch = int(values['channel to compute'])
+        except Exception :
+            raise ParameterInputError("Incorrect channel to compute parameter.")
+        if ch >= ch_len :
+            raise ParameterInputError("Channel to compute is out of range for image.\nPlease select from {0}".format(list(range(ch_len))))
+        values['channel to compute'] = ch
+
+    return values
+
+
+def reorder_shape(shape, map) :
+    x = [int(map['x']),]
+    y = [int(map['y']),]
+    z = [int(map['z']),] if type(map.get('z')) != type(None) else []
+    c = [int(map['c']),] if type(map.get('c')) != type(None) else []
+    t = [int(map['t']),] if type(map.get('t')) != type(None) else []
+
+    source = t + c + z + y + x
+
+    new_shape = tuple(
+        np.array(shape)[source]
+    )
+
+    return new_shape