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

small_fish_gui/pipeline/segmentation.py

@@ -5,17 +5,16 @@ Contains cellpose wrappers to segmentate images.
 from cellpose.core import use_gpu
 from skimage.measure import label
 from ..hints import pipeline_parameters
-from ..gui.layout import _segmentation_layout
-from ..gui import prompt, ask_cancel_segmentation
-from ..interface import open_image
+from ..interface import get_settings
+from ..gui import prompt, ask_cancel_segmentation, segmentation_prompt
 from ..gui.napari_visualiser import show_segmentation as napari_show_segmentation
+from ..interface import open_image, SettingsDict, get_settings
+
 from .utils import from_label_get_centeroidscoords
 from ._preprocess import ask_input_parameters
 from ._preprocess import map_channels, reorder_shape, reorder_image_stack
-from matplotlib.colors import ListedColormap
-
-import small_fish_gui.default_values as default
 
+from matplotlib.colors import ListedColormap
 import matplotlib as mpl
 import cellpose.models as models
 import numpy as np
@@ -25,8 +24,9 @@ import bigfish.plot as plot
 import FreeSimpleGUI as sg
 import matplotlib.pyplot as plt
 import os
+from .utils import using_mps
 
-def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cytoplasm_label) :
+def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cytoplasm_label, batch_mode=False) :
     """
     Ask user for necessary parameters and perform cell segmentation (cytoplasm + nucleus) with cellpose.
 
@@ -40,10 +40,11 @@ def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cyt
         cytoplasm_label, nucleus_label, user_parameters
     """
 
-    segmentation_parameters = user_parameters.copy()
+    segmentation_parameters : pipeline_parameters = user_parameters.copy()
+    default = get_settings()
 
     #Ask for image parameters
-    new_parameters = ask_input_parameters(ask_for_segmentation= True) #The image is open and stored inside user_parameters
+    new_parameters = ask_input_parameters(user_parameters, ask_for_segmentation= True) #The image is open and stored inside user_parameters
     if type(new_parameters) == type(None) : #if user clicks 'Cancel'
         return nucleus_label , cytoplasm_label, user_parameters
     else :
@@ -55,56 +56,28 @@ def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cyt
     segmentation_parameters['reordered_shape'] = reorder_shape(segmentation_parameters['shape'], map_)
     image = reorder_image_stack(map_, segmentation_parameters['image'])
 
+    is_multichannel = segmentation_parameters["is_multichannel"]
+    is_3D_stack = segmentation_parameters["is_3D_stack"]
+
     while True : # Loop if show_segmentation 
         #Default parameters
-        cyto_model_name = segmentation_parameters.setdefault('cyto_model_name', default.CYTO_MODEL)
-        cyto_size = segmentation_parameters.setdefault('cytoplasm_diameter', default.CYTO_DIAMETER)
-        cytoplasm_channel = segmentation_parameters.setdefault('cytoplasm_channel', default.CHANNEL)
-        nucleus_model_name = segmentation_parameters.setdefault('nucleus_model_name', default.NUC_MODEL)
-        nucleus_size = segmentation_parameters.setdefault('nucleus_diameter', default.NUC_DIAMETER)
-        nucleus_channel = segmentation_parameters.setdefault('nucleus_channel', default.CHANNEL)
-        other_nucleus_image = segmentation_parameters.setdefault('other_nucleus_image',None)
         path = os.getcwd()
-        show_segmentation = segmentation_parameters.setdefault('show_segmentation', default.SHOW_SEGMENTATION)
-        save_segmentation_visual = segmentation_parameters.setdefault('save_segmentation_visual', default.SAVE_SEGMENTATION_VISUAL)
-        segment_only_nuclei = segmentation_parameters.setdefault('segment_only_nuclei', default.SEGMENT_ONLY_NUCLEI)
-        multichannel = segmentation_parameters.setdefault('is_multichannel', default.IS_MULTICHANNEL)
-        is_3D_stack = segmentation_parameters.setdefault('is_3D_stack', default.IS_3D_STACK)
-        anisotropy = segmentation_parameters.setdefault('anisotropy', default.ANISOTROPY)
-        cytoplasm_segmentation_3D = segmentation_parameters.setdefault('cytoplasm_segmentation_3D', default.DO_3D_SEMGENTATION)
-        nucleus_segmentation_3D = segmentation_parameters.setdefault('nucleus_segmentation_3D', default.DO_3D_SEMGENTATION)
-        flow_threshold = segmentation_parameters.setdefault("flow_threshold",0.4)
-        cellprob_threshold = segmentation_parameters.setdefault("cellprob_threshold",0)
-        filename = segmentation_parameters['filename']
         available_channels = list(range(image.shape[0]))
-
+        available_slices = list(range(image.shape[is_multichannel])) #0 if not multichannel else 1
 
     #Ask user for parameters
     #if incorrect parameters --> set relaunch to True
         while True :
