celldetective 1.3.7.post1__py3-none-any.whl → 1.3.8__py3-none-any.whl

celldetective/io.py

@@ -16,7 +16,7 @@ import concurrent.futures
 from csbdeep.utils import normalize_mi_ma
 from csbdeep.io import save_tiff_imagej_compatible
 
-import skimage.io as skio
+import imageio.v2 as imageio
 from skimage.measure import regionprops_table, label
 
 from btrack.datasets import cell_config
@@ -58,6 +58,7 @@ def extract_experiment_from_well(well_path):
 	>>> well_path = "/path/to/experiment/plate/well"
 	>>> extract_experiment_from_well(well_path)
 	'/path/to/experiment'
+	
 	"""
 
 	if not well_path.endswith(os.sep):
@@ -94,6 +95,7 @@ def extract_well_from_position(pos_path):
 	>>> pos_path = "/path/to/experiment/plate/well/position"
 	>>> extract_well_from_position(pos_path)
 	'/path/to/experiment/plate/well/'
+
 	"""
 
 	if not pos_path.endswith(os.sep):
@@ -129,6 +131,7 @@ def extract_experiment_from_position(pos_path):
 	>>> pos_path = "/path/to/experiment/plate/well/position"
 	>>> extract_experiment_from_position(pos_path)
 	'/path/to/experiment'
+
 	"""
 
 	pos_path = pos_path.replace(os.sep, '/')
@@ -187,6 +190,7 @@ def collect_experiment_metadata(pos_path=None, well_path=None):
 	>>> metadata = collect_experiment_metadata(well_path=well_path)
 	>>> metadata["concentration"]
 	10.0
+
 	"""
 
 	if pos_path is not None:
@@ -289,6 +293,7 @@ def get_config(experiment):
 	>>> config_path = get_config(experiment)
 	>>> print(config_path)
 	'/path/to/experiment/config.ini'
+
 	"""
 
 	if not experiment.endswith(os.sep):
@@ -336,6 +341,7 @@ def get_spatial_calibration(experiment):
 	>>> calibration = get_spatial_calibration(experiment)
 	>>> print(calibration)
 	0.325  # pixels-to-micrometers conversion factor
+
 	"""
 
 	config = get_config(experiment)
@@ -380,6 +386,7 @@ def get_temporal_calibration(experiment):
 	>>> calibration = get_temporal_calibration(experiment)
 	>>> print(calibration)
 	0.5  # frames-to-minutes conversion factor
+
 	"""
 
 	config = get_config(experiment)
@@ -393,6 +400,23 @@ def get_experiment_metadata(experiment):
 	metadata = ConfigSectionMap(config, "Metadata")
 	return metadata
 
+def get_experiment_labels(experiment):
+
+	config = get_config(experiment)
+	wells = get_experiment_wells(experiment)
+	nbr_of_wells = len(wells)
+
+	labels = ConfigSectionMap(config, "Labels")
+	for k in list(labels.keys()):
+		values = labels[k].split(',')
+		if nbr_of_wells != len(values):
+			values = [str(s) for s in np.linspace(0, nbr_of_wells - 1, nbr_of_wells)]
+		if np.all([s.isnumeric() for s in values]):
+			values = [float(s) for s in values]
+		labels.update({k: values})
+
+	return labels
+
 
 def get_experiment_concentrations(experiment, dtype=str):
 	
@@ -435,6 +459,7 @@ def get_experiment_concentrations(experiment, dtype=str):
 	>>> concentrations = get_experiment_concentrations(experiment, dtype=float)
 	>>> print(concentrations)
 	[0.1, 0.2, 0.5, 1.0]
+
 	"""
 	
 	config = get_config(experiment)
@@ -489,6 +514,7 @@ def get_experiment_cell_types(experiment, dtype=str):
 	>>> cell_types = get_experiment_cell_types(experiment, dtype=str)
 	>>> print(cell_types)
 	['TypeA', 'TypeB', 'TypeC', 'TypeD']
