celldetective 1.3.5__py3-none-any.whl → 1.3.6.post2__py3-none-any.whl

celldetective/io.py

@@ -25,7 +25,7 @@ from magicgui import magicgui
 from pathlib import Path, PurePath
 from shutil import copyfile, rmtree
 
-from celldetective.utils import ConfigSectionMap, extract_experiment_channels, _extract_labels_from_config, get_zenodo_files, download_zenodo_file, interpolate_nan
+from celldetective.utils import ConfigSectionMap, extract_experiment_channels, _extract_labels_from_config, get_zenodo_files, download_zenodo_file
 from celldetective.utils import _estimate_scale_factor, _extract_channel_indices_from_config, _extract_channel_indices, _extract_nbr_channels_from_config, _get_img_num_per_channel, normalize_per_channel
 
 from stardist import fill_label_holes
@@ -211,7 +211,15 @@ def collect_experiment_metadata(pos_path=None, well_path=None):
 	antibodies = get_experiment_antibodies(experiment)
 	pharmaceutical_agents = get_experiment_pharmaceutical_agents(experiment)
 	
-	return {"pos_path": pos_path, "position": pos_path, "pos_name": pos_name, "well_path": well_path, "well_name": well_name, "well_nbr": well_nbr, "experiment": experiment, "antibody": antibodies[idx], "concentration": concentrations[idx], "cell_type": cell_types[idx], "pharmaceutical_agent": pharmaceutical_agents[idx]}
+	dico = {"pos_path": pos_path, "position": pos_path, "pos_name": pos_name, "well_path": well_path, "well_name": well_name, "well_nbr": well_nbr, "experiment": experiment, "antibody": antibodies[idx], "concentration": concentrations[idx], "cell_type": cell_types[idx], "pharmaceutical_agent": pharmaceutical_agents[idx]}
+
+	meta = get_experiment_metadata(experiment) # None or dict of metadata
+	if meta is not None:
+		keys = list(meta.keys())
+		for k in keys:
+			dico.update({k: meta[k]})
+	
+	return dico
 
 
 def get_experiment_wells(experiment):
@@ -379,6 +387,12 @@ def get_temporal_calibration(experiment):
 
 	return FrameToMin
 
+def get_experiment_metadata(experiment):
+
+	config = get_config(experiment)
+	metadata = ConfigSectionMap(config, "Metadata")
+	return metadata
+
 
 def get_experiment_concentrations(experiment, dtype=str):
 	
@@ -957,6 +971,7 @@ def load_experiment_tables(experiment, population='targets', well_option='*', po
 	cell_types = get_experiment_cell_types(experiment)
 	antibodies = get_experiment_antibodies(experiment)
 	pharmaceutical_agents = get_experiment_pharmaceutical_agents(experiment)
+	metadata = get_experiment_metadata(experiment) # None or dict of metadata
 	well_labels = _extract_labels_from_config(config, len(wells))
 
 	well_indices, position_indices = interpret_wells_and_positions(experiment, well_option, position_option)
@@ -1011,15 +1026,23 @@ def load_experiment_tables(experiment, population='targets', well_option='*', po
 				df_pos['antibody'] = well_antibody
 				df_pos['cell_type'] = well_cell_type
 				df_pos['pharmaceutical_agent'] = well_pharmaceutical_agent
+				if metadata is not None:
+					keys = list(metadata.keys())
+					for k in keys:
+						df_pos[k] = metadata[k]
 
 				df.append(df_pos)
 				any_table = True
 
-				df_pos_info.append(
-					{'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})
+				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)
 
 				real_pos_index += 1
 
@@ -2851,7 +2874,7 @@ def locate_segmentation_model(name):
 
 	main_dir = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0],"celldetective"])
 	modelpath = os.sep.join([main_dir, "models", "segmentation*"]) + os.sep
