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

celldetective/neighborhood.py

@@ -7,6 +7,8 @@ from celldetective.utils import contour_of_instance_segmentation, extract_identi
 from scipy.spatial.distance import cdist
 from celldetective.io import locate_labels, get_position_pickle, get_position_table
 
+import matplotlib.pyplot as plt
+
 abs_path = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], 'celldetective'])
 
 
@@ -818,10 +820,7 @@ def contact_neighborhood(labelsA, labelsB=None, border=3, connectivity=2):
 	if labelsB is not None:
 		labelsB = labelsB.astype(float)
 
-	print(f"Border = {border}")
-
 	if border > 0:
-		print(labelsA.shape, border * (-1))
 		labelsA_edge = contour_of_instance_segmentation(label=labelsA, distance=border * (-1)).astype(float)
 		labelsA[np.where(labelsA_edge > 0)] = labelsA_edge[np.where(labelsA_edge > 0)]
 		if labelsB is not None:
@@ -851,6 +850,7 @@ def contact_neighborhood(labelsA, labelsB=None, border=3, connectivity=2):
 	return neighs
 
 def merge_labels(labelsA, labelsB):
+
 	labelsA = labelsA.astype(float)
 	labelsB = labelsB.astype(float)
 
@@ -861,6 +861,7 @@ def merge_labels(labelsA, labelsB):
 
 
 def find_contact_neighbors(labels, connectivity=2):
+	
 	assert labels.ndim == 2, "Wrong dimension for labels..."
 	g, nodes = pixel_graph(labels, mask=labels.astype(bool), connectivity=connectivity)
 	g.eliminate_zeros()