+
 	"""
 
 	config = get_config(experiment)
@@ -540,6 +566,7 @@ def get_experiment_antibodies(experiment, dtype=str):
 
 	>>> get_experiment_antibodies("path/to/experiment2", dtype=int)
 	array([0, 1, 2])
+
 	"""
 
 	config = get_config(experiment)
@@ -594,6 +621,7 @@ def get_experiment_pharmaceutical_agents(experiment, dtype=str):
 	>>> antibodies = get_experiment_antibodies(experiment, dtype=str)
 	>>> print(antibodies)
 	['AntibodyA', 'AntibodyB', 'AntibodyC', 'AntibodyD']
+
 	"""
 
 	config = get_config(experiment)
@@ -702,6 +730,7 @@ def extract_well_name_and_number(well):
 	>>> well_path = "another/path/W1"
 	>>> extract_well_name_and_number(well_path)
 	('W1', 1)
+
 	"""
 
 	split_well_path = well.split(os.sep)
@@ -740,6 +769,7 @@ def extract_position_name(pos):
 	>>> pos_path = "another/path/positionA"
 	>>> extract_position_name(pos_path)
 	'positionA'
+
 	"""
 
 	split_pos_path = pos.split(os.sep)
@@ -890,6 +920,7 @@ def get_position_movie_path(pos, prefix=''):
 	>>> pos_path = "nonexistent/path"
 	>>> get_position_movie_path(pos_path)
 	None
+
 	"""
 	
 
@@ -961,16 +992,15 @@ def load_experiment_tables(experiment, population='targets', well_option='*', po
 	Use pickle files for faster loading:
 
 	>>> df = load_experiment_tables("experiment_01", load_pickle=True)
+
 	"""
 
 	config = get_config(experiment)
 	wells = get_experiment_wells(experiment)
 
 	movie_prefix = ConfigSectionMap(config, "MovieSettings")["movie_prefix"]
-	concentrations = get_experiment_concentrations(experiment, dtype=float)
-	cell_types = get_experiment_cell_types(experiment)
-	antibodies = get_experiment_antibodies(experiment)
-	pharmaceutical_agents = get_experiment_pharmaceutical_agents(experiment)
+
+	labels = get_experiment_labels(experiment)
 	metadata = get_experiment_metadata(experiment) # None or dict of metadata
 	well_labels = _extract_labels_from_config(config, len(wells))
 
@@ -986,14 +1016,8 @@ def load_experiment_tables(experiment, population='targets', well_option='*', po
 
 		well_name, well_number = extract_well_name_and_number(well_path)
 		widx = well_indices[k]
-
 		well_alias = well_labels[widx]
 
-		well_concentration = concentrations[widx]
-		well_antibody = antibodies[widx]
-		well_cell_type = cell_types[widx]
-		well_pharmaceutical_agent = pharmaceutical_agents[widx]
-
 		positions = get_positions_in_well(well_path)
 		if position_indices is not None:
 			try:
@@ -1022,10 +1046,13 @@ def load_experiment_tables(experiment, population='targets', well_option='*', po
 				df_pos['well_name'] = well_name
 				df_pos['pos_name'] = pos_name
 
-				df_pos['concentration'] = well_concentration
-				df_pos['antibody'] = well_antibody
-				df_pos['cell_type'] = well_cell_type
-				df_pos['pharmaceutical_agent'] = well_pharmaceutical_agent
+				for k in list(labels.keys()):
+					values = labels[k]
+					try:
+						df_pos[k] = values[widx]
+					except Exception as e:
+						print(f"{e=}")
+
 				if metadata is not None:
 					keys = list(metadata.keys())
 					for k in keys:
@@ -1037,10 +1064,6 @@ def load_experiment_tables(experiment, population='targets', well_option='*', po
 				pos_dict = {'pos_path': pos_path, 'pos_index': real_pos_index, 'pos_name': pos_name, 'table_path': table,
 					 'stack_path': stack_path,'well_path': well_path, 'well_index': real_well_index, 'well_name': well_name,
 					 'well_number': well_number, 'well_alias': well_alias}
-				# if metadata is not None:
-				# 	keys = list(metadata.keys())
-				# 	for k in keys:
-				# 		pos_dict.update({k: metadata[k]})
 
 				df_pos_info.append(pos_dict)
 
@@ -1171,6 +1194,7 @@ def locate_labels(position, population='target', frames=None):
 	Load multiple specific frames:
 
 	>>> labels = locate_labels("/path/to/position", population="target", frames=[0, 1, 2])
+
 	"""
 
 	if not position.endswith(os.sep):
@@ -1241,6 +1265,7 @@ def fix_missing_labels(position, population='target', prefix='Aligned'):
 	-------
 	None
 		The function creates new label files in the corresponding folder for any frames missing label files.
+
 	"""
 
 	if not position.endswith(os.sep):
@@ -1414,6 +1439,7 @@ def auto_load_number_of_frames(stack_path):
 	>>> frames = auto_load_number_of_frames(None)
 	>>> print(frames)
 	None
+
 	"""
 
 	if stack_path is None:
@@ -1510,6 +1536,7 @@ def parse_isotropic_radii(string):
 	- It identifies ranges using square brackets and assumes that ranges are always 
 	  two consecutive values.
 	- Non-integer sections of the string are ignored.
+
 	"""
 
 	sections = re.split(',| ', string)
@@ -1618,6 +1645,7 @@ def interpret_tracking_configuration(config):
 
 	>>> interpret_tracking_configuration(None)
 	'/path/to/default/config.json'
+
 	"""
 
 	if isinstance(config, str):
@@ -1792,6 +1820,7 @@ def locate_signal_model(name, path=None, pairs=False):
 
 	>>> locate_signal_model("remote_model")
 	'path/to/celldetective/models/signal_detection/remote_model/'
+
 	"""
 
 	main_dir = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], "celldetective"])
@@ -1859,6 +1888,7 @@ def locate_pair_signal_model(name, path=None):
 
 	>>> locate_pair_signal_model("custom_model", path="/additional/models/")
 	'/additional/models/custom_model/'
+
 	"""
 
 
@@ -1937,6 +1967,7 @@ def relabel_segmentation(labels, df, exclude_nans=True, column_labels={'track':
 	... }
 	>>> new_labels = relabel_segmentation(labels, df, column_labels=column_labels, exclude_nans=True)
 	Done.
+
 	"""
 
 	n_threads = threads
@@ -2037,6 +2068,7 @@ def control_tracks(position, prefix="Aligned", population="target", relabel=True
 	Example
 	-------
 	>>> control_tracks("/path/to/data/position_1", prefix="Aligned", population="target", relabel=True, flush_memory=True, threads=4)
+	
 	"""
 	
 	if not position.endswith(os.sep):
@@ -2089,6 +2121,7 @@ def tracks_to_btrack(df, exclude_nans=False):
 	Example
 	-------
 	>>> data, properties, graph = tracks_to_btrack(df, exclude_nans=True)
+
 	"""
 
 	graph = {}
@@ -3310,7 +3343,7 @@ def load_frames(img_nums, stack_path, scale=None, normalize_input=True, dtype=fl
 	"""
 
 	try:
-		frames = skio.imread(stack_path, key=img_nums, plugin="tifffile")
+		frames = imageio.imread(stack_path, key=img_nums)
 	except Exception as e:
 		print(
 			f'Error in loading the frame {img_nums} {e}. Please check that the experiment channel information is consistent with the movie being read.')

celldetective/measure.py

@@ -86,14 +86,14 @@ def measure(stack=None, labels=None, trajectories=None, channel_names=None,
 	>>> stack = np.random.rand(10, 100, 100, 3)
 	>>> labels = np.random.randint(0, 2, (10, 100, 100))
 	>>> trajectories = pd.DataFrame({'TRACK_ID': [1, 2, 3], 'FRAME': [1, 1, 1],
-	...                              'POSITION_X': [10, 20, 30], 'POSITION_Y': [15, 25, 35]})
+	...							'POSITION_X': [10, 20, 30], 'POSITION_Y': [15, 25, 35]})
 	>>> channel_names = ['channel1', 'channel2', 'channel3']
 	>>> features = ['area', 'intensity_mean']
 	>>> intensity_measurement_radii = [5, 10]
 	>>> border_distances = 2
 	>>> measurements = measure(stack=stack, labels=labels, trajectories=trajectories, channel_names=channel_names,
-	...                        features=features, intensity_measurement_radii=intensity_measurement_radii,
-	...                        border_distances=border_distances)
+	...							features=features, intensity_measurement_radii=intensity_measurement_radii,
+	...							border_distances=border_distances)
 	# Perform measurements on the stack, labels, and trajectories, computing isotropic intensities and additional features.
 
 	"""
@@ -661,12 +661,12 @@ def measure_isotropic_intensity(positions, # Dataframe of cell positions @ t
 	Examples
 	--------
 	>>> positions = pd.DataFrame({'TRACK_ID': [1, 2, 3], 'FRAME': [1, 1, 1],
-	...                           'POSITION_X': [10, 20, 30], 'POSITION_Y': [15, 25, 35]})
+	...							'POSITION_X': [10, 20, 30], 'POSITION_Y': [15, 25, 35]})
 	>>> img = np.random.rand(100, 100, 3)
 	>>> channels = ['channel1', 'channel2', 'channel3']
 	>>> intensity_measurement_radii = 5
 	>>> positions = measure_isotropic_intensity(positions, img, channels=channels,
-	...                                         intensity_measurement_radii=intensity_measurement_radii)
+	...											intensity_measurement_radii=intensity_measurement_radii)
 	# Measure isotropic intensity values around cell positions in the image.
 
 	"""
@@ -813,45 +813,7 @@ def measure_at_position(pos, mode, return_measurements=False, threads=1):
 
 
 def local_normalisation(image, labels, background_intensity, measurement='intensity_median', operation='subtract', clip=False):
-	"""
-	 Perform local normalization on an image based on labels.
-
-	 Parameters:
-	 - image (numpy.ndarray): The input image.
-	 - labels (numpy.ndarray): An array specifying the labels for different regions in the image.
-	 - background_intensity (pandas.DataFrame): A DataFrame containing background intensity values
-												 corresponding to each label.
-	 - mode (str): The normalization mode ('Mean' or 'Median').
-	 - operation (str): The operation to perform ('Subtract' or 'Divide').
-
-	 Returns:
-	 - numpy.ndarray: The normalized image.
-
-	 This function performs local normalization on an image based on the provided labels. It iterates over
-	 each unique label, excluding the background label (0), and performs the specified operation with the
-	 background intensity values corresponding to that label. The background intensity values are obtained
-	 from the provided background_intensity DataFrame based on the normalization mode.
-
-	 If the operation is 'Subtract', the background intensity is subtracted from the image pixel values.
-	 If the operation is 'Divide', the image pixel values are divided by the background intensity.
-
-	 Example:
-	 >>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-	 >>> labels = np.array([[0, 1, 1], [2, 2, 3], [3, 3, 0]])
-	 >>> background_intensity = pd.DataFrame({'intensity_mean': [10, 20, 30]})
-	 >>> mode = 'Mean'
-	 >>> operation = 'Subtract'
-	 >>> result = local_normalisation(image, labels, background_intensity, mode, operation)
-	 >>> print(result)
-	 [[-9. -8. -7.]
-	  [14. 15.  6.]
-	  [27. 28.  9.]]
-
-	 Note:
-	 - The background intensity DataFrame should have columns named 'intensity_mean' or 'intensity_median'
-	   based on the mode specified.
-	 - The background intensity values should be provided in the same order as the labels.
-	 """
+	
 	
 	for index, cell in enumerate(np.unique(labels)):
 		if cell == 0:
@@ -869,42 +831,8 @@ def local_normalisation(image, labels, background_intensity, measurement='intens
 
 
 def normalise_by_cell(image, labels, distance=5, model='median', operation='subtract', clip=False):
-	"""
-	Normalize an image based on cell regions.
-
-	Parameters:
-	- image (numpy.ndarray): The input image.
-	- labels (numpy.ndarray): An array specifying the labels for different regions in the image.
-	- distance (float): The distance parameter for finding the contour of cell regions.
-	- mode (str): The normalization mode ('Mean' or 'Median').
-	- operation (str): The operation to perform ('Subtract' or 'Divide').
-
-	Returns:
-	- numpy.ndarray: The normalized image.
-
-	This function normalizes an image based on cell regions defined by the provided labels. It calculates
-	the border of cell regions using the contour_of_instance_segmentation function with the specified
-	distance parameter. Then, it computes the background intensity of each cell region based on the mode
-	('Mean' or 'Median'). Finally, it performs local normalization using the local_normalisation function
-	and returns the normalized image.
-
-	Example:
-	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-	>>> labels = np.array([[0, 1, 1], [2, 2, 3], [3, 3, 0]])
-	>>> distance = 2.0
-	>>> mode = 'Mean'
-	>>> operation = 'Subtract'
-	>>> result = normalise_by_cell(image, labels, distance, mode, operation)
-	>>> print(result)
-	[[-9. -8. -7.]
-	 [14. 15.  6.]
-	 [27. 28.  9.]]
-
-	Note:
-	- The contour of cell regions is calculated using the contour_of_instance_segmentation function.
-	- The background intensity is computed based on the specified mode ('Mean' or 'Median').
-	- The operation determines whether to subtract or divide the background intensity from the image.
-	"""
+
+
 	border = contour_of_instance_segmentation(label=labels, distance=distance * (-1))
 	if model == 'mean':
 		measurement = 'intensity_nanmean'
@@ -987,70 +915,6 @@ def blob_detection(image, label, diameter, threshold=0., channel_name=None, targ
 	return detections
 
 
-# def blob_detectionv0(image, label, threshold, diameter):
-# 	"""
-# 	Perform blob detection on an image based on labeled regions.
-
-# 	Parameters:
-# 	- image (numpy.ndarray): The input image data.
-# 	- label (numpy.ndarray): An array specifying labeled regions in the image.
-# 	- threshold (float): The threshold value for blob detection.
-# 	- diameter (float): The expected diameter of blobs.
-
-# 	Returns:
-# 	- dict: A dictionary containing information about detected blobs.
-
-# 	This function performs blob detection on an image based on labeled regions. It iterates over each labeled region
-# 	and detects blobs within the region using the Difference of Gaussians (DoG) method. Detected blobs are filtered
-# 	based on the specified threshold and expected diameter. The function returns a dictionary containing the number of
-# 	detected blobs and their mean intensity for each labeled region.
-
-# 	Example:
-# 	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-# 	>>> label = np.array([[0, 1, 1], [2, 2, 0], [3, 3, 0]])
-# 	>>> threshold = 0.1
-# 	>>> diameter = 5.0
-# 	>>> result = blob_detection(image, label, threshold, diameter)
-# 	>>> print(result)
-# 	{1: [1, 4.0], 2: [0, nan], 3: [0, nan]}
-
-# 	Note:
-# 	- Blobs are detected using the Difference of Gaussians (DoG) method.
-# 	- Detected blobs are filtered based on the specified threshold and expected diameter.
-# 	- The returned dictionary contains information about the number of detected blobs and their mean intensity
-# 	  for each labeled region.
-# 	"""
-# 	blob_labels = {}
-# 	dilated_image = ndimage.grey_dilation(label, footprint=disk(10))
-# 	for mask_index in np.unique(label):
-# 		if mask_index == 0:
-# 			continue
-# 		removed_background = image.copy()
-# 		one_mask = label.copy()
-# 		one_mask[np.where(label != mask_index)] = 0
-# 		dilated_copy = dilated_image.copy()
-# 		dilated_copy[np.where(dilated_image != mask_index)] = 0
-# 		removed_background[np.where(dilated_copy == 0)] = 0
-# 		min_sigma = (1 / (1 + math.sqrt(2))) * diameter
-# 		max_sigma = math.sqrt(2) * min_sigma
-# 		blobs = blob_dog(removed_background, threshold=threshold, min_sigma=min_sigma,
-# 										 max_sigma=max_sigma)
-
-# 		mask = np.array([one_mask[int(y), int(x)] != 0 for y, x, r in blobs])
-# 		if not np.any(mask):
-# 			continue
-# 		blobs_filtered = blobs[mask]
-# 		binary_blobs = np.zeros_like(label)
-# 		for blob in blobs_filtered:
-# 			y, x, r = blob
-# 			rr, cc = dsk((y, x), r, shape=binary_blobs.shape)
-# 			binary_blobs[rr, cc] = 1
-# 		spot_intensity = regionprops_table(binary_blobs, removed_background, ['intensity_mean'])
-# 		blob_labels[mask_index] = [blobs_filtered.shape[0], spot_intensity['intensity_mean'][0]]
-# 	return blob_labels
-
-### Classification ####
-
 def estimate_time(df, class_attr, model='step_function', class_of_interest=[2], r2_threshold=0.5):
 
 	"""
@@ -1178,6 +1042,7 @@ def interpret_track_classification(df, class_attr, irreversible_event=False, uni
 	Example
 	-------
 	>>> df = interpret_track_classification(df, 'class', irreversible_event=True, r2_threshold=0.7)
+
 	"""
 
 	cols = list(df.columns)
@@ -1325,6 +1190,7 @@ def classify_irreversible_events(data, class_attr, r2_threshold=0.5, percentile_
 	Example
 	-------
 	>>> df = classify_irreversible_events(df, 'class', r2_threshold=0.7)
+
 	"""
 
 	df = data.copy()
@@ -1426,6 +1292,7 @@ def classify_unique_states(df, class_attr, percentile=50, pre_event=None):
 	Example
 	-------
 	>>> df = classify_unique_states(df, 'class', percentile=75)
+
 	"""
 
 	cols = list(df.columns)
@@ -1521,6 +1388,7 @@ def classify_cells_from_query(df, status_attr, query):
 	------
 	Exception
 		If the query is invalid or if there are issues with the DataFrame or query syntax, an error message is printed, and `None` is returned.
+	
 	"""
 
 

celldetective/relative_measurements.py

@@ -129,14 +129,7 @@ def measure_pairs(pos, neighborhood_protocol):
 
 
 def measure_pair_signals_at_position(pos, neighborhood_protocol, velocity_kwargs={'window': 3, 'mode': 'bi'}):
-	"""
-	pos: position to process
-	target_classes [list]: target classes to keep
-	neigh_dist: neighborhood cut distance
-	theta_dist: distance to edge threshold
-	velocity_kwargs: params for derivative of relative position
-	neighborhood_kwargs: params for neigh
-	"""
+
 
 	reference_population = neighborhood_protocol['reference']
 	neighbor_population = neighborhood_protocol['neighbor']
@@ -422,12 +415,13 @@ def timeline_matching(timeline1, timeline2):
 	-------
 	tuple
 		A tuple containing:
-		- full_timeline : numpy.ndarray
-			The unified timeline spanning from the minimum to the maximum time point in the input timelines.
-		- index1 : list of int
-			The indices of `timeline1` in the `full_timeline`.
-		- index2 : list of int
-			The indices of `timeline2` in the `full_timeline`.
+
+			- full_timeline : numpy.ndarray
+				The unified timeline spanning from the minimum to the maximum time point in the input timelines.
+			- index1 : list of int
+				The indices of `timeline1` in the `full_timeline`.
+			- index2 : list of int
+				The indices of `timeline2` in the `full_timeline`.
 
 	Examples
 	--------
@@ -446,6 +440,7 @@ def timeline_matching(timeline1, timeline2):
 	- The function combines the two timelines and generates a continuous range from the minimum to the maximum time point.
 	- It then finds the indices of the original timelines in this unified timeline.
 	- The function assumes that the input timelines consist of integer values.
+
 	"""
 
 	min_t = np.amin(np.concatenate((timeline1, timeline2)))
@@ -550,16 +545,17 @@ def extract_neighborhoods_from_pickles(pos):
 	-------
 	list of dict
 		A list of dictionaries, each containing a neighborhood protocol. Each dictionary has the keys:
-		- 'reference' : str
-			The reference population ('targets' or 'effectors').
-		- 'neighbor' : str
-			The neighbor population.
-		- 'type' : str
-			The type of neighborhood ('circle' or 'contact').
-		- 'distance' : float
-			The distance parameter for the neighborhood.
-		- 'description' : str
-			The original neighborhood string.
+			
+			- 'reference' : str
+				The reference population ('targets' or 'effectors').
+			- 'neighbor' : str
+				The neighbor population.
+			- 'type' : str
+				The type of neighborhood ('circle' or 'contact').
+			- 'distance' : float
+				The distance parameter for the neighborhood.
+			- 'description' : str
+				The original neighborhood string.
 
 	Notes
 	-----
@@ -572,8 +568,9 @@ def extract_neighborhoods_from_pickles(pos):
 	--------
 	>>> protocols = extract_neighborhoods_from_pickles('/path/to/data')
 	>>> for protocol in protocols:
-	>>>     print(protocol)
+	>>>		print(protocol)
 	{'reference': 'targets', 'neighbor': 'targets', 'type': 'contact', 'distance': 5.0, 'description': 'neighborhood_self_contact_5_px'}
+	
 	"""
 
 	tab_tc = pos + os.sep.join(['output', 'tables', 'trajectories_targets.pkl'])
@@ -618,16 +615,17 @@ def extract_neighborhood_settings(neigh_string, population='targets'):
 	-------
 	dict
 		A dictionary containing the neighborhood protocol with keys:
-		- 'reference' : str
-			The reference population.
-		- 'neighbor' : str
-			The neighbor population.
-		- 'type' : str
-			The type of neighborhood ('circle' or 'contact').
-		- 'distance' : float
-			The distance parameter for the neighborhood.
-		- 'description' : str
-			The original neighborhood string.
+		
+			- 'reference' : str
+				The reference population.
+			- 'neighbor' : str
+				The neighbor population.
+			- 'type' : str
+				The type of neighborhood ('circle' or 'contact').
+			- 'distance' : float
+				The distance parameter for the neighborhood.
+			- 'description' : str
+				The original neighborhood string.
 
 	Raises
 	------
@@ -644,6 +642,7 @@ def extract_neighborhood_settings(neigh_string, population='targets'):
 	--------
 	>>> extract_neighborhood_settings('neighborhood_self_contact_5_px', 'targets')
 	{'reference': 'targets', 'neighbor': 'targets', 'type': 'contact', 'distance': 5.0, 'description': 'neighborhood_self_contact_5_px'}
+	
 	"""
 
 	assert neigh_string.startswith('neighborhood')
@@ -684,23 +683,20 @@ def expand_pair_table(data):
 	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.
+		DataFrame containing the pair table
 
 	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.
+		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 
+	- 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.
@@ -713,7 +709,8 @@ def expand_pair_table(data):
 	Raises
 	------
 	AssertionError
-		If 'reference_population' or 'neighbor_population' is not found in the columns of `data`.
+		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..."