celldetective 1.3.6.post1__tar.gz → 1.3.6.post2__tar.gz

{celldetective-1.3.6.post1 → celldetective-1.3.6.post2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: celldetective
-Version: 1.3.6.post1
+Version: 1.3.6.post2
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro

celldetective-1.3.6.post2/celldetective/_version.py

@@ -0,0 +1 @@
+__version__ = "1.3.6.post2"

{celldetective-1.3.6.post1 → celldetective-1.3.6.post2}/celldetective/filters.py

@@ -88,9 +88,13 @@ def laplace_filter(img, output=float, interpolate=True, *kwargs):
 		img = interpolate_nan(img.astype(float))
 	return snd.laplace(img.astype(float), *kwargs)
 
-def dog_filter(img, sigma_low, sigma_high, interpolate=True, *kwargs):
+def dog_filter(img, blob_size=None, sigma_low=1, sigma_high=2, interpolate=True, *kwargs):
+	
 	if interpolate:
 		img = interpolate_nan(img.astype(float))
+	if blob_size is not None:
+		sigma_low = 1.0 / (1.0 + np.sqrt(2)) * blob_size
+		sigma_high = np.sqrt(2)*sigma_low
 	return difference_of_gaussians(img.astype(float), sigma_low, sigma_high, *kwargs)
 
 def otsu_filter(img, *kwargs):
@@ -115,13 +119,18 @@ def sauvola_filter(img, *kwargs):
 	binary = img >= thresh
 	return binary.astype(float)
 
-def log_filter(img, sigma, *kwargs):
+def log_filter(img, blob_size=None, sigma=1, interpolate=True, *kwargs):
 
 	if interpolate:
 		img = interpolate_nan(img.astype(float))
+	if blob_size is not None:
+		sigma_low = 1.0 / (1.0 + np.sqrt(2)) * blob_size
+		sigma_high = np.sqrt(2)*sigma_low
+
 	return snd.gaussian_laplace(img.astype(float), sigma, *kwargs)
 
 def tophat_filter(img, size, connectivity=4, interpolate=True, *kwargs):
+	
 	if interpolate:
 		img = interpolate_nan(img.astype(float))
 	structure = snd.generate_binary_structure(rank=2, connectivity=connectivity)

{celldetective-1.3.6.post1 → celldetective-1.3.6.post2}/celldetective/gui/gui_utils.py

@@ -622,8 +622,8 @@ class FilterChoice(QWidget, Styles):
 			'ln_filter': None,
 			'invert_filter': {'value': 65535},
 			'subtract_filter': {'value': 1},
-			'dog_filter': {'sigma_low': 0.8, 'sigma_high': 1.6},
-			'log_filter': {'sigma': 2},
+			'dog_filter': {'blob_size': 30},
+			'log_filter': {'blob_size': 30},
 			'tophat_filter': {'size': 4, 'connectivity': 4},
 			'otsu_filter': None,
 			'local_filter': {'block_size': 73, 'method': 'mean', 'offset': 0},

{celldetective-1.3.6.post1 → celldetective-1.3.6.post2}/celldetective/gui/neighborhood_options.py

@@ -400,7 +400,7 @@ class ConfigNeighborhoods(QWidget, Styles):
 		
 		status_options = [self.reference_population_status_cb.currentText(), self.neighbor_population_status_cb.currentText()]
 		for k in range(2):
-			if status_options[k]=='--':
+			if status_options[k]=='--' or status_options[k]=='':
 				status_options[k] = None
 		if pop[0]!=pop[1]:
 			mode = 'two-pop'

{celldetective-1.3.6.post1 → celldetective-1.3.6.post2}/celldetective/gui/signal_annotator2.py

@@ -205,14 +205,14 @@ class SignalAnnotator2(QMainWindow,Styles):
 
 		self.cell_events_hbox = QHBoxLayout()
 		self.cell_events_hbox.setContentsMargins(0,0,0,0)
-		self.cell_events_hbox.addWidget(QLabel('reference event: '), 25)
+		self.cell_events_hbox.addWidget(QLabel('Event: '), 25)
 		self.reference_event_choice_cb = QComboBox()
 		self.cell_events_hbox.addWidget(self.reference_event_choice_cb, 75)
 		
 		#if 'self' not in self.neighborhood_choice_cb.currentText():
 		self.neigh_cell_events_hbox = QHBoxLayout()
 		self.neigh_cell_events_hbox.setContentsMargins(0,0,0,0)
-		self.neigh_lab=QLabel('neighbor event: ')
+		self.neigh_lab=QLabel('Event: ')
 		self.neigh_cell_events_hbox.addWidget(self.neigh_lab, 25)
 		self.neighbor_event_choice_cb = QComboBox()
 		self.neigh_cell_events_hbox.addWidget(self.neighbor_event_choice_cb, 75)
@@ -233,7 +233,7 @@ class SignalAnnotator2(QMainWindow,Styles):
 		neighbor_layout.addLayout(self.neigh_cell_events_hbox)
 
 		self.cell_info_hbox.addLayout(reference_layout, 33)
-		self.cell_info_hbox.addWidget(self.pair_info, 33, alignment=Qt.AlignCenter)
+		self.cell_info_hbox.addWidget(self.pair_info, 33)
 		self.cell_info_hbox.addLayout(neighbor_layout, 33)
 
 		self.left_panel.addLayout(self.cell_info_hbox)
@@ -2378,41 +2378,41 @@ class SignalAnnotator2(QMainWindow,Styles):
 
 		df_reference = self.dataframes[self.reference_population]
 		if self.reference_track_of_interest is not None:
-			reference_cell_selected = f"reference cell: {self.reference_track_of_interest}\n"
-			reference_cell_population = f"population: {self.reference_population}\n"
+			reference_cell_selected = f"Ref #{self.reference_track_of_interest}\n"
+			reference_cell_population = f"Pop: {self.reference_population}\n"
 			#reference_cell_class = f"class: {df_reference[df_reference['TRACK_ID']==self.reference_track_of_interest, self.reference_event_choice_cb.currentText()].values[0]}\n"
 			#reference_cell_time = f"time of interest: {df_reference[df_reference['TRACK_ID']==self.reference_track_of_interest, ''].values[0]}\n"
 			self.reference_cell_info.setText(reference_cell_selected+reference_cell_population)
 		else:
-			reference_cell_selected = f"reference cell: None\n"
-			reference_cell_population = f"population: {self.reference_population}\n"
+			reference_cell_selected = f"Ref: None\n"
+			reference_cell_population = f"Pop: {self.reference_population}\n"
 			self.reference_cell_info.setText(reference_cell_selected+reference_cell_population)
 
 	def give_neighbor_cell_information(self):
 
 		if self.neighbor_track_of_interest is not None:
-			neighbor_cell_selected = f"neighbor cell: {self.neighbor_track_of_interest}\n"
-			neighbor_cell_population = f"population: {self.neighbor_population}\n"
+			neighbor_cell_selected = f"Neigh #{self.neighbor_track_of_interest}\n"
+			neighbor_cell_population = f"Pop: {self.neighbor_population}\n"
 			#neighbor_cell_time = f"time of interest: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest), self.pair_time_name].to_numpy()[0]}\n"
 			#neighbor_cell_class = f"class: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest), self.pair_class_name].to_numpy()[0]}\n"
 			self.neighbor_cell_info.setText(neighbor_cell_selected+neighbor_cell_population) #neighbor_cell_class+neighbor_cell_time 
 		else:
-			neighbor_cell_selected = f"neighbor cell: None\n"
-			neighbor_cell_population = f"population: {self.neighbor_population}\n"
+			neighbor_cell_selected = f"Neigh: None\n"
+			neighbor_cell_population = f"Pop: {self.neighbor_population}\n"
 			self.neighbor_cell_info.setText(neighbor_cell_selected+neighbor_cell_population)
 
 	def give_pair_information(self):
 
 		if self.neighbor_track_of_interest is not None and self.reference_track_of_interest is not None:
-			pair_selected = f"(reference/neighbor) pair: ({self.reference_track_of_interest},{self.neighbor_track_of_interest})\n"
-			pair_populations = f"populations: ({self.reference_population}, {self.neighbor_population})\n"
+			pair_selected = f"Pair: ({self.reference_track_of_interest},{self.neighbor_track_of_interest})\n"
+			pair_populations = "" #f"populations: ({self.reference_population}, {self.neighbor_population})\n"
 			current_class = self.relative_class_choice_cb.currentText()
-			pair_class = f"interaction event class: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest)&(self.df_relative['reference_population']==self.reference_population)&(self.df_relative['neighbor_population']==self.neighbor_population)&(~self.df_relative['status_'+self.current_neighborhood].isnull()), current_class].values[0]}\n"
-			pair_time = f"time of interest: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest)&(self.df_relative['reference_population']==self.reference_population)&(self.df_relative['neighbor_population']==self.neighbor_population)&(~self.df_relative['status_'+self.current_neighborhood].isnull()), self.pair_time_name].values[0]}\n"
+			pair_class = f"Event class: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest)&(self.df_relative['reference_population']==self.reference_population)&(self.df_relative['neighbor_population']==self.neighbor_population)&(~self.df_relative['status_'+self.current_neighborhood].isnull()), current_class].values[0]}\n"
+			pair_time = f"Time: {self.df_relative.loc[(self.df_relative['REFERENCE_ID']==self.reference_track_of_interest)&(self.df_relative['NEIGHBOR_ID']==self.neighbor_track_of_interest)&(self.df_relative['reference_population']==self.reference_population)&(self.df_relative['neighbor_population']==self.neighbor_population)&(~self.df_relative['status_'+self.current_neighborhood].isnull()), self.pair_time_name].values[0]}\n"
 			self.pair_info.setText(pair_selected+pair_populations+pair_class+pair_time)
 		else:
-			pair_selected = f"(reference/neighbor) pair: None\n"
-			pair_populations = f"populations: ({self.reference_population}, {self.neighbor_population})\n"
+			pair_selected = f"Pair: None\n"
+			pair_populations = "" #f"populations: ({self.reference_population}, {self.neighbor_population})\n"
 			self.pair_info.setText(pair_selected+pair_populations)
 
 

{celldetective-1.3.6.post1 → celldetective-1.3.6.post2}/celldetective/io.py

@@ -2874,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-1.3.6.post1 → celldetective-1.3.6.post2}/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.')

{celldetective-1.3.6.post1 → celldetective-1.3.6.post2}/celldetective/scripts/segment_cells.py

@@ -8,7 +8,7 @@ import os
 import json
 from stardist.models import StarDist2D
 from cellpose.models import CellposeModel
-from celldetective.io import locate_segmentation_model, auto_load_number_of_frames, load_frames
+from celldetective.io import locate_segmentation_model, auto_load_number_of_frames, load_frames, extract_position_name
 from celldetective.utils import interpolate_nan, _estimate_scale_factor, _extract_channel_indices_from_config, ConfigSectionMap, _extract_nbr_channels_from_config, _get_img_num_per_channel
 from pathlib import Path, PurePath
 from glob import glob
@@ -44,6 +44,7 @@ if use_gpu=='True' or use_gpu=='true' or use_gpu=='1':
 	n_threads = 1  # avoid misbehavior on GPU with multithreading
 else:
 	use_gpu = False
+	#n_threads = 1 # force 1 threads since all CPUs seem to be in use anyway
 
 if not use_gpu:
 	os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
@@ -60,20 +61,22 @@ 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}...")
 
 ####################################
 # Check model requirements #########
 ####################################
 
 modelpath = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0],"models"])
-print(modelpath)
 model_complete_path = locate_segmentation_model(modelname)
 if model_complete_path is None:
 	print('Model could not be found. Abort.')
 	os.abort()
 else:
-	print(f'Model successfully located in {model_complete_path}')
+	print(f'Model path: {model_complete_path}...')
 
 # load config
 assert os.path.exists(model_complete_path+"config_input.json"),'The configuration for the inputs to the model could not be located. Abort.'
@@ -86,7 +89,7 @@ required_channels = input_config["channels"]
 channel_indices = _extract_channel_indices_from_config(config, required_channels)
 print(f'Required channels: {required_channels} located at channel indices {channel_indices}.')
 required_spatial_calibration = input_config['spatial_calibration']
-print(f'Expected spatial calibration is {required_spatial_calibration}.')
+print(f'Spatial calibration expected by the model: {required_spatial_calibration}...')
 
 normalization_percentile = input_config['normalization_percentile']
 normalization_clip = input_config['normalization_clip']
@@ -117,18 +120,19 @@ if model_type=='cellpose':
 	flow_threshold = input_config['flow_threshold']
 
 scale = _estimate_scale_factor(spatial_calibration, required_spatial_calibration)
-print(f"Scale = {scale}...")
+print(f"Scale: {scale}...")
 
 nbr_channels = _extract_nbr_channels_from_config(config)
-print(f'Number of channels in the input movie: {nbr_channels}')
+#print(f'Number of channels in the input movie: {nbr_channels}')
 img_num_channels = _get_img_num_per_channel(channel_indices, int(len_movie), nbr_channels)
 
 # If everything OK, prepare output, load models