@@ -906,6 +907,15 @@ def mask_contact_neighborhood(setA, setB, labelsA, labelsB, distance, mode='two-
 	"""
 
 	# Check live_status option
+	# if setA is not None:
+	# 	setA_id = extract_identity_col(setA)
+	# 	if setA_id=="TRACK_ID":
+	# 		setA = setA.loc[~setA['TRACK_ID'].isnull(),:].copy()
+	# if setB is not None:
+	# 	setB_id = extract_identity_col(setB)
+	# 	if setB_id=="TRACK_ID":
+	# 		setB = setB.loc[~setB['TRACK_ID'].isnull(),:].copy()
+
 	if setA is not None and setB is not None:
 		setA, setB, status = set_live_status(setA, setB, status, not_status_option)
 	else:
@@ -915,6 +925,25 @@ def mask_contact_neighborhood(setA, setB, labelsA, labelsB, distance, mode='two-
 	if not isinstance(distance, list):
 		distance = [distance]
 
+	cl = []
+	for s in [setA, setB]:
+
+		# Check whether data can be tracked
+		temp_column_labels = column_labels.copy()
+
+		id_col = extract_identity_col(s)
+		temp_column_labels.update({'track': id_col})
+		if id_col=='ID':
+			compute_cum_sum = False
+		
+		cl.append(temp_column_labels)
+	
+	setA = setA.loc[~setA[cl[0]['track']].isnull(),:].copy()
+	setB = setB.loc[~setB[cl[1]['track']].isnull(),:].copy()
+
+	if labelsB is None:
+		labelsB = [None] * len(labelsA)
+
 	for d in distance:
 		# loop over each provided distance
 
@@ -923,22 +952,11 @@ def mask_contact_neighborhood(setA, setB, labelsA, labelsB, distance, mode='two-
 		elif mode == 'self':
 			neigh_col = f'neighborhood_self_contact_{d}_px'
 
-		cl = []
-		for s in [setA, setB]:
+		setA[neigh_col] = np.nan
+		setA[neigh_col] = setA[neigh_col].astype(object)
 
-			# Check whether data can be tracked
-			temp_column_labels = column_labels.copy()
-
-			id_col = extract_identity_col(s)
-			temp_column_labels.update({'track': id_col})
-			if id_col=='ID':
-				compute_cum_sum = False  # if no tracking data then cum_sum is not relevant
-			cl.append(temp_column_labels)
-
-			# Remove nan tracks (cells that do not belong to a track)
-			s[neigh_col] = np.nan
-			s[neigh_col] = s[neigh_col].astype(object)
-			s.dropna(subset=[cl[-1]['track']], inplace=True)
+		setB[neigh_col] = np.nan
+		setB[neigh_col] = setB[neigh_col].astype(object)
 
 		# Loop over each available timestep
 		timeline = np.unique(np.concatenate([setA[cl[0]['time']].to_numpy(), setB[cl[1]['time']].to_numpy()])).astype(
@@ -946,38 +964,34 @@ def mask_contact_neighborhood(setA, setB, labelsA, labelsB, distance, mode='two-
 		for t in tqdm(timeline):
 
 			index_A = list(setA.loc[setA[cl[0]['time']] == t].index)
-			coordinates_A = setA.loc[setA[cl[0]['time']] == t, [cl[0]['x'], cl[0]['y']]].to_numpy()
-			ids_A = setA.loc[setA[cl[0]['time']] == t, cl[0]['track']].to_numpy()
-			mask_ids_A = setA.loc[setA[cl[0]['time']] == t, cl[0]['mask_id']].to_numpy()
-			status_A = setA.loc[setA[cl[0]['time']] == t, status[0]].to_numpy()
+			dataA = setA.loc[setA[cl[0]['time']] == t, [cl[0]['x'], cl[0]['y'], cl[0]['track'], cl[0]['mask_id'], status[0]]].to_numpy()
+			coordinates_A = dataA[:,[0,1]]; ids_A = dataA[:,2]; mask_ids_A = dataA[:,3]; status_A = dataA[:,4];
 
 			index_B = list(setB.loc[setB[cl[1]['time']] == t].index)
-			coordinates_B = setB.loc[setB[cl[1]['time']] == t, [cl[1]['x'], cl[1]['y']]].to_numpy()
-			ids_B = setB.loc[setB[cl[1]['time']] == t, cl[1]['track']].to_numpy()
-			mask_ids_B = setB.loc[setB[cl[1]['time']] == t, cl[1]['mask_id']].to_numpy()
-			status_B = setB.loc[setB[cl[1]['time']] == t, status[1]].to_numpy()
+			dataB = setB.loc[setB[cl[1]['time']] == t, [cl[1]['x'], cl[1]['y'], cl[1]['track'], cl[1]['mask_id'], status[1]]].to_numpy()
+			coordinates_B = dataB[:,[0,1]]; ids_B = dataB[:,2]; mask_ids_B = dataB[:,3]; status_B = dataB[:,4]
 
-			print(f"Frame {t}")
-			print(f"{mask_ids_A=}", f"{mask_ids_B}")
-
-			if len(ids_A) > 0 and len(ids_B) > 0:
+			if len(coordinates_A) > 0 and len(coordinates_B) > 0:
 
 				# compute distance matrix
 				dist_map = cdist(coordinates_A, coordinates_B, metric="euclidean")
+				intersection_map = np.zeros_like(dist_map).astype(float)
 
 				# Do the mask contact computation
-				if labelsB is not None:
-					lblB = labelsB[t]
-				else:
-					lblB = labelsB
+				lblA = labelsA[t]
+				lblA = np.where(np.isin(lblA, mask_ids_A), lblA, 0.)
+				
+				lblB = labelsB[t]
+				if lblB is not None:
+					lblB = np.where(np.isin(lblB, mask_ids_B), lblB, 0.)
 
-				print(f"Distance {d} for contact as border")
-				contact_pairs = contact_neighborhood(labelsA[t], labelsB=lblB, border=d, connectivity=2)
+				contact_pairs = contact_neighborhood(lblA, labelsB=lblB, border=d, connectivity=2)
 
-				print(t, f"{np.unique(labelsA[t])=}")
-				print(f"Frame {t}: found the following contact pairs: {contact_pairs}...")
 				# Put infinite distance to all non-contact pairs (something like this)
 				plot_map = False
+				flatA = lblA.flatten()
+				if lblB is not None:
+					flatB = lblB.flatten()
 
 				if len(contact_pairs) > 0:
 					mask = np.ones_like(dist_map).astype(bool)
@@ -985,48 +999,32 @@ def mask_contact_neighborhood(setA, setB, labelsA, labelsB, distance, mode='two-
 					indices_to_keep = []
 					for cp in contact_pairs:
 
-						if np.any(cp < 0):
-							if cp[0] < 0:
-								mask_A = cp[1]
-								mask_B = np.abs(cp[0])
-							else:
-								mask_A = cp[0]
-								mask_B = np.abs(cp[1])
-						else:
-							mask_A = cp[0]
-							mask_B = cp[1]
-
-						try:
+						cp = np.abs(cp)
+						mask_A, mask_B = cp
+						idx_A = np.where(mask_ids_A == int(mask_A))[0][0]
+						idx_B = np.where(mask_ids_B == int(mask_B))[0][0]
+						
+						intersection = 0
+						if lblB is not None:
+							intersection = len(flatA[(flatA==int(mask_A))&(flatB==int(mask_B))])
 
-							idx_A = np.where(mask_ids_A == int(mask_A))[0][0]
-							idx_B = np.where(mask_ids_B == int(mask_B))[0][0]
-							print(idx_A, idx_B)
-							indices_to_keep.append([idx_A,idx_B])
-						except Exception as e:
-							print(f'{e} {t=} error something happened!!')
-							pass
+						indices_to_keep.append([idx_A,idx_B, intersection])
+						print(f'Ref cell #{ids_A[idx_A]} matched with neigh. cell #{ids_B[idx_B]}...')
+						print(f'Computed intersection: {intersection} px...')
 
-					print(f'Indices to keep: {indices_to_keep}...')
 					if len(indices_to_keep) > 0:
 						indices_to_keep = np.array(indices_to_keep)
 						mask[indices_to_keep[:, 0], indices_to_keep[:, 1]] = False
 						if mode == 'self':
 							mask[indices_to_keep[:, 1], indices_to_keep[:, 0]] = False
 						dist_map[mask] = 1.0E06
+						intersection_map[indices_to_keep[:,0], indices_to_keep[:,1]] = indices_to_keep[:,2]
 						plot_map=True
 					else:
 						dist_map[:,:] = 1.0E06
 				else:
 					dist_map[:, :] = 1.0E06
 
-				# PROCEED all the same?? --> I guess so
-				# if plot_map:
-				# 	import matplotlib.pyplot as plt
-				# 	print(indices_to_keep)
-				# 	plt.imshow(dist_map)
-				# 	plt.pause(5)
-				# 	plt.close()
-
 				d_filter = 1.0E05
 				if attention_weight:
 					weights, closest_A = compute_attention_weight(dist_map, d_filter, status_A, ids_A, axis=1,
@@ -1036,11 +1034,14 @@ def mask_contact_neighborhood(setA, setB, labelsA, labelsB, distance, mode='two-
 				for k in range(dist_map.shape[0]):
 
 					col = dist_map[k, :]
+					col_inter = intersection_map[k, :]
 					col[col == 0.] = 1.0E06
 
 					neighs_B = np.array([ids_B[i] for i in np.where((col <= d_filter))[0]])
 					status_neigh_B = np.array([status_B[i] for i in np.where((col <= d_filter))[0]])
 					dist_B = [round(col[i], 2) for i in np.where((col <= d_filter))[0]]
+					intersect_B = [round(col_inter[i], 2) for i in np.where((col <= d_filter))[0]]
+
 					if len(dist_B) > 0:
 						closest_B_cell = neighs_B[np.argmin(dist_B)]
 
@@ -1080,14 +1081,14 @@ def mask_contact_neighborhood(setA, setB, labelsA, labelsB, distance, mode='two-
 							else:
 								closest_b = False
 							if isinstance(sym_neigh, list):
-								sym_neigh.append({'id': ids_A[k], 'distance': dist_B[n], 'status': status_A[k]})
+								sym_neigh.append({'id': ids_A[k], 'distance': dist_B[n], 'status': status_A[k], 'intersection': intersect_B[n]})
 							else:
-								sym_neigh = [{'id': ids_A[k], 'distance': dist_B[n], 'status': status_A[k]}]
+								sym_neigh = [{'id': ids_A[k], 'distance': dist_B[n], 'status': status_A[k], 'intersection': intersect_B[n]}]
 							if attention_weight:
 								sym_neigh[-1].update({'weight': weight_A, 'closest': closest_b})
 
 						# Write the minimum info about neighborhing cell B
-						neigh_dico = {'id': neighs_B[n], 'distance': dist_B[n], 'status': status_neigh_B[n]}
+						neigh_dico = {'id': neighs_B[n], 'distance': dist_B[n], 'status': status_neigh_B[n], 'intersection': intersect_B[n]}
 						if attention_weight:
 							neigh_dico.update({'weight': weights[n_index], 'closest': closest})
 
@@ -1303,6 +1304,90 @@ def compute_contact_neighborhood_at_position(pos, distance, population=['targets
 		return df_A, df_B
 
 
+def extract_neighborhood_in_pair_table(df, distance=None, reference_population="targets", neighbor_population="effectors",  mode="circle", neighborhood_key=None, contact_only=True,):
+
+	"""
+	Extracts data from a pair table that matches specific neighborhood criteria based on reference and neighbor 
+	populations, distance, and mode of neighborhood computation (e.g., circular or contact-based).
+
+	Parameters
+	----------
+	df : pandas.DataFrame
+		DataFrame containing the pair table, which includes columns for 'reference_population', 'neighbor_population', 
+		and a column for neighborhood status.
+	distance : int, optional
+		Radius in pixels for neighborhood calculation, used only if `neighborhood_key` is not provided.
+	reference_population : str, default="targets"
+		The reference population to consider. Must be either "targets" or "effectors".
+	neighbor_population : str, default="effectors"
+		The neighbor population to consider. Must be either "targets" or "effectors", used only if `neighborhood_key` is not provided.
+	mode : str, default="circle"
+		Neighborhood computation mode. Options are "circle" for radius-based or "contact" for contact-based neighborhood, used only if `neighborhood_key` is not provided.
+	neighborhood_key : str, optional
+		A precomputed neighborhood key to identify specific neighborhoods. If provided, this key overrides `distance`, 
+		`mode`, and `neighbor_population`.
+	contact_only : bool, default=True
+		If True, only rows indicating contact with the neighbor population (status=1) are kept; if False, both 
+		contact (status=1) and no-contact (status=0) rows are included.
+
+	Returns
+	-------
+	pandas.DataFrame
+		Filtered DataFrame containing rows that meet the specified neighborhood criteria.
+
+	Notes
+	-----
+	- When `neighborhood_key` is None, the neighborhood column is generated based on the provided `reference_population`, 
+	  `neighbor_population`, `distance`, and `mode`.
+	- The function uses `status_<neigh_col>` to filter rows based on `contact_only` criteria.
+	- Ensures that `reference_population` and `neighbor_population` are valid inputs and consistent with the neighborhood 
+	  mode and key.
+
+	Example
+	-------
+	>>> neighborhood_data = extract_neighborhood_in_pair_table(df, distance=50, reference_population="targets", 
+															   neighbor_population="effectors", mode="circle")
+	>>> neighborhood_data.head()
+
+	Raises
+	------
+	AssertionError
+		If `reference_population` or `neighbor_population` is not valid, or if the required neighborhood status 
+		column does not exist in `df`.
+	"""
+
+
+	assert reference_population in ["targets", "effectors"], "Please set a valid reference population ('targets' or 'effectors')"
+	if neighborhood_key is None:
+		assert neighbor_population in ["targets", "effectors"], "Please set a valid neighbor population ('targets' or 'effectors')"
+		assert mode in ["circle", "contact"], "Please set a valid neighborhood computation mode ('circle' or 'contact')"
+		if reference_population==neighbor_population:
+			type = "self"
+		else:
+			type = "2"
+
+		neigh_col = f"neighborhood_{type}_{mode}_{distance}_px"
+	else:
+		neigh_col = neighborhood_key.replace('status_','')
+		if 'self' in neigh_col:
+			neighbor_population = reference_population
+		else:
+			if reference_population=="effectors":
+				neighbor_population=='targets'
+			else:
+				neighbor_population=='effectors'
+
+	assert "status_"+neigh_col in list(df.columns),"The selected neighborhood does not appear in the data..."
+
+	if contact_only:
+		s_keep = [1]
+	else:
+		s_keep = [0,1]
+
+	data = df.loc[(df['reference_population']==reference_population)&(df['neighbor_population']==neighbor_population)&(df["status_"+neigh_col].isin(s_keep))]
+
+	return data
+
 
 # def mask_intersection_neighborhood(setA, labelsA, setB, labelsB, threshold_iou=0.5, viewpoint='B'):
 # 	# do whatever to match objects in A and B

celldetective/relative_measurements.py

@@ -90,6 +90,10 @@ def measure_pairs(pos, neighborhood_protocol):
 				cosine_dot_vector[:] = np.nan
 
 				coords_neighbor = group_neigh[['POSITION_X', 'POSITION_Y']].to_numpy()[0]
+				intersection = np.nan
+				if 'intersection' in list(group_neigh.columns):
+					intersection = group_neigh['intersection'].values[0]
+
 				neighbor_vector[0] = coords_neighbor[0] - coords_reference[0]
 				neighbor_vector[1] = coords_neighbor[1] - coords_reference[1]
 
@@ -109,7 +113,7 @@ def measure_pairs(pos, neighborhood_protocol):
 							{'REFERENCE_ID': tid, 'NEIGHBOR_ID': nc,
 							'reference_population': reference_population,
 							'neighbor_population': neighbor_population,
-							'FRAME': t, 'distance': relative_distance,
+							'FRAME': t, 'distance': relative_distance, 'intersection': intersection,
 							'angle': angle * 180 / np.pi,
 							f'status_{neighborhood_description}': 1,
 							f'class_{neighborhood_description}': 0,
@@ -201,9 +205,14 @@ def measure_pair_signals_at_position(pos, neighborhood_protocol, velocity_kwargs
 			neighbor_dicts = group.loc[: , f'{neighborhood_description}'].values
 			timeline_reference = group['FRAME'].to_numpy()
 			coords_reference = group[['POSITION_X', 'POSITION_Y']].to_numpy()
+			if "area" in list(group.columns):
+				ref_area = group['area'].to_numpy()
+			else:
+				ref_area = [np.nan]*len(coords_reference)
 
 			neighbor_ids = []
 			neighbor_ids_per_t = []
+			intersection_values = []
 
 			time_of_first_entrance_in_neighborhood = {}
 			t_departure={}
@@ -218,10 +227,16 @@ def measure_pair_signals_at_position(pos, neighborhood_protocol, velocity_kwargs
 					for neigh in neighbors_at_t:
 						if neigh['id'] not in neighbor_ids:
 							time_of_first_entrance_in_neighborhood[neigh['id']]=t
+						if 'intersection' in neigh:
+							intersection_values.append({"frame": t, "neigh_id": neigh['id'], "intersection": neigh['intersection']})
+						else:
+							intersection_values.append({"frame": t, "neigh_id": neigh['id'], "intersection": np.nan})
 						neighbor_ids.append(neigh['id'])
 						neighs_t.append(neigh['id'])
 				neighbor_ids_per_t.append(neighs_t)
 
+			intersection_values = pd.DataFrame(intersection_values)
+
 			#print(neighbor_ids_per_t)
 			unique_neigh = list(np.unique(neighbor_ids))
 			print(f'Reference cell {tid}: found {len(unique_neigh)} neighbour cells: {unique_neigh}...')
@@ -232,6 +247,11 @@ def measure_pair_signals_at_position(pos, neighborhood_protocol, velocity_kwargs
 				
 				coords_neighbor = group_neigh[['POSITION_X', 'POSITION_Y']].to_numpy()
 				timeline_neighbor = group_neigh['FRAME'].to_numpy()
+				if "area" in list(group_neigh.columns):
+					neigh_area = group_neigh['area'].to_numpy()
+				else:
+					neigh_area = [np.nan]*len(timeline_neighbor)
+
 
 				# # Perform timeline matching to have same start-end points and no gaps
 				full_timeline, _, _ = timeline_matching(timeline_reference, timeline_neighbor)
@@ -239,6 +259,9 @@ def measure_pair_signals_at_position(pos, neighborhood_protocol, velocity_kwargs
 				neighbor_vector = np.zeros((len(full_timeline), 2))
 				neighbor_vector[:,:] = np.nan
 
+				intersection_vector = np.zeros((len(full_timeline)))
+				intersection_vector[:] = np.nan
+
 				centre_of_mass_columns = [(c,c.replace('POSITION_X','POSITION_Y')) for c in list(neighbor_properties.columns) if c.endswith('centre_of_mass_POSITION_X')]
 				centre_of_mass_labels = [c.replace('_centre_of_mass_POSITION_X','') for c in list(neighbor_properties.columns) if c.endswith('centre_of_mass_POSITION_X')]
 
@@ -319,7 +342,20 @@ def measure_pair_signals_at_position(pos, neighborhood_protocol, velocity_kwargs
 
 					if t in timeline_reference: # meaning position exists on both sides
 
-						idx_reference = list(timeline_reference).index(t) 
+						idx_reference = list(timeline_reference).index(t)
+						inter = intersection_values.loc[(intersection_values['neigh_id']==nc)&(intersection_values["frame"]==t),"intersection"].values
+						if len(inter)==0:
+							inter = np.nan
+						else:
+							inter = inter[0]
+
+						neigh_inter_fraction = np.nan
+						if inter==inter and neigh_area[t]==neigh_area[t]:
+							neigh_inter_fraction = inter / neigh_area[t]
+
+						ref_inter_fraction = np.nan
+						if inter==inter and ref_area[t]==ref_area[t]:
+							ref_inter_fraction = inter / ref_area[t]						
 
 						if nc in neighbor_ids_per_t[idx_reference]:
 
@@ -328,7 +364,7 @@ def measure_pair_signals_at_position(pos, neighborhood_protocol, velocity_kwargs
 									{'REFERENCE_ID': tid, 'NEIGHBOR_ID': nc,
 									'reference_population': reference_population,
 									'neighbor_population': neighbor_population,
-									'FRAME': t, 'distance': relative_distance[t],
+									'FRAME': t, 'distance': relative_distance[t], 'intersection': inter, 'reference_frac_area_intersection': ref_inter_fraction, 'neighbor_frac_area_intersection': neigh_inter_fraction,
 									'velocity': rel_velocity[t],
 									'velocity_smooth': rel_velocity_long_timescale[t], 
 									'angle': angle[t] * 180 / np.pi,
@@ -349,7 +385,7 @@ def measure_pair_signals_at_position(pos, neighborhood_protocol, velocity_kwargs
 									{'REFERENCE_ID': tid, 'NEIGHBOR_ID': nc,
 									'reference_population': reference_population,
 									'neighbor_population': neighbor_population,
-									'FRAME': t, 'distance': relative_distance[t],
+									'FRAME': t, 'distance': relative_distance[t], 'intersection': inter, 'reference_frac_area_intersection': ref_inter_fraction, 'neighbor_frac_area_intersection': neigh_inter_fraction,
 									'velocity': rel_velocity[t], 
 									'velocity_smooth': rel_velocity_long_timescale[t],
 									'angle': angle[t] * 180 / np.pi,
@@ -642,4 +678,92 @@ def extract_neighborhood_settings(neigh_string, population='targets'):
 	return neigh_protocol
 
 
+def expand_pair_table(data):
+
+	"""
+	Expands a pair table by merging reference and neighbor trajectory data from CSV files based on the specified 
+	reference and neighbor populations, and their associated positions and frames.
+
+	Parameters
+	----------
+	data : pandas.DataFrame
+		DataFrame containing the pair table, which should include the columns:
+		- 'reference_population': The reference population type.
+		- 'neighbor_population': The neighbor population type.
+		- 'position': The position identifier for each pair.
+
+	Returns
+	-------
+	pandas.DataFrame
+		Expanded DataFrame that includes merged reference and neighbor data, sorted by position, reference population, 
+		neighbor population, and frame. Rows without values in 'REFERENCE_ID', 'NEIGHBOR_ID', 'reference_population', 
+		or 'neighbor_population' are dropped.
+
+	Notes
+	-----
+	- For each unique pair of `reference_population` and `neighbor_population`, the function identifies corresponding 
+	  trajectories CSV files based on the position identifier.
+	- The function reads the trajectories CSV files, prefixes columns with 'reference_' or 'neighbor_' to avoid 
+	  conflicts, and merges data from reference and neighbor tables based on `TRACK_ID` or `ID`, and `FRAME`.
+	- Merges are performed in an outer join manner to retain all rows, regardless of missing values in the target files.
+	- The final DataFrame is sorted and cleaned to ensure only valid pairings are included.
+
+	Example
+	-------
+	>>> expanded_df = expand_pair_table(pair_table)
+	>>> expanded_df.head()
+
+	Raises
+	------
+	AssertionError
+		If 'reference_population' or 'neighbor_population' is not found in the columns of `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..."
+
+	expanded_table = []
+	
+	for neigh, group in data.groupby(['reference_population','neighbor_population']):
+		
+		ref_pop = neigh[0]; neigh_pop = neigh[1];
+
+		for pos,pos_group in group.groupby('position'):
+			
+			ref_tab = os.sep.join([pos,'output','tables',f'trajectories_{ref_pop}.csv'])
+			neigh_tab = os.sep.join([pos,'output','tables',f'trajectories_{neigh_pop}.csv'])
+			
+			if os.path.exists(ref_tab):
+				df_ref = pd.read_csv(ref_tab)
+				if 'TRACK_ID' in df_ref.columns:
+					if not np.all(df_ref['TRACK_ID'].isnull()):
+						ref_merge_cols = ['TRACK_ID','FRAME']
+					else:
+						ref_merge_cols = ['ID','FRAME']
+				else:
+					ref_merge_cols = ['ID','FRAME']
+
+			if os.path.exists(neigh_tab):
+				df_neigh = pd.read_csv(neigh_tab)
+				if 'TRACK_ID' in df_neigh.columns:
+					if not np.all(df_neigh['TRACK_ID'].isnull()):
+						neigh_merge_cols = ['TRACK_ID','FRAME']
+					else:
+						neigh_merge_cols = ['ID','FRAME']
+				else:
+					neigh_merge_cols = ['ID','FRAME']
+
+			df_ref = df_ref.add_prefix('reference_',axis=1)
+			df_neigh = df_neigh.add_prefix('neighbor_',axis=1)
+			ref_merge_cols = ['reference_'+c for c in ref_merge_cols]
+			neigh_merge_cols = ['neighbor_'+c for c in neigh_merge_cols]
+
+			merge_ref = pos_group.merge(df_ref, how='outer', left_on=['REFERENCE_ID','FRAME'], right_on=ref_merge_cols, suffixes=('', '_reference'))
+			merge_neigh = merge_ref.merge(df_neigh, how='outer', left_on=['NEIGHBOR_ID','FRAME'], right_on=neigh_merge_cols, suffixes=('_reference', '_neighbor'))
+			expanded_table.append(merge_neigh)
+
+	df_expanded = pd.concat(expanded_table, axis=0, ignore_index = True)
+	df_expanded = df_expanded.sort_values(by=['position', 'reference_population','neighbor_population','REFERENCE_ID','NEIGHBOR_ID','FRAME'])
+	df_expanded = df_expanded.dropna(axis=0, subset=['REFERENCE_ID','NEIGHBOR_ID','reference_population','neighbor_population'])
 
+	return df_expanded

celldetective/scripts/measure_cells.py

@@ -251,14 +251,14 @@ def measure_index(indices):
 			iso_table = measure_isotropic_intensity(positions_at_t, img, channels=channel_names, intensity_measurement_radii=intensity_measurement_radii, column_labels=column_labels, operations=isotropic_operations, verbose=False)
 
 		if do_iso_intensities and do_features:
-			measurements_at_t = iso_table.merge(feature_table, how='outer', on='class_id',suffixes=('', '_delme'))
+			measurements_at_t = iso_table.merge(feature_table, how='outer', on='class_id',suffixes=('_delme', ''))
 			measurements_at_t = measurements_at_t[[c for c in measurements_at_t.columns if not c.endswith('_delme')]]
 		elif do_iso_intensities * (not do_features):
 			measurements_at_t = iso_table
 		elif do_features:
-			measurements_at_t = positions_at_t.merge(feature_table, how='outer', on='class_id',suffixes=('', '_delme'))
+			measurements_at_t = positions_at_t.merge(feature_table, how='outer', on='class_id',suffixes=('_delme', ''))
 			measurements_at_t = measurements_at_t[[c for c in measurements_at_t.columns if not c.endswith('_delme')]]
-	
+
 		center_of_mass_x_cols = [c for c in list(measurements_at_t.columns) if c.endswith('centre_of_mass_x')]
 		center_of_mass_y_cols = [c for c in list(measurements_at_t.columns) if c.endswith('centre_of_mass_y')]
 		for c in center_of_mass_x_cols: