celldetective 1.3.9.post5__py3-none-any.whl → 1.4.0__py3-none-any.whl

celldetective/preprocessing.py

@@ -14,7 +14,7 @@ from lmfit import Parameters, Model
 import tifffile.tifffile as tiff
 from scipy.ndimage import shift
 
-def estimate_background_per_condition(experiment, threshold_on_std=1, well_option='*', target_channel="channel_name", frame_range=[0,5], mode="timeseries", activation_protocol=[['gauss',2],['std',4]], show_progress_per_pos=False, show_progress_per_well=True):
+def estimate_background_per_condition(experiment, threshold_on_std=1, well_option='*', target_channel="channel_name", frame_range=[0,5], mode="timeseries", activation_protocol=[['gauss',2],['std',4]], show_progress_per_pos=False, show_progress_per_well=True, offset=None):
 	
 	"""
 	Estimate the background for each condition in an experiment.
@@ -149,6 +149,9 @@ def estimate_background_per_condition(experiment, threshold_on_std=1, well_optio
 
 		try:
 			background = np.nanmedian(frame_mean_per_position,axis=0)
+			if offset is not None:
+				#print("The offset is applied to background...")
+				background -= offset
 			backgrounds.append({"bg": background, "well": well_path})
 			print(f"Background successfully computed for well {well_name}...")
 		except Exception as e:
@@ -170,6 +173,7 @@ def correct_background_model_free(
 					   opt_coef_nbr = 100,
 					   operation = 'divide',
 					   clip = False,
+					   offset = None,
 					   show_progress_per_well = True,
 					   show_progress_per_pos = False,
 					   export = False,
@@ -259,7 +263,7 @@ def correct_background_model_free(
 		well_name, _ = extract_well_name_and_number(well_path)
 
 		try:
-			background = estimate_background_per_condition(experiment, threshold_on_std=threshold_on_std, well_option=int(well_indices[k]), target_channel=target_channel, frame_range=frame_range, mode=mode, show_progress_per_pos=True, show_progress_per_well=False, activation_protocol=activation_protocol)
+			background = estimate_background_per_condition(experiment, threshold_on_std=threshold_on_std, well_option=int(well_indices[k]), target_channel=target_channel, frame_range=frame_range, mode=mode, show_progress_per_pos=True, show_progress_per_well=False, activation_protocol=activation_protocol, offset=offset)
 			background = background[0]
 			background = background['bg']
 		except Exception as e:
@@ -283,18 +287,19 @@ def correct_background_model_free(
 
 				corrected_stack = apply_background_to_stack(stack_path, 
 															background,
-															target_channel_index=channel_indices[0],
-															nbr_channels=nbr_channels,
-															stack_length=len_movie,
-															threshold_on_std=threshold_on_std,
-															optimize_option=optimize_option,
-															opt_coef_range=opt_coef_range,
-															opt_coef_nbr=opt_coef_nbr,
-															operation=operation,
-															clip=clip,
-															export=export,
-															activation_protocol=activation_protocol,
-															prefix=export_prefix,
+															target_channel_index = channel_indices[0],
+															nbr_channels = nbr_channels,
+															stack_length = len_movie,
+															threshold_on_std = threshold_on_std,
+															optimize_option = optimize_option,
+															opt_coef_range = opt_coef_range,
+															opt_coef_nbr = opt_coef_nbr,
+															operation = operation,
+															clip = clip,
+															offset = offset,
+															export = export,
+															activation_protocol = activation_protocol,
+															prefix = export_prefix,
 														  )
 				print('Correction successful.')
 				if return_stacks:
@@ -310,7 +315,7 @@ def correct_background_model_free(
 
 
 
-def apply_background_to_stack(stack_path, background, target_channel_index=0, nbr_channels=1, stack_length=45,activation_protocol=[['gauss',2],['std',4]], threshold_on_std=1, optimize_option=True, opt_coef_range=(0.95,1.05), opt_coef_nbr=100, operation='divide', clip=False, export=False, prefix="Corrected"):
+def apply_background_to_stack(stack_path, background, target_channel_index=0, nbr_channels=1, stack_length=45, offset = None, activation_protocol=[['gauss',2],['std',4]], threshold_on_std=1, optimize_option=True, opt_coef_range=(0.95,1.05), opt_coef_nbr=100, operation='divide', clip=False, export=False, prefix="Corrected"):
 
 	"""
 	Apply background correction to an image stack.
