celldetective 1.0.2.post1__py3-none-any.whl → 1.1.1__py3-none-any.whl

celldetective/utils.py

@@ -22,6 +22,413 @@ import zipfile
 from tqdm import tqdm
 import shutil
 import tempfile
+from scipy.interpolate import griddata
+
+
+def derivative(x, timeline, window, mode='bi'):
+	
+	"""
+	Compute the derivative of a given array of values with respect to time using a specified numerical differentiation method.
+
+	Parameters
+	----------
+	x : array_like
+		The input array of values.
+	timeline : array_like
+		The array representing the time points corresponding to the input values.
+	window : int
+		The size of the window used for numerical differentiation. Must be a positive odd integer.
+	mode : {'bi', 'forward', 'backward'}, optional
+		The numerical differentiation method to be used:
+		- 'bi' (default): Bidirectional differentiation using a symmetric window.
+		- 'forward': Forward differentiation using a one-sided window.
+		- 'backward': Backward differentiation using a one-sided window.
+
+	Returns
+	-------
+	dxdt : ndarray
+		The computed derivative values of the input array with respect to time.
+
+	Raises
+	------
+	AssertionError
+		If the window size is not an odd integer and mode is 'bi'.
+
+	Notes
+	-----
+	- For 'bi' mode, the window size must be an odd number.
+	- For 'forward' mode, the derivative at the edge points may not be accurate due to the one-sided window.
+	- For 'backward' mode, the derivative at the first few points may not be accurate due to the one-sided window.
+
+	Examples
+	--------
+	>>> import numpy as np
+	>>> x = np.array([1, 2, 4, 7, 11])
+	>>> timeline = np.array([0, 1, 2, 3, 4])
+	>>> window = 3
+	>>> derivative(x, timeline, window, mode='bi')
+	array([3., 3., 3.])
+
+	>>> derivative(x, timeline, window, mode='forward')
+	array([1., 2., 3.])
+
+	>>> derivative(x, timeline, window, mode='backward')
+	array([3., 3., 3., 3.])
+	"""
+
+	# modes = bi, forward, backward
+	dxdt = np.zeros(len(x))
+	dxdt[:] = np.nan
+	
+	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
+	elif mode=='forward':
+		lower_bound = 0
+		upper_bound = len(x) - window
+	elif mode=='backward':
+		lower_bound = window
+		upper_bound = len(x)
+
+	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])
+		elif mode=='forward':
+			dxdt[t] = (x[t+window] - x[t]) /  (timeline[t+window] - timeline[t])
+		elif mode=='backward':
+			dxdt[t] = (x[t] - x[t-window]) /  (timeline[t] - timeline[t-window])
+	return dxdt
+
+def differentiate_per_track(tracks, measurement, window_size=3, mode='bi'):
+	
+	groupby_cols = ['TRACK_ID']
+	if 'position' in list(tracks.columns):
+		groupby_cols = ['position']+groupby_cols
+
+	tracks = tracks.sort_values(by=groupby_cols+['FRAME'],ignore_index=True)
+	tracks = tracks.reset_index(drop=True)
+	for tid, group in tracks.groupby(groupby_cols):
+		indices = group.index
+		timeline = group['FRAME'].values
+		signal = group[measurement].values
+		dsignal = derivative(signal, timeline, window_size, mode=mode)
+		tracks.loc[indices, 'd/dt.'+measurement] = dsignal
+	return tracks
+
+def velocity_per_track(tracks, window_size=3, mode='bi'):
+	
+	groupby_cols = ['TRACK_ID']
+	if 'position' in list(tracks.columns):
+		groupby_cols = ['position']+groupby_cols
+
+	tracks = tracks.sort_values(by=groupby_cols+['FRAME'],ignore_index=True)
+	tracks = tracks.reset_index(drop=True)
+	for tid, group in tracks.groupby(groupby_cols):
+		indices = group.index
+		timeline = group['FRAME'].values
+		x = group['POSITION_X'].values
+		y = group['POSITION_Y'].values
+		v = velocity(x,y,timeline,window=window_size,mode=mode)
+		v_abs = magnitude_velocity(v)
+		tracks.loc[indices, 'velocity'] = v_abs
+	return tracks
+
+def velocity(x,y,timeline,window,mode='bi'):
+
+	"""
+	Compute the velocity vector of a given 2D trajectory represented by arrays of x and y coordinates
+	with respect to time using a specified numerical differentiation method.
+
+	Parameters
+	----------
+	x : array_like
+		The array of x-coordinates of the trajectory.
+	y : array_like
+		The array of y-coordinates of the trajectory.
+	timeline : array_like
+		The array representing the time points corresponding to the x and y coordinates.
+	window : int
+		The size of the window used for numerical differentiation. Must be a positive odd integer.
+	mode : {'bi', 'forward', 'backward'}, optional
+		The numerical differentiation method to be used:
+		- 'bi' (default): Bidirectional differentiation using a symmetric window.
+		- 'forward': Forward differentiation using a one-sided window.
+		- 'backward': Backward differentiation using a one-sided window.
+
+	Returns
+	-------
+	v : ndarray
+		The computed velocity vector of the 2D trajectory with respect to time.
+		The first column represents the x-component of velocity, and the second column represents the y-component.
+
+	Raises
+	------
+	AssertionError
+		If the window size is not an odd integer and mode is 'bi'.
+
+	Notes
+	-----
+	- For 'bi' mode, the window size must be an odd number.
+	- For 'forward' mode, the velocity at the edge points may not be accurate due to the one-sided window.
+	- For 'backward' mode, the velocity at the first few points may not be accurate due to the one-sided window.
+
+	Examples
+	--------
+	>>> import numpy as np
+	>>> x = np.array([1, 2, 4, 7, 11])
+	>>> y = np.array([0, 3, 5, 8, 10])
+	>>> timeline = np.array([0, 1, 2, 3, 4])
+	>>> window = 3
+	>>> velocity(x, y, timeline, window, mode='bi')
+	array([[3., 3.],
+		   [3., 3.]])
+
+	>>> velocity(x, y, timeline, window, mode='forward')
+	array([[2., 2.],
+		   [3., 3.]])
+
+	>>> velocity(x, y, timeline, window, mode='backward')
+	array([[3., 3.],
+		   [3., 3.]])
+	"""
+
+	v = np.zeros((len(x),2))
+	v[:,:] = np.nan
+	
+	v[:,0] = derivative(x, timeline, window, mode=mode)
+	v[:,1] = derivative(y, timeline, window, mode=mode)
+
+	return v
+
+def magnitude_velocity(v_matrix):
+
+	"""
+	Compute the magnitude of velocity vectors given a matrix representing 2D velocity vectors.
+
+	Parameters
+	----------
+	v_matrix : array_like
+		The matrix where each row represents a 2D velocity vector with the first column
+		being the x-component and the second column being the y-component.
+
+	Returns
+	-------
+	magnitude : ndarray
+		The computed magnitudes of the input velocity vectors.
+
+	Notes
+	-----
+	- If a velocity vector has NaN components, the corresponding magnitude will be NaN.
+	- The function handles NaN values in the input matrix gracefully.
+
+	Examples
+	--------
+	>>> import numpy as np
+	>>> v_matrix = np.array([[3, 4],
+	...                      [2, 2],
+	...                      [3, 3]])
+	>>> magnitude_velocity(v_matrix)
+	array([5., 2.82842712, 4.24264069])
+
+	>>> v_matrix_with_nan = np.array([[3, 4],
+	...                               [np.nan, 2],
+	...                               [3, np.nan]])
+	>>> magnitude_velocity(v_matrix_with_nan)
+	array([5., nan, nan])
+	"""
+
+	magnitude = np.zeros(len(v_matrix))
+	magnitude[:] = np.nan
+	for i in range(len(v_matrix)):
+		if v_matrix[i,0]==v_matrix[i,0]:
+			magnitude[i] = np.sqrt(v_matrix[i,0]**2 + v_matrix[i,1]**2)
+	return magnitude
+		
+def orientation(v_matrix):
+
+	"""
+	Compute the orientation angles (in radians) of 2D velocity vectors given a matrix representing velocity vectors.
+
+	Parameters
+	----------
+	v_matrix : array_like
+		The matrix where each row represents a 2D velocity vector with the first column
+		being the x-component and the second column being the y-component.
+
+	Returns
+	-------
+	orientation_array : ndarray
+		The computed orientation angles of the input velocity vectors in radians.
+		If a velocity vector has NaN components, the corresponding orientation angle will be NaN.
+
+	Examples
+	--------
+	>>> import numpy as np
+	>>> v_matrix = np.array([[3, 4],
+	...                      [2, 2],
+	...                      [-3, -3]])
+	>>> orientation(v_matrix)
+	array([0.92729522, 0.78539816, -2.35619449])
+
+	>>> v_matrix_with_nan = np.array([[3, 4],
+	...                               [np.nan, 2],
+	...                               [3, np.nan]])
+	>>> orientation(v_matrix_with_nan)
+	array([0.92729522, nan, nan])
+	"""
+
+	orientation_array = np.zeros(len(v_matrix))
+	for t in range(len(orientation_array)):
+		if v_matrix[t,0]==v_matrix[t,0]:
+			orientation_array[t] = np.arctan2(v_matrix[t,0],v_matrix[t,1])
+	return orientation_array
+
+
+def estimate_unreliable_edge(activation_protocol=[['gauss',2],['std',4]]):
+
+	"""
+	Safely estimate the distance to the edge of an image in which the filtered image values can be artefactual.
+
+	Parameters
+	----------
+	activation_protocol : list of list, optional
+		A list of lists, where each sublist contains a string naming the filter function, followed by its arguments (usually a kernel size). 
+		Default is [['gauss', 2], ['std', 4]].
+
+	Returns
+	-------
+	int or None
+		The sum of the kernel sizes in the activation protocol if the protocol 
+		is not empty. Returns None if the activation protocol is empty.
+
+	Notes
+	-----
+	This function assumes that the second element of each sublist in the 
+	activation protocol is a kernel size.
+
+	Examples
+	--------
+	>>> estimate_unreliable_edge([['gauss', 2], ['std', 4]])
+	6
+	>>> estimate_unreliable_edge([])
+	None
+	"""
+
+	if activation_protocol==[]:
+		return None
+	else:
+		edge=0
+		for fct in activation_protocol:
+			if isinstance(fct[1],(int,np.int_)):
+				edge+=fct[1]
+		return edge
+
+def unpad(img, pad):
+	
+	"""
+	Remove padding from an image.
+
+	This function removes the specified amount of padding from the borders
+	of an image. The padding is assumed to be the same on all sides.
+
+	Parameters
+	----------
+	img : ndarray
+		The input image from which the padding will be removed.
+	pad : int
+		The amount of padding to remove from each side of the image.
+
+	Returns
+	-------
+	ndarray
+		The image with the padding removed.
+
+	Raises
+	------
+	ValueError
+		If `pad` is greater than or equal to half of the smallest dimension 
+		of `img`.
+
+	See Also
+	--------
+	numpy.pad : Pads an array.
+
+	Notes
+	-----
+	This function assumes that the input image is a 2D array.
+
+	Examples
+	--------
+	>>> import numpy as np
+	>>> img = np.array([[0, 0, 0, 0, 0],
+	...                 [0, 1, 1, 1, 0],
+	...                 [0, 1, 1, 1, 0],
+	...                 [0, 1, 1, 1, 0],
+	...                 [0, 0, 0, 0, 0]])
+	>>> unpad(img, 1)
+	array([[1, 1, 1],
+		   [1, 1, 1],
+		   [1, 1, 1]])
+	"""
+
+	return img[pad:-pad, pad:-pad]
+
+def mask_edges(binary_mask, border_size):
+	
+	"""
+	Mask the edges of a binary mask.
+
+	This function sets the edges of a binary mask to False, effectively 
+	masking out a border of the specified size.
+
+	Parameters
+	----------
+	binary_mask : ndarray
+		A 2D binary mask array where the edges will be masked.
+	border_size : int
+		The size of the border to mask (set to False) on all sides.
+
+	Returns
+	-------
+	ndarray
+		The binary mask with the edges masked out.
+
+	Raises
+	------
+	ValueError
+		If `border_size` is greater than or equal to half of the smallest 
+		dimension of `binary_mask`.
+
+	Notes
+	-----
+	This function assumes that the input `binary_mask` is a 2D array. The 
+	input mask is converted to a boolean array before masking the edges.
+
+	Examples
+	--------
+	>>> import numpy as np
+	>>> binary_mask = np.array([[1, 1, 1, 1, 1],
+	...                         [1, 1, 1, 1, 1],
+	...                         [1, 1, 1, 1, 1],
+	...                         [1, 1, 1, 1, 1],
+	...                         [1, 1, 1, 1, 1]])
+	>>> mask_edges(binary_mask, 1)
+	array([[False, False, False, False, False],
+		   [False,  True,  True,  True, False],
+		   [False,  True,  True,  True, False],
+		   [False,  True,  True,  True, False],
+		   [False, False, False, False, False]])
+	"""
+
+	binary_mask = binary_mask.astype(bool)
+	binary_mask[:border_size,:] = False
+	binary_mask[(binary_mask.shape[0]-border_size):,:] = False
+	binary_mask[:,:border_size] = False
+	binary_mask[:,(binary_mask.shape[1]-border_size):] = False
+
+	return binary_mask
+
 
 def create_patch_mask(h, w, center=None, radius=None):
 
