celldetective 1.1.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

celldetective/scripts/segment_cells.py

@@ -22,6 +22,9 @@ from art import tprint
 from scipy.ndimage import zoom
 import threading
 
+import matplotlib.pyplot as plt
+import time
+
 tprint("Segment")
 
 parser = argparse.ArgumentParser(description="Segment a movie in position with the selected model",
@@ -159,10 +162,18 @@ def segment_index(indices):
 	for t in tqdm(indices,desc="frame"):
 		
 		# Load channels at time t
-		f = load_frames(img_num_channels[:,t], file, scale=scale, normalize_input=False)
-		f = normalize_per_channel([f], normalization_percentile_mode=normalization_percentile, normalization_values=normalization_values,
-									normalization_clipping=normalization_clip)
-		f = f[0]
+		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, normalize_input=True, normalize_kwargs={"percentiles": percentiles, 'values': values, 'clip': normalization_clip})
+
 		if np.any(img_num_channels[:,t]==-1):
 			f[:,:,np.where(img_num_channels[:,t]==-1)[0]] = 0.
 

celldetective/scripts/train_segmentation_model.py

@@ -11,28 +11,15 @@ from tqdm import tqdm
 import numpy as np
 import random
 
-from celldetective.utils import load_image_dataset, normalize_per_channel, augmenter
+from celldetective.utils import load_image_dataset, normalize_per_channel, augmenter, interpolate_nan
+from celldetective.io import normalize_multichannel
 from stardist import fill_label_holes
 from art import tprint
 import matplotlib.pyplot as plt
 
-def interpolate_nan(array_like):
-	array = array_like.copy()
-	
-	isnan_array = ~np.isnan(array)
-	
-	xp = isnan_array.ravel().nonzero()[0]
-	
-	fp = array[~np.isnan(array)]
-	x = np.isnan(array).ravel().nonzero()[0]
-	
-	array[np.isnan(array)] = np.interp(x, xp, fp)
-	
-	return array
 
 tprint("Train")
 
-
 parser = argparse.ArgumentParser(description="Train a signal model from instructions.",
 								formatter_class=argparse.ArgumentDefaultsHelpFormatter)
 parser.add_argument('-c',"--config", required=True,help="Training instructions")
