celldetective 1.3.5__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'])
 
@@ -341,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:
@@ -919,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
@@ -933,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):
@@ -944,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:
@@ -976,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):
@@ -1126,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, pre_event=None):
+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.
@@ -1191,8 +1138,80 @@ def interpret_track_classification(df, class_attr, irreversible_event=False, uni
 		
 		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(data, class_attr, r2_threshold=0.5, percentile_recovery=50, pre_event=None):
 
 	"""
@@ -1246,62 +1265,41 @@ def classify_irreversible_events(data, class_attr, r2_threshold=0.5, percentile_
 
 	stat_col = class_attr.replace('class','status')
 
-	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
+	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:
-				# Pre-event never took place, all NaN
 				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
-
-				# 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
+		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
-
-			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
+		
+		# 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
 		
 	print("Classes after initial pass: ",df.loc[df['FRAME']==0,class_attr].value_counts())
 
@@ -1316,6 +1314,7 @@ def classify_irreversible_events(data, class_attr, r2_threshold=0.5, percentile_
 	
 	return df
 
+
 def classify_unique_states(df, class_attr, percentile=50, pre_event=None):
 
 	"""
@@ -1364,62 +1363,38 @@ def classify_unique_states(df, class_attr, percentile=50, pre_event=None):
 		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
+		indices = track[class_attr].index
 
+		if pre_event is not None:
 			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
+				continue
 			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
+				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):
-
-			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
+		# 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)
+		
+		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):

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/tracking.py

@@ -12,13 +12,14 @@ from celldetective.io import interpret_tracking_configuration
 
 import os
 import subprocess