@@ -170,8 +577,6 @@ def rename_intensity_column(df, channels):
 						new_name = '_'.join(list(measure))
 						new_name = new_name.replace('radial_gradient', "radial_intercept")
 						to_rename.update({intensity_columns[k]: new_name.replace('-', '_')})
-
-
 		else:
 			to_rename = {}
 			for k in range(len(intensity_columns)):
@@ -367,7 +772,7 @@ def compute_weights(y):
 
 	return class_weights
 
-def train_test_split(data_x, data_y1, data_y2=None, validation_size=0.25, test_size=0):
+def train_test_split(data_x, data_y1, data_class=None, validation_size=0.25, test_size=0, n_iterations=10):
 
 	"""
 
@@ -407,37 +812,56 @@ def train_test_split(data_x, data_y1, data_y2=None, validation_size=0.25, test_s
 
 	"""
 
-	n_values = len(data_x)
-	randomize = np.arange(n_values)
-	np.random.shuffle(randomize)
+	if data_class is not None:
+		print(f"Unique classes: {np.sort(np.argmax(np.unique(data_class,axis=0),axis=1))}")
+
+	for i in range(n_iterations):
 
-	train_percentage = 1- validation_size - test_size
-	chunks = split_by_ratio(randomize, train_percentage, validation_size, test_size)
+		n_values = len(data_x)
+		randomize = np.arange(n_values)
+		np.random.shuffle(randomize)
 
