celldetective 1.3.6.post1__py3-none-any.whl → 1.3.7__py3-none-any.whl

celldetective/scripts/segment_cells.py

@@ -6,21 +6,17 @@ import argparse
 import datetime
 import os
 import json
-from stardist.models import StarDist2D
-from cellpose.models import CellposeModel
-from celldetective.io import locate_segmentation_model, auto_load_number_of_frames, load_frames
-from celldetective.utils import interpolate_nan, _estimate_scale_factor, _extract_channel_indices_from_config, ConfigSectionMap, _extract_nbr_channels_from_config, _get_img_num_per_channel
+from celldetective.io import locate_segmentation_model, auto_load_number_of_frames, extract_position_name, _load_frames_to_segment, _check_label_dims
+from celldetective.utils import _prep_stardist_model, _prep_cellpose_model, _rescale_labels, _segment_image_with_stardist_model,_segment_image_with_cellpose_model,_get_normalize_kwargs_from_config, _estimate_scale_factor, _extract_channel_indices_from_config, ConfigSectionMap, _extract_nbr_channels_from_config, _get_img_num_per_channel
 from pathlib import Path, PurePath
 from glob import glob
 from shutil import rmtree
 from tqdm import tqdm
 import numpy as np
-from skimage.transform import resize
 from csbdeep.io import save_tiff_imagej_compatible
 import gc
 from art import tprint
-from scipy.ndimage import zoom
-
+import concurrent.futures
 
 tprint("Segment")
 
@@ -44,6 +40,7 @@ if use_gpu=='True' or use_gpu=='true' or use_gpu=='1':
 	n_threads = 1  # avoid misbehavior on GPU with multithreading
 else:
 	use_gpu = False
+	#n_threads = 1 # force 1 threads since all CPUs seem to be in use anyway
 
 if not use_gpu:
 	os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
@@ -60,20 +57,22 @@ parent1 = Path(pos).parent
 expfolder = parent1.parent
 config = PurePath(expfolder,Path("config.ini"))
 assert os.path.exists(config),'The configuration file for the experiment could not be located. Abort.'
+
+print(f"Position: {extract_position_name(pos)}...")
 print("Configuration file: ",config)
+print(f"Population: {mode}...")
 
 ####################################
 # Check model requirements #########
 ####################################
 
 modelpath = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0],"models"])
-print(modelpath)
 model_complete_path = locate_segmentation_model(modelname)
 if model_complete_path is None:
 	print('Model could not be found. Abort.')
 	os.abort()
 else:
-	print(f'Model successfully located in {model_complete_path}')
+	print(f'Model path: {model_complete_path}...')
 
 # load config
 assert os.path.exists(model_complete_path+"config_input.json"),'The configuration for the inputs to the model could not be located. Abort.'
@@ -86,11 +85,9 @@ required_channels = input_config["channels"]
 channel_indices = _extract_channel_indices_from_config(config, required_channels)
 print(f'Required channels: {required_channels} located at channel indices {channel_indices}.')
 required_spatial_calibration = input_config['spatial_calibration']
-print(f'Expected spatial calibration is {required_spatial_calibration}.')
+print(f'Spatial calibration expected by the model: {required_spatial_calibration}...')
 
-normalization_percentile = input_config['normalization_percentile']
-normalization_clip = input_config['normalization_clip']
-normalization_values = input_config['normalization_values']
+normalize_kwargs = _get_normalize_kwargs_from_config(input_config)
 
 model_type = input_config['model_type']
 
@@ -117,18 +114,19 @@ if model_type=='cellpose':
 	flow_threshold = input_config['flow_threshold']
 
 scale = _estimate_scale_factor(spatial_calibration, required_spatial_calibration)
-print(f"Scale = {scale}...")
+print(f"Scale: {scale}...")
 
 nbr_channels = _extract_nbr_channels_from_config(config)
