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

celldetective/utils.py

@@ -29,9 +29,513 @@ from scipy import ndimage
 from skimage.morphology import disk
 from scipy.stats import ks_2samp
 from cliffs_delta import cliffs_delta
+from stardist.models import StarDist2D
+from cellpose.models import CellposeModel
 
+def _remove_invalid_cols(df):
+
+	"""
+	Removes invalid columns from a DataFrame.
+
+	This function identifies and removes columns in the DataFrame whose names 
+	start with "Unnamed", which often indicate extraneous or improperly 
+	formatted columns (e.g., leftover columns from improperly read CSV files).
+
+	Parameters
+	----------
+	df : pandas.DataFrame
+		The input DataFrame from which invalid columns will be removed.
+
+	Returns
+	-------
+	pandas.DataFrame
+		A new DataFrame with the invalid columns removed. If no invalid 
+		columns are found, the original DataFrame is returned unchanged.
+
+	Notes
+	-----
+	- This function does not modify the original DataFrame in place; instead, 
+	  it returns a new DataFrame.
+	- Columns starting with "Unnamed" are commonly introduced when saving 
+	  or loading data files with misaligned headers.
+	"""
+
+	invalid_cols = [c for c in list(df.columns) if c.startswith('Unnamed')]
+	if len(invalid_cols)>0:
+		df = df.drop(invalid_cols, axis=1)
+	return df
+
+def _extract_coordinates_from_features(features, timepoint):
+
+	"""
+	Extracts spatial coordinates and other relevant metadata from a features DataFrame.
+
+	This function processes a DataFrame of features to extract and rename centroid 
+	coordinates, assign a unique identifier to each feature, and add a frame (timepoint) 
+	column. The resulting DataFrame is structured for use in trajectory analysis.
+
+	Parameters
+	----------
+	features : pandas.DataFrame
+		A DataFrame containing feature data, including columns for centroids 
+		(`'centroid-1'` and `'centroid-0'`) and feature classes (`'class_id'`).
+	timepoint : int
+		The timepoint (frame) to assign to all features. This is used to populate 
+		the `'FRAME'` column in the output.
+
+	Returns
+	-------
+	pandas.DataFrame
+		A DataFrame containing the extracted coordinates and additional metadata, 
+		with the following columns:
+		- `'POSITION_X'`: X-coordinate of the centroid.
+		- `'POSITION_Y'`: Y-coordinate of the centroid.
+		- `'class_id'`: The label associated to the cell mask.
+		- `'ID'`: A unique identifier for each cell (index-based).
+		- `'FRAME'`: The timepoint associated with the features.
+
+	Notes
+	-----
+	- The function assumes that the input DataFrame contains columns `'centroid-1'`, 
+	  `'centroid-0'`, and `'class_id'`. Missing columns will raise a KeyError.
+	- The `'ID'` column is created based on the index of the input DataFrame.
+	- This function renames `'centroid-1'` to `'POSITION_X'` and `'centroid-0'` 
+	  to `'POSITION_Y'`.
+	"""
+
+	coords = features[['centroid-1', 'centroid-0', 'class_id']].copy()
+	coords['ID'] = np.arange(len(coords))
+	coords.rename(columns={'centroid-1': 'POSITION_X', 'centroid-0': 'POSITION_Y'}, inplace=True)
+	coords['FRAME'] = int(timepoint)
+
+	return coords
+
+def _mask_intensity_measurements(df, mask_channels):
+
+	"""
+	Removes columns from a DataFrame that match specific channel name patterns.
+
+	This function filters out intensity measurement columns in a DataFrame based on 
+	specified channel names. It identifies columns containing the channel 
+	names as substrings and drops them from the DataFrame.
+
+	Parameters
+	----------
+	df : pandas.DataFrame
+		The input DataFrame containing intensity measurement data. Column names should 
+		include the mask channel names if they are to be filtered.
+	mask_channels : list of str or None
+		A list of channel names (as substrings) to use for identifying columns 
+		to remove. If `None`, no filtering is applied, and the original DataFrame is 
+		returned.
+
+	Returns
+	-------
+	pandas.DataFrame
+		The modified DataFrame with specified columns removed. If no columns match 
+		the mask channels, the original DataFrame is returned.
+
+	Notes
+	-----
+	- The function searches for mask channel substrings in column names. 
+	  Partial matches are sufficient to mark a column for removal.
+	- If no mask channels are specified (`mask_channels` is `None`), the function 
+	  does not modify the input DataFrame.
+	"""
+
+	if mask_channels is not None:
+		
+		cols_to_drop = []
+		columns = df.columns
+
+		for mc in mask_channels:
+			cols_to_remove = [c for c in columns if mc in c]
+			cols_to_drop.extend(cols_to_remove)
+
+		if len(cols_to_drop)>0:
+			df = df.drop(cols_to_drop, axis=1)
+	return df
+
+def _rearrange_multichannel_frame(frame):
+
+	"""
+	Rearranges the axes of a multi-channel frame to ensure the channel axis is at the end.
+
+	This function standardizes the input frame to ensure that the channel axis (if present)
+	is moved to the last position. For 2D frames, it adds a singleton channel axis at the end.
+
+	Parameters
+	----------
+	frame : ndarray
+		The input frame to be rearranged. Can be 2D or 3D.
+		- If 3D, the function identifies the channel axis (assumed to be the axis with the smallest size)
+		  and moves it to the last position.
+		- If 2D, the function adds a singleton channel axis to make it compatible with 3D processing.
+
+	Returns
+	-------
+	ndarray
+		The rearranged frame with the channel axis at the end.
+		- For 3D frames, the output shape will have the channel axis as the last dimension.
+		- For 2D frames, the output will have shape `(H, W, 1)` where `H` and `W` are the height and width of the frame.
+
+	Notes
+	-----
+	- This function assumes that in a 3D input, the channel axis is the one with the smallest size.
+	- For 2D frames, this function ensures compatibility with multi-channel processing pipelines by
+	  adding a singleton dimension for the channel axis.
+
+	Examples
+	--------
+	Rearranging a 3D multi-channel frame:
+	>>> frame = np.zeros((10, 10, 3))  # Already channel-last
+	>>> _rearrange_multichannel_frame(frame).shape
+	(10, 10, 3)
+
+	Rearranging a 3D frame with channel axis not at the end:
+	>>> frame = np.zeros((3, 10, 10))  # Channel-first
+	>>> _rearrange_multichannel_frame(frame).shape
+	(10, 10, 3)
+
+	Converting a 2D frame to have a channel axis:
+	>>> frame = np.zeros((10, 10))  # Grayscale image
+	>>> _rearrange_multichannel_frame(frame).shape
+	(10, 10, 1)
+	"""
+
+
+	if frame.ndim == 3:
+		# Systematically move channel axis to the end
+		channel_axis = np.argmin(frame.shape)
+		frame = np.moveaxis(frame, channel_axis, -1)
+
+	if frame.ndim==2:
+		frame = frame[:,:,np.newaxis]
+
+	return frame
+
+def _fix_no_contrast(frames, value=1):
+
+	"""
+	Ensures that frames with no contrast (i.e., containing only a single unique value) are adjusted.
+
+	This function modifies frames that lack contrast by adding a small value to the first pixel in
+	the affected frame. This prevents downstream issues in image processing pipelines that require
+	a minimum level of contrast.
+
+	Parameters
+	----------
+	frames : ndarray
+		A 3D array of shape `(H, W, N)`, where:
+		- `H` is the height of the frame,
+		- `W` is the width of the frame,
+		- `N` is the number of frames or channels.
+		Each frame (or channel) is independently checked for contrast.
+	value : int or float, optional
+		The value to add to the first pixel (`frames[0, 0, k]`) of any frame that lacks contrast.
+		Default is `1`.
+
+	Returns
+	-------
+	ndarray
+		The modified `frames` array, where frames with no contrast have been adjusted.
+
+	Notes
+	-----
+	- A frame is determined to have "no contrast" if all its pixel values are identical.
+	- Only the first pixel (`[0, 0, k]`) of a no-contrast frame is modified, leaving the rest
+	  of the frame unchanged.
+	"""
+
+	for k in range(frames.shape[2]):
+		unique_values = np.unique(frames[:,:,k])
+		if len(unique_values)==1:
+			frames[0,0,k] += value
+	return frames
+
+def zoom_multiframes(frames, zoom_factor):
+
+	"""
+	Applies zooming to each frame (channel) in a multi-frame image.
+
+	This function resizes each channel of a multi-frame image independently using a specified zoom factor. 
+	The zoom is applied using spline interpolation of the specified order, and the channels are combined 
+	back into the original format.
+
+	Parameters
+	----------
+	frames : ndarray
+		A multi-frame image with dimensions `(height, width, channels)`. The last axis represents different 
+		channels.
+	zoom_factor : float
+		The zoom factor to apply to each channel. Values greater than 1 increase the size, and values 
+		between 0 and 1 decrease the size.
+
+	Returns
+	-------
+	ndarray
+		A new multi-frame image with the same number of channels as the input, but with the height and width 
+		scaled by the zoom factor.
+
+	Notes
+	-----
+	- The function uses spline interpolation (order 3) for resizing, which provides smooth results.
+	- `prefilter=False` is used to prevent additional filtering during the zoom operation.
+	- The function assumes that the input is in `height x width x channels` format, with channels along the 
+	  last axis.
+	"""
+
+	frames = [zoom(frames[:,:,c].copy(), [zoom_factor,zoom_factor], order=3, prefilter=False) for c in range(frames.shape[-1])]
+	frames = np.moveaxis(frames,0,-1)
+	return frames
+
+def _prep_stardist_model(model_name, path, use_gpu=False, scale=1):
+
+	"""
+	Prepares and loads a StarDist2D model for segmentation tasks.
+
+	This function initializes a StarDist2D model with the specified parameters, sets GPU usage if desired, 
+	and allows scaling to adapt the model for specific applications.
+
+	Parameters
+	----------
+	model_name : str
+		The name of the StarDist2D model to load. This name should match the model saved in the specified path.
+	path : str
+		The directory where the model is stored.
+	use_gpu : bool, optional
+		If `True`, the model will be configured to use GPU acceleration for computations. Default is `False`.
+	scale : int or float, optional
+		A scaling factor for the model. This can be used to adapt the model for specific image resolutions. 
+		Default is `1`.
+
+	Returns
+	-------
+	tuple
+		- model : StarDist2D
+			The loaded StarDist2D model configured with the specified parameters.
+		- scale_model : int or float
+			The scaling factor passed to the function.
+
+	Notes
+	-----
+	- Ensure the StarDist2D package is installed and the model files are correctly stored in the provided path.
+	- GPU support depends on the availability of compatible hardware and software setup.
+	"""
+
+	model = StarDist2D(None, name=model_name, basedir=path)
+	model.config.use_gpu = use_gpu
+	model.use_gpu = use_gpu
+	scale_model = scale
+	print(f"StarDist model {model_name} successfully loaded...")
+	return model, scale_model
+
+def _prep_cellpose_model(model_name, path, use_gpu=False, n_channels=2, scale=None):
+
+	"""
+	Prepares and loads a Cellpose model for segmentation tasks.
+
+	This function initializes a Cellpose model with the specified parameters, configures GPU usage if available, 
+	and calculates or applies a scaling factor for the model based on image resolution.
+
+	Parameters
+	----------
+	model_name : str
+		The name of the pretrained Cellpose model to load.
+	path : str
+		The directory where the model is stored.
+	use_gpu : bool, optional
+		If `True`, the model will use GPU acceleration for computations. Default is `False`.
+	n_channels : int, optional
+		The number of input channels expected by the model. Default is `2`.
+	scale : float, optional
+		A scaling factor to adjust the model's output to match the image resolution. If not provided, the scale is 
+		automatically calculated based on the model's diameter parameters.
+
+	Returns
+	-------
+	tuple
+		- model : CellposeModel
+			The loaded Cellpose model configured with the specified parameters.
+		- scale_model : float
+			The scaling factor applied to the model, calculated or provided.
+
+	Notes
+	-----
+	- Ensure the Cellpose package is installed and the model files are correctly stored in the provided path.
+	- GPU support depends on the availability of compatible hardware and software setup.
+	- The scale is calculated as `(diam_mean / diam_labels)` if `scale` is not provided, where `diam_mean` and 
+	  `diam_labels` are attributes of the model.
+	"""
+
+	import torch
+	if not use_gpu:
+		device = torch.device("cpu")
+	else:
+		device = torch.device("cuda")
+
+	model = CellposeModel(gpu=use_gpu, device=device, pretrained_model=path+model_name, model_type=None, nchan=n_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 {model_name} successfully loaded...')
+	return model, scale_model
+
+
+def _get_normalize_kwargs_from_config(config):
+
+	if isinstance(config, str):
+		if os.path.exists(config):
+			with open(config) as cfg:
+				config = json.load(cfg)
+		else:
+			print('Configuration could not be loaded...')
+			os.abort()
+
+	normalization_percentile = config['normalization_percentile']
+	normalization_clip = config['normalization_clip']
+	normalization_values = config['normalization_values']
+	normalize_kwargs = _get_normalize_kwargs(normalization_percentile, normalization_values, normalization_clip)
+
+	return normalize_kwargs
+
+def _get_normalize_kwargs(normalization_percentile, normalization_values, normalization_clip):
+
+	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])
+
+	return {"percentiles": percentiles, 'values': values, 'clip': normalization_clip}
+
+def _segment_image_with_cellpose_model(img, model=None, diameter=None, cellprob_threshold=None, flow_threshold=None, channel_axis=-1):
+
+	"""
+	Segments an input image using a Cellpose model.
+
+	This function applies a preloaded Cellpose model to segment an input image and returns the resulting labeled mask. 
+	The image is rearranged into the format expected by the Cellpose model, with the specified channel axis moved to the first dimension.
+
+	Parameters
+	----------
+	img : ndarray
+		The input image to be segmented. It is expected to have a channel axis specified by `channel_axis`.
+	model : CellposeModel, optional
+		A preloaded Cellpose model instance used for segmentation.
+	diameter : float, optional
+		The diameter of objects to segment. If `None`, the model's default diameter is used.
+	cellprob_threshold : float, optional
+		The threshold for the probability of cells used during segmentation. If `None`, the default threshold is used.
+	flow_threshold : float, optional
+		The threshold for flow error during segmentation. If `None`, the default threshold is used.
+	channel_axis : int, optional
+		The axis of the input image that represents the channels. Default is `-1` (channel-last format).
+
+	Returns
+	-------
+	ndarray
+		A labeled mask of the same spatial dimensions as the input image, with segmented regions assigned unique 
+		integer labels. The dtype of the mask is `uint16`.
+
+	Notes
+	-----
+	- The `img` array is internally rearranged to move the specified `channel_axis` to the first dimension to comply 
+	  with the Cellpose model's input requirements.
+	- Ensure the provided `model` is a properly initialized Cellpose model instance.
+	- Parameters `diameter`, `cellprob_threshold`, and `flow_threshold` allow fine-tuning of the segmentation process.
+	"""
+
+	img = np.moveaxis(img, channel_axis, 0)
+	lbl, _, _ = model.eval(img, diameter = diameter, cellprob_threshold=cellprob_threshold, flow_threshold=flow_threshold, channels=None, normalize=False)
+
+	return lbl.astype(np.uint16)
+
+def _segment_image_with_stardist_model(img, model=None, return_details=False, channel_axis=-1):
+
+	"""
+	Segments an input image using a StarDist model.
+
+	This function applies a preloaded StarDist model to segment an input image and returns the resulting labeled mask. 
+	Optionally, additional details about the segmentation can also be returned.
+
+	Parameters
+	----------
+	img : ndarray
+		The input image to be segmented. It is expected to have a channel axis specified by `channel_axis`.
+	model : StarDist2D, optional
+		A preloaded StarDist model instance used for segmentation.
+	return_details : bool, optional
+		Whether to return additional details from the model alongside the labeled mask. Default is `False`.
+	channel_axis : int, optional
+		The axis of the input image that represents the channels. Default is `-1` (channel-last format).
+
+	Returns
+	-------
+	ndarray
+		A labeled mask of the same spatial dimensions as the input image, with segmented regions assigned unique 
+		integer labels. The dtype of the mask is `uint16`.
+	tuple of (ndarray, dict), optional
+		If `return_details` is `True`, returns a tuple where the first element is the labeled mask and the second 
+		element is a dictionary containing additional details about the segmentation.
+
+	Notes
+	-----
+	- The `img` array is internally rearranged to move the specified `channel_axis` to the last dimension to comply 
+	  with the StarDist model's input requirements.
+	- Ensure the provided `model` is a properly initialized StarDist model instance.
+	- The model automatically determines the number of tiles (`n_tiles`) required for processing large images.
+	"""
+
+	if channel_axis!=-1:
+		img = np.moveaxis(img, channel_axis, -1)
+
+	lbl, details = model.predict_instances(img, n_tiles=model._guess_n_tiles(img), show_tile_progress=False, verbose=False)
+	if not return_details:
+		return lbl.astype(np.uint16)
+	else:
+		return lbl.astype(np.uint16), details
+
+def _rescale_labels(lbl, scale_model=1):
+	return zoom(lbl, [1./scale_model, 1./scale_model], order=0)
 
 def extract_cols_from_table_list(tables, nrows=1):
+
+	"""
+	Extracts a unique list of column names from a list of CSV tables.
+
+	Parameters
+	----------
+	tables : list of str
+		A list of file paths to the CSV tables from which to extract column names.
+	nrows : int, optional
+		The number of rows to read from each table to identify the columns.
+		Default is 1.
+
+	Returns
+	-------
+	numpy.ndarray
+		An array of unique column names found across all the tables.
+
+	Notes
+	-----
+	- This function reads only the first `nrows` rows of each table to improve performance when dealing with large files.
+	- The function ensures that column names are unique by consolidating them using `numpy.unique`.
+
+	Examples
+	--------
+	>>> tables = ["table1.csv", "table2.csv"]
+	>>> extract_cols_from_table_list(tables)
+	array(['Column1', 'Column2', 'Column3'], dtype='<U8')
+	"""
+
 	all_columns = []
 	for tab in tables:
 		cols = pd.read_csv(tab, nrows=1).columns.tolist()
@@ -41,18 +545,48 @@ def extract_cols_from_table_list(tables, nrows=1):
 
 def safe_log(array):
 
-	if isinstance(array,int) or isinstance(array,float):
-		if value<=0.:
-			return np.nan
-		else:
-			return np.log10(value)
-	else:
-		if isinstance(array, list):
-			array = np.array(array)
-		output_array = np.zeros_like(array).astype(float)
-		output_array[:] = np.nan
-		output_array[array==array] = np.log10(array[array==array])
-		return output_array
+	"""
+	Safely computes the base-10 logarithm for numeric inputs, handling invalid or non-positive values.
+
+	Parameters
+	----------
+	array : int, float, list, or numpy.ndarray
+		The input value or array for which to compute the logarithm.
+		Can be a single number (int or float), a list, or a numpy array.
+
+	Returns
+	-------
+	float or numpy.ndarray
+		- If the input is a single numeric value, returns the base-10 logarithm as a float, or `np.nan` if the value is non-positive.
+		- If the input is a list or numpy array, returns a numpy array with the base-10 logarithm of each element.
+		  Invalid or non-positive values are replaced with `np.nan`.
+
+	Notes
+	-----
+	- Non-positive values (`<= 0`) are considered invalid and will result in `np.nan`.
+	- NaN values in the input array are preserved in the output.
+	- If the input is a list, it is converted to a numpy array for processing.
+
+	Examples
+	--------
+	>>> safe_log(10)
+	1.0
+
+	>>> safe_log(-5)
+	nan
+
+	>>> safe_log([10, 0, -5, 100])
+	array([1.0, nan, nan, 2.0])
+
+	>>> import numpy as np
+	>>> safe_log(np.array([1, 10, 100]))
+	array([0.0, 1.0, 2.0])
+	"""
+
+	array = np.asarray(array, dtype=float)
+	result = np.where(array > 0, np.log10(array), np.nan)
+
+	return result.item() if np.isscalar(array) else result
 
 def contour_of_instance_segmentation(label, distance):
 
