celldetective 1.3.4.post1__py3-none-any.whl → 1.3.6.post1__py3-none-any.whl

celldetective/measure.py

@@ -24,6 +24,9 @@ import celldetective.extra_properties as extra_properties
 from celldetective.extra_properties import *
 from inspect import getmembers, isfunction
 from skimage.morphology import disk
+from scipy.signal import find_peaks, peak_widths
+
+from celldetective.segmentation import filter_image
 
 abs_path = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], 'celldetective'])
 
@@ -193,6 +196,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 +309,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]
@@ -326,7 +344,9 @@ def measure_features(img, label, features=['area', 'intensity_mean'], channels=N
 			for index, channel in enumerate(channels):
 				if channel == spot_detection['channel']:
 					ind = index
-					df_spots = blob_detection(img, label, diameter=spot_detection['diameter'],threshold=spot_detection['threshold'], channel_name=spot_detection['channel'], target_channel=ind)
+					if "image_preprocessing" not in spot_detection:
+						spot_detection.update({'image_preprocessing': None})
+					df_spots = blob_detection(img, label, diameter=spot_detection['diameter'],threshold=spot_detection['threshold'], channel_name=spot_detection['channel'], target_channel=ind, image_preprocessing=spot_detection['image_preprocessing'])
 		
 		if normalisation_list:
 			for norm in normalisation_list:
@@ -351,10 +371,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:
@@ -898,12 +924,15 @@ def normalise_by_cell(image, labels, distance=5, model='median', operation='subt
 	return normalised_frame
 
 
-def extract_blobs_in_image(image, label, diameter, threshold=0., method="log"):
+def extract_blobs_in_image(image, label, diameter, threshold=0., method="log", image_preprocessing=None):
 	
 	if np.percentile(image.flatten(),99.9)==0.0:
 		return None
 
-	dilated_image = ndimage.grey_dilation(label, footprint=disk(10))
+	if isinstance(image_preprocessing, (list, np.ndarray)):
+		image = filter_image(image.copy(),filters=image_preprocessing) # apply prefiltering to images before spot detection
+
+	dilated_image = ndimage.grey_dilation(label, footprint=disk(int(1.2*diameter))) # dilation larger than spot diameter to be safe
 
 	masked_image = image.copy()
 	masked_image[np.where((dilated_image == 0)|(image!=image))] = 0
@@ -912,7 +941,8 @@ def extract_blobs_in_image(image, label, diameter, threshold=0., method="log"):
 	if method=="dog":
 		blobs = blob_dog(masked_image, threshold=threshold, min_sigma=min_sigma, max_sigma=max_sigma, overlap=0.75)
 	elif method=="log":
-		blobs = blob_log(masked_image, threshold=threshold, min_sigma=min_sigma, max_sigma=max_sigma, overlap=0.75)		
+		blobs = blob_log(masked_image, threshold=threshold, min_sigma=min_sigma, max_sigma=max_sigma, overlap=0.75)
+
 	# Exclude spots outside of cell masks
 	mask = np.array([label[int(y), int(x)] != 0 for y, x, _ in blobs])
 	if np.any(mask):
@@ -923,14 +953,15 @@ def extract_blobs_in_image(image, label, diameter, threshold=0., method="log"):
 	return blobs_filtered
 
 
-def blob_detection(image, label, diameter, threshold=0., channel_name=None, target_channel=0, method="log"):
+def blob_detection(image, label, diameter, threshold=0., channel_name=None, target_channel=0, method="log", image_preprocessing=None):
 	
+
 	image = image[:, :, target_channel].copy()
 	if np.percentile(image.flatten(),99.9)==0.0:
 		return None
 
 	detections = []
-	blobs_filtered = extract_blobs_in_image(image, label, diameter, threshold=threshold)
+	blobs_filtered = extract_blobs_in_image(image, label, diameter, method=method, threshold=threshold, image_preprocessing=image_preprocessing)
 
 	for lbl in np.unique(label):
 		if lbl>0:
@@ -955,69 +986,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):
@@ -1105,7 +1073,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, transient_event=False, r2_threshold=0.5, percentile_recovery=50, pre_event=None):
 
 	"""
 	Interpret and classify tracked cells based on their status signals.
@@ -1164,15 +1132,87 @@ 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)
+
+	elif transient_event:
+
+		df = classify_transient_events(df, class_attr, pre_event=pre_event)
+
+	return df
+
+
+def classify_transient_events(data, class_attr, pre_event=None):
+
+	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']
+		df = df.sort_values(by=sort_cols+['FRAME'])
+	else:
+		sort_cols = ['TRACK_ID']
+		df = df.sort_values(by=sort_cols+['FRAME'])
+	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):
+
+		indices = track[class_attr].index
+
+		if pre_event is not None:
+			
+			if track['class_'+pre_event].values[0]==1:
+				df.loc[indices, class_attr] = np.nan
+				df.loc[indices, stat_col] = np.nan
+				continue
+			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
+		
+		status = track[stat_col].to_numpy()
+		timeline = track['FRAME'].to_numpy()
+		timeline_safe = timeline[status==status]
+		status_safe = list(status[status==status])
+
+		peaks, _ = find_peaks(status_safe)
+		widths, _, left, right = peak_widths(status_safe, peaks, rel_height=1)
+		minimum_weight = 0
+
+		if len(peaks)>0:
+			idx = np.argmax(widths)
+			peak = peaks[idx]; width = widths[idx]; 
+			if width >= minimum_weight:
+				left = left[idx]; right = right[idx];
+				left = timeline_safe[int(left)]; right = timeline_safe[int(right)];
+				
+				df.loc[indices, class_attr] = 0
+				df.loc[indices, class_attr.replace('class_','t_')] = left + (right - left)/2.0
+			else:
+				df.loc[indices, class_attr] = 1
+				df.loc[indices, class_attr.replace('class_','t_')] = -1				
+		else:
+			df.loc[indices, class_attr] = 1
+			df.loc[indices, class_attr.replace('class_','t_')] = -1
+
+		
+	print("Classes: ",df.loc[df['FRAME']==0,class_attr].value_counts())
 
 	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 +1250,62 @@ 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):
-		
-		# 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
+
+		if pre_event is not None:
+			if track['class_'+pre_event].values[0]==1:
+				df.loc[indices, class_attr] = np.nan
+				df.loc[indices, stat_col] = np.nan
+				continue
+			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
+		else:
+			# set state to 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
+		
+		# 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, no event
+			# 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
+			# all positive, event already observed (left-censored)
 			df.loc[indices, class_attr] = 2
-			#df.loc[indices, class_attr.replace('class','status')] = 2
 		else:
-			# ambiguity, possible transition
+			# ambiguity, possible transition, use `unique_state` technique after
 			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 +1314,8 @@ 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,19 +1358,31 @@ 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..."
 
-	for tid,track in df.groupby(sort_cols):
-
-
-		track_valid = track.dropna(subset=stat_col)
-		indices_valid = track_valid[class_attr].index
+	stat_col = class_attr.replace('class','status')
+	
+	for tid, track in df.groupby(sort_cols):
 
 		indices = track[class_attr].index
-		status_values = track_valid[stat_col].to_numpy()
 
+		if pre_event is not None:
+			if track['class_'+pre_event].values[0]==1:
+				df.loc[indices, class_attr] = np.nan
+				df.loc[indices, stat_col] = np.nan
+				df.loc[indices, stat_col.replace('status_','t_')] = -1
+				continue
+			else:
+				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()
 		t_first = track['t_firstdetection'].to_numpy()[0]
 		perc_status = np.nanpercentile(status_values[frames>=t_first], percentile)
@@ -1383,8 +1453,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/scripts/track_cells.py

@@ -97,6 +97,18 @@ if os.path.exists(instr_path):
 		post_processing_options = instructions['post_processing_options']
 	else:
 		post_processing_options = None
+
+	btrack_option = True
+	if 'btrack_option' in instructions:
+		btrack_option = instructions['btrack_option']
+	search_range = None
+	if 'search_range' in instructions:
+		search_range = instructions['search_range']
+	memory = None
+	if 'memory' in instructions:
+		memory = instructions['memory']
+
+
 else:
 	print('Tracking instructions could not be located... Using a standard bTrack motion model instead...')
 	btrack_config = interpret_tracking_configuration(None)
@@ -104,7 +116,9 @@ else:
 	mask_channels = None
 	haralick_options = None
 	post_processing_options = None
-
+	btrack_option = True
+	memory = None
+	search_range = None
 if features is None:
 	features = []
 
@@ -147,6 +161,13 @@ with open(pos+f'log_{mode}.json', 'a') as f:
 	f.write(f'{datetime.datetime.now()} TRACK \n')
 	f.write(log+"\n")
 
+
+if not btrack_option:
+	features = []
+	channel_names = None
+	haralick_options = None
+
+
 def measure_index(indices):
 	for t in tqdm(indices,desc="frame"):
 		
@@ -203,6 +224,9 @@ trajectories, napari_data = track(None,
 		  			track_kwargs={'step_size': 100}, 
 		  			clean_trajectories_kwargs=post_processing_options, 
 		  			volume=(shape_x, shape_y),
+		  			btrack_option=btrack_option, 
+		  			search_range=search_range,
+		  			memory=memory,
 		  			)
 
 # out trajectory table, create POSITION_X_um, POSITION_Y_um, TIME_min (new ones)

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)