celldetective 1.3.4.post1__py3-none-any.whl → 1.3.5__py3-none-any.whl

celldetective/measure.py

@@ -193,6 +193,12 @@ def measure(stack=None, labels=None, trajectories=None, channel_names=None,
 		elif do_features*(trajectories is None):
 			measurements_at_t = positions_at_t
 
+		try:
+			measurements_at_t['radial_distance'] = np.sqrt((measurements_at_t[column_labels['x']] - img.shape[0] / 2) ** 2 + (
+					measurements_at_t[column_labels['y']] - img.shape[1] / 2) ** 2)
+		except Exception as e:
+			print(f"{e=}")
+
 		timestep_dataframes.append(measurements_at_t)
 
 	measurements = pd.concat(timestep_dataframes)
@@ -300,19 +306,28 @@ def measure_features(img, label, features=['area', 'intensity_mean'], channels=N
 
 	"""
 
+	if isinstance(features, list):
+		features = features.copy()
+		
 	if features is None:
 		features = []
 
-	# Add label to have identity of mask
-	if 'label' not in features:
-		features.append('label')
-
+	measure_mean_intensities = False
 	if img is None:
 		if verbose:
 			print('No image was provided... Skip intensity measurements.')
 		border_dist = None;
 		haralick_options = None;
 		features = drop_tonal_features(features)
+
+	if 'intensity_mean' in features:
+		measure_mean_intensities = True
+		features.remove('intensity_mean')
+
+	# Add label to have identity of mask
+	if 'label' not in features:
+		features.append('label')
+
 	if img is not None:
 		if img.ndim == 2:
 			img = img[:, :, np.newaxis]
@@ -351,10 +366,16 @@ def measure_features(img, label, features=['area', 'intensity_mean'], channels=N
 		if f in extra_props:
 			feats.remove(f)
 			extra_props_list.append(getattr(extra_properties, f))
+
+	# Add intensity nan mean if need to measure mean intensities
+	if measure_mean_intensities:
+		extra_props_list.append(getattr(extra_properties, 'intensity_nanmean'))
+
 	if len(extra_props_list) == 0:
 		extra_props_list = None
 	else:
 		extra_props_list = tuple(extra_props_list)
+
 	props = regionprops_table(label, intensity_image=img, properties=feats, extra_properties=extra_props_list)
 	df_props = pd.DataFrame(props)
 	if spot_detection is not None:
@@ -1105,7 +1126,7 @@ def estimate_time(df, class_attr, model='step_function', class_of_interest=[2],
 	return df
 
 
-def interpret_track_classification(df, class_attr, irreversible_event=False, unique_state=False,r2_threshold=0.5, percentile_recovery=50):
+def interpret_track_classification(df, class_attr, irreversible_event=False, unique_state=False,r2_threshold=0.5, percentile_recovery=50, pre_event=None):
 
 	"""
 	Interpret and classify tracked cells based on their status signals.
@@ -1164,15 +1185,15 @@ def interpret_track_classification(df, class_attr, irreversible_event=False, uni
 
 	if irreversible_event:
 
-		df = classify_irreversible_events(df, class_attr, r2_threshold=r2_threshold, percentile_recovery=percentile_recovery)
+		df = classify_irreversible_events(df, class_attr, r2_threshold=r2_threshold, percentile_recovery=percentile_recovery, pre_event=pre_event)
 	
 	elif unique_state:
 		
-		df = classify_unique_states(df, class_attr, percentile=50)
+		df = classify_unique_states(df, class_attr, percentile=50, pre_event=pre_event)
 
 	return df
 
-def classify_irreversible_events(df, class_attr, r2_threshold=0.5, percentile_recovery=50):
+def classify_irreversible_events(data, class_attr, r2_threshold=0.5, percentile_recovery=50, pre_event=None):
 
 	"""
 	Classify irreversible events in a tracked dataset based on the status of cells and transitions.
@@ -1210,45 +1231,83 @@ def classify_irreversible_events(df, class_attr, r2_threshold=0.5, percentile_re
 	>>> df = classify_irreversible_events(df, 'class', r2_threshold=0.7)
 	"""
 
+	df = data.copy()
 	cols = list(df.columns)
+
+	# Control input
 	assert 'TRACK_ID' in cols,'Please provide tracked data...'
 	if 'position' in cols:
 		sort_cols = ['position', 'TRACK_ID']
 	else:
 		sort_cols = ['TRACK_ID']
+	if pre_event is not None:
+		assert 't_'+pre_event in cols,"Pre-event time does not seem to be a valid column in the DataFrame..."
+		assert 'class_'+pre_event in cols,"Pre-event class does not seem to be a valid column in the DataFrame..."
 
 	stat_col = class_attr.replace('class','status')
 
-	for tid,track in df.groupby(sort_cols):
+	if pre_event is not None:
+		
+		# Version with pre event; intuition: mask status value before pre-event takes place with NaN
+		for tid, track in df.groupby(sort_cols):
+			
+			indices = track[class_attr].index
+
+			if track['class_'+pre_event].values[0]==1:
+				# Pre-event never took place, all NaN
+				df.loc[indices, class_attr] = np.nan
+				df.loc[indices, stat_col] = np.nan
+			else:
+				# pre-event took place (if left-censored took place at time -1)
+				t_pre_event = track['t_'+pre_event].values[0]
+				indices_pre = track.loc[track['FRAME']<=t_pre_event,class_attr].index
+				df.loc[indices_pre, stat_col] = np.nan # set to NaN all statuses before pre-event
+				track.loc[track['FRAME']<=t_pre_event, stat_col] = np.nan
+
+				# The non-NaN part of track (post pre-event)
+				track_valid = track.dropna(subset=stat_col, inplace=False)
+				status_values = track_valid[stat_col].to_numpy()
+
+				if np.all([s==0 for s in status_values]):
+					# all negative to condition, event not observed
+					df.loc[indices, class_attr] = 1
+				elif np.all([s==1 for s in status_values]):
+					# all positive, event already observed (left-censored)
+					df.loc[indices, class_attr] = 2
+				else:
+					# ambiguity, possible transition, use `unique_state` technique after
+					df.loc[indices, class_attr] = 2
+	else:
+		for tid,track in df.groupby(sort_cols):
+			
+			# Set status to 0.0 before first detection
+			t_firstdetection = track['t_firstdetection'].values[0]
+			indices_pre_detection = track.loc[track['FRAME']<=t_firstdetection,class_attr].index
+			track.loc[indices_pre_detection,stat_col] = 0.0
+			df.loc[indices_pre_detection,stat_col] = 0.0
+
+			track_valid = track.dropna(subset=stat_col)
+
+			indices = track[class_attr].index
+			status_values = track_valid[stat_col].to_numpy()
+
+			if np.all([s==0 for s in status_values]):
+				# all negative, no event
+				df.loc[indices, class_attr] = 1
+
+			elif np.all([s==1 for s in status_values]):
+				# all positive, event already observed
+				df.loc[indices, class_attr] = 2
+				#df.loc[indices, class_attr.replace('class','status')] = 2
+			else:
+				# ambiguity, possible transition
+				df.loc[indices, class_attr] = 2
 		
-		# Set status to 0.0 before first detection
-		t_firstdetection = track['t_firstdetection'].values[0]
-		indices_pre_detection = track.loc[track['FRAME']<=t_firstdetection,class_attr].index
-		track.loc[indices_pre_detection,stat_col] = 0.0
-		df.loc[indices_pre_detection,stat_col] = 0.0
-
-		track_valid = track.dropna(subset=stat_col)
-		indices_valid = track_valid[class_attr].index
-
-		indices = track[class_attr].index
-		status_values = track_valid[stat_col].to_numpy()
-
-		if np.all([s==0 for s in status_values]):
-			# all negative, no event
-			df.loc[indices, class_attr] = 1
-
-		elif np.all([s==1 for s in status_values]):
-			# all positive, event already observed
-			df.loc[indices, class_attr] = 2
-			#df.loc[indices, class_attr.replace('class','status')] = 2
-		else:
-			# ambiguity, possible transition
-			df.loc[indices, class_attr] = 2
-	
 	print("Classes after initial pass: ",df.loc[df['FRAME']==0,class_attr].value_counts())
 
 	df.loc[df[class_attr]!=2, class_attr.replace('class', 't')] = -1
-	df = estimate_time(df, class_attr, model='step_function', class_of_interest=[2],r2_threshold=r2_threshold)
+	# Try to fit time on class 2 cells (ambiguous)
+	df = estimate_time(df, class_attr, model='step_function', class_of_interest=[2], r2_threshold=r2_threshold)
 	print("Classes after fit: ", df.loc[df['FRAME']==0,class_attr].value_counts())
 
 	# Revisit class 2 cells to classify as neg/pos with percentile tolerance
@@ -1257,7 +1316,7 @@ def classify_irreversible_events(df, class_attr, r2_threshold=0.5, percentile_re
 	
 	return df
 
-def classify_unique_states(df, class_attr, percentile=50):
+def classify_unique_states(df, class_attr, percentile=50, pre_event=None):
 
 	"""
 	Classify unique cell states based on percentile values of a status attribute in a tracked dataset.
@@ -1300,31 +1359,67 @@ def classify_unique_states(df, class_attr, percentile=50):
 	else:
 		sort_cols = ['TRACK_ID']
 
-	stat_col = class_attr.replace('class','status')
+	if pre_event is not None:
+		assert 't_'+pre_event in cols,"Pre-event time does not seem to be a valid column in the DataFrame..."
+		assert 'class_'+pre_event in cols,"Pre-event class does not seem to be a valid column in the DataFrame..."
 
+	stat_col = class_attr.replace('class','status')
 
-	for tid,track in df.groupby(sort_cols):
+	if pre_event is not None:
 
+		for tid, track in df.groupby(sort_cols):
+			
+			indices = track[class_attr].index
 
-		track_valid = track.dropna(subset=stat_col)
-		indices_valid = track_valid[class_attr].index
+			if track['class_'+pre_event].values[0]==1:
+				# then pre event not satisfied, class/status is NaN
+				df.loc[indices, class_attr] = np.nan
+				df.loc[indices, stat_col] = np.nan
+				df.loc[indices, stat_col.replace('status_','t_')] = -1
+			else:
+				# Pre event might happen, set to NaN observations before pre event
+				t_pre_event = track['t_'+pre_event].values[0]
+				indices_pre = track.loc[track['FRAME']<=t_pre_event,class_attr].index
+				df.loc[indices_pre, stat_col] = np.nan
+				track.loc[track['FRAME']<=t_pre_event, stat_col] = np.nan
+
+				# Post pre-event track
+				track_valid = track.dropna(subset=stat_col, inplace=False)
+				status_values = track_valid[stat_col].to_numpy()
+
+				frames = track_valid['FRAME'].to_numpy() # from t_pre-event to T
+				t_first = track['t_firstdetection'].to_numpy()[0]
+				perc_status = np.nanpercentile(status_values[frames>=t_first], percentile)
+				
+				if perc_status==perc_status:
+					c = ceil(perc_status)
+					if c==0:
+						df.loc[indices, class_attr] = 1
+						df.loc[indices, class_attr.replace('class','t')] = -1
+					elif c==1:
+						df.loc[indices, class_attr] = 2
+						df.loc[indices, class_attr.replace('class','t')] = -1
+	else:
+		for tid,track in df.groupby(sort_cols):
 
-		indices = track[class_attr].index
-		status_values = track_valid[stat_col].to_numpy()
+			track_valid = track.dropna(subset=stat_col)
+			indices_valid = track_valid[class_attr].index
 
+			indices = track[class_attr].index
+			status_values = track_valid[stat_col].to_numpy()
 
-		frames = track_valid['FRAME'].to_numpy()
-		t_first = track['t_firstdetection'].to_numpy()[0]
-		perc_status = np.nanpercentile(status_values[frames>=t_first], percentile)
-		
-		if perc_status==perc_status:
-			c = ceil(perc_status)
-			if c==0:
-				df.loc[indices, class_attr] = 1
-				df.loc[indices, class_attr.replace('class','t')] = -1
-			elif c==1:
-				df.loc[indices, class_attr] = 2
-				df.loc[indices, class_attr.replace('class','t')] = -1
+			frames = track_valid['FRAME'].to_numpy()
+			t_first = track['t_firstdetection'].to_numpy()[0]
+			perc_status = np.nanpercentile(status_values[frames>=t_first], percentile)
+			
+			if perc_status==perc_status:
+				c = ceil(perc_status)
+				if c==0:
+					df.loc[indices, class_attr] = 1
+					df.loc[indices, class_attr.replace('class','t')] = -1
+				elif c==1:
+					df.loc[indices, class_attr] = 2
+					df.loc[indices, class_attr.replace('class','t')] = -1
 	return df
 
 def classify_cells_from_query(df, status_attr, query):
@@ -1383,8 +1478,11 @@ def classify_cells_from_query(df, status_attr, query):
 
 	df = df.copy()
 	df.loc[:,status_attr] = 0
+	df[status_attr] = df[status_attr].astype(float)
 
 	cols = extract_cols_from_query(query)
+	print(f"{cols=}")
+
 	cols_in_df = np.all([c in list(df.columns) for c in cols], axis=0)
 	if query=='':
 		print('The provided query is empty...')

celldetective/preprocessing.py

@@ -894,7 +894,7 @@ def fit_and_apply_model_background_to_stack(stack_path,
 		else:
 			newfile = '_'.join([prefix,file])
 		
-		with tiff.TiffWriter(os.sep.join([path,newfile]),imagej=True) as tif:
+		with tiff.TiffWriter(os.sep.join([path,newfile]), imagej=True, bigtiff=True) as tif:
 
 			for i in tqdm(range(0,int(stack_length*nbr_channels),nbr_channels)):
 				
@@ -1156,7 +1156,7 @@ def correct_channel_offset_single_stack(stack_path,
 		else:
 			newfile = '_'.join([prefix,file])
 		
-		with tiff.TiffWriter(os.sep.join([path,newfile]),imagej=True) as tif:
+		with tiff.TiffWriter(os.sep.join([path,newfile]),bigtiff=True,imagej=True) as tif:
 
 			for i in tqdm(range(0,int(stack_length*nbr_channels),nbr_channels)):
 				

celldetective/relative_measurements.py

@@ -128,10 +128,6 @@ 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
@@ -340,9 +336,10 @@ def measure_pair_signals_at_position(pos, neighborhood_protocol, velocity_kwargs
 				cum_sum = 0
 				for t in range(len(full_timeline)):
 
-					if t in timeline_reference: # meaning position exists on both sides
+					if t in timeline_reference and t in timeline_neighbor: # meaning position exists on both sides
 
 						idx_reference = list(timeline_reference).index(t)
+						idx_neighbor = list(timeline_neighbor).index(t)
 						inter = intersection_values.loc[(intersection_values['neigh_id']==nc)&(intersection_values["frame"]==t),"intersection"].values
 						if len(inter)==0:
 							inter = np.nan
@@ -350,12 +347,12 @@ def measure_pair_signals_at_position(pos, neighborhood_protocol, velocity_kwargs
 							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]
+						if inter==inter and neigh_area[idx_neighbor]==neigh_area[idx_neighbor]:
+							neigh_inter_fraction = inter / neigh_area[idx_neighbor]
 
 						ref_inter_fraction = np.nan
-						if inter==inter and ref_area[t]==ref_area[t]:
-							ref_inter_fraction = inter / ref_area[t]						
+						if inter==inter and ref_area[idx_reference]==ref_area[idx_reference]:
+							ref_inter_fraction = inter / ref_area[idx_reference]						
 
 						if nc in neighbor_ids_per_t[idx_reference]:
 

celldetective/scripts/measure_cells.py

@@ -259,13 +259,13 @@ def measure_index(indices):
 								 'y': column_labels['y']}
 			feature_table.rename(columns={'centroid-1': 'POSITION_X', 'centroid-0': 'POSITION_Y'}, inplace=True)
 		
-		if do_iso_intensities:
+		if do_iso_intensities and not trajectories is None:
 			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:
+		if do_iso_intensities and do_features and not trajectories is None:
 			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):
+		elif do_iso_intensities * (not do_features) * (not trajectories is None):
 			measurements_at_t = iso_table
 		elif do_features:
 			measurements_at_t = positions_at_t.merge(feature_table, how='outer', on='class_id',suffixes=('_delme', ''))
@@ -279,6 +279,12 @@ def measure_index(indices):
 			measurements_at_t.loc[:,c.replace('_y','_POSITION_Y')] = measurements_at_t[c] + measurements_at_t['POSITION_Y']
 		measurements_at_t = measurements_at_t.drop(columns = center_of_mass_x_cols+center_of_mass_y_cols)
 		
+		try:
+			measurements_at_t['radial_distance'] = np.sqrt((measurements_at_t[column_labels['x']] - img.shape[0] / 2) ** 2 + (
+					measurements_at_t[column_labels['y']] - img.shape[1] / 2) ** 2)
+		except Exception as e:
+			print(f"{e=}")
+
 		if measurements_at_t is not None:
 			measurements_at_t[column_labels['time']] = t
 			timestep_dataframes.append(measurements_at_t)
@@ -308,6 +314,10 @@ if len(timestep_dataframes)>0:
 		df['ID'] = np.arange(len(df))
 
 	df = df.reset_index(drop=True)
+	
+	invalid_cols = [c for c in list(df.columns) if c.startswith('Unnamed')]
+	if len(invalid_cols)>0:
+		df = df.drop(invalid_cols, axis=1)	
 
 	df.to_csv(pos+os.sep.join(["output", "tables", table_name]), index=False)
 	print(f'Measurements successfully written in table {pos+os.sep.join(["output", "tables", table_name])}')

celldetective/scripts/segment_cells.py

@@ -47,7 +47,6 @@ else:
 
 if not use_gpu:
 	os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
-n_threads = int(process_arguments['threads'])
 
 modelname = str(process_arguments['model'])
 

celldetective/signals.py

@@ -167,12 +167,13 @@ def analyze_signals(trajectories, model, interpolate_na=True,
 	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 = 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])
+			priority_cols = [a for a in available_signals if a==s]
+			second_priority_cols = [a for a in available_signals if a.startswith(s) and a!=s]
+			third_priority_cols = [a for a in available_signals if s in a and not a.startswith(s)]
+			candidates = priority_cols + second_priority_cols + third_priority_cols
+			assert len(candidates)>0,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.'
+			print(f"Selecting the first time series among: {candidates} for input requirement {s}...")
+			selected_signals.append(candidates[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.'
 
@@ -878,6 +879,7 @@ class SignalDetectionModel(object):
 
 		assert self.model_class.layers[0].input_shape[0] == self.model_reg.layers[0].input_shape[0], f"mismatch between input shape of classification: {self.model_class.layers[0].input_shape[0]} and regression {self.model_reg.layers[0].input_shape[0]} models... Error."
 
+
 		return True
 
 	def create_models_from_scratch(self):
@@ -3143,4 +3145,4 @@ if __name__ == "__main__":
 	model = ResNetModelCurrent(1, 2, depth=2, use_pooling=True, n_classes = 3, dropout_rate=0.1, dense_collection=512,
 					   header="classifier", model_signal_length = 128)
 	print(model.summary())
-	#plot_model(model, to_file='test.png', show_shapes=True)
+	#plot_model(model, to_file='test.png', show_shapes=True)

celldetective/tracking.py

@@ -8,7 +8,7 @@ from btrack import BayesianTracker
 
 from celldetective.measure import measure_features
 from celldetective.utils import rename_intensity_column, velocity_per_track
-from celldetective.io import view_on_napari_btrack, interpret_tracking_configuration
+from celldetective.io import interpret_tracking_configuration
 
 import os
 import subprocess
@@ -160,15 +160,19 @@ def track(labels, configuration=None, stack=None, spatial_calibration=1, feature
 	if channel_names is not None:
 		df = rename_intensity_column(df, channel_names)
 
-	df = write_first_detection_class(df, column_labels=column_labels)
+	df = write_first_detection_class(df, img_shape=volume, column_labels=column_labels)
 
 	if clean_trajectories_kwargs is not None:
 		df = clean_trajectories(df.copy(),**clean_trajectories_kwargs)
 
 	df['ID'] = np.arange(len(df)).astype(int)
 
-	if view_on_napari:
-		view_on_napari_btrack(data,properties,graph,stack=stack,labels=labels,relabel=True)
+	invalid_cols = [c for c in list(df.columns) if c.startswith('Unnamed')]
+	if len(invalid_cols)>0:
+		df = df.drop(invalid_cols, axis=1)	
+
+	# if view_on_napari:
+	# 	view_on_napari_btrack(data,properties,graph,stack=stack,labels=labels,relabel=True)
 
 	if return_napari_data:
 		napari_data = {"data": data, "properties": properties, "graph": graph}
@@ -921,44 +925,58 @@ def track_at_position(pos, mode, return_tracks=False, view_on_napari=False, thre
 	# # else:
 	# return None
 
-def write_first_detection_class(tab, column_labels={'track': "TRACK_ID", 'time': 'FRAME', 'x': 'POSITION_X', 'y': 'POSITION_Y'}):
+def write_first_detection_class(df, img_shape=None, edge_threshold=20, column_labels={'track': "TRACK_ID", 'time': 'FRAME', 'x': 'POSITION_X', 'y': 'POSITION_Y'}):
 	
 	"""
-	Annotates a dataframe with the time of the first detection and classifies tracks based on their detection status.
+	Assigns a classification and first detection time to tracks in the given DataFrame. This function must be called
+	before any track post-processing.
 
-	This function processes a dataframe containing tracking data, identifying the first point of detection for each
-	track based on the x-coordinate values. It annotates the dataframe with the time of the first detection and
-	assigns a class to each track indicating whether the first detection occurs at the start, during, or if there's
-	no detection within the tracking data.
+	This function computes the first detection time and a detection class (`class_firstdetection`) for each track in the data. 
+	Tracks that start on or near the image edge, or those detected at the initial frame, are marked with special classes.
 
 	Parameters
 	----------
-	tab : pandas.DataFrame
-		The dataframe containing tracking data, expected to have columns for track ID, time, and spatial coordinates.
+	df : pandas.DataFrame
+		A DataFrame containing track data. Expected to have at least the columns specified in `column_labels` and `class_id` (mask value).
+
+	img_shape : tuple of int, optional
+		The shape of the image as `(height, width)`. Used to determine whether the first detection occurs near the image edge.
+
+	edge_threshold : int, optional, default=20
+		The distance in pixels from the image edge to consider a detection as near the edge.
+
 	column_labels : dict, optional
-		A dictionary mapping standard column names ('track', 'time', 'x', 'y') to the corresponding column names in
-		`tab`. Default column names are 'TRACK_ID', 'FRAME', 'POSITION_X', 'POSITION_Y'.
+		A dictionary mapping logical column names to actual column names in `tab`. Keys include:
+		- `'track'`: The column indicating the track ID (default: `"TRACK_ID"`).
+		- `'time'`: The column indicating the frame/time (default: `"FRAME"`).
+		- `'x'`: The column indicating the X-coordinate (default: `"POSITION_X"`).
+		- `'y'`: The column indicating the Y-coordinate (default: `"POSITION_Y"`).
 
 	Returns
 	-------
 	pandas.DataFrame
-		The input dataframe `tab` with two additional columns: 'class_firstdetection' indicating the detection class,
-		and 't_firstdetection' indicating the time of the first detection.
+		The input DataFrame `df` with two additional columns:
+		- `'class_firstdetection'`: A class assigned based on detection status:
+			- `0`: Valid detection not near the edge and not at the initial frame.
+			- `2`: Detection near the edge, at the initial frame, or no detection available.
+		- `'t_firstdetection'`: The adjusted first detection time (in frame units):
+			- `-1`: Indicates no valid detection or detection near the edge.
+			- A float value representing the adjusted first detection time otherwise.
 
 	Notes
 	-----
-	- Detection is based on the presence of non-NaN values in the 'x' column for each track.
-	- Tracks with their first detection at the first time point are classified differently (`cclass=2`) and assigned
-	  a `t_first` of -1, indicating no prior detection.
-	- The function assumes uniform time steps between each frame in the tracking data.
-
+	- The function assumes that tracks are grouped and sorted by track ID and frame.
+	- Detections near the edge or at the initial frame (frame 0) are considered invalid and assigned special values.
+	- If `img_shape` is not provided, edge checks are skipped.
 	"""
 
-	tab = tab.sort_values(by=[column_labels['track'],column_labels['time']])
-	for tid,track_group in tab.groupby(column_labels['track']):
+	df = df.sort_values(by=[column_labels['track'],column_labels['time']])
+	for tid,track_group in df.groupby(column_labels['track']):
 		indices = track_group.index
-		detection = track_group[column_labels['x']].values
+		detection = track_group['class_id'].values
 		timeline = track_group[column_labels['time']].values
+		positions_x = track_group[column_labels['x']].values
+		positions_y = track_group[column_labels['y']].values
 		dt = 1
 		
 		# Initialize
@@ -966,8 +984,14 @@ def write_first_detection_class(tab, column_labels={'track': "TRACK_ID", 'time':
 
 		if np.any(detection==detection):
 			t_first = timeline[detection==detection][0]
+			x_first = positions_x[detection==detection][0]; y_first = positions_y[detection==detection][0];
+
+			edge_test = False
+			if img_shape is not None:
+				edge_test = (x_first < edge_threshold) or (y_first < edge_threshold) or (y_first > (img_shape[0] - edge_threshold)) or (x_first > (img_shape[1] - edge_threshold))
+
 			cclass = 0
-			if t_first<=0:
+			if t_first<=0 or edge_test:
 				t_first = -1
 				cclass = 2
 			else:
@@ -978,10 +1002,10 @@ def write_first_detection_class(tab, column_labels={'track': "TRACK_ID", 'time':
 			t_first = -1
 			cclass = 2
 
-		tab.loc[indices, 'class_firstdetection'] = cclass
-		tab.loc[indices, 't_firstdetection'] = t_first
+		df.loc[indices, 'class_firstdetection'] = cclass
+		df.loc[indices, 't_firstdetection'] = t_first
 
-	return tab
+	return df
 
 
 

celldetective/utils.py

@@ -30,6 +30,15 @@ from skimage.morphology import disk
 from scipy.stats import ks_2samp
 from cliffs_delta import cliffs_delta
 
+
+def extract_cols_from_table_list(tables, nrows=1):
+	all_columns = []
+	for tab in tables:
+		cols = pd.read_csv(tab, nrows=1).columns.tolist()
+		all_columns.extend(cols)
+	all_columns = np.unique(all_columns)
+	return all_columns
+
 def safe_log(array):
 
 	if isinstance(array,int) or isinstance(array,float):
@@ -547,8 +556,14 @@ def extract_cols_from_query(query: str):
 			# Add the name to the globals dictionary with a dummy value.
 			variables[name] = None
 
-	return list(variables.keys())
+	# Reverse mangling for special characters in column names.
+	def demangle_column_name(name):
+		if name.startswith("BACKTICK_QUOTED_STRING_"):
+			# Unquote backtick-quoted string.
+			return name[len("BACKTICK_QUOTED_STRING_"):].replace("_DOT_", ".").replace("_SLASH_", "/")
+		return name
 
+	return [demangle_column_name(name) for name in variables.keys()]
 
 def create_patch_mask(h, w, center=None, radius=None):
 
@@ -646,15 +661,14 @@ def rename_intensity_column(df, channels):
 	channel_names = np.array(channels)
 	channel_indices = np.arange(len(channel_names),dtype=int)
 
-	if np.any(['intensity' in c for c in df.columns]):
+	if np.any(['intensity' in c for c in list(df.columns)]):
 
 		intensity_indices = [s.startswith('intensity') for s in df.columns]
 		intensity_columns = df.columns[intensity_indices]
 
-		if len(channel_names) > 1:
+		if len(channel_names) >= 1:
 			to_rename = {}
 			for k in range(len(intensity_columns)):
-				#print(intensity_columns[k])
 
 				sections = np.array(re.split('-|_', intensity_columns[k]))
 				test_digit = np.array([s.isdigit() for s in sections])
@@ -664,7 +678,11 @@ def rename_intensity_column(df, channels):
 				new_name = np.delete(sections, np.where(test_digit)[0]) #np.where(test_digit)[0]
 				new_name = '_'.join(list(new_name))
 				new_name = new_name.replace('intensity', channel_name)
-				to_rename.update({intensity_columns[k]: new_name.replace('-','_')})
+				new_name = new_name.replace('-','_')
+				new_name = new_name.replace('_nanmean','_mean')
+
+				to_rename.update({intensity_columns[k]: new_name})
+
 				if 'centre' in intensity_columns[k]:
 					# sections = np.array(re.split('-|_', intensity_columns[k]))
 					measure = np.array(re.split('-|_', new_name))