-print(f'Number of channels in the input movie: {nbr_channels}')
+#print(f'Number of channels in the input movie: {nbr_channels}')
 img_num_channels = _get_img_num_per_channel(channel_indices, int(len_movie), nbr_channels)
 
 # If everything OK, prepare output, load models
-print('Erasing previous segmentation folder.')
 if os.path.exists(pos+label_folder):
+	print('Erasing the previous labels folder...')
 	rmtree(pos+label_folder)
 os.mkdir(pos+label_folder)
-print(f'Folder {pos+label_folder} successfully generated.')
+print(f'Labels folder successfully generated...')
+
 log=f'segmentation model: {modelname}\n'
 with open(pos+f'log_{mode}.json', 'a') as f:
 	f.write(f'{datetime.datetime.now()} SEGMENT \n')
@@ -137,93 +135,52 @@ with open(pos+f'log_{mode}.json', 'a') as f:
 
 # Loop over all frames and segment
 def segment_index(indices):
-	global scale
 
 	if model_type=='stardist':
-		model = StarDist2D(None, name=modelname, basedir=Path(model_complete_path).parent)
-		model.config.use_gpu = use_gpu
-		model.use_gpu = use_gpu
-		print(f"StarDist model {modelname} successfully loaded.")
-		scale_model = scale
+		model, scale_model = _prep_stardist_model(modelname, Path(model_complete_path).parent, use_gpu=use_gpu, scale=scale)
 
 	elif model_type=='cellpose':
-
-		import torch
-		if not use_gpu:
-			device = torch.device("cpu")
-		else:
-			device = torch.device("cuda")
-
-		model = CellposeModel(gpu=use_gpu, device=device, pretrained_model=model_complete_path+modelname, model_type=None, nchan=len(required_channels)) #diam_mean=30.0,
-		if scale is None:
-			scale_model = model.diam_mean / model.diam_labels
-		else:
-			scale_model = scale * model.diam_mean / model.diam_labels
-		print(f"Diam mean: {model.diam_mean}; Diam labels: {model.diam_labels}; Final rescaling: {scale_model}...")
-		print(f'Cellpose model {modelname} successfully loaded.')
+		model, scale_model = _prep_cellpose_model(modelname, model_complete_path, use_gpu=use_gpu, n_channels=len(required_channels), scale=scale)
 
 	for t in tqdm(indices,desc="frame"):
-		
-		# Load channels at time t
-		values = []
-		percentiles = []
-		for k in range(len(normalization_percentile)):
-			if normalization_percentile[k]:
-				percentiles.append(normalization_values[k])
-				values.append(None)
-			else:
-				percentiles.append(None)
-				values.append(normalization_values[k])
-
-		f = load_frames(img_num_channels[:,t], file, scale=scale_model, normalize_input=True, normalize_kwargs={"percentiles": percentiles, 'values': values, 'clip': normalization_clip})
-		f = np.moveaxis([interpolate_nan(f[:,:,c].copy()) for c in range(f.shape[-1])],0,-1)
-
-		if np.any(img_num_channels[:,t]==-1):
-			f[:,:,np.where(img_num_channels[:,t]==-1)[0]] = 0.
-		
 
-		if model_type=="stardist":
-			Y_pred, details = model.predict_instances(f, n_tiles=model._guess_n_tiles(f), show_tile_progress=False, verbose=False)
-			Y_pred = Y_pred.astype(np.uint16)
+		f = _load_frames_to_segment(file, img_num_channels[:,t], scale_model=scale_model, normalize_kwargs=normalize_kwargs)
 
+		if model_type=="stardist":
+			Y_pred = _segment_image_with_stardist_model(f, model=model, return_details=False)
 		elif model_type=="cellpose":
-
-			img = np.moveaxis(f, -1, 0)
-			Y_pred, _, _ = model.eval(img, diameter = diameter, cellprob_threshold=cellprob_threshold, flow_threshold=flow_threshold, channels=None, normalize=False)
-			Y_pred = Y_pred.astype(np.uint16)
+			Y_pred = _segment_image_with_cellpose_model(f, model=model, diameter=diameter, cellprob_threshold=cellprob_threshold, flow_threshold=flow_threshold)
 
 		if scale is not None:
