celldetective 1.3.0.post1__py3-none-any.whl → 1.3.2__py3-none-any.whl

celldetective/models/tracking_configs/biased_motion.json

@@ -0,0 +1,68 @@
+{
+  "TrackerConfig":
+    {
+      "MotionModel":
+        {
+          "name": "biased_motion",
+          "dt": 1.0,
+          "measurements": 3,
+          "states": 6,
+          "accuracy": 7.5,
+          "prob_not_assign": 0.001,
+          "max_lost": 5,
+          "A": {
+            "matrix": [1,0,0,1,0,0,
+                       0,1,0,0,0,0,
+                       0,0,1,0,0,1,
+                       0,0,0,1,0,0,
+                       0,0,0,0,0,0,
+                       0,0,0,0,0,1]
+          },
+          "H": {
+            "matrix": [1,0,0,0,0,0,
+                       0,1,0,0,0,0,
+                       0,0,1,0,0,0]
+          },
+          "P": {
+            "sigma": 150.0,
+            "matrix": [0.1,0,0,0,0,0,
+                       0,0.1,0,0,0,0,
+                       0,0,0.1,0,0,0,
+                       0,0,0,1,0,0,
+                       0,0,0,0,1,0,
+                       0,0,0,0,0,1]
+          },
+          "G": {
+            "sigma": 15.0,
+            "matrix": [0.5,0.5,0.5,1,1,1]
+
+          },
+          "R": {
+            "sigma": 5.0,
+            "matrix": [1,0,0,
+                       0,1,0,
+                       0,0,1]
+          }
+        },
+      "ObjectModel":
+        {},
+      "HypothesisModel":
+        {
+          "name": "cell_hypothesis",
+          "hypotheses": ["P_FP", "P_init", "P_term", "P_branch","P_link", "P_merge"],
+          "lambda_time": 5.0,
+          "lambda_dist": 3.0,
+          "lambda_link": 10.0,
+          "lambda_branch": 1.0,
+          "eta": 1e-10,
+          "theta_dist": 20.0,
+          "theta_time": 5.0,
+          "dist_thresh": 35.0,
+          "time_thresh": 20.0,
+          "apop_thresh": 10,
+          "segmentation_miss_rate": 0.05,
+          "apoptosis_rate": 0.0005,
+          "relax": true
+        }
+    }
+}

celldetective/models/tracking_configs/no_z_motion.json

@@ -0,0 +1,202 @@
+{
+  "name": "no_z_motion",
+  "verbose": false,
+  "motion_model": {
+    "measurements": 3,
+    "states": 6,
+    "A": [
+      1.0,
+      0.0,
+      0.0,
+      1.0,
+      0.0,
+      0.0,
+      0.0,
+      1.0,
+      0.0,
+      0.0,
+      1.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      1.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      1.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0
+    ],
+    "H": [
+      1.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      1.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      1.0,
+      0.0,
+      0.0,
+      0.0
+    ],
+    "P": [
+      30.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      30.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      30.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      300.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      300.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      0.0,
+      300.0
+    ],
+    "R": [
+      10.0,
+      0.0,
+      0.0,
+      0.0,
+      10.0,
+      0.0,
+      0.0,
+      0.0,
+      10.0
+    ],
+    "G": [
+      15.0,
+      15.0,
+      15.0,
+      30.0,
+      30.0,
+      30.0
+    ],
+    "Q": [
+      225.0,
+      225.0,
+      225.0,
+      450.0,
+      450.0,
+      450.0,
+      225.0,
+      225.0,
+      225.0,
+      450.0,
+      450.0,
+      450.0,
+      225.0,
+      225.0,
+      225.0,
+      450.0,
+      450.0,
+      450.0,
+      450.0,
+      450.0,
+      450.0,
+      900.0,
+      900.0,
+      900.0,
+      450.0,
+      450.0,
+      450.0,
+      900.0,
+      900.0,
+      900.0,
+      450.0,
+      450.0,
+      450.0,
+      900.0,
+      900.0,
+      900.0
+    ],
+    "dt": 1.0,
+    "accuracy": 5.0,
+    "max_lost": 5,
+    "prob_not_assign": 0.1,
+    "name": "ricm2"
+  },
+  "object_model": null,
+  "hypothesis_model": {
+    "hypotheses": [
+      "P_FP",
+      "P_init",
+      "P_term",
+      "P_link"
+    ],
+    "lambda_time": 5.0,
+    "lambda_dist": 3.0,
+    "lambda_link": 50.0,
+    "lambda_branch": 50.0,
+    "eta": 1e-10,
+    "theta_dist": 20.0,
+    "theta_time": 5.0,
+    "dist_thresh": 75.0,
+    "time_thresh": 5.0,
+    "apop_thresh": 5,
+    "segmentation_miss_rate": 0.1,
+    "apoptosis_rate": 0.001,
+    "relax": true,
+    "name": "ricm2"
+  },
+  "max_search_radius": 200.0,
+  "return_kalman": false,
+  "store_candidate_graph": false,
+  "volume": null,
+  "update_method": 0,
+  "optimizer_options": {
+    "tm_lim": 60000
+  },
+  "features": [],
+  "tracking_updates": [
+    1
+  ],
+  "enable_optimisation": true
+}

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