celldetective 1.3.1__py3-none-any.whl → 1.3.3.post1__py3-none-any.whl

celldetective/signals.py

@@ -17,6 +17,7 @@ from sklearn.metrics import confusion_matrix, classification_report
 from sklearn.metrics import jaccard_score, balanced_accuracy_score, precision_score, recall_score
 from scipy.interpolate import interp1d
 from scipy.ndimage import shift
+from sklearn.metrics import ConfusionMatrixDisplay
 
 from celldetective.io import locate_signal_model, get_position_pickle, get_position_table
 from celldetective.tracking import clean_trajectories, interpolate_nan_properties
@@ -149,7 +150,7 @@ def analyze_signals(trajectories, model, interpolate_na=True,
 	assert os.path.exists(model_config_path),f'Model configuration could not be located in folder {model_path}... Abort.'
 
 	available_signals = list(trajectories.columns)
-	print('The available_signals are : ',available_signals)
+	#print('The available_signals are : ',available_signals)
 
 	f = open(model_config_path)
 	config = json.load(f)
@@ -167,22 +168,11 @@ def analyze_signals(trajectories, model, interpolate_na=True,
 		selected_signals = []
 		for s in required_signals:
 			pattern_test = [s in a or s==a for a in available_signals]
-			print(f'Pattern test for signal {s}: ', pattern_test)
+			#print(f'Pattern test for signal {s}: ', pattern_test)
 			assert np.any(pattern_test),f'No signal matches with the requirements of the model {required_signals}. Please pass the signals manually with the argument selected_signals or add measurements. Abort.'
-			valid_columns = np.array(available_signals)[np.array(pattern_test)]
-			if len(valid_columns)==1:
-				selected_signals.append(valid_columns[0])
-			else:
-				#print(test_number_of_nan(trajectories, valid_columns))
-				print(f'Found several candidate signals: {valid_columns}')
-				for vc in natsorted(valid_columns):
-					if 'circle' in vc:
-						selected_signals.append(vc)
-						break
-				else:
-					selected_signals.append(valid_columns[0])
-				# do something more complicated in case of one to many columns
-				#pass
+			valid_columns = natsorted(np.array(available_signals)[np.array(pattern_test)])
+			print(f"Selecting the first time series among: {valid_columns} for input requirement {s}...")
+			selected_signals.append(valid_columns[0])
 	else:
 		assert len(selected_signals)==len(required_signals),f'Mismatch between the number of required signals {required_signals} and the provided signals {selected_signals}... Abort.'
 
@@ -202,13 +192,7 @@ def analyze_signals(trajectories, model, interpolate_na=True,
 			signals[i,frames,j] = signal
 			signals[i,max(frames):,j] = signal[-1]
 
-	# for i in range(5):
-	# 	print('pre model')
-	# 	plt.plot(signals[i,:,0])
-	# 	plt.show()
-
 	model = SignalDetectionModel(pretrained=complete_path)
-	print('signal shape: ', signals.shape)
 
 	classes = model.predict_class(signals)
 	times_recast = model.predict_time_of_interest(signals)
@@ -378,194 +362,193 @@ def analyze_pair_signals_at_position(pos, model, use_gpu=True):
 	return None		
 
 
-def analyze_signals(trajectories, model, interpolate_na=True,
-                    selected_signals=None,
-                    model_path=None,
-                    column_labels={'track': "TRACK_ID", 'time': 'FRAME', 'x': 'POSITION_X', 'y': 'POSITION_Y'},
-                    plot_outcome=False, output_dir=None):
-    """
-	Analyzes signals from trajectory data using a specified signal detection model and configuration.
-
-	This function preprocesses trajectory data, selects specified signals, and applies a pretrained signal detection
-	model to predict classes and times of interest for each trajectory. It supports custom column labeling, interpolation
-	of missing values, and plotting of analysis outcomes.
-
-	Parameters
-	----------
-	trajectories : pandas.DataFrame
-		DataFrame containing trajectory data with columns for track ID, frame, position, and signals.
-	model : str
-		The name of the signal detection model to be used for analysis.
-	interpolate_na : bool, optional
-		Whether to interpolate missing values in the trajectories (default is True).
-	selected_signals : list of str, optional
-		A list of column names from `trajectories` representing the signals to be analyzed. If None, signals will
-		be automatically selected based on the model configuration (default is None).
-	column_labels : dict, optional
-		A dictionary mapping the default column names ('track', 'time', 'x', 'y') to the corresponding column names
-		in `trajectories` (default is {'track': "TRACK_ID", 'time': 'FRAME', 'x': 'POSITION_X', 'y': 'POSITION_Y'}).
-	plot_outcome : bool, optional
-		If True, generates and saves a plot of the signal analysis outcome (default is False).
-	output_dir : str, optional
-		The directory where the outcome plot will be saved. Required if `plot_outcome` is True (default is None).
-
-	Returns
-	-------
-	pandas.DataFrame
-		The input `trajectories` DataFrame with additional columns for predicted classes, times of interest, and
-		corresponding colors based on status and class.
-
-	Raises
-	------
-	AssertionError
-		If the model or its configuration file cannot be located.
-
-	Notes
-	-----
-	- The function relies on an external model configuration file (`config_input.json`) located in the model's directory.
-	- Signal selection and preprocessing are based on the requirements specified in the model's configuration.
-
-	"""
-
-    model_path = locate_signal_model(model, path=model_path)
-    complete_path = model_path  # +model
-    complete_path = rf"{complete_path}"
-    model_config_path = os.sep.join([complete_path, 'config_input.json'])
-    model_config_path = rf"{model_config_path}"
-    assert os.path.exists(complete_path), f'Model {model} could not be located in folder {model_path}... Abort.'
-    assert os.path.exists(
-        model_config_path), f'Model configuration could not be located in folder {model_path}... Abort.'
-
-    available_signals = list(trajectories.columns)
-    print('The available_signals are : ', available_signals)
-
-    f = open(model_config_path)
-    config = json.load(f)
-    required_signals = config["channels"]
-
-    try:
-        label = config['label']
-        if label == '':
-            label = None
-    except:
-        label = None
-
-    if selected_signals is None:
-        selected_signals = []
-        for s in required_signals:
-            pattern_test = [s in a or s == a for a in available_signals]
-            print(f'Pattern test for signal {s}: ', pattern_test)
-            assert np.any(
-                pattern_test), f'No signal matches with the requirements of the model {required_signals}. Please pass the signals manually with the argument selected_signals or add measurements. Abort.'
-            valid_columns = np.array(available_signals)[np.array(pattern_test)]
-            if len(valid_columns) == 1:
-                selected_signals.append(valid_columns[0])
-            else:
-                # print(test_number_of_nan(trajectories, valid_columns))
-                print(f'Found several candidate signals: {valid_columns}')
-                for vc in natsorted(valid_columns):
-                    if 'circle' in vc:
-                        selected_signals.append(vc)
-                        break
-                else:
-                    selected_signals.append(valid_columns[0])
-        # do something more complicated in case of one to many columns
-        # pass
-    else:
-        assert len(selected_signals) == len(
-            required_signals), f'Mismatch between the number of required signals {required_signals} and the provided signals {selected_signals}... Abort.'
-
-    print(f'The following channels will be passed to the model: {selected_signals}')
-    trajectories_clean = clean_trajectories(trajectories, interpolate_na=interpolate_na,
-                                            interpolate_position_gaps=interpolate_na, column_labels=column_labels)
-
-    max_signal_size = int(trajectories_clean[column_labels['time']].max()) + 2
-    tracks = trajectories_clean[column_labels['track']].unique()
-    signals = np.zeros((len(tracks), max_signal_size, len(selected_signals)))
-
-    for i, (tid, group) in enumerate(trajectories_clean.groupby(column_labels['track'])):
-        frames = group[column_labels['time']].to_numpy().astype(int)
-        for j, col in enumerate(selected_signals):
-            signal = group[col].to_numpy()
-            signals[i, frames, j] = signal
-            signals[i, max(frames):, j] = signal[-1]
-
-    # for i in range(5):
-    # 	print('pre model')
-    # 	plt.plot(signals[i,:,0])
-    # 	plt.show()
-
-    model = SignalDetectionModel(pretrained=complete_path)
-    print('signal shape: ', signals.shape)
-
-    classes = model.predict_class(signals)
-    times_recast = model.predict_time_of_interest(signals)
-
-    if label is None:
-        class_col = 'class'
-        time_col = 't0'
-        status_col = 'status'
-    else:
-        class_col = 'class_' + label
-        time_col = 't_' + label
-        status_col = 'status_' + label
-
-    for i, (tid, group) in enumerate(trajectories.groupby(column_labels['track'])):
-        indices = group.index
-        trajectories.loc[indices, class_col] = classes[i]
-        trajectories.loc[indices, time_col] = times_recast[i]
-    print('Done.')
-
-    for tid, group in trajectories.groupby(column_labels['track']):
-
-        indices = group.index
-        t0 = group[time_col].to_numpy()[0]
-        cclass = group[class_col].to_numpy()[0]
-        timeline = group[column_labels['time']].to_numpy()
-        status = np.zeros_like(timeline)
-        if t0 > 0:
-            status[timeline >= t0] = 1.
-        if cclass == 2:
-            status[:] = 2
-        if cclass > 2:
-            status[:] = 42
-        status_color = [color_from_status(s) for s in status]
-        class_color = [color_from_class(cclass) for i in range(len(status))]
-
-        trajectories.loc[indices, status_col] = status
-        trajectories.loc[indices, 'status_color'] = status_color
-        trajectories.loc[indices, 'class_color'] = class_color
-
-    if plot_outcome:
-        fig, ax = plt.subplots(1, len(selected_signals), figsize=(10, 5))
-        for i, s in enumerate(selected_signals):
-            for k, (tid, group) in enumerate(trajectories.groupby(column_labels['track'])):
-                cclass = group[class_col].to_numpy()[0]
-                t0 = group[time_col].to_numpy()[0]
-                timeline = group[column_labels['time']].to_numpy()
-                if cclass == 0:
-                    if len(selected_signals) > 1:
-                        ax[i].plot(timeline - t0, group[s].to_numpy(), c='tab:blue', alpha=0.1)
-                    else:
-                        ax.plot(timeline - t0, group[s].to_numpy(), c='tab:blue', alpha=0.1)
-        if len(selected_signals) > 1:
-            for a, s in zip(ax, selected_signals):
-                a.set_title(s)
-                a.set_xlabel(r'time - t$_0$ [frame]')
-                a.spines['top'].set_visible(False)
-                a.spines['right'].set_visible(False)
-        else:
-            ax.set_title(s)
-            ax.set_xlabel(r'time - t$_0$ [frame]')
-            ax.spines['top'].set_visible(False)
-            ax.spines['right'].set_visible(False)
-        plt.tight_layout()
-        if output_dir is not None:
-            plt.savefig(output_dir + 'signal_collapse.png', bbox_inches='tight', dpi=300)
-        plt.pause(3)
-        plt.close()
-
-    return trajectories
+# def analyze_signals(trajectories, model, interpolate_na=True,
+#                     selected_signals=None,
+#                     model_path=None,
+#                     column_labels={'track': "TRACK_ID", 'time': 'FRAME', 'x': 'POSITION_X', 'y': 'POSITION_Y'},
+#                     plot_outcome=False, output_dir=None):
+#     """
+# 	Analyzes signals from trajectory data using a specified signal detection model and configuration.
+
+# 	This function preprocesses trajectory data, selects specified signals, and applies a pretrained signal detection
+# 	model to predict classes and times of interest for each trajectory. It supports custom column labeling, interpolation
+# 	of missing values, and plotting of analysis outcomes.
+
+# 	Parameters
+# 	----------
+# 	trajectories : pandas.DataFrame
+# 		DataFrame containing trajectory data with columns for track ID, frame, position, and signals.
+# 	model : str
+# 		The name of the signal detection model to be used for analysis.
+# 	interpolate_na : bool, optional
+# 		Whether to interpolate missing values in the trajectories (default is True).
+# 	selected_signals : list of str, optional
+# 		A list of column names from `trajectories` representing the signals to be analyzed. If None, signals will
+# 		be automatically selected based on the model configuration (default is None).
+# 	column_labels : dict, optional
+# 		A dictionary mapping the default column names ('track', 'time', 'x', 'y') to the corresponding column names
+# 		in `trajectories` (default is {'track': "TRACK_ID", 'time': 'FRAME', 'x': 'POSITION_X', 'y': 'POSITION_Y'}).
+# 	plot_outcome : bool, optional
+# 		If True, generates and saves a plot of the signal analysis outcome (default is False).
+# 	output_dir : str, optional
+# 		The directory where the outcome plot will be saved. Required if `plot_outcome` is True (default is None).
+
+# 	Returns
+# 	-------
+# 	pandas.DataFrame
+# 		The input `trajectories` DataFrame with additional columns for predicted classes, times of interest, and
+# 		corresponding colors based on status and class.
+
+# 	Raises
+# 	------
+# 	AssertionError
+# 		If the model or its configuration file cannot be located.
+
+# 	Notes
+# 	-----
+# 	- The function relies on an external model configuration file (`config_input.json`) located in the model's directory.
+# 	- Signal selection and preprocessing are based on the requirements specified in the model's configuration.
+
+# 	"""
+
+#     model_path = locate_signal_model(model, path=model_path)
+#     complete_path = model_path  # +model
+#     complete_path = rf"{complete_path}"
+#     model_config_path = os.sep.join([complete_path, 'config_input.json'])
+#     model_config_path = rf"{model_config_path}"
+#     assert os.path.exists(complete_path), f'Model {model} could not be located in folder {model_path}... Abort.'
+#     assert os.path.exists(
+#         model_config_path), f'Model configuration could not be located in folder {model_path}... Abort.'
+
+#     available_signals = list(trajectories.columns)
+
+#     f = open(model_config_path)
+#     config = json.load(f)
+#     required_signals = config["channels"]
+
+#     try:
+#         label = config['label']
+#         if label == '':
+#             label = None
+#     except:
+#         label = None
+
+#     if selected_signals is None:
+#         selected_signals = []
+#         for s in required_signals:
+#             pattern_test = [s in a or s == a for a in available_signals]
+#             #print(f'Pattern test for signal {s}: ', pattern_test)
+#             assert np.any(
+#                 pattern_test), f'No signal matches with the requirements of the model {required_signals}. Please pass the signals manually with the argument selected_signals or add measurements. Abort.'
+#             valid_columns = np.array(available_signals)[np.array(pattern_test)]
+#             if len(valid_columns) == 1:
+#                 selected_signals.append(valid_columns[0])
+#             else:
+#                 # print(test_number_of_nan(trajectories, valid_columns))
+#                 print(f'Found several candidate signals: {valid_columns}')
+#                 for vc in natsorted(valid_columns):
+#                     if 'circle' in vc:
+#                         selected_signals.append(vc)
+#                         break
+#                 else:
+#                     selected_signals.append(valid_columns[0])
+#         # do something more complicated in case of one to many columns
+#         # pass
+#     else:
+#         assert len(selected_signals) == len(
+#             required_signals), f'Mismatch between the number of required signals {required_signals} and the provided signals {selected_signals}... Abort.'
+
+#     print(f'The following channels will be passed to the model: {selected_signals}')
+#     trajectories_clean = clean_trajectories(trajectories, interpolate_na=interpolate_na,
+#                                             interpolate_position_gaps=interpolate_na, column_labels=column_labels)
+
+#     max_signal_size = int(trajectories_clean[column_labels['time']].max()) + 2
+#     tracks = trajectories_clean[column_labels['track']].unique()
+#     signals = np.zeros((len(tracks), max_signal_size, len(selected_signals)))
+
+#     for i, (tid, group) in enumerate(trajectories_clean.groupby(column_labels['track'])):
+#         frames = group[column_labels['time']].to_numpy().astype(int)
+#         for j, col in enumerate(selected_signals):
+#             signal = group[col].to_numpy()
+#             signals[i, frames, j] = signal
+#             signals[i, max(frames):, j] = signal[-1]
+
+#     # for i in range(5):
+#     # 	print('pre model')
+#     # 	plt.plot(signals[i,:,0])
+#     # 	plt.show()
+
+#     model = SignalDetectionModel(pretrained=complete_path)
+#     print('signal shape: ', signals.shape)
+
+#     classes = model.predict_class(signals)
+#     times_recast = model.predict_time_of_interest(signals)
+
+#     if label is None:
+#         class_col = 'class'
+#         time_col = 't0'
+#         status_col = 'status'
+#     else:
+#         class_col = 'class_' + label
+#         time_col = 't_' + label
+#         status_col = 'status_' + label
+
+#     for i, (tid, group) in enumerate(trajectories.groupby(column_labels['track'])):
+#         indices = group.index
+#         trajectories.loc[indices, class_col] = classes[i]
+#         trajectories.loc[indices, time_col] = times_recast[i]
+#     print('Done.')
+
+#     for tid, group in trajectories.groupby(column_labels['track']):
+
+#         indices = group.index
+#         t0 = group[time_col].to_numpy()[0]
+#         cclass = group[class_col].to_numpy()[0]
+#         timeline = group[column_labels['time']].to_numpy()
+#         status = np.zeros_like(timeline)
+#         if t0 > 0:
+#             status[timeline >= t0] = 1.
+#         if cclass == 2:
+#             status[:] = 2
+#         if cclass > 2:
+#             status[:] = 42
+#         status_color = [color_from_status(s) for s in status]
+#         class_color = [color_from_class(cclass) for i in range(len(status))]
+
+#         trajectories.loc[indices, status_col] = status
+#         trajectories.loc[indices, 'status_color'] = status_color
+#         trajectories.loc[indices, 'class_color'] = class_color
+
+#     if plot_outcome:
+#         fig, ax = plt.subplots(1, len(selected_signals), figsize=(10, 5))
+#         for i, s in enumerate(selected_signals):
+#             for k, (tid, group) in enumerate(trajectories.groupby(column_labels['track'])):
+#                 cclass = group[class_col].to_numpy()[0]
+#                 t0 = group[time_col].to_numpy()[0]
+#                 timeline = group[column_labels['time']].to_numpy()
+#                 if cclass == 0:
+#                     if len(selected_signals) > 1:
+#                         ax[i].plot(timeline - t0, group[s].to_numpy(), c='tab:blue', alpha=0.1)
+#                     else:
+#                         ax.plot(timeline - t0, group[s].to_numpy(), c='tab:blue', alpha=0.1)
+#         if len(selected_signals) > 1:
+#             for a, s in zip(ax, selected_signals):
+#                 a.set_title(s)
+#                 a.set_xlabel(r'time - t$_0$ [frame]')
+#                 a.spines['top'].set_visible(False)
+#                 a.spines['right'].set_visible(False)
+#         else:
+#             ax.set_title(s)
+#             ax.set_xlabel(r'time - t$_0$ [frame]')
+#             ax.spines['top'].set_visible(False)
+#             ax.spines['right'].set_visible(False)
+#         plt.tight_layout()
+#         if output_dir is not None:
+#             plt.savefig(output_dir + 'signal_collapse.png', bbox_inches='tight', dpi=300)
+#         plt.pause(3)
+#         plt.close()
+
+#     return trajectories
 
 
 def analyze_pair_signals(trajectories_pairs,trajectories_reference,trajectories_neighbors, model, interpolate_na=True, selected_signals=None,
@@ -1405,7 +1388,10 @@ class SignalDetectionModel(object):
 
 			if self.show_plots:
 				try:
-					plot_confusion_matrix(results, ["dead","alive","miscellaneous"], output_dir=self.model_folder+os.sep, title=title)
+					ConfusionMatrixDisplay.from_predictions(ground_truth, predictions, cmap="Blues", normalize="pred", display_labels=["event","no event","left censored"])
+					plt.savefig(os.sep.join([self.model_folder,"test_confusion_matrix.png"]),bbox_inches='tight',dpi=300)
+					plt.pause(3)
+					plt.close()
 				except Exception as e:
 					print(e)
 					pass
@@ -1434,8 +1420,12 @@ class SignalDetectionModel(object):
 
 			if self.show_plots:
 				try:
-					plot_confusion_matrix(results, ["dead","alive","miscellaneous"], output_dir=self.model_folder+os.sep, title=title)
-				except:
+					ConfusionMatrixDisplay.from_predictions(ground_truth, predictions, cmap="Blues", normalize="pred", display_labels=["event","no event","left censored"])
+					plt.savefig(os.sep.join([self.model_folder,"validation_confusion_matrix.png"]),bbox_inches='tight',dpi=300)
+					plt.pause(3)
+					plt.close()
+				except Exception as e:
+					print(e)
 					pass
 			print("Validation set: ",classification_report(ground_truth,predictions))
 
@@ -3077,6 +3067,10 @@ def mean_signal(df, signal_name, class_col, time_col=None, class_value=[0], retu
 	assert signal_name in list(df.columns),"The signal you want to plot is not one of the measured features."
 	if isinstance(class_value,int):
 		class_value = [class_value]
+	elif class_value is None or class_col is None:
+		class_col = 'class_temp'
+		df['class_temp'] = 1
+		class_value = [1]
 
 	if forced_max_duration is None:
 		max_duration = int(df['FRAME'].max())+1 #ceil(np.amax(df.groupby(['position','TRACK_ID']).size().values))

celldetective/utils.py

@@ -1,3 +1,4 @@
+
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
@@ -29,6 +30,21 @@ from skimage.morphology import disk
 from scipy.stats import ks_2samp
 from cliffs_delta import cliffs_delta
 
+def safe_log(array):
+
+	if isinstance(array,int) or isinstance(array,float):
+		if value<=0.:
+			return np.nan
+		else:
+			return np.log10(value)
+	else:
+		if isinstance(array, list):
+			array = np.array(array)
+		output_array = np.zeros_like(array).astype(float)
+		output_array[:] = np.nan
+		output_array[array==array] = np.log10(array[array==array])
+		return output_array
+
 def contour_of_instance_segmentation(label, distance):
 
 	"""

{celldetective-1.3.1.dist-info → celldetective-1.3.3.post1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: celldetective
-Version: 1.3.1
+Version: 1.3.3.post1
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro
@@ -10,8 +10,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: wheel
 Requires-Dist: nbsphinx
-Requires-Dist: nbsphinx-link
-Requires-Dist: sphinx-rtd-theme
+Requires-Dist: nbsphinx_link
+Requires-Dist: sphinx_rtd_theme
 Requires-Dist: sphinx
 Requires-Dist: jinja2
 Requires-Dist: ipykernel
@@ -34,12 +34,13 @@ Requires-Dist: liblapack
 Requires-Dist: gputools
 Requires-Dist: lmfit
 Requires-Dist: superqt[cmap]
-Requires-Dist: matplotlib-scalebar
+Requires-Dist: setuptools
+Requires-Dist: matplotlib_scalebar
 Requires-Dist: numpy==1.26.4
 Requires-Dist: pytest
 Requires-Dist: pytest-qt
 Requires-Dist: h5py
-Requires-Dist: cliffs-delta
+Requires-Dist: cliffs_delta
 
 # Celldetective
 
@@ -171,20 +172,20 @@ 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.585250v1)
+[Celldetective](https://www.biorxiv.org/content/10.1101/2024.03.15.585250v3)
 paper (currently preprint):
 
 ``` raw
 @article {Torro2024.03.15.585250,
-    author = {R{\'e}my Torro and Beatriz D{\`\i}az-Bello and Dalia El Arawi and Lorna Ammer and Patrick Chames and Kheya Sengupta and Laurent Limozin},
+    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 key challenge in bioimaging is the analysis of multimodal and multidimensional data reporting dynamic interactions between diverse cell populations. We developed Celldetective, a software that integrates AI-based segmentation and tracking algorithms and automated signal analysis into a user-friendly graphical interface. It offers complete interactive visualization, annotation, and training capabilities. We demonstrate it by analyzing original experimental data of spreading immune effector cells as well as antibody-dependent cell cytotoxicity events using multimodal fluorescence microscopy.Competing Interest StatementThe authors have declared no competing interest.},
-    URL = {https://www.biorxiv.org/content/early/2024/03/17/2024.03.15.585250},
-    eprint = {https://www.biorxiv.org/content/early/2024/03/17/2024.03.15.585250.full.pdf},
+    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}
 }
 ```