-	print(f'Looking for {name} in {modelpath}')
+	#print(f'Looking for {name} in {modelpath}')
 	models = glob(modelpath + f'*{os.sep}')
 
 	match = None

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

@@ -5,7 +5,7 @@ Copright © 2022 Laboratoire Adhesion et Inflammation, Authored by Remy Torro.
 import argparse
 import os
 import json
-from celldetective.io import auto_load_number_of_frames, load_frames, fix_missing_labels, locate_labels
+from celldetective.io import auto_load_number_of_frames, load_frames, fix_missing_labels, locate_labels, extract_position_name
 from celldetective.utils import extract_experiment_channels, ConfigSectionMap, _get_img_num_per_channel, extract_experiment_channels
 from celldetective.utils import remove_redundant_features, remove_trajectory_measurements
 from celldetective.measure import drop_tonal_features, measure_features, measure_isotropic_intensity
@@ -50,7 +50,10 @@ parent1 = Path(pos).parent
 expfolder = parent1.parent
 config = PurePath(expfolder,Path("config.ini"))
 assert os.path.exists(config),'The configuration file for the experiment could not be located. Abort.'
+
+print(f"Position: {extract_position_name(pos)}...")
 print("Configuration file: ",config)
+print(f"Population: {mode}...")
 
 # from exp config fetch spatial calib, channel names
 movie_prefix = ConfigSectionMap(config,"MovieSettings")["movie_prefix"]
@@ -62,11 +65,15 @@ nbr_channels = len(channel_names)
 
 # from tracking instructions, fetch btrack config, features, haralick, clean_traj, idea: fetch custom timeline?
 instr_path = PurePath(expfolder,Path(f"{instruction_file}"))
+print('Looking for measurement instruction file...')
+
 if os.path.exists(instr_path):
-	print(f"Tracking instructions for the {mode} population has been successfully located.")
+	
 	with open(instr_path, 'r') as f:
 		instructions = json.load(f)
-		print("Reading the following instructions: ", instructions)
+		print(f"Measurement instruction file successfully loaded...")
+		print(f"Instructions: {instructions}...")
+
 	if 'background_correction' in instructions:
 		background_correction = instructions['background_correction']
 	else:
@@ -144,7 +151,7 @@ except IndexError:
 # Load trajectories, add centroid if not in trajectory
 trajectories = pos+os.sep.join(['output','tables', table_name])
 if os.path.exists(trajectories):
-	print('trajectory exists...')
+	print('A trajectory table was found...')
 	trajectories = pd.read_csv(trajectories)
 	if 'TRACK_ID' not in list(trajectories.columns):
 		do_iso_intensities = False
@@ -289,18 +296,26 @@ def measure_index(indices):
 			measurements_at_t[column_labels['time']] = t
 			timestep_dataframes.append(measurements_at_t)
 
+	return 
+
+
+print(f"Starting the measurements with {n_threads} thread(s)...")
+
+import concurrent.futures
 
 # Multithreading
 indices = list(range(img_num_channels.shape[1]))
 chunks = np.array_split(indices, n_threads)
-threads = []
-for i in range(n_threads):
-	thread_i = threading.Thread(target=measure_index, args=[chunks[i]])
-	threads.append(thread_i)
-for th in threads:
-	th.start()
-for th in threads:
-	th.join()
+
+with concurrent.futures.ThreadPoolExecutor() as executor:
+	results = executor.map(measure_index, chunks)
+	try:
+		for i,return_value in enumerate(results):
+			print(f"Thread {i} output check: ",return_value)
+	except Exception as e:
+		print("Exception: ", e)
+
+print('Done.')
 
 
 if len(timestep_dataframes)>0:
@@ -320,7 +335,7 @@ if len(timestep_dataframes)>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])}')
+	print(f'Measurement table successfully exported in  {os.sep.join(["output", "tables"])}...')
 	print('Done.')
 else:
 	print('No measurement could be performed. Check your inputs.')