celldetective 1.1.0__py3-none-any.whl → 1.1.1.post1__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)):
@@ -1163,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:
@@ -1563,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'):
 
@@ -1688,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)
@@ -1807,17 +2214,24 @@ def download_zenodo_file(file, output_dir):
 
 	os.remove(path_to_zip_file)
 
-def interpolate_nan(array_like):
+def interpolate_nan(img, method='nearest'):
 
-	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
+	"""
+	Interpolate NaN on single channel array 2D
+	"""
+
+	if np.all(img==0):
+		return img
+
+	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

{celldetective-1.1.0.dist-info → celldetective-1.1.1.post1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: celldetective
-Version: 1.1.0
+Version: 1.1.1.post1
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro

{celldetective-1.1.0.dist-info → celldetective-1.1.1.post1.dist-info}/RECORD

@@ -1,43 +1,43 @@
 celldetective/__init__.py,sha256=FEZpJKcskBH2IginYzeqPWoR1lVGuyYCXhv7Hnlkoo8,49
-celldetective/__main__.py,sha256=zX2ZDiUp02OlHSwsVUDJ6aCKRAAYU0SSmallsiz1HsA,14054
+celldetective/__main__.py,sha256=XFAkq_2cBEkWAVXDGSNFagoQBglyl0Y-GOO3KFc8UqM,13888
 celldetective/events.py,sha256=s2pWnR3Z1fcB15sET5WsF2Pi6v6qv16hks_m3WiklNs,3658
-celldetective/extra_properties.py,sha256=9tQiXgkUlhmqyE7gUMgq_Kq-XTWTeeMAtFzDNwSmCgU,3961
-celldetective/filters.py,sha256=i-XN6psgdaG_w6gjK2Qvb1OshspQaDsV_PF1WTyo2Sw,2704
-celldetective/io.py,sha256=nkMj9s8fO_I3J-fVVsuRiEDrJ4nHcdWQqN-9P20DcHQ,80323
-celldetective/measure.py,sha256=5Jr9F9LEj3KzD32ssbPuGgS7sCghRurxYV9e2qjkuj0,56981
-celldetective/neighborhood.py,sha256=WZihWn6npFhe9C_LSmGhLuPevzsvjuscmH-xPLoWO6I,49406
-celldetective/preprocessing.py,sha256=jo5mtCBTh8OwETeGRG89RHjSb3yM_75icA2bMJe35bY,24280
-celldetective/segmentation.py,sha256=L_dP3n0U4V0QQhQBl-dL5NenE4d04KEYt1zFRlRUvkM,28496
-celldetective/signals.py,sha256=q7JSyQolsbCqrClyiigDVKhWGj1KmXkWDrk-VGgvjeY,109452
-celldetective/tracking.py,sha256=uTwCc8saEEHE7bcrv0ML9BNfbiwxUM6DWYK2yBoyzIU,37526
-celldetective/utils.py,sha256=msx-aPX4Uqyrt1jSwzwbq7GIuqkLs8LL3cDqRuTOnQo,65322
+celldetective/extra_properties.py,sha256=ZdWV046RR8jrQPYxLSVVb1cXkWYxfrrLj2tXfc358cU,4179
+celldetective/filters.py,sha256=b0qKwHor1fvNA_dHovP17nQz8EsW5YlyhT2TJnayn08,3615
+celldetective/io.py,sha256=ptaX4GadWuf0zOQ3ZWSLCzihEID-YAalPfxW1nqvgIU,80889
+celldetective/measure.py,sha256=HDQZfSRx3daOCV5Snu1paYU5JYkwu8engO2qZqhTAUo,48089
+celldetective/neighborhood.py,sha256=QCuhesMHGyr3c3ys9wWcNR1HM6CHdHe51R8upoolgPw,49514
+celldetective/preprocessing.py,sha256=psCs4CAI7gG3YlKvxkXKnpClFL4SjWm5TToXq2ZwL-s,37137
+celldetective/segmentation.py,sha256=Hu4-lOJ4UhPw2o0Hn_NPOCHsa6Iwsw5A3PR6X3Tzbb8,29196
+celldetective/signals.py,sha256=P7eiDZGGIAYCFBKjGCBi8gMBvJYywxlxZNzyGgw-26Y,102783
+celldetective/tracking.py,sha256=A0mhdF4uq4m8OX1-rhtuhG69rlh_6Pb34Aebu7hIeKM,37601
+celldetective/utils.py,sha256=00jBr_Ur6wX3xeFQzwgpFv9XDhnt_VCh-e2usFdrfo4,77543
 celldetective/datasets/segmentation_annotations/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 celldetective/datasets/signal_annotations/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 celldetective/gui/__init__.py,sha256=y2dvrUdJi17QMgPjl8WN3XFHYzJpu2ul4_8y7MQV1Bk,941
 celldetective/gui/about.py,sha256=i-y54Opb10pKTVNUEcJC-D6Cbiqud2EJ3ZLayXqhdqc,1715
 celldetective/gui/analyze_block.py,sha256=WD3JQQylx_dVozFCvNqrOyR6LcNHV7R1_gGh7XqOVeI,25423
 celldetective/gui/btrack_options.py,sha256=eQEf63yTUsPCN-d1LqgAMmUQpfv2FH85FqnOSaR-9Q8,35575
-celldetective/gui/classifier_widget.py,sha256=qvRl6svlelGsi-IRa7MrCGXrx4sRI8egl5xdGLH3r1A,15341
+celldetective/gui/classifier_widget.py,sha256=52a3kOfU3uMEzUYMIOHGqiy-Q5itMEvcG-3JYrO34I8,16918
 celldetective/gui/configure_new_exp.py,sha256=ANJ-Zn4sjBphtj_aoJu6m1PFEKyv9gxeh9XqS6xOGjk,18969
-celldetective/gui/control_panel.py,sha256=Ndd6zeTNfo3KqfNeIa7XHX4Cj9GDKq5Qw1LtIsUQBgY,17466
+celldetective/gui/control_panel.py,sha256=wcDqe4XaDJRMmPmWKJpxd0D9V4_DrdRGnEH6D7B_IK0,17557
 celldetective/gui/gui_utils.py,sha256=PidFfdc8XASeIzZO5pfKgwqe4vROG7-KpYMcBZ42jdw,22673
 celldetective/gui/json_readers.py,sha256=fTrNrlxv9NCae8ZJexBEHxI3yCLRqt6F0Yo1OeDycfA,3686
-celldetective/gui/layouts.py,sha256=6q3mvOEYdvceFYYGtWFKxAJTLKnaGj0FzYhjM3--x6g,26884
-celldetective/gui/measurement_options.py,sha256=L6NETkOM7wucRVuwY4SP7JenQ9bMNGEv-DI3C3t9JW0,52725
+celldetective/gui/layouts.py,sha256=gC24lyA48hzOo2oabYF1vXTFh5r7WcQFVkqjAXXo5g0,26997
+celldetective/gui/measurement_options.py,sha256=i0CdAfupHJAqhOT7RsufEK919sAzQnFBkQO4IAMYZL0,47704
 celldetective/gui/neighborhood_options.py,sha256=sdKxVRliZtuKSpcPfnFxqkW4V8rN2tzjhDxOPVmElyE,20191
 celldetective/gui/plot_measurements.py,sha256=xUoGxV6uXcen-t4yWtAmcGTUayICI-FxTVKPrWMNlfg,51799
-celldetective/gui/plot_signals_ui.py,sha256=AQ_Ab6bg2tmvZv5dypbaBqJBML7IE_WlDsrkxL0dXAY,43699
-celldetective/gui/process_block.py,sha256=pI-HDU8_s0_jNNnbRBYj7RZrz7Z6cg6xVYOfrfvdwpc,53564
+celldetective/gui/plot_signals_ui.py,sha256=TwWU2u3_mkRNsM8er0kI_kwr5EoZ29YEzlr0cQzyW4A,43732
+celldetective/gui/process_block.py,sha256=7n9glZ1ojEi1bObqwIj4giNhrteT69X1EPMQ1hK63aU,53565
 celldetective/gui/retrain_segmentation_model_options.py,sha256=-rkuUzI_vFFlZC3LAAYEELoJUKcz6PmkpCrxKZindhg,27218
 celldetective/gui/retrain_signal_model_options.py,sha256=uHZy3FGsGMHfZL_nYnuFiXF57XaAMVzjYxVF2OXhYnY,24184
 celldetective/gui/seg_model_loader.py,sha256=uKp8oab-4QdTGqb-tb6bOD-FLD_154GOvgWFYz97BwY,17350
 celldetective/gui/signal_annotator.py,sha256=4ymMpo_GjSBsJSRkyNKrWRLy0EFXHINbFtp9ykDqfGE,84864
 celldetective/gui/signal_annotator_options.py,sha256=-Q7f8eCwniqbgLJqMCa91Wc-V3VHAZidwt7LPd4Z5yU,10879
 celldetective/gui/styles.py,sha256=Vw4wr6MQ4iBwhOY-ZWAxFDZZ3CNohmEnuPPazwhJaho,4129
-celldetective/gui/survival_ui.py,sha256=Y7EbLFqINSBA_Cl3_fjGImbfp2PvpFt11pHuqkcT3OM,33537
-celldetective/gui/tableUI.py,sha256=DR2HVTLkR3XYZ_Rkyt7DLObOszuG7rlxyz5d6wIO1Oc,22467
-celldetective/gui/thresholds_gui.py,sha256=vbkiJcBejiqdk45r57Ig38LDyNMqLqqmh1FnaVltxVA,47821
-celldetective/gui/viewers.py,sha256=eN4JevoDGAZGI_QdmRJ3SJRh4_XGUR9BhA_ymAF4xAY,19676
+celldetective/gui/survival_ui.py,sha256=2JGLC5m6D_gVLwnBAM7uEvuCKw1Cli8nM9i5s7TIpGg,33612
+celldetective/gui/tableUI.py,sha256=QRYlXc7751Ka5qbUHSGbE_nXTiiezAVfEWXiRKRmuRM,32188
+celldetective/gui/thresholds_gui.py,sha256=b8SkG4DlfxBRjacKTe1NSNkq7rJm8lnSLifH-mg846k,49529
+celldetective/gui/viewers.py,sha256=G8uNb0U_4tJiZkcAWX9BbCSBIUbF4tjedZD-5o4WKxY,27734
 celldetective/icons/logo-large.png,sha256=FXSwV3u6zEKcfpuSn4unnqB0oUnN9cHqQ9BCKWytrpg,36631
 celldetective/icons/logo.png,sha256=wV2OS8_dU5Td5cgdPbCOU3JpMpTwNuYLnfVcnQX0tJA,2437
 celldetective/icons/signals_icon.png,sha256=vEiKoqWTtN0-uJgVqtAlwCuP-f4QeWYOlO3sdp2tg2w,3969
@@ -49,6 +49,9 @@ celldetective/icons/vignette_signals2.png,sha256=hsVOdQDpEfMGM45aaSeacEm3lvxbquR
 celldetective/icons/vignette_signals2.svg,sha256=muGNcQudV1jG-bmFd9FwV-Wb8PcrRV5osdZ7pHR7Ekk,5947
 celldetective/links/zenodo.json,sha256=7WKRuZY7MHTR-IChWBbU0i47H_479NtlxsCGaJn9-xM,22728
 celldetective/models/segmentation_effectors/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+celldetective/models/segmentation_effectors/primNK_cfse/config_input.json,sha256=gwEGP5wc6iVcwLrR5IbEb-9lTbdQuPyLLFYXh00374U,509
+celldetective/models/segmentation_effectors/primNK_cfse/cp-cfse-transfer,sha256=ps4BAzGxr2i2R0uBGJqfF9wjg5bIeSeBGQb0YcUChhY,26559970
+celldetective/models/segmentation_effectors/primNK_cfse/training_instructions.json,sha256=DqEO4_oQuQmJkZiefREXz8ts60svoqxIQB-LMScuCnc,909
 celldetective/models/segmentation_generic/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 celldetective/models/segmentation_targets/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 celldetective/models/signal_detection/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -57,10 +60,10 @@ celldetective/models/tracking_configs/ricm.json,sha256=L-vmwCR1f89U-qnH2Ms0cBfPF
 celldetective/models/tracking_configs/ricm2.json,sha256=DDjJ6ScYcDWvlsy7ujPID8v8H28vcNcMuZmNR8XmGxo,2718
 celldetective/scripts/analyze_signals.py,sha256=23TXGNw-j5xT3ss4mXlnKdBgFLnQ50JUEQOC6_H7Q_0,2203
 celldetective/scripts/measure_cells.py,sha256=4uRG6Dg0WsO-N8ZaBJ4loWOvX6FdHaCblIFXq6Dtirc,11000
-celldetective/scripts/segment_cells.py,sha256=xz1wERezJFF3sI0tS3mRLD7-K0zhEIyAEH60p06DFgU,7660
+celldetective/scripts/segment_cells.py,sha256=OSP52sPPHyhfXEjiXXdezkDY4MiFXLBWTb2_umRBD-M,8269
 celldetective/scripts/segment_cells_thresholds.py,sha256=GbWXa6xoO8s4PinJPZIxAuosw4vpzyJ7FiFYpSURojk,4998
 celldetective/scripts/track_cells.py,sha256=AaNiYEW4osYKKR2kbdVLOUnQEBbcZIA-D0mkhcxPWTY,7985
-celldetective/scripts/train_segmentation_model.py,sha256=dBXq3OOu6F0kWyYcI3K7W_hMUYvndrwKRswBS_-zQnw,8378
+celldetective/scripts/train_segmentation_model.py,sha256=UY493QK7_FhS9uHYl2eeEYx7t0kw1jhvc0YMY12YZpI,8614
 celldetective/scripts/train_signal_model.py,sha256=9-dmPCLKJ9ypjsV9AwFd-Sb6B6YaHS0QGT218H5hUPo,1861
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_events.py,sha256=eLFwwEEJfQAdwhews3-fn1HSvzozcNNFN_Qn0gOvQkE,685
@@ -68,13 +71,14 @@ tests/test_filters.py,sha256=iJksl_HgquqGzPPv46qpNtlD4rkBpZ5eVtIotgZ7LDs,656
 tests/test_io.py,sha256=gk5FmoI7ANEczUtNXYRxc48KzkfYzemwS_eYaLq4_NI,2093
 tests/test_measure.py,sha256=FEUAs1rVHylvIvubCb0bJDNGZLVmkgXNgI3NaGQ1dA8,4542
 tests/test_neighborhood.py,sha256=gk5FmoI7ANEczUtNXYRxc48KzkfYzemwS_eYaLq4_NI,2093
+tests/test_preprocessing.py,sha256=FI-Wk-kc4wWmOQg_NLCUIZC1oti396wr5cC-BauBai0,1436
 tests/test_segmentation.py,sha256=-3b7o_fUVMYxfVwX5VHFqRF0dDXObSTtylf5XQGcq1A,3493
 tests/test_signals.py,sha256=No4cah6KxplhDcKXnU8RrA7eDla4hWw6ccf7xGnBokU,3599
 tests/test_tracking.py,sha256=8hebWSqEIuttD1ABn-6dKCT7EXKRR7-4RwyFWi1WPFo,8800
-tests/test_utils.py,sha256=emElC0EgoIeCXnTweZVh-TFT2czu9XSgiRqP9sqFUX8,2175
-celldetective-1.1.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-celldetective-1.1.0.dist-info/METADATA,sha256=ilgLPeG4uYwEibAGA2uO68p83-eWwP6k7azcQIF8gT4,12412
-celldetective-1.1.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-celldetective-1.1.0.dist-info/entry_points.txt,sha256=2NU6_EOByvPxqBbCvjwxlVlvnQreqZ3BKRCVIKEv3dg,62
-celldetective-1.1.0.dist-info/top_level.txt,sha256=6rsIKKfGMKgud7HPuATcpq6EhdXwcg_yknBVWn9x4C4,20
-celldetective-1.1.0.dist-info/RECORD,,
+tests/test_utils.py,sha256=NKRCAC1d89aBK5cWjTb7-pInYow901RrT-uBlIdz4KI,3692
+celldetective-1.1.1.post1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+celldetective-1.1.1.post1.dist-info/METADATA,sha256=MItn6uMJhqWHbN0urj8068yO8xcUoc9c3kUsYTVre10,12418
+celldetective-1.1.1.post1.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+celldetective-1.1.1.post1.dist-info/entry_points.txt,sha256=2NU6_EOByvPxqBbCvjwxlVlvnQreqZ3BKRCVIKEv3dg,62
+celldetective-1.1.1.post1.dist-info/top_level.txt,sha256=6rsIKKfGMKgud7HPuATcpq6EhdXwcg_yknBVWn9x4C4,20
+celldetective-1.1.1.post1.dist-info/RECORD,,

{celldetective-1.1.0.dist-info → celldetective-1.1.1.post1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (70.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/test_preprocessing.py

@@ -0,0 +1,37 @@
+import unittest
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+from celldetective.preprocessing import fit_background_model, field_correction
+
+import matplotlib.pyplot as plt
+
+class TestFitPlane(unittest.TestCase):
+
+	@classmethod
+	def setUpClass(self):
+		a = 5.
+		self.img = np.full((100,100),5.0)
+		self.img_with_cell = self.img.copy()
+		self.img_with_cell[:10,:10] = 25.0
+
+	def test_plane_is_well_fit(self):
+		mat = np.array(fit_background_model(self.img, cell_masks=None, model='plane', edge_exclusion=None))
+		self.assertTrue(np.allclose(self.img, mat))
+
+	def test_plane_is_well_fit_and_applied_with_division(self):
+		result = field_correction(self.img, threshold_on_std=1.0E05, operation='divide', model='plane', clip=False, return_bg=False, activation_protocol=[])
+		self.assertTrue(np.allclose(result, np.full((100,100), 1.0)))
+
+	def test_plane_is_well_fit_and_applied_with_subtraction(self):
+		result = field_correction(self.img, threshold_on_std=1.0E05, operation='subtract', model='plane', clip=False, return_bg=False, activation_protocol=[])
+		self.assertTrue(np.allclose(result, np.zeros((100,100))))
+
+	def test_plane_is_well_fit_with_cell(self):
+		cell_masks = np.zeros_like(self.img)
+		cell_masks[:10,:10] = 1.0
+		mat = np.array(fit_background_model(self.img, cell_masks=cell_masks, model='plane', edge_exclusion=None))
+		self.assertTrue(np.allclose(self.img, mat))
+
+if __name__=="__main__":
+	unittest.main()