-	x_train = data_x[chunks[0]]
-	y1_train = data_y1[chunks[0]]
-	if data_y2 is not None:
-		y2_train = data_y2[chunks[0]]
+		train_percentage = 1 - validation_size - test_size
 
+		chunks = split_by_ratio(randomize, train_percentage, validation_size, test_size)
 
-	x_val = data_x[chunks[1]]
-	y1_val = data_y1[chunks[1]]
-	if data_y2 is not None:
-		y2_val = data_y2[chunks[1]]
+		x_train = data_x[chunks[0]]
+		y1_train = data_y1[chunks[0]]
+		if data_class is not None:
+			y2_train = data_class[chunks[0]]
 
-	ds = {"x_train": x_train, "x_val": x_val,
-		 "y1_train": y1_train, "y1_val": y1_val}
-	if data_y2 is not None:
-		ds.update({"y2_train": y2_train, "y2_val": y2_val})
+		x_val = data_x[chunks[1]]
+		y1_val = data_y1[chunks[1]]
+		if data_class is not None:
+			y2_val = data_class[chunks[1]]
+
+		if data_class is not None:
+			print(f"classes in train set: {np.sort(np.argmax(np.unique(y2_train,axis=0),axis=1))}; classes in validation set: {np.sort(np.argmax(np.unique(y2_val,axis=0),axis=1))}")
+			same_class_test = np.array_equal(np.sort(np.argmax(np.unique(y2_train,axis=0),axis=1)), np.sort(np.argmax(np.unique(y2_val,axis=0),axis=1)))
+			print(f"Check that classes are found in all sets: {same_class_test}...")
+		else:
+			same_class_test = True
+
+		if same_class_test:
+
+			ds = {"x_train": x_train, "x_val": x_val,
+				 "y1_train": y1_train, "y1_val": y1_val}
+			if data_class is not None:
+				ds.update({"y2_train": y2_train, "y2_val": y2_val})
+
+			if test_size>0:
+				x_test = data_x[chunks[2]]
+				y1_test = data_y1[chunks[2]]
+				ds.update({"x_test": x_test, "y1_test": y1_test})
+				if data_class is not None:
+					y2_test = data_class[chunks[2]]
+					ds.update({"y2_test": y2_test})
+			return ds
+		else:
+			continue
+
+	raise Exception("Some classes are missing from the train or validation set... Abort.")
 