-			Y_pred = zoom(Y_pred, [1./scale_model,1./scale_model],order=0)
+			Y_pred = _rescale_labels(Y_pred, scale_model=scale_model)
 
-		template = load_frames(0,file,scale=1,normalize_input=False)
-		if Y_pred.shape != template.shape[:2]:
-			Y_pred = resize(Y_pred, template.shape[:2], order=0)
+		Y_pred = _check_label_dims(Y_pred, file)
 
 		save_tiff_imagej_compatible(pos+os.sep.join([label_folder,f"{str(t).zfill(4)}.tif"]), Y_pred, axes='YX')
 
 		del f;
-		del template;
 		del Y_pred;
 		gc.collect()
 
+	del model;
+	gc.collect()
 
-import concurrent.futures
+	return
+
+
+print(f"Starting the segmentation with {n_threads} thread(s) and GPU={use_gpu}...")
 
 # Multithreading
 indices = list(range(img_num_channels.shape[1]))
 chunks = np.array_split(indices, n_threads)
 
 with concurrent.futures.ThreadPoolExecutor() as executor:
-	executor.map(segment_index, chunks)
-
-# threads = []
-# for i in range(n_threads):
-# 	thread_i = threading.Thread(target=segment_index, args=[chunks[i]])
-# 	threads.append(thread_i)
-# for th in threads:
-# 	th.start()
-# for th in threads:
-# 	th.join()
+	results = executor.map(segment_index, chunks)
+	try:
+		for i,return_value in enumerate(results):
+			print(f"Thread {i} output check: ",return_value)
+	except Exception as e:
+		print("Exception: ", e)
 
 print('Done.')
 

celldetective/scripts/segment_cells_thresholds.py

@@ -5,7 +5,7 @@ Copright © 2022 Laboratoire Adhesion et Inflammation, Authored by Remy Torro.
 import argparse
 import os
 import json
-from celldetective.io import auto_load_number_of_frames, load_frames
+from celldetective.io import auto_load_number_of_frames, load_frames, extract_position_name
 from celldetective.segmentation import segment_frame_from_thresholds
 from celldetective.utils import _extract_channel_indices_from_config, ConfigSectionMap, _extract_nbr_channels_from_config, _get_img_num_per_channel, extract_experiment_channels
 from pathlib import Path, PurePath
@@ -16,6 +16,7 @@ import numpy as np
 from csbdeep.io import save_tiff_imagej_compatible
 import gc
 from art import tprint
+import concurrent.futures
 
 tprint("Segment")
 
@@ -48,8 +49,6 @@ else:
 	print('The configuration path is not valid. Abort.')
 	os.abort()
 
-print('The following instructions were successfully loaded: ', threshold_instructions)
-
 if mode.lower()=="target" or mode.lower()=="targets":
 	label_folder = "labels_targets"
 elif mode.lower()=="effector" or mode.lower()=="effectors":
@@ -60,12 +59,14 @@ parent1 = Path(pos).parent
 expfolder = parent1.parent
 config = PurePath(expfolder,Path("config.ini"))
 assert os.path.exists(config),'The configuration file for the experiment could not be located. Abort.'
-print("Configuration file: ",config)
 
+print(f"Position: {extract_position_name(pos)}...")
+print("Configuration file: ",config)
+print(f"Population: {mode}...")
 
 channel_indices = _extract_channel_indices_from_config(config, required_channels)
 # need to abort if channel not found
-print(f'Required channels: {required_channels} located at channel indices {channel_indices}.')
+print(f'Required channels: {required_channels} located at channel indices {channel_indices}...')
 
 threshold_instructions.update({'target_channel': channel_indices[0]})
 