@@ -114,20 +648,35 @@ def contour_of_instance_segmentation(label, distance):
 
 def extract_identity_col(trajectories):
 
-	if 'TRACK_ID' in list(trajectories.columns):
-		if not np.all(trajectories['TRACK_ID'].isnull()):
-			id_col = 'TRACK_ID'
-		else:
-			if 'ID' in list(trajectories.columns):
-				id_col = 'ID'
-	elif 'ID' in list(trajectories.columns):
-		
-		id_col = 'ID'
-	else:
-		print('ID or TRACK ID column could not be found in the table...')
-		id_col = None
+	"""
+	Determines the identity column name in a DataFrame of trajectories.
 
-	return id_col
+	This function checks the provided DataFrame for the presence of a column
+	that can serve as the identity column. It first looks for the column
+	'TRACK_ID'. If 'TRACK_ID' exists but contains only null values, it checks
+	for the column 'ID' instead. If neither column is found, the function
+	returns `None` and prints a message indicating the issue.
+
+	Parameters
+	----------
+	trajectories : pandas.DataFrame
+		A DataFrame containing trajectory data. The function assumes that
+		the identity of each trajectory might be stored in either the
+		'TRACK_ID' or 'ID' column.
+
+	Returns
+	-------
+	str or None
+		The name of the identity column ('TRACK_ID' or 'ID') if found;
+		otherwise, `None`.
+	"""
+
+	for col in ['TRACK_ID', 'ID']:
+		if col in trajectories.columns and not trajectories[col].isnull().all():
+			return col
+
+	print('ID or TRACK_ID column could not be found in the table...')
+	return None
 
 def derivative(x, timeline, window, mode='bi'):
 	