-	if test_size>0:
-		x_test = data_x[chunks[2]]
-		y1_test = data_y1[chunks[2]]
-		ds.update({"x_test": x_test, "y1_test": y1_test})
-		if data_y2 is not None:
-			y2_test = data_y2[chunks[2]]
-			ds.update({"y2_test": y2_test})
-	return ds
 
 def remove_redundant_features(features, reference_features, channel_names=None):
 
@@ -482,7 +906,7 @@ def remove_redundant_features(features, reference_features, channel_names=None):
 
 	"""
 
-	new_features = features.copy()
+	new_features = features[:]
 
 	for f in features:
 
@@ -1144,7 +1568,7 @@ def remove_trajectory_measurements(trajectories, column_labels):
 	tracks = trajectories.copy()
 
 	columns_to_keep = [column_labels['track'], column_labels['time'], column_labels['x'], column_labels['y'],column_labels['x']+'_um', column_labels['y']+'_um', 'class_id', 
-					  't', 'state', 'generation', 'root', 'parent', 'ID', 't0', 'class', 'status', 'class_color', 'status_color', 'class_firstdetection', 't_firstdetection']
+					  't', 'state', 'generation', 'root', 'parent', 'ID', 't0', 'class', 'status', 'class_color', 'status_color', 'class_firstdetection', 't_firstdetection', 'velocity']
 	cols = tracks.columns
 	for c in columns_to_keep:
 		if c not in cols:
@@ -1201,11 +1625,32 @@ def color_from_class(cclass, recently_modified=False):
 def random_fliprot(img, mask):
 
 	"""