@@ -86,15 +87,15 @@ if len_movie_auto is not None:
 	len_movie = len_movie_auto
 
 nbr_channels = _extract_nbr_channels_from_config(config)
-print(f'Number of channels in the input movie: {nbr_channels}')
+#print(f'Number of channels in the input movie: {nbr_channels}')
 img_num_channels = _get_img_num_per_channel(np.arange(nbr_channels), len_movie, nbr_channels)
 
 # If everything OK, prepare output, load models
-print('Erasing previous segmentation folder.')
 if os.path.exists(os.sep.join([pos,label_folder])):
+	print('Erasing the previous labels folder...')
 	rmtree(os.sep.join([pos,label_folder]))
 os.mkdir(os.sep.join([pos,label_folder]))
-print(f'Folder {os.sep.join([pos,label_folder])} successfully generated.')
+print(f'Labels folder successfully generated...')
 
 if equalize:
 	f_reference = load_frames(img_num_channels[:,equalize_time], file, scale=None, normalize_input=False)
@@ -103,7 +104,7 @@ else:
 	f_reference = None
 
 threshold_instructions.update({'equalize_reference': f_reference})
-print(threshold_instructions)
+print(f"Instructions: {threshold_instructions}...")
 
 # Loop over all frames and segment
 def segment_index(indices):
@@ -119,27 +120,25 @@ def segment_index(indices):
 		del mask;
 		gc.collect()
 
-import concurrent.futures
+	return 
+
+
+print(f"Starting the segmentation with {n_threads} thread(s)...")
 
 # Multithreading
 indices = list(range(img_num_channels.shape[1]))
 chunks = np.array_split(indices, n_threads)
 
 with concurrent.futures.ThreadPoolExecutor() as executor:
-	executor.map(segment_index, chunks)
-
-# indices = list(range(img_num_channels.shape[1]))
-# chunks = np.array_split(indices, n_threads)
-# threads = []
-# for i in range(n_threads):
-# 	thread_i = threading.Thread(target=segment_index, args=[chunks[i]])
-# 	threads.append(thread_i)
-# for th in threads:
-# 	th.start()
-# for th in threads:
-# 	th.join()
+	results = executor.map(segment_index, chunks)
+	try:
+		for i,return_value in enumerate(results):
+			print(f"Thread {i} output check: ",return_value)
+	except Exception as e:
+		print("Exception: ", e)
 
 print('Done.')
+
 gc.collect()
 
 

celldetective/scripts/track_cells.py

@@ -6,8 +6,8 @@ import argparse
 import datetime
 import os
 import json
-from celldetective.io import auto_load_number_of_frames, load_frames, interpret_tracking_configuration
-from celldetective.utils import extract_experiment_channels, ConfigSectionMap, _get_img_num_per_channel, extract_experiment_channels
+from celldetective.io import auto_load_number_of_frames, interpret_tracking_configuration, extract_position_name
+from celldetective.utils import _mask_intensity_measurements, extract_experiment_channels, ConfigSectionMap, _get_img_num_per_channel, extract_experiment_channels
 from celldetective.measure import drop_tonal_features, measure_features
 from celldetective.tracking import track
 from pathlib import Path, PurePath
@@ -19,7 +19,8 @@ import gc
 import os
 from natsort import natsorted
 from art import tprint
-from tifffile import imread
+import concurrent.futures
+
 
 tprint("Track")
 
@@ -59,6 +60,10 @@ expfolder = parent1.parent
 config = PurePath(expfolder,Path("config.ini"))
 assert os.path.exists(config),'The configuration file for the experiment could not be located. Abort.'
 
+print(f"Position: {extract_position_name(pos)}...")
+print("Configuration file: ",config)
+print(f"Population: {mode}...")
+
 # from exp config fetch spatial calib, channel names
 movie_prefix = ConfigSectionMap(config,"MovieSettings")["movie_prefix"]
 spatial_calibration = float(ConfigSectionMap(config,"MovieSettings")["pxtoum"])