-            layout = _segmentation_layout(
-                cytoplasm_model_preset = cyto_model_name,
-                cytoplasm_channel_preset= cytoplasm_channel,
-                nucleus_model_preset = nucleus_model_name,
-                nucleus_channel_preset= nucleus_channel,
-                cyto_diameter_preset= cyto_size,
-                nucleus_diameter_preset= nucleus_size,
-                other_nucleus_image_preset=other_nucleus_image,
-                saving_path_preset= path,
-                save_segmentation_visual_preset=save_segmentation_visual,
-                show_segmentation_preset=show_segmentation,
-                segment_only_nuclei_preset=segment_only_nuclei,
-                filename_preset=filename,
-                multichannel=multichannel,
-                is_3D_stack=is_3D_stack,
-                cytoplasm_segmentation_3D=cytoplasm_segmentation_3D,
-                nucleus_segmentation_3D=nucleus_segmentation_3D,
-                anisotropy=anisotropy,
-                flow_threshold=flow_threshold,
-                cellprob_threshold=cellprob_threshold,
-            )
+            segmentation_parameters.setdefault("other_nucleus_image", segmentation_parameters["working_directory"])
+            segmentation_parameters.setdefault("cytoplasm_channel", segmentation_parameters["detection_channel"])
+            segmentation_parameters.setdefault("cytoplasm_segmentation_3D", segmentation_parameters["do_3D_segmentation"])
+            segmentation_parameters.setdefault("nucleus_segmentation_3D", segmentation_parameters["do_3D_segmentation"])
+
+            event, values = segmentation_prompt(
+                saving_path= segmentation_parameters.setdefault("seg_control_saving_path", segmentation_parameters["working_directory"]),
+                **segmentation_parameters
+                )
 
-            event, values = prompt(layout)
             if event == 'Cancel' :
                 cancel_segmentation = ask_cancel_segmentation()
 
@@ -114,180 +87,46 @@ def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cyt
                     continue
 
             #Extract parameters
-            values : pipeline_parameters = _cast_segmentation_parameters(values)
-            do_only_nuc = values['segment_only_nuclei']
-            cyto_model_name = values['cyto_model_name']
-            cyto_size = values['cytoplasm_diameter']
-            cytoplasm_channel = values['cytoplasm_channel']
-            nucleus_model_name = values['nucleus_model_name']
-            nucleus_size = values['nucleus_diameter']
-            nucleus_channel = values['nucleus_channel']
-            other_nucleus_image = values['other_nucleus_image']
-            path = values['saving path'] if values['saving path'] != '' else None
-            save_segmentation_visual = values['save_segmentation_visual']
-            show_segmentation = values['show_segmentation']
-            filename = values['filename'] if type(path) != type(None) else None
-            channels = [cytoplasm_channel, nucleus_channel] if multichannel else [...,...]
-            nucleus_segmentation_3D = values['nucleus_segmentation_3D']
-            cytoplasm_segmentation_3D = values['cytoplasm_segmentation_3D']
-            anisotropy = values['anisotropy']
-            cellprob_threshold_cyto = values['cellprob_threshold_cyto']
-            cellprob_threshold_nuc = values['cellprob_threshold_nuc']
-            flow_threshold_cyto = values['flow_threshold_cyto']
-            flow_threshold_nuc = values['flow_threshold_nuc']
-
-            relaunch= False
-            #Checking integrity of parameters
-
-            #flow thresholds
-            if type(flow_threshold_nuc) != float : 
-                sg.popup('Invalid value for flow threshold in nuc parameters, must be a float between 0 and 1.')
-                values['flow_threshold_nuc'] = user_parameters.setdefault('flow_threshold_nuc',default.FLOW_THRESHOLD)
-                relaunch= True
-            if type(flow_threshold_cyto) != float : 
-                sg.popup('Invalid value for flow threshold in cyto parameters, must be a float between 0 and 1.')
-                values['flow_threshold_cyto'] = user_parameters.setdefault('flow_threshold_cyto',default.FLOW_THRESHOLD)
-                relaunch= True
-            
-            #cellprob thresholds
-            if type(flow_threshold_nuc) != float : 
-                sg.popup('Invalid value for cellprob threshold in nuc parameters, must be a float between -3 and +3.')
-                values['flow_threshold_nuc'] = user_parameters.setdefault('flow_threshold_nuc',default.FLOW_THRESHOLD)
-                relaunch= True
-            if type(flow_threshold_cyto) != float : 
-                sg.popup('Invalid value for cellprob threshold in cyto parameters, must be a float between -3 and +3.')
-                values['flow_threshold_cyto'] = user_parameters.setdefault('flow_threshold_cyto',default.FLOW_THRESHOLD)
-                relaunch= True
-
-            
-            #Models
-            if type(cyto_model_name) != str  and not do_only_nuc:
-                sg.popup('Invalid cytoplasm model name.')
-                values['cyto_model_name'] = user_parameters.setdefault('cyto_model_name', default.CYTO_MODEL)
-                relaunch= True
-            if multichannel :
-                if cytoplasm_channel not in available_channels and not do_only_nuc:
-                    sg.popup('For given input image please select channel in {0}\ncytoplasm_channel : {1}'.format(available_channels, cytoplasm_channel))
-                    relaunch= True
-                    values['cytoplasm_channel'] = user_parameters.setdefault('cytoplasm_channel',default.CHANNEL)
-            else :
-                cytoplasm_channel = ...
-
-            if is_3D_stack :
-                try :
-                    float(anisotropy)
-                    if anisotropy <0 : raise ValueError()
-
-                except ValueError :
-                    sg.popup("Anisotropy must be a positive float.")
-                    relaunch = True
-                    values['anisotropy'] = user_parameters.setdefault('anisotropy', default.ANISOTROPY)
-
-            if type(cyto_size) not in [int, float] and not do_only_nuc:
-                sg.popup("Incorrect cytoplasm size.")
-                relaunch= True
-                values['cytoplasm_diameter'] = user_parameters.setdefault('cytoplasm_diameter', default.CYTO_DIAMETER)
-
-            if type(nucleus_model_name) != str :
-                sg.popup('Invalid nucleus model name.')
-                values['nucleus_model_name'] = user_parameters.setdefault('nucleus_model_name', default.NUC_MODEL)
-                relaunch= True
-            
-            if multichannel :
-                if nucleus_channel not in available_channels :
-                    sg.popup('For given input image please select channel in {0}\nnucleus channel : {1}'.format(available_channels, nucleus_channel))
-                    relaunch= True
-                    values['nucleus_channel'] = user_parameters.setdefault('nucleus_channel', default.CHANNEL)
-            else : 
-                nucleus_channel = ...
-
-            if type(nucleus_size) not in [int, float] :
-                sg.popup("Incorrect nucleus size.")
-                relaunch= True
-                values['nucleus_diameter'] = user_parameters.setdefault('nucleus_diameter', default.NUC_DIAMETER)
-
-            if other_nucleus_image != '' :
-                if not os.path.isfile(other_nucleus_image) :
-                    sg.popup("Nucleus image is not a file.")
-                    relaunch=True
-                    values['other_nucleus_image'] = None
-                else :
-                    try :
-                        nucleus_image = open_image(other_nucleus_image)
-                    except Exception as e :
-                        sg.popup("Could not open image.\n{0}".format(e))
-                        relaunch=True
-                        values['other_nucleus_image'] = user_parameters.setdefault('other_nucleus_image', None)
-                    else :
-                        if nucleus_image.ndim != image.ndim - multichannel :
-                            sg.popup("Nucleus image dimension missmatched. Expected same dimension as cytoplasm_image for monochannel or same dimension as cytoplasm_image -1 for multichannel\ncytoplasm dimension : {0}, nucleus dimension : {1}".format(image.ndim, nucleus_image.ndim))
-                            nucleus_image = None
-                            relaunch=True
-                            values['other_nucleus_image'] = user_parameters.setdefault('other_nucleus_image', None)
-                        
-                        elif nucleus_image.shape != image[cytoplasm_channel].shape :
-                            sg.popup("Nucleus image shape missmatched. Expected same shape as cytoplasm_image \ncytoplasm shape : {0}, nucleus shape : {1}".format(image[cytoplasm_channel].shape, nucleus_image.shape))
-                            nucleus_image = None
-                            relaunch=True
-                            values['other_nucleus_image'] = user_parameters.setdefault('other_nucleus_image', None)
-
-            else :
-                nucleus_image = None
-
-            user_parameters.update(values)
+            values, relaunch = _check_integrity_segmentation_parameters(values, segmentation_parameters, available_channels=available_channels, available_slices=available_slices)
+            segmentation_parameters.update(values)
             if not relaunch : break
 
-        #Launching segmentation
-        waiting_layout = [
-            [sg.Text("Running segmentation...")]
-        ]
-        window = sg.Window(
-            title= 'small_fish',
-            layout= waiting_layout,
-            grab_anywhere= True,
-            no_titlebar= False
-        )
+        if not batch_mode :
+            #Launching segmentation
+            waiting_layout = [
+                [sg.Text("Running segmentation...")]
+            ]
+            window = sg.Window(
+                title= 'small_fish',
+                layout= waiting_layout,
+                grab_anywhere= True,
+                no_titlebar= False
+            )
 
-        window.read(timeout= 30, close= False)
+            window.read(timeout= 30, close= False)
 
         try :
-            if type(path) != type(None) and filename != '':
-                output_path = path + '/' + filename
-                nuc_path = output_path + "_nucleus_segmentation"
-                cyto_path = output_path + "_cytoplasm_segmentation"
-            else :
-                output_path = None
-                nuc_path = None
-                cyto_path = None
-
             cytoplasm_label, nucleus_label = cell_segmentation(
                 image,
-                cyto_model_name= cyto_model_name,
-                cyto_diameter= cyto_size,
-                nucleus_model_name= nucleus_model_name,
-                nucleus_diameter= nucleus_size,
-                channels=channels,
-                do_only_nuc=do_only_nuc,
-                external_nucleus_image = nucleus_image,
-                anisotropy=anisotropy,
-                nucleus_3D_segmentation=nucleus_segmentation_3D,
-                cyto_3D_segmentation=cytoplasm_segmentation_3D,
-                cellprob_threshold_cyto=cellprob_threshold_cyto,
-                cellprob_threshold_nuc=cellprob_threshold_nuc,
-                flow_threshold_cyto=flow_threshold_cyto,
-                flow_threshold_nuc=flow_threshold_nuc,
-
+                channels=[segmentation_parameters["cytoplasm_channel"], segmentation_parameters["nucleus_channel"]],
+                do_only_nuc=segmentation_parameters["segment_only_nuclei"],
+                external_nucleus_image = segmentation_parameters["other_nucleus_image"],
+                nucleus_3D_segmentation=segmentation_parameters["nucleus_segmentation_3D"],
+                cyto_3D_segmentation=segmentation_parameters["cytoplasm_segmentation_3D"],
+                **segmentation_parameters
                 )
 