+import trackpy as tp
 
 abs_path = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0],'celldetective'])
 
 def track(labels, configuration=None, stack=None, spatial_calibration=1, features=None, channel_names=None,
 		  haralick_options=None, return_napari_data=False, view_on_napari=False, mask_timepoints=None, mask_channels=None, volume=(2048,2048),
 		  optimizer_options = {'tm_lim': int(12e4)}, track_kwargs={'step_size': 100}, objects=None,
-		  clean_trajectories_kwargs=None, column_labels={'track': "TRACK_ID", 'time': 'FRAME', 'x': 'POSITION_X', 'y': 'POSITION_Y'},
+		  clean_trajectories_kwargs=None, btrack_option=True, search_range=None, memory=None,column_labels={'track': "TRACK_ID", 'time': 'FRAME', 'x': 'POSITION_X', 'y': 'POSITION_Y'},
 		  ):
 
 	"""
@@ -90,6 +91,12 @@ def track(labels, configuration=None, stack=None, spatial_calibration=1, feature
 	configuration = interpret_tracking_configuration(configuration)
 
 	if objects is None:
+		
+		if not btrack_option:
+			features = []
+			channel_names = None
+			haralick_options = None
+
 		objects = extract_objects_and_features(labels, stack, features, 
 										   channel_names=channel_names,
 										   haralick_options=haralick_options,
@@ -97,63 +104,81 @@ def track(labels, configuration=None, stack=None, spatial_calibration=1, feature
 										   mask_channels=mask_channels,
 										   )
 
-	columns = list(objects.columns)
-	to_remove = ['x','y','class_id','t']
-	for tr in to_remove:
-		try:
-			columns.remove(tr)
-		except:
-			print(f'column {tr} could not be found...')
-
-	scaler = StandardScaler()
-	if columns:
-		x = objects[columns].values
-		x_scaled = scaler.fit_transform(x)
-		df_temp = pd.DataFrame(x_scaled, columns=columns, index = objects.index)
-		objects[columns] = df_temp
-	else:
-		print('Warning: no features were passed to bTrack...')
+	if btrack_option:
+		columns = list(objects.columns)
+		to_remove = ['x','y','class_id','t']
+		for tr in to_remove:
+			try:
+				columns.remove(tr)
+			except:
+				print(f'column {tr} could not be found...')
 
-	# 2) track the objects
-	new_btrack_objects = localizations_to_objects(objects)
+		scaler = StandardScaler()
+		if columns:
+			x = objects[columns].values
+			x_scaled = scaler.fit_transform(x)
+			df_temp = pd.DataFrame(x_scaled, columns=columns, index = objects.index)
+			objects[columns] = df_temp
+		else:
+			print('Warning: no features were passed to bTrack...')
 
-	with BayesianTracker() as tracker:
+		# 2) track the objects
+		new_btrack_objects = localizations_to_objects(objects)
 
-		tracker.configure(configuration)
+		with BayesianTracker() as tracker:
 
-		if columns:
-			tracking_updates = ["motion","visual"]
-			#tracker.tracking_updates = ["motion","visual"]
-			tracker.features = columns
+			tracker.configure(configuration)
+
+			if columns:
+				tracking_updates = ["motion","visual"]
+				#tracker.tracking_updates = ["motion","visual"]
+				tracker.features = columns
+			else:
+				tracking_updates = ["motion"]
+			
+			tracker.append(new_btrack_objects)
+			tracker.volume = ((0,volume[0]), (0,volume[1]), (-1e5, 1e5)) #(-1e5, 1e5)
+			#print(tracker.volume)
+			tracker.track(tracking_updates=tracking_updates, **track_kwargs)
+			tracker.optimize(options=optimizer_options)
+
+			data, properties, graph = tracker.to_napari() #ndim=2
+		# do the table post processing and napari options
+		if data.shape[1]==4:
+			df = pd.DataFrame(data, columns=[column_labels['track'],column_labels['time'],column_labels['y'],column_labels['x']])
+		elif data.shape[1]==5:
+			df = pd.DataFrame(data, columns=[column_labels['track'],column_labels['time'],"z",column_labels['y'],column_labels['x']])
+			df = df.drop(columns=['z'])	
+		df[column_labels['x']+'_um'] = df[column_labels['x']]*spatial_calibration
+		df[column_labels['y']+'_um'] = df[column_labels['y']]*spatial_calibration
+
+	else:
+		properties = None
+		graph = {}
+		print(f"{objects=} {objects.columns=}")
+		objects = objects.rename(columns={"t": "frame"})
+		if search_range is not None and memory is not None:
+			data = tp.link(objects, search_range, memory=memory,link_strategy='auto')
 		else:
-			tracking_updates = ["motion"]
-		
-		tracker.append(new_btrack_objects)
-		tracker.volume = ((0,volume[0]), (0,volume[1]), (-1e5, 1e5)) #(-1e5, 1e5)
-		#print(tracker.volume)
-		tracker.track(tracking_updates=tracking_updates, **track_kwargs)
-		tracker.optimize(options=optimizer_options)
-
-		data, properties, graph = tracker.to_napari() #ndim=2
-
-	# do the table post processing and napari options
-	if data.shape[1]==4:
-		df = pd.DataFrame(data, columns=[column_labels['track'],column_labels['time'],column_labels['y'],column_labels['x']])
-	elif data.shape[1]==5:
-		df = pd.DataFrame(data, columns=[column_labels['track'],column_labels['time'],"z",column_labels['y'],column_labels['x']])
-		df = df.drop(columns=['z'])	
-	df[column_labels['x']+'_um'] = df[column_labels['x']]*spatial_calibration
-	df[column_labels['y']+'_um'] = df[column_labels['y']]*spatial_calibration
-
-	df = df.merge(pd.DataFrame(properties),left_index=True, right_index=True)
-	if columns:
-		x = df[columns].values
-		x_scaled = scaler.inverse_transform(x)
-		df_temp = pd.DataFrame(x_scaled, columns=columns, index = df.index)
-		df[columns] = df_temp
-
-	# set dummy features to NaN
-	df.loc[df['dummy'],['class_id']+columns] = np.nan 
+			print('Please provide a valid search range and memory value...')
+			return None
+		data['particle'] = data['particle'] + 1 # force track id to start at 1
+		df = data.rename(columns={'frame': column_labels['time'], 'x': column_labels['x'], 'y': column_labels['y'], 'particle': column_labels['track']})
+		df['state'] = 5.0; df['generation'] = 0.0; df['root'] = 1.0; df['parent'] = 1.0; df['dummy'] = False; df['z'] = 0.0;
+		data = df[[column_labels['track'],column_labels['time'],"z",column_labels['y'],column_labels['x']]].to_numpy()
+		print(f"{df=}")
+
+	if btrack_option:
+		df = df.merge(pd.DataFrame(properties),left_index=True, right_index=True)
+		if columns:
+			x = df[columns].values
+			x_scaled = scaler.inverse_transform(x)
+			df_temp = pd.DataFrame(x_scaled, columns=columns, index = df.index)
+			df[columns] = df_temp
+
+		# set dummy features to NaN
+		df.loc[df['dummy'],['class_id']+columns] = np.nan
+
 	df = df.sort_values(by=[column_labels['track'],column_labels['time']])
 	df = velocity_per_track(df, window_size=3, mode='bi')
 

celldetective/utils.py

@@ -424,7 +424,7 @@ def estimate_unreliable_edge(activation_protocol=[['gauss',2],['std',4]]):
 	else:
 		edge=0
 		for fct in activation_protocol:
-			if isinstance(fct[1],(int,np.int_)):
+			if isinstance(fct[1],(int,np.int_)) and not fct[0]=='invert':
 				edge+=fct[1]
 		return edge
 
@@ -1250,7 +1250,10 @@ def ConfigSectionMap(path,section):
 	Config = configparser.ConfigParser()
 	Config.read(path)
 	dict1 = {}
-	options = Config.options(section)
+	try:
+		options = Config.options(section)
+	except:
+		return None
 	for option in options:
 		try:
 			dict1[option] = Config.get(section, option)

{celldetective-1.3.5.dist-info → celldetective-1.3.6.post1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: celldetective
-Version: 1.3.5
+Version: 1.3.6.post1
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro
@@ -42,6 +42,7 @@ Requires-Dist: pytest-qt
 Requires-Dist: h5py
 Requires-Dist: cliffs_delta
 Requires-Dist: requests
+Requires-Dist: trackpy
 
 # Celldetective