+	Randomly flips and rotates an image and its corresponding mask.
+
+	This function applies a series of random flips and permutations (rotations) to both the input image and its
+	associated mask, ensuring that any transformations applied to the image are also exactly applied to the mask.
+	The function is designed to handle multi-dimensional images (e.g., multi-channel images in YXC format where
+	channels are last).
+
+	Parameters
+	----------
+	img : ndarray
+		The input image to be transformed. This array is expected to have dimensions where the channel axis is last.
+	mask : ndarray
+		The mask corresponding to `img`, to be transformed in the same way as the image.
+
+	Returns
+	-------
+	tuple of ndarray
+		A tuple containing the transformed image and mask.
 
-	Perform random flipping of the image and the associated mask. 
-	Needs YXC (channel last).
+	Raises
+	------
+	AssertionError
+		If the number of dimensions of the mask exceeds that of the image, indicating incompatible shapes.
 
 	"""
+
 	assert img.ndim >= mask.ndim
 	axes = tuple(range(mask.ndim))
 	perm = tuple(np.random.permutation(axes))
@@ -1225,12 +1670,37 @@ def random_fliprot(img, mask):
 def random_shift(image,mask, max_shift_amplitude=0.1):
 
 	"""
+	Randomly shifts an image and its corresponding mask along the X and Y axes.
 