-        finally  : window.close()
+        finally  : 
+            if not batch_mode : window.close()
 
-        if show_segmentation :
+        if segmentation_parameters["show_segmentation"] :
+            
             nucleus_label, cytoplasm_label = napari_show_segmentation(
-                nuc_image=image[nucleus_channel] if type(nucleus_image) == type(None) else nucleus_image,
+                nuc_image=image[segmentation_parameters["nucleus_channel"]] if type(segmentation_parameters["other_nucleus_image"]) == type(None) else segmentation_parameters["other_nucleus_image"],
                 nuc_label= nucleus_label,
-                cyto_image=image[cytoplasm_channel],
+                cyto_image=image[segmentation_parameters["cytoplasm_channel"]],
                 cyto_label=cytoplasm_label,
-                anisotrpy=anisotropy,
+                anisotrpy=segmentation_parameters["anisotropy"],
             )
 
             if nucleus_label.ndim == 3 : nucleus_label = np.max(nucleus_label, axis=0)
@@ -302,17 +141,17 @@ def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cyt
             if event == "No" :
                 continue
 
-        if type(output_path) != type(None) and save_segmentation_visual:
+        if type(segmentation_parameters["seg_control_saving_path"]) != type(None) and segmentation_parameters["save_segmentation_visuals"]:
             
             #Get backgrounds
-            nuc_proj = image[nucleus_channel]
-            im_proj = image[cytoplasm_channel]
+            nuc_proj = image[segmentation_parameters["nucleus_channel"]]
+            im_proj = image[segmentation_parameters["cytoplasm_channel"]]
             if im_proj.ndim == 3 :
                 im_proj = stack.mean_projection(im_proj)
             if nuc_proj.ndim == 3 :
                 nuc_proj = stack.mean_projection(nuc_proj)
             if nucleus_label.ndim == 3 :
-                nucleus_label_proj = np.max(nucleus_channel,axis=0)
+                nucleus_label_proj = np.max(segmentation_parameters["nucleus_channel"],axis=0)
             else : 
                 nucleus_label_proj = nucleus_label
             if cytoplasm_label.ndim == 3 :
@@ -322,21 +161,28 @@ def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cyt
 
             
             #Call plots
-            plot.plot_segmentation_boundary(nuc_proj, cytoplasm_label_proj, nucleus_label_proj, boundary_size=2, contrast=True, show=False, path_output=nuc_path, title= "Nucleus segmentation (blue)", remove_frame=True,)
-            if not do_only_nuc : 
-                plot.plot_segmentation_boundary(im_proj, cytoplasm_label_proj, nucleus_label_proj, boundary_size=2, contrast=True, show=False, path_output=cyto_path, title="Cytoplasm Segmentation (red)", remove_frame=True)
-            plot_labels(
-                nucleus_label,
-                path_output=output_path + "_nucleus_label_map.png",
-                show=False
-                )
-            if not do_only_nuc : 
+            if segmentation_parameters["save_segmentation_visuals"]:
+                output_path = segmentation_parameters["seg_control_saving_path"] + '/' + segmentation_parameters["filename"]
+                nuc_path = output_path + "_nucleus_segmentation"
+                cyto_path = output_path + "_cytoplasm_segmentation"
+
+                #Plots boundaries
+                plot.plot_segmentation_boundary(nuc_proj, cytoplasm_label_proj, nucleus_label_proj, boundary_size=2, contrast=True, show=False, path_output=nuc_path, title= "Nucleus segmentation (blue)", remove_frame=True,)
+                if not segmentation_parameters["segment_only_nuclei"] : 
+                    plot.plot_segmentation_boundary(im_proj, cytoplasm_label_proj, nucleus_label_proj, boundary_size=2, contrast=True, show=False, path_output=cyto_path, title="Cytoplasm Segmentation (red)", remove_frame=True)
+            
+                #Plots cell labels
                 plot_labels(
-                    cytoplasm_label_proj,
-                    path_output=output_path + "_cytoplasm_label_map.png",
+                    nucleus_label,
+                    path_output=output_path + "_nucleus_label_map.png",
                     show=False
                     )
-
+                if not segmentation_parameters["segment_only_nuclei"] : 
+                    plot_labels(
+                        cytoplasm_label_proj,
+                        path_output=output_path + "_cytoplasm_label_map.png",
+                        show=False
+                        )
 
 
         if cytoplasm_label.max() == 0 : #No cell segmented
@@ -344,31 +190,32 @@ def launch_segmentation(user_parameters: pipeline_parameters, nucleus_label, cyt
             [sg.Text("No cell segmented. Proceed anyway ?")],
             [sg.Button("Yes"), sg.Button("No")]
         ]
-            event, values = prompt(layout=layout, add_ok_cancel=False)
+            event, _ = prompt(layout=layout, add_ok_cancel=False)
             if event == "Yes" :
                 return None, None, user_parameters
         else :
             break
 