@@ -187,7 +736,7 @@ def derivative(x, timeline, window, mode='bi'):
 	if mode=='bi':
 		assert window%2==1,'Please set an odd window for the bidirectional mode'
 		lower_bound = window//2
-		upper_bound = len(x) - window//2 - 1
+		upper_bound = len(x) - window//2
 	elif mode=='forward':
 		lower_bound = 0
 		upper_bound = len(x) - window
@@ -197,7 +746,7 @@ def derivative(x, timeline, window, mode='bi'):
 
 	for t in range(lower_bound,upper_bound):
 		if mode=='bi':
-			dxdt[t] = (x[t+window//2+1] - x[t-window//2]) / (timeline[t+window//2+1] - timeline[t-window//2])
+			dxdt[t] = (x[t+window//2] - x[t-window//2]) / (timeline[t+window//2] - timeline[t-window//2])
 		elif mode=='forward':
 			dxdt[t] = (x[t+window] - x[t]) /  (timeline[t+window] - timeline[t])
 		elif mode=='backward':
@@ -533,6 +1082,11 @@ def mask_edges(binary_mask, border_size):
 
 	return binary_mask
 
+def demangle_column_name(name):
+	if name.startswith("BACKTICK_QUOTED_STRING_"):
+		# Unquote backtick-quoted string.
+		return name[len("BACKTICK_QUOTED_STRING_"):].replace("_DOT_", ".").replace("_SLASH_", "/")
+	return name
 
 def extract_cols_from_query(query: str):
 	
@@ -556,13 +1110,6 @@ def extract_cols_from_query(query: str):
 			# Add the name to the globals dictionary with a dummy value.
 			variables[name] = None
 
-	# Reverse mangling for special characters in column names.
-	def demangle_column_name(name):
-		if name.startswith("BACKTICK_QUOTED_STRING_"):
-			# Unquote backtick-quoted string.
-			return name[len("BACKTICK_QUOTED_STRING_"):].replace("_DOT_", ".").replace("_SLASH_", "/")
-		return name
-
 	return [demangle_column_name(name) for name in variables.keys()]
 
 def create_patch_mask(h, w, center=None, radius=None):
@@ -1307,7 +1854,6 @@ def _extract_channel_indices_from_config(config, channels_to_extract):
 	# [1, 2] or None if an error occurs or the channels are not found.
 	"""
 
-	# V2
 	channels = []
 	for c in channels_to_extract:
 		try:
@@ -1319,30 +1865,6 @@ def _extract_channel_indices_from_config(config, channels_to_extract):
 	if np.all([c is None for c in channels]):
 		channels = None
 
-	# channels = []
-	# for c in channels_to_extract:
-	# 	if c!='None' and c is not None:
-	# 		try:
-	# 			c1 = int(ConfigSectionMap(config,"Channels")[c])
-	# 			channels.append(c1)
-	# 		except Exception as e:
-	# 			print(f"Error {e}. The channel required by the model is not available in your data... Check the configuration file.")
-	# 			channels = None
-	# 			break
-	# 	else:
-	# 		channels.append(None)
-
-	# LEGACY
-	if channels is None:
-		channels = []
-		for c in channels_to_extract:
-			try:
-				c1 = int(ConfigSectionMap(config,"MovieSettings")[c])
-				channels.append(c1)
-			except Exception as e:
-				print(f"Error {e}. The channel required by the model is not available in your data... Check the configuration file.")
-				channels = None
-				break
 	return channels
 
 def _extract_nbr_channels_from_config(config, return_names=False):
@@ -2242,7 +2764,7 @@ def load_image_dataset(datasets, channels, train_spatial_calibration=None, mask_
 					intersection = list(set(list(channels)) & set(list(existing_channels)))
 					print(f'{existing_channels=} {intersection=}')
 					if len(intersection)==0:
-						print(e,' channels could not be found in the config... Skipping image.')
+						print('Channels could not be found in the config... Skipping image.')
 						continue
 					else:
 						ch_idx = []
@@ -2384,13 +2906,6 @@ def download_zenodo_file(file, output_dir):
 	if len(file_to_rename)>0 and not file_to_rename[0].endswith(os.sep) and not file.startswith('demo'):
 		os.rename(file_to_rename[0], os.sep.join([output_dir,file,file]))
 
-	#if file.startswith('db_'):
-	#	os.rename(os.sep.join([output_dir,file.replace('db_','')]), os.sep.join([output_dir,file]))
-	#if file=='db-si-NucPI':
-	#	os.rename(os.sep.join([output_dir,'db2-NucPI']), os.sep.join([output_dir,file]))
-	#if file=='db-si-NucCondensation':
-	#	os.rename(os.sep.join([output_dir,'db1-NucCondensation']), os.sep.join([output_dir,file]))
-
 	os.remove(path_to_zip_file)
 
 def interpolate_nan(img, method='nearest'):
@@ -2415,6 +2930,11 @@ def interpolate_nan(img, method='nearest'):
 	else:
 		return img
 
+
+def interpolate_nan_multichannel(frames):
+	frames = np.moveaxis([interpolate_nan(frames[:,:,c].copy()) for c in range(frames.shape[-1])],0,-1)
+	return frames
+
 def collapse_trajectories_by_status(df, status=None, projection='mean', population='effectors', groupby_columns=['position','TRACK_ID']):
 	
 	static_columns = ['well_index', 'well_name', 'pos_name', 'position', 'well', 'status', 't0', 'class','cell_type','concentration', 'antibody', 'pharmaceutical_agent','TRACK_ID','position', 'neighbor_population', 'reference_population', 'NEIGHBOR_ID', 'REFERENCE_ID', 'FRAME']