-	Perform random shift of the image in X and or Y. 
-	Needs YXC (channel last).
+	This function shifts both the image and the mask by a randomly chosen distance up to a maximum
+	percentage of the image's dimensions, specified by `max_shift_amplitude`. The shifts are applied
+	independently in both the X and Y directions. This type of augmentation can help improve the robustness
+	of models to positional variations in images.
+
+	Parameters
+	----------
+	image : ndarray
+		The input image to be shifted. Must be in YXC format (height, width, channels).
+	mask : ndarray
+		The mask corresponding to `image`, to be shifted in the same way as the image.
+	max_shift_amplitude : float, optional
+		The maximum shift as a fraction of the image's dimension. Default is 0.1 (10% of the image's size).
+
+	Returns
+	-------
+	tuple of ndarray
+		A tuple containing the shifted image and mask.
+
+	Notes
+	-----
+	- The shift values are chosen randomly within the range defined by the maximum amplitude.
+	- Shifting is performed using the 'constant' mode where missing values are filled with zeros (cval=0.0),
+	  which may introduce areas of zero-padding along the edges of the shifted images and masks.
+	- This function is designed to support data augmentation for machine learning and image processing tasks,
+	  particularly in contexts where spatial invariance is beneficial.
+
+	"""
 
-	"""	
-	
 	input_shape = image.shape[0]
 	max_shift = input_shape*max_shift_amplitude
 	
@@ -1249,9 +1719,35 @@ def random_shift(image,mask, max_shift_amplitude=0.1):
 
 
 def blur(x,max_sigma=4.0):
+
 	"""
-	Random image blur
+	Applies a random Gaussian blur to an image.
+
+	This function blurs an image by applying a Gaussian filter with a randomly chosen sigma value. The sigma
+	represents the standard deviation for the Gaussian kernel and is selected randomly up to a specified maximum.
+	The blurring is applied while preserving the range of the image's intensity values and maintaining any
+	zero-valued pixels as they are.
+
+	Parameters
+	----------
+	x : ndarray
+		The input image to be blurred. The image can have any number of channels, but must be in a format
+		where the channels are the last dimension (YXC format).
+	max_sigma : float, optional
+		The maximum value for the standard deviation of the Gaussian blur. Default is 4.0.
+
+	Returns
+	-------
+	ndarray
+		The blurred image. The output will have the same shape and type as the input image.
+
+	Notes
+	-----
+	- The function ensures that zero-valued pixels in the input image remain unchanged after the blurring,
+	  which can be important for maintaining masks or other specific regions within the image.
+	- Gaussian blurring is commonly used in image processing to reduce image noise and detail by smoothing.
 	"""
+
 	sigma = np.random.random()*max_sigma
 	loc_i,loc_j,loc_c = np.where(x==0.)
 	x = gaussian(x, sigma, channel_axis=-1, preserve_range=True)
@@ -1262,8 +1758,44 @@ def blur(x,max_sigma=4.0):
 def noise(x, apply_probability=0.5, clip_option=False):
 
 	"""
-	Apply random noise to a multichannel image
+	Applies random noise to each channel of a multichannel image based on a specified probability.
+
+	This function introduces various types of random noise to an image. Each channel of the image can be
+	modified independently with different noise models chosen randomly from a predefined list. The application
+	of noise to any given channel is determined by a specified probability, allowing for selective noise
+	addition.
+
+	Parameters
+	----------
+	x : ndarray
+		The input multichannel image to which noise will be added. The image should be in format with channels
+		as the last dimension (e.g., height x width x channels).
+	apply_probability : float, optional
+		The probability with which noise is applied to each channel of the image. Default is 0.5.
+	clip_option : bool, optional
+		Specifies whether to clip the corrupted data to stay within the valid range after noise addition.
+		If True, the output array will be clipped to the range [0, 1] or [0, 255] depending on the input
+		data type. Default is False.
+
+	Returns
+	-------
+	ndarray
+		The noised image. This output has the same shape as the input but potentially altered intensity values
+		due to noise addition.
+
+	Notes
+	-----
+	- The types of noise that can be applied include 'gaussian', 'localvar', 'poisson', and 'speckle'.
+	- The choice of noise type for each channel is randomized and the noise is only applied if a randomly
+	  generated number is less than or equal to `apply_probability`.
+	- Zero-valued pixels in the input image remain zero in the output to preserve background or masked areas.
 
+	Examples
+	--------
+	>>> import numpy as np
+	>>> x = np.random.rand(256, 256, 3)  # Example 3-channel image
+	>>> noised_image = noise(x)
+	# The image 'x' may have different types of noise applied to each of its channels with a 50% probability.
 	"""
 
 	x_noise = x.astype(float).copy()