-print('Erasing previous segmentation folder.')
 if os.path.exists(pos+label_folder):
+	print('Erasing the previous labels folder...')
 	rmtree(pos+label_folder)
 os.mkdir(pos+label_folder)
-print(f'Folder {pos+label_folder} successfully generated.')
+print(f'Labels folder successfully generated...')
+
 log=f'segmentation model: {modelname}\n'
 with open(pos+f'log_{mode}.json', 'a') as f:
 	f.write(f'{datetime.datetime.now()} SEGMENT \n')
@@ -137,6 +141,7 @@ with open(pos+f'log_{mode}.json', 'a') as f:
 
 # Loop over all frames and segment
 def segment_index(indices):
+
 	global scale
 
 	if model_type=='stardist':
@@ -179,8 +184,7 @@ def segment_index(indices):
 		f = np.moveaxis([interpolate_nan(f[:,:,c].copy()) for c in range(f.shape[-1])],0,-1)
 
 		if np.any(img_num_channels[:,t]==-1):
-			f[:,:,np.where(img_num_channels[:,t]==-1)[0]] = 0.
-		
+			f[:,:,np.where(img_num_channels[:,t]==-1)[0]] = 0.	
 
 		if model_type=="stardist":
 			Y_pred, details = model.predict_instances(f, n_tiles=model._guess_n_tiles(f), show_tile_progress=False, verbose=False)
@@ -206,6 +210,10 @@ def segment_index(indices):
 		del Y_pred;
 		gc.collect()
 
+	return
+
+
+print(f"Starting the segmentation with {n_threads} thread(s) and GPU={use_gpu}...")
 
 import concurrent.futures
 
@@ -214,16 +222,12 @@ indices = list(range(img_num_channels.shape[1]))
 chunks = np.array_split(indices, n_threads)
 
 with concurrent.futures.ThreadPoolExecutor() as executor:
-	executor.map(segment_index, chunks)
-
-# threads = []
-# for i in range(n_threads):
-# 	thread_i = threading.Thread(target=segment_index, args=[chunks[i]])
-# 	threads.append(thread_i)
-# for th in threads:
-# 	th.start()
-# for th in threads:
-# 	th.join()
+	results = executor.map(segment_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.')
 

{celldetective-1.3.6.post1 → celldetective-1.3.6.post2}/celldetective/scripts/segment_cells_thresholds.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
+from celldetective.io import auto_load_number_of_frames, load_frames, extract_position_name
 from celldetective.segmentation import segment_frame_from_thresholds
 from celldetective.utils import _extract_channel_indices_from_config, ConfigSectionMap, _extract_nbr_channels_from_config, _get_img_num_per_channel, extract_experiment_channels
 from pathlib import Path, PurePath
@@ -48,8 +48,6 @@ else:
 	print('The configuration path is not valid. Abort.')
 	os.abort()
 
-print('The following instructions were successfully loaded: ', threshold_instructions)
-
 if mode.lower()=="target" or mode.lower()=="targets":
 	label_folder = "labels_targets"
 elif mode.lower()=="effector" or mode.lower()=="effectors":
@@ -60,12 +58,14 @@ 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("Configuration file: ",config)
 
+print(f"Position: {extract_position_name(pos)}...")
+print("Configuration file: ",config)
+print(f"Population: {mode}...")
 
 channel_indices = _extract_channel_indices_from_config(config, required_channels)
 # need to abort if channel not found
-print(f'Required channels: {required_channels} located at channel indices {channel_indices}.')
+print(f'Required channels: {required_channels} located at channel indices {channel_indices}...')
 
 threshold_instructions.update({'target_channel': channel_indices[0]})
 
@@ -86,15 +86,15 @@ if len_movie_auto is not None:
 	len_movie = len_movie_auto
 
 nbr_channels = _extract_nbr_channels_from_config(config)
-print(f'Number of channels in the input movie: {nbr_channels}')
+#print(f'Number of channels in the input movie: {nbr_channels}')
 img_num_channels = _get_img_num_per_channel(np.arange(nbr_channels), len_movie, nbr_channels)
 
 # If everything OK, prepare output, load models
-print('Erasing previous segmentation folder.')
 if os.path.exists(os.sep.join([pos,label_folder])):
+	print('Erasing the previous labels folder...')
 	rmtree(os.sep.join([pos,label_folder]))
 os.mkdir(os.sep.join([pos,label_folder]))
-print(f'Folder {os.sep.join([pos,label_folder])} successfully generated.')
+print(f'Labels folder successfully generated...')
 
 if equalize:
 	f_reference = load_frames(img_num_channels[:,equalize_time], file, scale=None, normalize_input=False)
@@ -103,7 +103,7 @@ else:
 	f_reference = None
 
 threshold_instructions.update({'equalize_reference': f_reference})
-print(threshold_instructions)
+print(f"Instructions: {threshold_instructions}...")
 
 # Loop over all frames and segment
 def segment_index(indices):
@@ -119,6 +119,11 @@ def segment_index(indices):
 		del mask;
 		gc.collect()
 
+	return 
+
+
+print(f"Starting the segmentation with {n_threads} thread(s)...")
+
 import concurrent.futures
 
 # Multithreading
@@ -126,20 +131,15 @@ indices = list(range(img_num_channels.shape[1]))
 chunks = np.array_split(indices, n_threads)
 
 with concurrent.futures.ThreadPoolExecutor() as executor:
-	executor.map(segment_index, chunks)
-
-# 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=segment_index, args=[chunks[i]])
-# 	threads.append(thread_i)
-# for th in threads:
-# 	th.start()
-# for th in threads:
-# 	th.join()
+	results = executor.map(segment_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.')
+
 gc.collect()
 
 

{celldetective-1.3.6.post1 → celldetective-1.3.6.post2}/celldetective/scripts/track_cells.py

@@ -6,7 +6,7 @@ import argparse
 import datetime
 import os
 import json
-from celldetective.io import auto_load_number_of_frames, load_frames, interpret_tracking_configuration
+from celldetective.io import auto_load_number_of_frames, load_frames, interpret_tracking_configuration, extract_position_name
 from celldetective.utils import extract_experiment_channels, ConfigSectionMap, _get_img_num_per_channel, extract_experiment_channels
 from celldetective.measure import drop_tonal_features, measure_features
 from celldetective.tracking import track
@@ -59,6 +59,10 @@ 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"]
 spatial_calibration = float(ConfigSectionMap(config,"MovieSettings")["pxtoum"])
@@ -71,9 +75,10 @@ channel_names, channel_indices = extract_experiment_channels(config)
 nbr_channels = len(channel_names)
 
 # from tracking instructions, fetch btrack config, features, haralick, clean_traj, idea: fetch custom timeline?
+print('Looking for tracking instruction file...')
 instr_path = PurePath(expfolder,Path(f"{instruction_file}"))
 if os.path.exists(instr_path):
-	print(f"Tracking instructions for the {mode} population have been successfully loaded...")
+	print(f"Tracking instruction file successfully loaded...")
 	with open(instr_path, 'r') as f:
 		instructions = json.load(f)
 	btrack_config = interpret_tracking_configuration(instructions['btrack_config_path'])
@@ -107,8 +112,6 @@ if os.path.exists(instr_path):
 	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)
@@ -169,6 +172,7 @@ if not btrack_option:
 
 
 def measure_index(indices):
+
 	for t in tqdm(indices,desc="frame"):
 		
 		# Load channels at time t
@@ -181,24 +185,27 @@ def measure_index(indices):
 		df_props.rename(columns={'centroid-1': 'x', 'centroid-0': 'y'},inplace=True)
 		df_props['t'] = int(t)
 		timestep_dataframes.append(df_props)
+	return 
+
+
+
+print(f"Measuring features with {n_threads} thread(s)...")
+
+import concurrent.futures
 
 # Multithreading
 indices = list(range(img_num_channels.shape[1]))
 chunks = np.array_split(indices, n_threads)
 
-import concurrent.futures
-
 with concurrent.futures.ThreadPoolExecutor() as executor:
-	executor.map(measure_index, chunks)
+	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)
 