@@ -78,25 +65,39 @@ X,Y = load_image_dataset(datasets, target_channels, train_spatial_calibration=sp
 print('Dataset loaded...')
 
 # Normalize images
-X = normalize_per_channel(X,
-						  normalization_percentile_mode=normalization_percentile, 
-						  normalization_values=normalization_values, 
-						  normalization_clipping=normalization_clip
-						  )
-
-for x in X:
-	plt.imshow(x[:,:,0])
-	plt.xlim(0,1004)
-	plt.ylim(0,1002)
-	plt.colorbar()
-	plt.pause(2)
-	plt.close()
-	print(x.shape)
-	interp = interpolate_nan(x)
-	print(interp.shape)
-	print(np.any(np.isnan(x).flatten()))
-	print(np.any(np.isnan(interp).flatten()))
-
+# X = normalize_per_channel(X,
+# 						  normalization_percentile_mode=normalization_percentile, 
+# 						  normalization_values=normalization_values, 
+# 						  normalization_clipping=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])
+
+X = [normalize_multichannel(x, **{"percentiles": percentiles, 'values': values, 'clip': normalization_clip}) for x in X]
+
+for k in range(len(X)):
+	x = X[k].copy()
+	x_interp = np.moveaxis([interpolate_nan(x[:,:,c].copy()) for c in range(x.shape[-1])],0,-1)
+	X[k] = x_interp
+
+# for x in X[:10]:
+# 	plt.imshow(x[:,:,0])
+# 	plt.colorbar()
+# 	plt.pause(2)
+# 	plt.close()
+
+# 	plt.imshow(x[:,:,1])
+# 	plt.colorbar()
+# 	plt.pause(2)
+# 	plt.close()
 
 Y = [fill_label_holes(y) for y in tqdm(Y)]
 

celldetective/segmentation.py

@@ -13,7 +13,8 @@ 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.filters import * #rework this to give a name
-from celldetective.utils import rename_intensity_column
+from celldetective.utils import rename_intensity_column, mask_edges, estimate_unreliable_edge
+from stardist import fill_label_holes
 import scipy.ndimage as ndi
 from skimage.segmentation import watershed
 from skimage.feature import peak_local_max
@@ -132,7 +133,7 @@ def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_
 			frame = normalize_multichannel(frame, values=normalization_values)
 
 		if scale is not None:
-			frame = ndi.zoom(frame, [scale,scale,1], order=3)		
+			frame = [ndi.zoom(frame[:,:,c].copy(), [scale,scale], order=3, prefilter=False) for c in range(frame.shape[-1])]
 
 		if model_type=="stardist":
 
@@ -273,7 +274,8 @@ def segment_frame_from_thresholds(frame, target_channel=0, thresholds=None, equa
 		img = match_histograms(img, equalize_reference)
 	img_mc = frame.copy()
 	img = filter_image(img, filters=filters)
-	binary_image = threshold_image(img, thresholds[0], thresholds[1])
+	edge = estimate_unreliable_edge(filters)
+	binary_image = threshold_image(img, thresholds[0], thresholds[1], fill_holes=True, edge_exclusion=edge)
 	coords,distance = identify_markers_from_binary(binary_image, marker_min_distance, footprint_size=marker_footprint_size, footprint=marker_footprint, return_edt=True)
 	instance_seg = apply_watershed(binary_image, coords, distance)
 	instance_seg = filter_on_property(instance_seg, intensity_image=img_mc, queries=feature_queries, channel_names=channel_names)
@@ -357,7 +359,7 @@ def filter_on_property(labels, intensity_image=None, queries=None, channel_names
 	return labels
 
 
-def apply_watershed(binary_image, coords, distance):
+def apply_watershed(binary_image, coords, distance, fill_holes=True):
 
 	"""
 	Applies the watershed algorithm to segment objects in a binary image using given markers and distance map.
@@ -404,7 +406,8 @@ def apply_watershed(binary_image, coords, distance):
 	mask[tuple(coords.T)] = True
 	markers, _ = ndi.label(mask)
 	labels = watershed(-distance, markers, mask=binary_image)
-
+	if fill_holes:
+		labels = fill_label_holes(labels)
 	return labels
 
 def identify_markers_from_binary(binary_image, min_distance, footprint_size=20, footprint=None, return_edt=False):
@@ -457,7 +460,7 @@ def identify_markers_from_binary(binary_image, min_distance, footprint_size=20,
 		return coords
 
 
-def threshold_image(img, min_threshold, max_threshold, foreground_value=255., fill_holes=True):
+def threshold_image(img, min_threshold, max_threshold, foreground_value=255., fill_holes=True, edge_exclusion=None):
 
 	"""
 	
@@ -496,10 +499,12 @@ def threshold_image(img, min_threshold, max_threshold, foreground_value=255., fi
 
 	"""
 
-
-	binary = (img>=min_threshold)*(img<=max_threshold) * foreground_value
+	binary = np.zeros_like(img).astype(bool)
+	binary[img==img] = (img[img==img]>=min_threshold)*(img[img==img]<=max_threshold) * foreground_value
+	if isinstance(edge_exclusion, (int,np.int_)):
+		binary = mask_edges(binary, edge_exclusion)
 	if fill_holes:
-		binary = ndi.binary_fill_holes(binary)
+		binary = ndi.binary_fill_holes(binary.astype(int))
 	return binary
 
 def filter_image(img, filters=None):

celldetective/signals.py

@@ -2258,231 +2258,6 @@ def train_signal_model(config):
 	cmd = f'python "{script_path}" --config "{config}"'
 	subprocess.call(cmd, shell=True)
 
-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 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 T_MSD(x,y,dt):
 
 	"""
@@ -2859,14 +2634,14 @@ def columnwise_mean(matrix, min_nbr_values = 1):
 	
 	for k in range(matrix.shape[1]):
 		values = matrix[:,k]
-		values = values[values!=0]
+		values = values[values==values]
 		if len(values[values==values])>min_nbr_values:
 			mean_line[k] = np.nanmean(values)
 			mean_line_std[k] = np.nanstd(values)
 	return mean_line, mean_line_std
 
 
-def mean_signal(df, signal_name, class_col, time_col=None, class_value=[0], return_matrix=False, forced_max_duration=None, min_nbr_values=2):
+def mean_signal(df, signal_name, class_col, time_col=None, class_value=[0], return_matrix=False, forced_max_duration=None, min_nbr_values=2,conflict_mode='mean'):
 
 	"""
 	Calculate the mean and standard deviation of a specified signal for tracks of a given class in the input DataFrame.
@@ -2912,12 +2687,13 @@ def mean_signal(df, signal_name, class_col, time_col=None, class_value=[0], retu
 	else:
 		max_duration = forced_max_duration
 	n_tracks = len(df.groupby(['position','TRACK_ID']))
-	signal_matrix = np.zeros((n_tracks,max_duration*2 + 1))
+	signal_matrix = np.zeros((n_tracks,int(max_duration)*2 + 1))
 	signal_matrix[:,:] = np.nan
 
+	df = df.sort_values(by=['position','TRACK_ID','FRAME'])
+
 	trackid=0
 	for track,track_group in df.loc[df[class_col].isin(class_value)].groupby(['position','TRACK_ID']):
-		track_group = track_group.sort_values(by='FRAME')
 		cclass = track_group[class_col].to_numpy()[0]
 		if cclass != 0:
 			ref_time = 0
@@ -2926,8 +2702,14 @@ def mean_signal(df, signal_name, class_col, time_col=None, class_value=[0], retu
 				ref_time = floor(track_group[time_col].to_numpy()[0])
 			except:
 				continue
-		signal = track_group[signal_name].to_numpy()
-		timeline = track_group['FRAME'].to_numpy().astype(int)
+		if conflict_mode=='mean':
+			signal = track_group.groupby('FRAME')[signal_name].mean().to_numpy()
+		elif conflict_mode=='first':
+			signal = track_group.groupby('FRAME')[signal_name].first().to_numpy()
+		else:
+			signal = track_group[signal_name].to_numpy()
+
+		timeline = track_group['FRAME'].unique().astype(int)
 		timeline_shifted = timeline - ref_time + max_duration
 		signal_matrix[trackid,timeline_shifted] = signal
 		trackid+=1

celldetective/tracking.py

@@ -7,7 +7,7 @@ from btrack.io.utils import localizations_to_objects
 from btrack import BayesianTracker
 
 from celldetective.measure import measure_features
-from celldetective.utils import rename_intensity_column
+from celldetective.utils import rename_intensity_column, velocity_per_track
 from celldetective.io import view_on_napari_btrack, interpret_tracking_configuration
 
 from btrack.datasets import cell_config
@@ -150,6 +150,7 @@ def track(labels, configuration=None, stack=None, spatial_calibration=1, feature
 		df[columns] = df_temp
 
 	df = df.sort_values(by=[column_labels['track'],column_labels['time']])
+	df = velocity_per_track(df, window_size=3, mode='bi')
 
 	if channel_names is not None:
 		df = rename_intensity_column(df, channel_names)