@@ -1436,26 +1968,29 @@ def normalize_per_channel(X, normalization_percentile_mode=True, normalization_v
 	assert len(normalization_clipping)==n_channels
 	assert len(normalization_percentile_mode)==n_channels
 	
+	X_normalized = []
 	for i in range(len(X)):
-		x = X[i]
+		x = X[i].copy()
 		loc_i,loc_j,loc_c = np.where(x==0.)
 		norm_x = np.zeros_like(x, dtype=np.float32)
 		for k in range(x.shape[-1]):
-			chan = x[:,:,k]
+			chan = x[:,:,k].copy()
 			if not np.all(chan.flatten()==0):
 				if normalization_percentile_mode[k]:
-					min_val = np.percentile(chan[chan!=0.].flatten(), normalization_values[k][0])
-					max_val = np.percentile(chan[chan!=0.].flatten(), normalization_values[k][1])
+					min_val = np.nanpercentile(chan[chan!=0.].flatten(), normalization_values[k][0])
+					max_val = np.nanpercentile(chan[chan!=0.].flatten(), normalization_values[k][1])
 				else:
 					min_val = normalization_values[k][0]
 					max_val = normalization_values[k][1]
 
 				clip_option = normalization_clipping[k]
-				norm_x[:,:,k] = normalize_mi_ma(chan.astype(np.float32), min_val, max_val, clip=clip_option, eps=1e-20, dtype=np.float32)
-		
-		X[i] = norm_x
+				norm_x[:,:,k] = normalize_mi_ma(chan.astype(np.float32).copy(), min_val, max_val, clip=clip_option, eps=1e-20, dtype=np.float32)
+			else:
+				norm_x[:,:,k] = 0.
+		norm_x[loc_i,loc_j,loc_c] = 0.
+		X_normalized.append(norm_x.copy())
 
-	return X
+	return X_normalized
 
 def load_image_dataset(datasets, channels, train_spatial_calibration=None, mask_suffix='labelled'):
 
@@ -1561,8 +2096,7 @@ def load_image_dataset(datasets, channels, train_spatial_calibration=None, mask_
 	
 				if im_calib != train_spatial_calibration:
 					factor = im_calib / train_spatial_calibration
-					print(f'{im_calib=}, {train_spatial_calibration=}, {factor=}')
-					image = zoom(image, [factor,factor,1], order=3)
+					image = np.moveaxis([zoom(image[:,:,c].astype(float).copy(), [factor,factor], order=3, prefilter=False) for c in range(image.shape[-1])],0,-1) #zoom(image, [factor,factor,1], order=3)
 					mask = zoom(mask, [factor,factor], order=0)        
 					
 			X.append(image)
@@ -1678,4 +2212,23 @@ def download_zenodo_file(file, output_dir):
 	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)
+	os.remove(path_to_zip_file)
+
+def interpolate_nan(img, method='nearest'):
+
+	"""
+	Interpolate NaN on single channel array 2D
+	"""
+
+	if np.any(img.flatten()!=img.flatten()):
+		# then need to interpolate
+		x_grid, y_grid = np.meshgrid(np.arange(img.shape[1]),np.arange(img.shape[0]))
+		mask = [~np.isnan(img)][0]
+		x = x_grid[mask].reshape(-1)
+		y = y_grid[mask].reshape(-1)
+		points = np.array([x,y]).T
+		values = img[mask].reshape(-1)
+		interp_grid = griddata(points, values, (x_grid, y_grid), method=method)
+		return interp_grid
+	else:
+		return img