-# 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()
+print('Features successfully measured...')
 
 df = pd.concat(timestep_dataframes)	
 df.reset_index(inplace=True, drop=True)
@@ -214,6 +221,13 @@ if mask_channels is not None:
 		df = df.drop(cols_to_drop, axis=1)
 
 # do tracking
+if btrack_option:
+	tracker = 'bTrack'
+else:
+	tracker = 'trackpy'
+
+print(f"Start the tracking step using the {tracker} tracker...")
+
 trajectories, napari_data = track(None,
 					configuration=btrack_config,
 					objects=df, 
@@ -228,14 +242,14 @@ trajectories, napari_data = track(None,
 		  			search_range=search_range,
 		  			memory=memory,
 		  			)
+print(f"Tracking successfully performed...")
 
 # out trajectory table, create POSITION_X_um, POSITION_Y_um, TIME_min (new ones)
-# Save napari data
+# Save napari data # deprecated, should disappear progressively
 np.save(pos+os.sep.join(['output', 'tables', napari_name]), napari_data, allow_pickle=True)
-print(f"napari data successfully saved in {pos+os.sep.join(['output', 'tables'])}")
 
 trajectories.to_csv(pos+os.sep.join(['output', 'tables', table_name]), index=False)
-print(f"Table {table_name} successfully saved in {os.sep.join(['output', 'tables'])}")
+print(f"Trajectory table successfully exported in {os.sep.join(['output', 'tables'])}...")
 
 if os.path.exists(pos+os.sep.join(['output', 'tables', table_name.replace('.csv','.pkl')])):
 	os.remove(pos+os.sep.join(['output', 'tables', table_name.replace('.csv','.pkl')]))

{celldetective-1.3.6.post1 → celldetective-1.3.6.post2}/celldetective.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: celldetective
-Version: 1.3.6.post1
+Version: 1.3.6.post2
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro

celldetective-1.3.6.post1/celldetective/_version.py

@@ -1 +0,0 @@
-__version__ = "1.3.6.post1"