@@ -71,9 +76,10 @@ channel_names, channel_indices = extract_experiment_channels(config)
 nbr_channels = len(channel_names)
 
 # from tracking instructions, fetch btrack config, features, haralick, clean_traj, idea: fetch custom timeline?
+print('Looking for tracking instruction file...')
 instr_path = PurePath(expfolder,Path(f"{instruction_file}"))
 if os.path.exists(instr_path):
-	print(f"Tracking instructions for the {mode} population have been successfully loaded...")
+	print(f"Tracking instruction file successfully loaded...")
 	with open(instr_path, 'r') as f:
 		instructions = json.load(f)
 	btrack_config = interpret_tracking_configuration(instructions['btrack_config_path'])
@@ -107,8 +113,6 @@ if os.path.exists(instr_path):
 	memory = None
 	if 'memory' in instructions:
 		memory = instructions['memory']
-
-
 else:
 	print('Tracking instructions could not be located... Using a standard bTrack motion model instead...')
 	btrack_config = interpret_tracking_configuration(None)
@@ -169,51 +173,58 @@ if not btrack_option:
 
 
 def measure_index(indices):
+
+	props = []
+
 	for t in tqdm(indices,desc="frame"):
 		
 		# Load channels at time t
-		img = load_frames(img_num_channels[:,t], file, scale=None, normalize_input=False)
-		lbl = imread(label_path[t])
+		img = _load_frames_to_measure(file, indices=img_num_channels[:,t])
+		lbl = locate_labels(pos, population=mode, frames=t)
+		if lbl is None:
+			continue
 
 		df_props = measure_features(img, lbl, features = features+['centroid'], border_dist=None, 
 										channels=channel_names, haralick_options=haralick_options, verbose=False, 
 									)
 		df_props.rename(columns={'centroid-1': 'x', 'centroid-0': 'y'},inplace=True)
 		df_props['t'] = int(t)
-		timestep_dataframes.append(df_props)
+
+		props.append(df_props)
+
+	return props
+
+print(f"Measuring features with {n_threads} thread(s)...")
 
 # Multithreading
 indices = list(range(img_num_channels.shape[1]))
 chunks = np.array_split(indices, n_threads)
 
-import concurrent.futures
-
+timestep_dataframes = []
 with concurrent.futures.ThreadPoolExecutor() as executor:
-	executor.map(measure_index, chunks)
+	results = executor.map(measure_index, chunks)
+	try:
+		for i,return_value in enumerate(results):
+			print(f"Thread {i} completed...")
+			timestep_dataframes.extend(return_value)
+	except Exception as e:
+		print("Exception: ", e)
 
-# threads = []
-# for i in range(n_threads):
-# 	thread_i = threading.Thread(target=measure_index, args=[chunks[i]])
-# 	threads.append(thread_i)
-# for th in threads:
-# 	th.start()
-# for th in threads:
-# 	th.join()
+print('Features successfully measured...')
 
 df = pd.concat(timestep_dataframes)	
 df.reset_index(inplace=True, drop=True)
 
-if mask_channels is not None:
-	cols_to_drop = []
-	for mc in mask_channels:
-		columns = df.columns
-		col_contains = [mc in c for c in columns]
-		to_remove = np.array(columns)[np.array(col_contains)]
-		cols_to_drop.extend(to_remove)
-	if len(cols_to_drop)>0:
-		df = df.drop(cols_to_drop, axis=1)
+df = _mask_intensity_measurements(df, mask_channels)
 
 # do tracking