@@ -385,11 +390,14 @@ def apply_background_to_stack(stack_path, background, target_channel_index=0, nb
 		
 		frames = load_frames(list(np.arange(i,(i+nbr_channels))), stack_path, normalize_input=False).astype(float)
 		target_img = frames[:,:,target_channel_index].copy()
-
+		if offset is not None:
+			#print(f"The offset is applied to image...")
+			target_img -= offset
+		
 		if optimize_option:
 			
 			target_copy = target_img.copy()
-
+			
 			std_frame = filter_image(target_copy.copy(),filters=activation_protocol)
 			edge = estimate_unreliable_edge(activation_protocol)
 			mask = threshold_image(std_frame, threshold_on_std, np.inf, foreground_value=1, edge_exclusion=edge)

celldetective/relative_measurements.py

@@ -396,7 +396,7 @@ def measure_pair_signals_at_position(pos, neighborhood_protocol, velocity_kwargs
 		return df_pairs
 
 	except KeyError:
-		print(f"Neighborhood {description} not found in data frame. Measurements for this neighborhood will not be calculated")
+		print(f"Neighborhood not found in data frame. Measurements for this neighborhood will not be calculated")
 
 
 def timeline_matching(timeline1, timeline2):
@@ -531,7 +531,7 @@ def update_effector_table(df_relative, df_effector):
 			df_effector.loc[df_effector['ID'] == effector, 'group_neighborhood'] = 0
 	return df_effector
 
-def extract_neighborhoods_from_pickles(pos):
+def extract_neighborhoods_from_pickles(pos, populations=['targets','effectors']):
 
 	"""
 	Extract neighborhood protocols from pickle files located at a given position.
@@ -573,29 +573,40 @@ def extract_neighborhoods_from_pickles(pos):
 	
 	"""
 
-	tab_tc = pos + os.sep.join(['output', 'tables', 'trajectories_targets.pkl'])
-	if os.path.exists(tab_tc):
-		df_targets = np.load(tab_tc, allow_pickle=True)
-	else:
-		df_targets = None
-	if os.path.exists(tab_tc.replace('targets','effectors')):
-		df_effectors = np.load(tab_tc.replace('targets','effectors'), allow_pickle=True)
-	else:
-		df_effectors = None
-
-	neighborhood_protocols=[]
-
-	if df_targets is not None:
-		for column in list(df_targets.columns):
-			if column.startswith('neighborhood'):
-				neigh_protocol = extract_neighborhood_settings(column, population='targets')
-				neighborhood_protocols.append(neigh_protocol)
-
-	if df_effectors is not None:
-		for column in list(df_effectors.columns):
-			if column.startswith('neighborhood'):
-				neigh_protocol = extract_neighborhood_settings(column, population='effectors')
-				neighborhood_protocols.append(neigh_protocol)
+	neighborhood_protocols = []
+
+	for pop in populations:
+		tab_pop = pos + os.sep.join(['output', 'tables', f'trajectories_{pop}.pkl'])
+		if os.path.exists(tab_pop):
+			df_pop = np.load(tab_pop, allow_pickle=True)
+			for column in list(df_pop.columns):
+				if column.startswith('neighborhood'):
+					neigh_protocol = extract_neighborhood_settings(column, population=pop)
+					neighborhood_protocols.append(neigh_protocol)
+
+	# tab_tc = pos + os.sep.join(['output', 'tables', 'trajectories_targets.pkl'])
+	# if os.path.exists(tab_tc):
+	# 	df_targets = np.load(tab_tc, allow_pickle=True)
+	# else:
+	# 	df_targets = None
+	# if os.path.exists(tab_tc.replace('targets','effectors')):
+	# 	df_effectors = np.load(tab_tc.replace('targets','effectors'), allow_pickle=True)
+	# else:
+	# 	df_effectors = None
+
+	# neighborhood_protocols=[]
+
+	# if df_targets is not None:
+	# 	for column in list(df_targets.columns):
+	# 		if column.startswith('neighborhood'):
+	# 			neigh_protocol = extract_neighborhood_settings(column, population='targets')
+	# 			neighborhood_protocols.append(neigh_protocol)
+
+	# if df_effectors is not None:
+	# 	for column in list(df_effectors.columns):
+	# 		if column.startswith('neighborhood'):
+	# 			neigh_protocol = extract_neighborhood_settings(column, population='effectors')
+	# 			neighborhood_protocols.append(neigh_protocol)
 
 	return neighborhood_protocols
 
@@ -646,10 +657,18 @@ def extract_neighborhood_settings(neigh_string, population='targets'):
 	"""
 
 	assert neigh_string.startswith('neighborhood')
-	if population=='targets':
-		neighbor_population = 'effectors'
-	elif population=='effectors':
-		neighbor_population = 'targets'
+	print(f"{neigh_string=}")
+
+	if '_(' in neigh_string and ')_' in neigh_string:
+		# determine neigh pop from string
+		neighbor_population = neigh_string.split('_(')[-1].split(')_')[0].split('-')[-1]
+		print(f'{neighbor_population=}')
+	else:
+		# old method
+		if population=='targets':
+			neighbor_population = 'effectors'
+		elif population=='effectors':
+			neighbor_population = 'targets'
 
 	if 'self' in neigh_string:
 		
@@ -716,6 +735,8 @@ def expand_pair_table(data):
 	assert 'reference_population' in list(data.columns),"Please provide a valid pair table..."
 	assert 'neighbor_population' in list(data.columns),"Please provide a valid pair table..."
 
+	data.__dict__.update(data.astype({'reference_population': str, 'neighbor_population': str}).__dict__)
+
 	expanded_table = []
 	
 	for neigh, group in data.groupby(['reference_population','neighbor_population']):

celldetective/scripts/analyze_signals.py

@@ -15,7 +15,7 @@ parser = argparse.ArgumentParser(description="Classify and regress the signals b
 								formatter_class=argparse.ArgumentDefaultsHelpFormatter)
 parser.add_argument('-p',"--position", required=True, help="Path to the position")
 parser.add_argument('-m',"--model", required=True, help="Path to the model")
-parser.add_argument("--mode", default="target", choices=["target","effector","targets","effectors"],help="Cell population of interest")
+parser.add_argument("--mode", default="target", help="Cell population of interest")
 parser.add_argument("--use_gpu", default="True", choices=["True","False"],help="use GPU")
 
 args = parser.parse_args()
@@ -36,6 +36,9 @@ if mode.lower()=="target" or mode.lower()=="targets":
 
 elif mode.lower()=="effector" or mode.lower()=="effectors":
 	table_name = "trajectories_effectors.csv"
+else:
+	table_name = f"trajectories_{mode}.csv"
+
 
 # Load trajectories, add centroid if not in trajectory
 trajectories = pos+os.sep.join(['output','tables', table_name])

celldetective/scripts/measure_relative.py

@@ -2,6 +2,7 @@ import argparse
 import os
 from celldetective.relative_measurements import measure_pair_signals_at_position, extract_neighborhoods_from_pickles
 from celldetective.utils import ConfigSectionMap, extract_experiment_channels
+from celldetective.io import get_experiment_populations
 
 from pathlib import Path, PurePath
 
@@ -37,6 +38,8 @@ len_movie = float(ConfigSectionMap(config, "MovieSettings")["len_movie"])
 channel_names, channel_indices = extract_experiment_channels(expfolder)
 nbr_channels = len(channel_names)
 
+populations = get_experiment_populations(expfolder, dtype=str)
+
 # from tracking instructions, fetch btrack config, features, haralick, clean_traj, idea: fetch custom timeline?
 instr_path = PurePath(expfolder, Path(f"{instruction_file}"))
 previous_pair_table_path = pos + os.sep.join(['output', 'tables', 'trajectories_pairs.csv'])
@@ -46,7 +49,7 @@ previous_neighborhoods = []
 associated_reference_population = []
 
 
-neighborhoods_to_measure = extract_neighborhoods_from_pickles(pos)
+neighborhoods_to_measure = extract_neighborhoods_from_pickles(pos, populations=populations)
 all_df_pairs = []
 if os.path.exists(previous_pair_table_path):
 	df_0 = pd.read_csv(previous_pair_table_path)

celldetective/scripts/segment_cells.py

@@ -183,12 +183,6 @@ with concurrent.futures.ThreadPoolExecutor() as executor:
 		print("Exception: ", e)
 
 print('Done.')
-
-try:
-	del model
-except:
-	pass
-
 gc.collect()
 
 

celldetective/scripts/track_cells.py

@@ -6,7 +6,9 @@ import argparse
 import datetime
 import os
 import json
-from celldetective.io import auto_load_number_of_frames, interpret_tracking_configuration, extract_position_name
+from celldetective.io import _load_frames_to_measure, auto_load_number_of_frames, interpret_tracking_configuration, \
+	extract_position_name, \
+	locate_labels
 from celldetective.utils import _mask_intensity_measurements, extract_experiment_channels, ConfigSectionMap, _get_img_num_per_channel, extract_experiment_channels
 from celldetective.measure import drop_tonal_features, measure_features
 from celldetective.tracking import track

celldetective/scripts/train_segmentation_model.py

@@ -124,15 +124,18 @@ if model_type=='cellpose':
 		device = torch.device("cpu")
 	else:
 		print('Using GPU for training...')
-		
+	
+	diam_mean = 30.0
 	logger, log_file = logger_setup()
 	print(f'Pretrained model: ',pretrained)
 	if pretrained is not None:
+		if pretrained.endswith('CP_nuclei'):
+			diam_mean = 17.0
 		pretrained_path = os.sep.join([pretrained,os.path.split(pretrained)[-1]])
 	else:
 		pretrained_path = pretrained
 	
-	model = CellposeModel(gpu=use_gpu, model_type=None, pretrained_model=pretrained_path, diam_mean=30.0, nchan=X_aug[0].shape[0],) 
+	model = CellposeModel(gpu=use_gpu, model_type=None, pretrained_model=pretrained_path, diam_mean=diam_mean, nchan=X_aug[0].shape[0],) 
 	model.train(train_data=X_aug, train_labels=Y_aug, normalize=False, channels=None, batch_size=batch_size,
 				min_train_masks=1,save_path=target_directory+os.sep+model_name,n_epochs=epochs, model_name=model_name, learning_rate=learning_rate, test_data = X_val, test_labels=Y_val)
 
@@ -152,7 +155,7 @@ if model_type=='cellpose':
 	config_inputs = {"channels": target_channels, "diameter": standard_diameter, 'cellprob_threshold': 0., 'flow_threshold': 0.4,
 	'normalization_percentile': normalization_percentile, 'normalization_clip': normalization_clip,
 	'normalization_values': normalization_values, 'model_type': 'cellpose',
-	'spatial_calibration': input_spatial_calibration, 'dataset': {'train': files_train, 'validation': files_val}}
+	'spatial_calibration': input_spatial_calibration, 'cell_size_um': round(diameter*input_spatial_calibration,4), 'dataset': {'train': files_train, 'validation': files_val}}
 	json_input_config = json.dumps(config_inputs, indent=4)
 	with open(os.sep.join([target_directory, model_name, "config_input.json"]), "w") as outfile:
 		outfile.write(json_input_config)
@@ -227,7 +230,7 @@ elif model_type=='stardist':
 
 	config_inputs = {"channels": target_channels, 'normalization_percentile': normalization_percentile,
 	'normalization_clip': normalization_clip, 'normalization_values': normalization_values, 
-	'model_type': 'stardist', 'spatial_calibration': spatial_calibration, 'dataset': {'train': files_train, 'validation': files_val}}
+	'model_type': 'stardist', 'spatial_calibration': spatial_calibration,'cell_size_um': median_size * spatial_calibration, 'dataset': {'train': files_train, 'validation': files_val}}
 
 	json_input_config = json.dumps(config_inputs, indent=4)
 	with open(os.sep.join([target_directory, model_name, "config_input.json"]), "w") as outfile:

celldetective/signals.py

@@ -156,6 +156,10 @@ def analyze_signals(trajectories, model, interpolate_na=True,
 	f = open(model_config_path)
 	config = json.load(f)
 	required_signals = config["channels"]
+	if 'selected_channels' in config:
+		selected_signals = config['selected_channels']
+		if np.any([s=='None' for s in selected_signals]):
+			trajectories['None'] = 0.
 	model_signal_length = config['model_signal_length']
 
 	try:
@@ -264,6 +268,8 @@ def analyze_signals(trajectories, model, interpolate_na=True,
 			plt.pause(3)
 			plt.close()
 
+	if "None" in list(trajectories.columns):
+		trajectories = trajectories.drop(columns=['None'])
 	return trajectories
 
 def analyze_signals_at_position(pos, model, mode, use_gpu=True, return_table=False):
@@ -324,7 +330,7 @@ def analyze_signals_at_position(pos, model, mode, use_gpu=True, return_table=Fal
 	else:
 		return None		
 
-def analyze_pair_signals_at_position(pos, model, use_gpu=True):
+def analyze_pair_signals_at_position(pos, model, use_gpu=True, populations=['targets','effectors']):
 	
 
 	pos = pos.replace('\\','/')
@@ -332,13 +338,10 @@ def analyze_pair_signals_at_position(pos, model, use_gpu=True):
 	assert os.path.exists(pos),f'Position {pos} is not a valid path.'
 	if not pos.endswith('/'):
 		pos += '/'
-					
-	df_targets = get_position_pickle(pos, population='targets')
-	df_effectors = get_position_pickle(pos, population='effectors')
-	dataframes = {
-		'targets': df_targets,
-		'effectors': df_effectors,
-	}
+
+	dataframes = {}
+	for pop in populations:
+		dataframes.update({pop: get_position_pickle(pos, population=pop)})
 	df_pairs = get_position_table(pos, population='pairs')
 
 	# Need to identify expected reference / neighbor tables
@@ -354,12 +357,19 @@ def analyze_pair_signals_at_position(pos, model, use_gpu=True):
 	reference_population = model_config_path['reference_population']
 	neighbor_population = model_config_path['neighbor_population']
 
+	if dataframes[reference_population] is None:
+		print(f"No tabulated data can be found for the reference population ({reference_population})... Abort...")
+		return None
+
+	if dataframes[neighbor_population] is None:
+		print(f"No tabulated data can be found for the neighbor population ({neighbor_population})... Abort...")
+		return None
+
 	df = analyze_pair_signals(df_pairs, dataframes[reference_population], dataframes[neighbor_population], model=model)
-	
 	table = pos + os.sep.join(["output","tables",f"trajectories_pairs.csv"])
 	df.to_csv(table, index=False)
 
-	return None		
+	return None
 
 
 def analyze_pair_signals(trajectories_pairs,trajectories_reference,trajectories_neighbors, model, interpolate_na=True, selected_signals=None,
@@ -2823,7 +2833,7 @@ def columnwise_mean(matrix, min_nbr_values = 1, projection='mean'):
 	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,conflict_mode='mean', projection='mean'):
+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', projection='mean',pairs=False):
 
 	"""
 	Calculate the mean and standard deviation of a specified signal for tracks of a given class in the input DataFrame.
@@ -2878,14 +2888,19 @@ def mean_signal(df, signal_name, class_col, time_col=None, class_value=[0], retu
 	if isinstance(time_col, (int,float)):
 		abs_time = True
 
-	n_tracks = len(df.groupby(['position','TRACK_ID']))
+	if not pairs:
+		groupby_cols = ['position','TRACK_ID']
+	else:
+		groupby_cols = ['position','REFERENCE_ID','NEIGHBOR_ID']
+
+	n_tracks = len(df.groupby(groupby_cols))
 	signal_matrix = np.zeros((n_tracks,int(max_duration)*2 + 1))
 	signal_matrix[:,:] = np.nan
 
-	df = df.sort_values(by=['position','TRACK_ID','FRAME'])
+	df = df.sort_values(by=groupby_cols+['FRAME'])
 
 	trackid=0
-	for track,track_group in df.loc[df[class_col].isin(class_value)].groupby(['position','TRACK_ID']):
+	for track,track_group in df.loc[df[class_col].isin(class_value)].groupby(groupby_cols):
 		cclass = track_group[class_col].to_numpy()[0]
 		if cclass != 0:
 			ref_time = 0

celldetective/tracking.py

@@ -1002,11 +1002,12 @@ def write_first_detection_class(df, img_shape=None, edge_threshold=20, column_la
 		positions_x = track_group[column_labels['x']].values
 		positions_y = track_group[column_labels['y']].values
 		dt = 1
-		
+
 		# Initialize
 		cclass = 2; t_first = np.nan;
 
 		if np.any(detection==detection):
+
 			t_first = timeline[detection==detection][0]
 			x_first = positions_x[detection==detection][0]; y_first = positions_y[detection==detection][0];
 
@@ -1015,13 +1016,17 @@ def write_first_detection_class(df, img_shape=None, edge_threshold=20, column_la
 				edge_test = (x_first < edge_threshold) or (y_first < edge_threshold) or (y_first > (img_shape[0] - edge_threshold)) or (x_first > (img_shape[1] - edge_threshold))
 
 			cclass = 0
-			if t_first<=0 or edge_test:
+			if t_first<=0:
 				t_first = -1
 				cclass = 2
 			else:
 				t_first =  float(t_first) - float(dt)
 				if t_first==0:
 					t_first += 0.01
+
+			if edge_test:
+				cclass = 2
+				# switch to class 2 but keep time/status information
 		else:
 			t_first = -1
 			cclass = 2

celldetective/utils.py

@@ -32,6 +32,19 @@ from cliffs_delta import cliffs_delta
 from stardist.models import StarDist2D
 from cellpose.models import CellposeModel
 from pathlib import PosixPath, PurePosixPath, WindowsPath
+from prettytable import PrettyTable
+
+
+def is_integer_array(arr):
+
+	# Mask out NaNs
+	non_nan_values = arr[arr==arr].flatten()
+	test = np.all(np.mod(non_nan_values, 1) == 0)
+
+	if test:
+		return True
+	else:
+		return False
 
 def get_config(experiment):
 
@@ -370,7 +383,10 @@ def _prep_stardist_model(model_name, path, use_gpu=False, scale=1):
 	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
 
@@ -424,7 +440,10 @@ def _prep_cellpose_model(model_name, path, use_gpu=False, n_channels=2, scale=No
 	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'Cell size in model: {model.diam_mean} pixels...')
+	print(f'Cell size in training set: {model.diam_labels} pixels...')
+	print(f"Rescaling factor to apply: {scale_model}...")
+
 	print(f'Cellpose model {model_name} successfully loaded...')
 	return model, scale_model
 
@@ -1899,7 +1918,7 @@ def _extract_channel_indices_from_config(config, channels_to_extract):
 			c1 = int(ConfigSectionMap(config,"Channels")[c])
 			channels.append(c1)
 		except Exception as e:
-			print(f"Warning... The channel {c} required by the model is not available in your data...")
+			print(f"Warning: The channel {c} required by the model is not available in your data...")
 			channels.append(None)
 	if np.all([c is None for c in channels]):
 		channels = None
@@ -2864,11 +2883,13 @@ def get_zenodo_files(cat=None):
 		categories.append(category)
 	
 	if cat is not None:
-		assert cat in [os.sep.join(['models','segmentation_generic']), os.sep.join(['models','segmentation_targets']), os.sep.join(['models','segmentation_effectors']), \
-						   'demos', os.sep.join(['datasets','signal_annotations']), os.sep.join(['datasets','segmentation_annotations']),  os.sep.join(['models','signal_detection'])]
-		categories = np.array(categories)
-		all_files_short = np.array(all_files_short)
-		return list(all_files_short[np.where(categories==cat)[0]])
+		if cat in [os.sep.join(['models','segmentation_generic']), os.sep.join(['models','segmentation_targets']), os.sep.join(['models','segmentation_effectors']), \
+						   'demos', os.sep.join(['datasets','signal_annotations']), os.sep.join(['datasets','segmentation_annotations']),  os.sep.join(['models','signal_detection'])]:
+			categories = np.array(categories)
+			all_files_short = np.array(all_files_short)
+			return list(all_files_short[np.where(categories==cat)[0]])
+		else:
+			return []
 	else:
 		return all_files_short,categories
 
@@ -3076,4 +3097,11 @@ def test_2samp_generic(data, feature=None, groupby_cols=None, method="ks_2samp",
 	pivot.set_index("cdt1",drop=True, inplace=True)
 	pivot.index.name = None
 
-	return pivot
+	return pivot
+
+def pretty_table(dct):
+	table = PrettyTable()
+	for c in dct.keys():
+		table.add_column(str(c), [])
+	table.add_row([dct.get(c, "") for c in dct.keys()])
+	print(table)

{celldetective-1.3.9.post5.dist-info → celldetective-1.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: celldetective
-Version: 1.3.9.post5
+Version: 1.4.0
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro
@@ -44,12 +44,17 @@ Requires-Dist: h5py
 Requires-Dist: cliffs_delta
 Requires-Dist: requests
 Requires-Dist: trackpy
+Requires-Dist: prettyprint
+Requires-Dist: pandas
+Requires-Dist: matplotlib
+Requires-Dist: prettytable
 Dynamic: author
 Dynamic: author-email
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 
@@ -183,26 +188,29 @@ For more information about how to get started, please check the [documentation](
 # How to cite?
 
 If you use this software in your research, please cite the
-[Celldetective](https://www.biorxiv.org/content/10.1101/2024.03.15.585250v3)
-paper (currently preprint):
+[Celldetective](https://elifesciences.org/reviewed-preprints/105302)
+paper (currently a reviewed preprint at eLife):
 
 ``` raw
-@article {Torro2024.03.15.585250,
-    author = {Torro, R{\'e}my and D{\'\i}az-Bello, Beatriz and Arawi, Dalia El and Dervanova, Ksenija and Ammer, Lorna and Dupuy, Florian and Chames, Patrick and Sengupta, Kheya and Limozin, Laurent},
-    title = {Celldetective: an AI-enhanced image analysis tool for unraveling dynamic cell interactions},
-    elocation-id = {2024.03.15.585250},
-    year = {2024},
-    doi = {10.1101/2024.03.15.585250},
-    publisher = {Cold Spring Harbor Laboratory},
-    abstract = {A current challenge in bioimaging for immunology and immunotherapy research lies in analyzing multimodal and multidimensional data that capture dynamic interactions between diverse cell populations. Here, we introduce Celldetective, an open-source Python-based software designed for high-performance, end-to-end analysis of image-based in vitro immune and immunotherapy assays. Purpose-built for multicondition, 2D multichannel time-lapse microscopy of mixed cell populations, Celldetective is optimized for the needs of immunology assays. The software seamlessly integrates AI-based segmentation, Bayesian tracking, and automated single-cell event detection, all within an intuitive graphical interface that supports interactive visualization, annotation, and training capabilities. We demonstrate its utility with original data on immune effector cell interactions with an activating surface, mediated by bispecific antibodies, and further showcase its potential for analyzing extensive sets of pairwise interactions in antibody-dependent cell cytotoxicity events.Competing Interest StatementThe authors have declared no competing interest.},
-    URL = {https://www.biorxiv.org/content/early/2024/11/13/2024.03.15.585250},
-    eprint = {https://www.biorxiv.org/content/early/2024/11/13/2024.03.15.585250.full.pdf},
-    journal = {bioRxiv}
+@article{torroCelldetectiveAIenhancedImage2025,
+  title = {Celldetective: An {{AI-enhanced}} Image Analysis Tool for Unraveling Dynamic Cell Interactions},
+  shorttitle = {Celldetective},
+  author = {Torro, Rémy and Díaz-Bello, Beatriz and Arawi, Dalia El and Dervanova, Ksenija and Ammer, Lorna and Dupuy, Florian and Chames, Patrick and Sengupta, Kheya and Limozin, Laurent},
+  date = {2025-03-10},
+  journaltitle = {eLife},
+  volume = {14},
+  publisher = {eLife Sciences Publications Limited},
+  doi = {10.7554/eLife.105302.1},
+  url = {https://elifesciences.org/reviewed-preprints/105302},
+  urldate = {2025-03-20},
+  abstract = {A current challenge in bioimaging for immunology and immunotherapy research lies in analyzing multimodal and multidimensional data that capture dynamic interactions between diverse cell populations. Here, we introduce Celldetective, an open-source Python-based software designed for high-performance, end-to-end analysis of image-based in vitro immune and immunotherapy assays. Purpose-built for multicondition, 2D multichannel time-lapse microscopy of mixed cell populations, Celldetective is optimized for the needs of immunology assays. The software seamlessly integrates AI-based segmentation, Bayesian tracking, and automated single-cell event detection, all within an intuitive graphical interface that supports interactive visualization, annotation, and training capabilities. We demonstrate its utility with original data on immune effector cell interactions with an activating surface, mediated by bispecific antibodies, and further showcase its potential for analyzing extensive sets of pairwise interactions in antibody-dependent cell cytotoxicity events.},
+  langid = {english},
+  file = {/home/torro/Zotero/storage/VFYBBMQF/Torro et al. - 2025 - Celldetective an AI-enhanced image analysis tool .pdf;/home/torro/Zotero/storage/UGMCKKST/105302.html}
 }
 ```
 
 Make sure you to cite the papers of any segmentation model (StarDist,
-Cellpose) or tracker (bTrack) you used through Celldetective.
+Cellpose) or tracker (bTrack, TrackPy) you used through Celldetective.
 
 # Bibliography