-
-        
-    user_parameters.update(values)
+    user_parameters.update(segmentation_parameters)
     return nucleus_label, cytoplasm_label, user_parameters
 
 def cell_segmentation(
-        image, cyto_model_name, 
+        reordered_image, 
+        cytoplasm_model_name, 
         nucleus_model_name, 
-        channels, cyto_diameter, 
+        channels, 
+        cytoplasm_diameter, 
         nucleus_diameter,
         nucleus_3D_segmentation=False,
         cyto_3D_segmentation=False,
         anisotropy = 1,
-        flow_threshold_nuc = 0.4,
-        flow_threshold_cyto = 0.4,
-        cellprob_threshold_nuc = 0.,
-        cellprob_threshold_cyto = 0.,
+        nucleus_flow_threshold = 0.4,
+        cytoplasm_flow_threshold = 0.4,
+        nucleus_cellprob_threshold = 0.,
+        cytoplasm_cellprob_threshold = 0.,
         do_only_nuc=False,
         external_nucleus_image = None,
+        **segmentation_parameters : pipeline_parameters
         ) :
 
     nuc_channel = channels[1]
@@ -377,46 +224,60 @@ def cell_segmentation(
     if type(external_nucleus_image) != type(None) :
         nuc = external_nucleus_image
     else :
-        nuc = image[nuc_channel]
+        nuc = reordered_image[nuc_channel]
 
     if nuc.ndim >= 3 and not nucleus_3D_segmentation:
-        nuc = stack.mean_projection(nuc)
+
+        if segmentation_parameters["nucleus_max_proj"] : nuc = np.max(nuc, axis=0)
+        elif segmentation_parameters["nucleus_mean_proj"] : nuc = np.mean(nuc, axis=0)
+        elif segmentation_parameters["nucleus_select_slice"] : nuc = nuc[segmentation_parameters["nucleus_selected_slice"]]
+        else : raise AssertionError("No option found for 2D nucleus seg. Should be impossible as this error is raised after integrity checks")
+    
+    
     nuc_label = _segmentate_object(
         nuc, 
         nucleus_model_name, 
         nucleus_diameter, 
         do_3D=nucleus_3D_segmentation, 
         anisotropy=anisotropy,
-        flow_threshold= flow_threshold_nuc,
-        cellprob_threshold=cellprob_threshold_nuc
+        flow_threshold= nucleus_flow_threshold,
+        cellprob_threshold=nucleus_cellprob_threshold,
+        min_size=segmentation_parameters["nucleus_min_size"]
         )
     
     if not do_only_nuc : 
         cyto_channel = channels[0]
-        nuc = image[nuc_channel] if type(external_nucleus_image) == type(None) else external_nucleus_image
+        nuc = reordered_image[nuc_channel] if type(external_nucleus_image) == type(None) else external_nucleus_image
 
-        if image[cyto_channel].ndim >= 3 and not cyto_3D_segmentation:
-            cyto = stack.mean_projection(image[cyto_channel])
+        if reordered_image[cyto_channel].ndim >= 3 and not cyto_3D_segmentation:
+            if segmentation_parameters["cytoplasm_max_proj"] : cyto = np.max(reordered_image[cyto_channel], axis=0)
+            elif segmentation_parameters["cytoplasm_mean_proj"] : cyto = np.mean(reordered_image[cyto_channel], axis=0)
+            elif segmentation_parameters["cytoplasm_select_slice"] : cyto = reordered_image[cyto_channel][segmentation_parameters["cytoplasm_selected_slice"]]
+            else : raise AssertionError("No option found for 2D cytoplasm seg. Should be impossible as this error is raised after integrity checks")
         else : 
-            cyto = image[cyto_channel]
+            cyto = reordered_image[cyto_channel]
         if nuc.ndim >= 3 and not cyto_3D_segmentation:
-            nuc = stack.mean_projection(nuc)
-
-        image = np.zeros(shape=(2,) + cyto.shape)
-        image[0] = cyto
-        image[1] = nuc
-        source = list(range(image.ndim))
+            if segmentation_parameters["cytoplasm_max_proj"] : nuc = np.max(nuc, axis=0)
+            elif segmentation_parameters["cytoplasm_mean_proj"] : nuc = np.mean(nuc, axis=0)
+            elif segmentation_parameters["cytoplasm_select_slice"] : nuc = nuc[segmentation_parameters["cytoplasm_selected_slice"]]
+            else : raise AssertionError("No option found for 2D cytoplasm seg. Should be impossible as this error is raised after integrity checks")
+
+        reordered_image = np.zeros(shape=(2,) + cyto.shape)
+        reordered_image[0] = cyto
+        reordered_image[1] = nuc
+        source = list(range(reordered_image.ndim))
         dest = source[-1:] + source[:-1]
-        image = np.moveaxis(image, source=range(image.ndim), destination= dest)
+        reordered_image = np.moveaxis(reordered_image, source=range(reordered_image.ndim), destination= dest)
 
         cytoplasm_label = _segmentate_object(
-            image, 
-            cyto_model_name, 
-            cyto_diameter, 
+            reordered_image, 
+            cytoplasm_model_name, 
+            cytoplasm_diameter, 
             do_3D=cyto_3D_segmentation, 
             anisotropy=anisotropy,
-            flow_threshold=flow_threshold_cyto,
-            cellprob_threshold=cellprob_threshold_cyto,
+            flow_threshold=cytoplasm_flow_threshold,
+            cellprob_threshold=cytoplasm_cellprob_threshold,
+            min_size=segmentation_parameters["cytoplasm_min_size"]
             )
 
         if cytoplasm_label.ndim == 3 and nuc_label.ndim == 2 :
@@ -438,11 +299,14 @@ def _segmentate_object(
         anisotropy : float = 1.0,
         flow_threshold : float = 0.4,
         cellprob_threshold : float = 0, 
+        min_size = 15 #Default cellpose
         ) :
+    
 
     model = models.CellposeModel(
         gpu= use_gpu(),
         pretrained_model= model_name,
+        use_bfloat16= not using_mps()
     )
 
     label, flow, style = model.eval(
@@ -454,30 +318,32 @@ def _segmentate_object(
         anisotropy=anisotropy,
         flow_threshold=flow_threshold,
         cellprob_threshold=cellprob_threshold,
+        min_size=min_size,
         )
     
     label = np.array(label, dtype= np.int64)
     if not do_3D : label = remove_disjoint(label) # Too much time consuming in 3D
-    else : pass #TODO : filter too litle regions
     
     return label
 
 def _cast_segmentation_parameters(values:dict) :
 
-    values.setdefault('cytoplasm_channel',0)
-    values.setdefault('nucleus_channel',0)
-
     cast_rules = {
         'cytoplasm_diameter' : int,
         'nucleus_diameter' : int,
         'cytoplasm_channel' : int,
         'nucleus_channel' : int,
         'anisotropy' : float,
-        'flow_threshold_cyto' : float,
-        'cellprob_threshold_cyto' : float,
-        'flow_threshold_nuc' : float,
-        'cellprob_threshold_nuc' : float,
-
+        'cytoplasm_flow_threshold' : float,
+        'cytoplasm_cellprob_threshold' : float,
+        'nucleus_flow_threshold' : float,
+        'nucleus_cellprob_threshold' : float,
+        'cytoplasm_anisotropy' : float,
+        'nucleus_anisotropy' : float,
+        'cytoplasm_selected_slice' : int,
+        'nucleus_selected_slice' : int,
+        'cytoplasm_min_size' : int,
+        'nucleus_min_size' : int,
     }    
 
     for key, constructor in cast_rules.items() :
@@ -487,14 +353,240 @@ def _cast_segmentation_parameters(values:dict) :
             pass
 
     #None if default
-    if values['cyto_model_name'] == '' :
-        values['cyto_model_name'] = None
+    if values['cytoplasm_model_name'] == '' :
+        values['cytoplasm_model_name'] = None
 
     if values['nucleus_model_name'] == '' :
         values['nucleus_model_name'] = None
 
     return values
 
+def _check_integrity_segmentation_parameters(
+    values : pipeline_parameters, 
+    user_parameters : pipeline_parameters, 
+    available_channels : list, 
+    available_slices : list
+    ) :
+    """
+    Check that parameters entered by user comply with what we need to do with them. Type checking is handle in _cast_segmentation_parameters, if any parameters could not be cast to 
+    appropriate type, it is set to None.
+    """
+
+    values : pipeline_parameters = _cast_segmentation_parameters(values)
+    is_3D_stack = user_parameters["is_3D_stack"]
+    is_multichannel = user_parameters["is_multichannel"]
+
+    relaunch= False
+    #Control plots
+    if values["save_segmentation_visuals"] :
+        if not os.path.isdir(values["seg_control_saving_path"]) :
+            relaunch=True
+            sg.popup(f"{values["seg_control_saving_path"]} is not a directory.")
+            values["seg_control_saving_path"] = user_parameters.get("seg_control_saving_path")
+        if values["filename"] == "" :
+            relaunch=True
+            sg.popup("Enter a filename for control plots.")
+            values["filename"] = user_parameters.get("filename")
+
+    #2D/3D seg
+    if is_3D_stack :
+        for obj in ["cytoplasm","nucleus"] :
+            assert values[obj + "_radio_2D"] + values[obj + "_radio_3D"] == 1, f"Incorrect number of segmentation dimension was selected (should be 1) for {obj}"
+            assert values[obj + "_max_proj"] + values[obj + "_mean_proj"] + values[obj + "_select_slice"] == 1, f"Incorrect number of 2D segmentation options were selected (should be 1) for {obj}"
+
+            if values[obj + "_radio_2D"] : values[obj + "_segmentation_3D"] = False
+            else : values[obj + "_segmentation_3D"] = True
+
+        #Selected slice
+        for key in ['cytoplasm_selected_slice', 'nucleus_selected_slice'] :
+            if not isinstance(values[key], int) :
+                relaunch = True
+                sg.popup("Invalid slice number for cytoplasm 2D segmentation.")
+                values[key] = user_parameters[key]
+            elif values[key] not in available_slices :
+                relaunch = True
+                sg.popup(f"Invalid slice number for cytoplasm 2D segmentation, selecgted between 0 and {available_slices[-1]}")
+                values[key] = user_parameters[key]
+        
+        #anisotropy
+        if not "anisotropy" in values.keys() :
+            values["anisotropy"] = 1
+        if not isinstance(values["nucleus_anisotropy"], (float, int)) :
+            relaunch=True
+            sg.popup("Invalid value for nucleus anisotropy, must be a positive float.")
+            values["anisotropy"] = user_parameters.get("anisotropy")
+        elif values["nucleus_anisotropy"] < 0 :
+            relaunch=True
+            sg.popup("Invalid value for nucleus anisotropy, must be a positive float.")
+            values["anisotropy"] = user_parameters.get("anisotropy")
+
+        if not values["segment_only_nuclei"] :
+            if not isinstance(values["cytoplasm_anisotropy"], (float, int)) :
+                relaunch=True
+                sg.popup("Invalid value for cytoplasm anisotropy, must be a positive float.")
+                values["anisotropy"] = user_parameters.get("anisotropy")
+            elif values["cytoplasm_anisotropy"] < 0 :
+                relaunch=True
+                sg.popup("Invalid value for cytoplasm anisotropy, must be a positive float.")
+                values["anisotropy"] = user_parameters.get("anisotropy")
+
+        if values["segment_only_nuclei"] :
+            values["anisotropy"] = values["nucleus_anisotropy"]
+        elif isinstance(values["cytoplasm_anisotropy"], (float, int)) and isinstance(values["nucleus_anisotropy"], (float, int)) and values["nucleus_segmentation_3D"] and values["cytoplasm_segmentation_3D"]:
+            if (not values["cytoplasm_anisotropy"] == values["nucleus_anisotropy"]) and (not values["segment_only_nuclei"]) :
+                relaunch=True
+                sg.popup("Anisotropy must be equal for nucleus and cytoplasm segmentation")
+                values["anisotropy"] = user_parameters.get("anisotropy")
+            else :
+                values["anisotropy"] = values["nucleus_anisotropy"]
+        elif isinstance(values["nucleus_anisotropy"], (float, int)) and values["nucleus_segmentation_3D"] :
+            values["anisotropy"] = values["nucleus_anisotropy"]
+        elif isinstance(values["cytoplasm_anisotropy"], (float, int)) and values["cytoplasm_segmentation_3D"] :
+            values["anisotropy"] = values["cytoplasm_anisotropy"]
+
+        if not isinstance(values["anisotropy"], (float,int)) :
+            sg.popup("Anisotropy must be a positive float.")
+            relaunch = True
+            values['anisotropy'] = user_parameters.get("anisotropy")
+    
+    else :
+        values["cytoplasm_segmentation_3D"] = False
+        values["nucleus_segmentation_3D"] = False
+        values["anisotropy"] = 1
+        for obj in ["nucleus","cytoplasm"] :
+            values[obj + "_max_proj"] = False
+            values[obj + "_mean_proj"] = True
+            values[obj + "_select_slice"] = False
+            values[obj + "_selected_slice"] = 0
+
+    #Min size
+    if not isinstance(values["cytoplasm_min_size"], int) :
+        relaunch=True
+        sg.popup("Invalid value for cytoplasm min size parameter, must be a positive int.")
+        values["cytoplasm_min_size"] = user_parameters["cytoplasm_min_size"]
+    elif values["cytoplasm_min_size"] < 0 :
+        relaunch=True
+        sg.popup("Invalid value for cytoplasm min size parameter, must be a positive int.")
+        values["cytoplasm_min_size"] = user_parameters["cytoplasm_min_size"]
+
+    if not isinstance(values["nucleus_min_size"], int) :
+        relaunch=True
+        sg.popup("Invalid value for nucleus min size parameter, must be a positive int.")
+        values["nucleus_min_size"] = user_parameters["nucleus_min_size"]
+    elif values["nucleus_min_size"] < 0 :
+        relaunch=True
+        sg.popup("Invalid value for nucleus min size parameter, must be a positive int.")
+        values["nucleus_min_size"] = user_parameters["nucleus_min_size"]
+
+    #flow thresholds
+    if type(values['nucleus_flow_threshold']) != float : 
+        sg.popup('Invalid value for flow threshold in nuc parameters, must be a float between 0 and 1.')
+        values['nucleus_flow_threshold'] = user_parameters['nucleus_flow_threshold']
+        relaunch= True
+    elif abs(values['nucleus_flow_threshold']) > 1 or values['nucleus_flow_threshold'] < 0 :
+        sg.popup('Invalid value for flow threshold in cyto parameters, must be a float between 0 and 1.')
+        values['nucleus_flow_threshold'] = user_parameters['nucleus_flow_threshold']
+        relaunch= True 
+
+    if type( values['cytoplasm_flow_threshold']) != float : 
+        sg.popup('Invalid value for flow threshold in cyto parameters, must be a float between 0 and 1.')
+        values['cytoplasm_flow_threshold'] = user_parameters['cytoplasm_flow_threshold']
+        relaunch= True
+    elif abs(values['cytoplasm_flow_threshold']) > 1 or values['cytoplasm_flow_threshold'] < 0 :
+        sg.popup('Invalid value for flow threshold in cyto parameters, must be a float between 0 and 1.')
+        values['cytoplasm_flow_threshold'] = user_parameters['cytoplasm_flow_threshold']
+        relaunch= True 
+    
+    #cellprob thresholds
+    if type(values['nucleus_cellprob_threshold']) != float : 
+        sg.popup('Invalid value for cellprob threshold in nuc parameters, must be a float between -3 and +3.')
+        values['nucleus_cellprob_threshold'] = user_parameters['nucleus_cellprob_threshold']
+        relaunch= True
+    elif abs(values['nucleus_cellprob_threshold']) > 3 :
+        sg.popup('Invalid value for cellprob threshold in cyto parameters, must be a float between -3 and +3.')
+        values['nucleus_cellprob_threshold'] = user_parameters['nucleus_cellprob_threshold']
+        relaunch= True
+
+    if type(values['cytoplasm_cellprob_threshold']) != float :
+        sg.popup('Invalid value for cellprob threshold in cyto parameters, must be a float between -3 and +3.')
+        values['cytoplasm_cellprob_threshold'] = user_parameters['cytoplasm_cellprob_threshold']
+        relaunch= True
+    elif abs(values['cytoplasm_cellprob_threshold']) > 3 :
+        sg.popup('Invalid value for cellprob threshold in cyto parameters, must be a float between -3 and +3.')
+        values['cytoplasm_cellprob_threshold'] = user_parameters['cytoplasm_cellprob_threshold']
+        relaunch= True
+
+    
+    #Cytoplasm parameters
+    if type(values["cytoplasm_model_name"]) != str  and not do_only_nuc:
+        sg.popup('Invalid cytoplasm model name.')
+        values['cytoplasm_model_name'] = user_parameters['cytoplasm_model_name']
+        relaunch= True
+    if is_multichannel :
+        if values["cytoplasm_channel"] not in available_channels and not do_only_nuc:
+            sg.popup('For given input image please select channel in {0}\ncytoplasm_channel : {1}'.format(available_channels, cytoplasm_channel))
+            relaunch= True
+            values['cytoplasm_channel'] = user_parameters['cytoplasm_channel']
+    else :
+        values["cytoplasm_channel"] = ...
+
+    if type(values["cytoplasm_diameter"]) not in [int, float] and not do_only_nuc:
+        sg.popup("Incorrect cytoplasm size.")
+        relaunch= True
+        values['cytoplasm_diameter'] = user_parameters['cytoplasm_diameter']
+
+    #Nucleus parameters
+    if type(values["nucleus_model_name"]) != str :
+        sg.popup('Invalid nucleus model name.')
+        values['nucleus_model_name'] = user_parameters['nucleus_model_name']
+        relaunch= True
+    
+    if is_multichannel :
+        if values["nucleus_channel"] not in available_channels :
+            sg.popup('For given input image please select channel in {0}\nnucleus channel : {1}'.format(available_channels, nucleus_channel))
+            relaunch= True
+            values['nucleus_channel'] = user_parameters['nucleus_channel']
+    else : 
+        values["nucleus_channel"] = ...
+
+    if type(values["nucleus_diameter"]) not in [int, float] :
+        sg.popup("Incorrect nucleus size.")
+        relaunch= True
+        values['nucleus_diameter'] = user_parameters['nucleus_diameter']
+
+    if values["other_nucleus_image"] != '' :
+        if os.path.isdir(values["other_nucleus_image"]) :
+            values['other_nucleus_image'] = None
+        elif not os.path.isfile(values["other_nucleus_image"]) :
+            sg.popup("Nucleus image is not a file.")
+            relaunch=True
+            values['other_nucleus_image'] = None
+        else :
+            try :
+                nucleus_image = open_image(other_nucleus_image)
+            except Exception as e :
+                sg.popup("Could not open image.\n{0}".format(e))
+                relaunch=True
+                values['other_nucleus_image'] = user_parameters['other_nucleus_image']
+            else :
+                if nucleus_image.ndim != image.ndim - is_multichannel :
+                    sg.popup("Nucleus image dimension missmatched. Expected same dimension as cytoplasm_image for monochannel or same dimension as cytoplasm_image -1 for is_multichannel\ncytoplasm dimension : {0}, nucleus dimension : {1}".format(image.ndim, nucleus_image.ndim))
+                    nucleus_image = None
+                    relaunch=True
+                    values['other_nucleus_image'] = user_parameters['other_nucleus_image']
+                
+                elif nucleus_image.shape != image[cytoplasm_channel].shape :
+                    sg.popup("Nucleus image shape missmatched. Expected same shape as cytoplasm_image \ncytoplasm shape : {0}, nucleus shape : {1}".format(image[cytoplasm_channel].shape, nucleus_image.shape))
+                    nucleus_image = None
+                    relaunch=True
+                    values['other_nucleus_image'] = user_parameters['other_nucleus_image']
+
+    else :
+        values["other_nucleus_image"] = None
+
+    return values, relaunch
+
+
 def remove_disjoint(image):
     """
     *CODE FROM BIG-FISH (LICENCE IN __INIT__.PY) IMPORTED TO AVOID IMPORT ERROR WHEN BIGFISH SEGMENTATION MODULE INITIALISES : try to import deprecated module for python 3.8