+if btrack_option:
+	tracker = 'bTrack'
+else:
+	tracker = 'trackpy'
+
+print(f"Start the tracking step using the {tracker} tracker...")
+
 trajectories, napari_data = track(None,
 					configuration=btrack_config,
 					objects=df, 
@@ -228,14 +239,14 @@ trajectories, napari_data = track(None,
 		  			search_range=search_range,
 		  			memory=memory,
 		  			)
+print(f"Tracking successfully performed...")
 
 # out trajectory table, create POSITION_X_um, POSITION_Y_um, TIME_min (new ones)
-# Save napari data
+# Save napari data # deprecated, should disappear progressively
 np.save(pos+os.sep.join(['output', 'tables', napari_name]), napari_data, allow_pickle=True)
-print(f"napari data successfully saved in {pos+os.sep.join(['output', 'tables'])}")
 
 trajectories.to_csv(pos+os.sep.join(['output', 'tables', table_name]), index=False)
-print(f"Table {table_name} successfully saved in {os.sep.join(['output', 'tables'])}")
+print(f"Trajectory table successfully exported in {os.sep.join(['output', 'tables'])}...")
 
 if os.path.exists(pos+os.sep.join(['output', 'tables', table_name.replace('.csv','.pkl')])):
 	os.remove(pos+os.sep.join(['output', 'tables', table_name.replace('.csv','.pkl')]))

celldetective/segmentation.py

@@ -8,12 +8,9 @@ from .utils import _estimate_scale_factor, _extract_channel_indices
 from pathlib import Path
 from tqdm import tqdm
 import numpy as np
-from stardist.models import StarDist2D
-from cellpose.models import CellposeModel
-from skimage.transform import resize
-from celldetective.io import _view_on_napari, locate_labels, locate_stack, _view_on_napari
+from celldetective.io import _view_on_napari, locate_labels, locate_stack, _view_on_napari, _check_label_dims
 from celldetective.filters import * #rework this to give a name
-from celldetective.utils import rename_intensity_column, mask_edges, estimate_unreliable_edge
+from celldetective.utils import interpolate_nan_multichannel,_rearrange_multichannel_frame, _fix_no_contrast, zoom_multiframes, _rescale_labels, rename_intensity_column, mask_edges, _prep_stardist_model, _prep_cellpose_model, estimate_unreliable_edge,_get_normalize_kwargs_from_config, _segment_image_with_stardist_model, _segment_image_with_cellpose_model
 from stardist import fill_label_holes
 import scipy.ndimage as ndi
 from skimage.segmentation import watershed
@@ -99,9 +96,7 @@ def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_
 	required_spatial_calibration = input_config['spatial_calibration']
 	model_type = input_config['model_type']
 
-	normalization_percentile = input_config['normalization_percentile']
-	normalization_clip = input_config['normalization_clip']
-	normalization_values = input_config['normalization_values']
+	normalize_kwargs = _get_normalize_kwargs_from_config(input_config)
 
 	if model_type=='cellpose':
 		diameter = input_config['diameter']
@@ -116,28 +111,10 @@ def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_
 	print(f"{spatial_calibration=} {required_spatial_calibration=} Scale = {scale}...")
 
 	if model_type=='stardist':
-
-		model = StarDist2D(None, name=model_name, basedir=Path(model_path).parent)
-		model.config.use_gpu = use_gpu
-		model.use_gpu = use_gpu
-		print(f"StarDist model {model_name} successfully loaded.")
-		scale_model = scale
+		model, scale_model = _prep_stardist_model(model_name, Path(model_path).parent, use_gpu=use_gpu, scale=scale)
 
 	elif model_type=='cellpose':
-		
-		import torch
-		if not use_gpu:
-			device = torch.device("cpu")
-		else:
-			device = torch.device("cuda")
-
-		model = CellposeModel(gpu=use_gpu, device=device, pretrained_model=model_path+model_path.split('/')[-2], model_type=None, nchan=len(required_channels))
-		if scale is None:
-			scale_model = model.diam_mean / model.diam_labels
-		else:
-			scale_model = scale * model.diam_mean / model.diam_labels
-		print(f"Diam mean: {model.diam_mean}; Diam labels: {model.diam_labels}; Final rescaling: {scale_model}...")
-		print(f'Cellpose model {model_name} successfully loaded.')
+		model, scale_model = _prep_cellpose_model(model_path.split('/')[-2], model_path, use_gpu=use_gpu, n_channels=len(required_channels), scale=scale)		
 
 	labels = []
 
@@ -149,11 +126,7 @@ def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_
 		channel_indices[channel_indices==None] = 0
 
 		frame = stack[t]
-		#frame = stack[t,:,:,channel_indices.astype(int)].astype(float)
-		if frame.ndim==2:
-			frame = frame[:,:,np.newaxis]
-		if frame.ndim==3 and np.array(frame.shape).argmin()==0:
-			frame = np.moveaxis(frame,0,-1)
+		frame = _rearrange_multichannel_frame(frame).astype(float)
 
 		frame_to_segment = np.zeros((frame.shape[0], frame.shape[1], len(required_channels))).astype(float)
 		for ch in channel_intersection:
@@ -162,45 +135,25 @@ def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_
 		frame = frame_to_segment
 		template = frame.copy()
 
-		values = []
-		percentiles = []
-		for k in range(len(normalization_percentile)):
-			if normalization_percentile[k]:
-				percentiles.append(normalization_values[k])
-				values.append(None)
-			else:
-				percentiles.append(None)
-				values.append(normalization_values[k])
-
-		frame = normalize_multichannel(frame, **{"percentiles": percentiles, 'values': values, 'clip': normalization_clip})
+		frame = normalize_multichannel(frame, **normalize_kwargs)
 		
 		if scale_model is not None:
-			frame = [zoom(frame[:,:,c].copy(), [scale_model,scale_model], order=3, prefilter=False) for c in range(frame.shape[-1])]
-			frame = np.moveaxis(frame,0,-1)
-		
-		for k in range(frame.shape[2]):
-			unique_values = np.unique(frame[:,:,k])
-			if len(unique_values)==1:
-				frame[0,0,k] += 1
+			frame = zoom_multiframes(frame, scale_model)
 		
-		frame = np.moveaxis([interpolate_nan(frame[:,:,c].copy()) for c in range(frame.shape[-1])],0,-1)
+		frame = _fix_no_contrast(frame)
+		frame = interpolate_nan_multichannel(frame)
 		frame[:,:,none_channel_indices] = 0.
 
 		if model_type=="stardist":
-
-			Y_pred, details = model.predict_instances(frame, n_tiles=model._guess_n_tiles(frame), show_tile_progress=False, verbose=False)
-			Y_pred = Y_pred.astype(np.uint16)
+			Y_pred = _segment_image_with_stardist_model(frame, model=model, return_details=False)
 
 		elif model_type=="cellpose":
-			
-			img = np.moveaxis(frame, -1, 0)
-			Y_pred, _, _ = model.eval(img, diameter = diameter, cellprob_threshold=cellprob_threshold, flow_threshold=flow_threshold, channels=None, normalize=False)
-			Y_pred = Y_pred.astype(np.uint16)
+			Y_pred = _segment_image_with_cellpose_model(frame, model=model, diameter=diameter, cellprob_threshold=cellprob_threshold, flow_threshold=flow_threshold)
 
 		if Y_pred.shape != stack[0].shape[:2]:
-			Y_pred = zoom(Y_pred, [1./scale_model,1./scale_model],order=0)
-		if Y_pred.shape != template.shape[:2]:
-			Y_pred = resize(Y_pred, template.shape[:2], order=0)
+			Y_pred = _rescale_labels(Y_pred, scale_model)
+		
+		Y_pred = _check_label_dims(Y_pred, template=template)
 
 		labels.append(Y_pred)
 
@@ -315,6 +268,7 @@ def segment_frame_from_thresholds(frame, target_channel=0, thresholds=None, equa
 	"""
 
 	img = frame[:,:,target_channel]
+	img = interpolate_nan(img)
 	if equalize_reference is not None:
 		img = match_histograms(img, equalize_reference)
 	img_mc = frame.copy()