celldetective 1.3.9.post5__py3-none-any.whl → 1.4.1__py3-none-any.whl

celldetective/preprocessing.py

@@ -1,12 +1,13 @@
 """
 Copright © 2024 Laboratoire Adhesion et Inflammation, Authored by Remy Torro & Ksenija Dervanova.
 """
+from typing import List
 
 from tqdm import tqdm
 import numpy as np
 import os
 from celldetective.io import get_config, get_experiment_wells, interpret_wells_and_positions, extract_well_name_and_number, get_positions_in_well, extract_position_name, get_position_movie_path, load_frames, auto_load_number_of_frames
-from celldetective.utils import interpolate_nan, estimate_unreliable_edge, unpad, ConfigSectionMap, _extract_channel_indices_from_config, _extract_nbr_channels_from_config, _get_img_num_per_channel
+from celldetective.utils import interpolate_nan, estimate_unreliable_edge, unpad, config_section_to_dict, _extract_channel_indices_from_config, _extract_nbr_channels_from_config, _get_img_num_per_channel
 from celldetective.segmentation import filter_image, threshold_image
 from csbdeep.io import save_tiff_imagej_compatible
 from gc import collect
@@ -14,7 +15,7 @@ from lmfit import Parameters, Model
 import tifffile.tifffile as tiff
 from scipy.ndimage import shift
 
-def estimate_background_per_condition(experiment, threshold_on_std=1, well_option='*', target_channel="channel_name", frame_range=[0,5], mode="timeseries", activation_protocol=[['gauss',2],['std',4]], show_progress_per_pos=False, show_progress_per_well=True):
+def estimate_background_per_condition(experiment, threshold_on_std=1, well_option='*', target_channel="channel_name", frame_range=[0,5], mode="timeseries", activation_protocol=[['gauss',2],['std',4]], show_progress_per_pos=False, show_progress_per_well=True, offset=None, fix_nan: bool = False):
 	
 	"""
 	Estimate the background for each condition in an experiment.
@@ -71,8 +72,8 @@ def estimate_background_per_condition(experiment, threshold_on_std=1, well_optio
 
 	config = get_config(experiment)
 	wells = get_experiment_wells(experiment)
-	len_movie = float(ConfigSectionMap(config,"MovieSettings")["len_movie"])
-	movie_prefix = ConfigSectionMap(config,"MovieSettings")["movie_prefix"]	
+	len_movie = float(config_section_to_dict(config, "MovieSettings")["len_movie"])
+	movie_prefix = config_section_to_dict(config, "MovieSettings")["movie_prefix"]
 
 	well_indices, position_indices = interpret_wells_and_positions(experiment, well_option, "*")
 
@@ -149,6 +150,11 @@ def estimate_background_per_condition(experiment, threshold_on_std=1, well_optio
 
 		try:
 			background = np.nanmedian(frame_mean_per_position,axis=0)
+			if offset is not None:
+				#print("The offset is applied to background...")
+				background -= offset
+			if fix_nan:
+				background = interpolate_nan(background.copy().astype(float))
 			backgrounds.append({"bg": background, "well": well_path})
 			print(f"Background successfully computed for well {well_name}...")
 		except Exception as e:
@@ -170,11 +176,13 @@ def correct_background_model_free(
 					   opt_coef_nbr = 100,
 					   operation = 'divide',
 					   clip = False,
+					   offset = None,
 					   show_progress_per_well = True,
 					   show_progress_per_pos = False,
 					   export = False,
 					   return_stacks = False,
 					   movie_prefix=None,
+					   fix_nan=False,
 					   activation_protocol=[['gauss',2],['std',4]],
 					   export_prefix='Corrected',
 					   **kwargs,
@@ -243,9 +251,9 @@ def correct_background_model_free(
 
 	config = get_config(experiment)
 	wells = get_experiment_wells(experiment)
-	len_movie = float(ConfigSectionMap(config,"MovieSettings")["len_movie"])
+	len_movie = float(config_section_to_dict(config, "MovieSettings")["len_movie"])
 	if movie_prefix is None:
-		movie_prefix = ConfigSectionMap(config,"MovieSettings")["movie_prefix"]	
+		movie_prefix = config_section_to_dict(config, "MovieSettings")["movie_prefix"]
 
 	well_indices, position_indices = interpret_wells_and_positions(experiment, well_option, position_option)
 	channel_indices = _extract_channel_indices_from_config(config, [target_channel])
@@ -259,7 +267,7 @@ def correct_background_model_free(
 		well_name, _ = extract_well_name_and_number(well_path)
 
 		try:
-			background = estimate_background_per_condition(experiment, threshold_on_std=threshold_on_std, well_option=int(well_indices[k]), target_channel=target_channel, frame_range=frame_range, mode=mode, show_progress_per_pos=True, show_progress_per_well=False, activation_protocol=activation_protocol)
+			background = estimate_background_per_condition(experiment, threshold_on_std=threshold_on_std, well_option=int(well_indices[k]), target_channel=target_channel, frame_range=frame_range, mode=mode, show_progress_per_pos=True, show_progress_per_well=False, activation_protocol=activation_protocol, offset=offset, fix_nan=fix_nan)
 			background = background[0]
 			background = background['bg']
 		except Exception as e:
@@ -283,18 +291,20 @@ def correct_background_model_free(
 
 				corrected_stack = apply_background_to_stack(stack_path, 
 															background,
-															target_channel_index=channel_indices[0],
-															nbr_channels=nbr_channels,
-															stack_length=len_movie,
-															threshold_on_std=threshold_on_std,
-															optimize_option=optimize_option,
-															opt_coef_range=opt_coef_range,
-															opt_coef_nbr=opt_coef_nbr,
-															operation=operation,
-															clip=clip,
-															export=export,
-															activation_protocol=activation_protocol,
-															prefix=export_prefix,
+															target_channel_index = channel_indices[0],
+															nbr_channels = nbr_channels,
+															stack_length = len_movie,
+															threshold_on_std = threshold_on_std,
+															optimize_option = optimize_option,
+															opt_coef_range = opt_coef_range,
+															opt_coef_nbr = opt_coef_nbr,
+															operation = operation,
+															clip = clip,
+															offset = offset,
+															export = export,
+															fix_nan=fix_nan,
+															activation_protocol = activation_protocol,
+															prefix = export_prefix,
 														  )
 				print('Correction successful.')
 				if return_stacks:
@@ -310,7 +320,7 @@ def correct_background_model_free(
 
 
 
-def apply_background_to_stack(stack_path, background, target_channel_index=0, nbr_channels=1, stack_length=45,activation_protocol=[['gauss',2],['std',4]], threshold_on_std=1, optimize_option=True, opt_coef_range=(0.95,1.05), opt_coef_nbr=100, operation='divide', clip=False, export=False, prefix="Corrected"):
+def apply_background_to_stack(stack_path, background, target_channel_index=0, nbr_channels=1, stack_length=45, offset = None, activation_protocol=[['gauss',2],['std',4]], threshold_on_std=1, optimize_option=True, opt_coef_range=(0.95,1.05), opt_coef_nbr=100, operation='divide', clip=False, export=False, prefix="Corrected", fix_nan=False):
 
 	"""
 	Apply background correction to an image stack.
@@ -385,11 +395,14 @@ def apply_background_to_stack(stack_path, background, target_channel_index=0, nb
 		
 		frames = load_frames(list(np.arange(i,(i+nbr_channels))), stack_path, normalize_input=False).astype(float)
 		target_img = frames[:,:,target_channel_index].copy()
-
+		if offset is not None:
+			#print(f"The offset is applied to image...")
+			target_img -= offset
+		
 		if optimize_option:
 			
 			target_copy = target_img.copy()
-
+			
 			std_frame = filter_image(target_copy.copy(),filters=activation_protocol)
 			edge = estimate_unreliable_edge(activation_protocol)
 			mask = threshold_image(std_frame, threshold_on_std, np.inf, foreground_value=1, edge_exclusion=edge)
@@ -412,7 +425,7 @@ def apply_background_to_stack(stack_path, background, target_channel_index=0, nb
 				loss.append(s)
 
 			c = coefficients[np.argmin(loss)]
-			print(f"Frame: {i}; optimal coefficient: {c}...")
+			print(f"IFD {i}; optimal coefficient: {c}...")
 			# if c==min(coefficients) or c==max(coefficients):
 			# 	print('Warning... The optimal coefficient is beyond the range provided... Please adjust your coefficient range...')	
 		else:
@@ -422,16 +435,20 @@ def apply_background_to_stack(stack_path, background, target_channel_index=0, nb
 			correction = np.divide(target_img, background*c, where=background==background)
 			correction[background!=background] = np.nan
 			correction[target_img!=target_img] = np.nan
-			fill_val = 1.0
 
 		elif operation=="subtract":
 			correction = np.subtract(target_img, background*c, where=background==background)
 			correction[background!=background] = np.nan
 			correction[target_img!=target_img] = np.nan
-			fill_val = 0.0
 			if clip:
 				correction[correction<=0.] = 0.
+		else:
+			print("Operation not supported... Abort.")
+			return
 
+		correction[~np.isfinite(correction)] = np.nan
+		if fix_nan:
+			correction = interpolate_nan(correction.copy())
 		frames[:,:,target_channel_index] = correction
 		corrected_stack.append(frames)
 
@@ -763,9 +780,9 @@ def correct_background_model(
 
 	config = get_config(experiment)
 	wells = get_experiment_wells(experiment)
-	len_movie = float(ConfigSectionMap(config,"MovieSettings")["len_movie"])
+	len_movie = float(config_section_to_dict(config, "MovieSettings")["len_movie"])
 	if movie_prefix is None:
-		movie_prefix = ConfigSectionMap(config,"MovieSettings")["movie_prefix"]	
+		movie_prefix = config_section_to_dict(config, "MovieSettings")["movie_prefix"]
 
 	well_indices, position_indices = interpret_wells_and_positions(experiment, well_option, position_option)
 	channel_indices = _extract_channel_indices_from_config(config, [target_channel])
@@ -785,6 +802,10 @@ def correct_background_model(
 		for pidx,pos_path in enumerate(tqdm(selection, disable=not show_progress_per_pos)):
 			
 			stack_path = get_position_movie_path(pos_path, prefix=movie_prefix)
+			if stack_path is None:
+				print(f"No stack could be found in {pos_path}... Skip...")
+				continue
+
 			print(f'Applying the correction to position {extract_position_name(pos_path)}...')
 			len_movie_auto = auto_load_number_of_frames(stack_path)
 			if len_movie_auto is not None:
@@ -901,7 +922,7 @@ def fit_and_apply_model_background_to_stack(stack_path,
 				frames = load_frames(list(np.arange(i,(i+nbr_channels))), stack_path, normalize_input=False).astype(float)
 				target_img = frames[:,:,target_channel_index].copy()
 				
-				correction = field_correction(target_img, threshold_on_std=threshold_on_std, operation=operation, model=model, clip=clip, activation_protocol=activation_protocol)
+				correction = field_correction(target_img, threshold=threshold_on_std, operation=operation, model=model, clip=clip, activation_protocol=activation_protocol)
 				frames[:,:,target_channel_index] = correction.copy()
 
 				if return_stacks:
@@ -922,7 +943,7 @@ def fit_and_apply_model_background_to_stack(stack_path,
 			frames = load_frames(list(np.arange(i,(i+nbr_channels))), stack_path, normalize_input=False).astype(float)
 			target_img = frames[:,:,target_channel_index].copy()
 			
-			correction = field_correction(target_img, threshold_on_std=threshold_on_std, operation=operation, model=model, clip=clip, activation_protocol=activation_protocol)
+			correction = field_correction(target_img, threshold=threshold_on_std, operation=operation, model=model, clip=clip, activation_protocol=activation_protocol)
 			frames[:,:,target_channel_index] = correction.copy()
 
 			corrected_stack.append(frames)
@@ -937,7 +958,7 @@ def fit_and_apply_model_background_to_stack(stack_path,
 	else:
 		return None
 
-def field_correction(img, threshold_on_std=1, operation='divide', model='paraboloid', clip=False, return_bg=False, activation_protocol=[['gauss',2],['std',4]]):
+def field_correction(img: np.ndarray, threshold: float = 1, operation: str = 'divide', model: str = 'paraboloid', clip: bool = False, return_bg: bool = False, activation_protocol: List[List] = [['gauss',2],['std',4]]):
 	
 	"""
 	Apply field correction to an image.
@@ -950,8 +971,8 @@ def field_correction(img, threshold_on_std=1, operation='divide', model='parabol
 	----------
 	img : numpy.ndarray
 		The input image to be corrected.
-	threshold_on_std : float, optional
-		The threshold value on the standard deviation for masking (default is 1).
+	threshold : float, optional
+		The threshold value on the image, post activation protocol for masking out cells (default is 1).
 	operation : str, optional
 		The operation to apply for background correction, either 'divide' or 'subtract' (default is 'divide').
 	model : str, optional
@@ -989,7 +1010,7 @@ def field_correction(img, threshold_on_std=1, operation='divide', model='parabol
 
 	std_frame = filter_image(target_copy,filters=activation_protocol)
 	edge = estimate_unreliable_edge(activation_protocol)
-	mask = threshold_image(std_frame, threshold_on_std, np.inf, foreground_value=1, edge_exclusion=edge).astype(int)
+	mask = threshold_image(std_frame, threshold, np.inf, foreground_value=1, edge_exclusion=edge).astype(int)
 	background = fit_background_model(img, cell_masks=mask, model=model, edge_exclusion=edge)
 
 	if operation=="divide":
@@ -1078,9 +1099,9 @@ def correct_channel_offset(
 
 	config = get_config(experiment)
 	wells = get_experiment_wells(experiment)
-	len_movie = float(ConfigSectionMap(config,"MovieSettings")["len_movie"])
+	len_movie = float(config_section_to_dict(config, "MovieSettings")["len_movie"])
 	if movie_prefix is None:
-		movie_prefix = ConfigSectionMap(config,"MovieSettings")["movie_prefix"]	
+		movie_prefix = config_section_to_dict(config, "MovieSettings")["movie_prefix"]
 
 	well_indices, position_indices = interpret_wells_and_positions(experiment, well_option, position_option)
 	channel_indices = _extract_channel_indices_from_config(config, [target_channel])

celldetective/regionprops/_regionprops.py

@@ -59,6 +59,22 @@ COL_DTYPES = {
 OBJECT_COLUMNS = [col for col, dtype in COL_DTYPES.items() if dtype == object]
 PROP_VALS = set(PROPS.values())
 
+_require_intensity_image = (
+    'image_intensity',
+    'intensity_max',
+    'intensity_mean',
+    'intensity_median',
+    'intensity_min',
+    'intensity_std',
+    'moments_weighted',
+    'moments_weighted_central',
+    'centroid_weighted',
+    'centroid_weighted_local',
+    'moments_weighted_hu',
+    'moments_weighted_normalized',
+)
+
+
 class CustomRegionProps(RegionProperties):
 
 	"""
@@ -79,11 +95,6 @@ class CustomRegionProps(RegionProperties):
 			assert len(self.channel_names)==self._intensity_image.shape[-1],'Mismatch between provided channel names and the number of channels in the image...'
 
 		if attr == "__setstate__":
-			# When deserializing this object with pickle, `__setstate__`
-			# is accessed before any other attributes like `self._intensity_image`
-			# are available which leads to a RecursionError when trying to
-			# access them later on in this function. So guard against this by
-			# provoking the default AttributeError (gh-6465).
 			return self.__getattribute__(attr)
 
 		if self._intensity_image is None and attr in _require_intensity_image:

celldetective/relative_measurements.py

@@ -396,7 +396,7 @@ def measure_pair_signals_at_position(pos, neighborhood_protocol, velocity_kwargs
 		return df_pairs
 
 	except KeyError:
-		print(f"Neighborhood {description} not found in data frame. Measurements for this neighborhood will not be calculated")
+		print(f"Neighborhood not found in data frame. Measurements for this neighborhood will not be calculated")
 
 
 def timeline_matching(timeline1, timeline2):
@@ -531,7 +531,7 @@ def update_effector_table(df_relative, df_effector):
 			df_effector.loc[df_effector['ID'] == effector, 'group_neighborhood'] = 0
 	return df_effector
 
-def extract_neighborhoods_from_pickles(pos):
+def extract_neighborhoods_from_pickles(pos, populations=['targets','effectors']):
 
 	"""
 	Extract neighborhood protocols from pickle files located at a given position.
@@ -573,29 +573,40 @@ def extract_neighborhoods_from_pickles(pos):
 	
 	"""
 
-	tab_tc = pos + os.sep.join(['output', 'tables', 'trajectories_targets.pkl'])
-	if os.path.exists(tab_tc):
-		df_targets = np.load(tab_tc, allow_pickle=True)
-	else:
-		df_targets = None
-	if os.path.exists(tab_tc.replace('targets','effectors')):
-		df_effectors = np.load(tab_tc.replace('targets','effectors'), allow_pickle=True)
-	else:
-		df_effectors = None
-
-	neighborhood_protocols=[]
-
-	if df_targets is not None:
-		for column in list(df_targets.columns):
-			if column.startswith('neighborhood'):
-				neigh_protocol = extract_neighborhood_settings(column, population='targets')
-				neighborhood_protocols.append(neigh_protocol)
-
-	if df_effectors is not None:
-		for column in list(df_effectors.columns):
-			if column.startswith('neighborhood'):
-				neigh_protocol = extract_neighborhood_settings(column, population='effectors')
-				neighborhood_protocols.append(neigh_protocol)
+	neighborhood_protocols = []
+
+	for pop in populations:
+		tab_pop = pos + os.sep.join(['output', 'tables', f'trajectories_{pop}.pkl'])
+		if os.path.exists(tab_pop):
+			df_pop = np.load(tab_pop, allow_pickle=True)
+			for column in list(df_pop.columns):
+				if column.startswith('neighborhood'):
+					neigh_protocol = extract_neighborhood_settings(column, population=pop)
+					neighborhood_protocols.append(neigh_protocol)
+
+	# tab_tc = pos + os.sep.join(['output', 'tables', 'trajectories_targets.pkl'])
+	# if os.path.exists(tab_tc):
+	# 	df_targets = np.load(tab_tc, allow_pickle=True)
+	# else:
+	# 	df_targets = None
+	# if os.path.exists(tab_tc.replace('targets','effectors')):
+	# 	df_effectors = np.load(tab_tc.replace('targets','effectors'), allow_pickle=True)
+	# else:
+	# 	df_effectors = None
+
+	# neighborhood_protocols=[]
+
+	# if df_targets is not None:
+	# 	for column in list(df_targets.columns):
+	# 		if column.startswith('neighborhood'):
+	# 			neigh_protocol = extract_neighborhood_settings(column, population='targets')
+	# 			neighborhood_protocols.append(neigh_protocol)
+
+	# if df_effectors is not None:
+	# 	for column in list(df_effectors.columns):
+	# 		if column.startswith('neighborhood'):
+	# 			neigh_protocol = extract_neighborhood_settings(column, population='effectors')
+	# 			neighborhood_protocols.append(neigh_protocol)
 
 	return neighborhood_protocols
 
@@ -646,10 +657,18 @@ def extract_neighborhood_settings(neigh_string, population='targets'):
 	"""
 
 	assert neigh_string.startswith('neighborhood')
-	if population=='targets':
-		neighbor_population = 'effectors'
-	elif population=='effectors':
-		neighbor_population = 'targets'
+	print(f"{neigh_string=}")
+
+	if '_(' in neigh_string and ')_' in neigh_string:
+		# determine neigh pop from string
+		neighbor_population = neigh_string.split('_(')[-1].split(')_')[0].split('-')[-1]
+		print(f'{neighbor_population=}')
+	else:
+		# old method
+		if population=='targets':
+			neighbor_population = 'effectors'
+		elif population=='effectors':
+			neighbor_population = 'targets'
 
 	if 'self' in neigh_string:
 		
@@ -716,6 +735,8 @@ def expand_pair_table(data):
 	assert 'reference_population' in list(data.columns),"Please provide a valid pair table..."
 	assert 'neighbor_population' in list(data.columns),"Please provide a valid pair table..."
 
+	data.__dict__.update(data.astype({'reference_population': str, 'neighbor_population': str}).__dict__)
+
 	expanded_table = []
 	
 	for neigh, group in data.groupby(['reference_population','neighbor_population']):

celldetective/scripts/analyze_signals.py

@@ -15,7 +15,7 @@ parser = argparse.ArgumentParser(description="Classify and regress the signals b
 								formatter_class=argparse.ArgumentDefaultsHelpFormatter)
 parser.add_argument('-p',"--position", required=True, help="Path to the position")
 parser.add_argument('-m',"--model", required=True, help="Path to the model")
-parser.add_argument("--mode", default="target", choices=["target","effector","targets","effectors"],help="Cell population of interest")
+parser.add_argument("--mode", default="target", help="Cell population of interest")
 parser.add_argument("--use_gpu", default="True", choices=["True","False"],help="use GPU")
 
 args = parser.parse_args()
@@ -36,6 +36,9 @@ if mode.lower()=="target" or mode.lower()=="targets":
 
 elif mode.lower()=="effector" or mode.lower()=="effectors":
 	table_name = "trajectories_effectors.csv"
+else:
+	table_name = f"trajectories_{mode}.csv"
+
 
 # Load trajectories, add centroid if not in trajectory
 trajectories = pos+os.sep.join(['output','tables', table_name])

celldetective/scripts/measure_cells.py

@@ -6,7 +6,7 @@ import argparse
 import os
 import json
 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 extract_experiment_channels, config_section_to_dict, _get_img_num_per_channel, extract_experiment_channels
 from celldetective.utils import _remove_invalid_cols, remove_redundant_features, remove_trajectory_measurements, _extract_coordinates_from_features
 from celldetective.measure import drop_tonal_features, measure_features, measure_isotropic_intensity, center_of_mass_to_abs_coordinates, measure_radial_distance_to_center
 from pathlib import Path, PurePath
@@ -55,10 +55,10 @@ 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"])
-time_calibration = float(ConfigSectionMap(config,"MovieSettings")["frametomin"])
-len_movie = float(ConfigSectionMap(config,"MovieSettings")["len_movie"])
+movie_prefix = config_section_to_dict(config, "MovieSettings")["movie_prefix"]
+spatial_calibration = float(config_section_to_dict(config, "MovieSettings")["pxtoum"])
+time_calibration = float(config_section_to_dict(config, "MovieSettings")["frametomin"])
+len_movie = float(config_section_to_dict(config, "MovieSettings")["len_movie"])
 channel_names, channel_indices = extract_experiment_channels(expfolder)
 nbr_channels = len(channel_names)
 

celldetective/scripts/measure_relative.py

@@ -1,7 +1,8 @@
 import argparse
 import os
 from celldetective.relative_measurements import measure_pair_signals_at_position, extract_neighborhoods_from_pickles
-from celldetective.utils import ConfigSectionMap, extract_experiment_channels
+from celldetective.utils import config_section_to_dict, extract_experiment_channels
+from celldetective.io import get_experiment_populations
 
 from pathlib import Path, PurePath
 
@@ -30,13 +31,15 @@ assert os.path.exists(config), 'The configuration file for the experiment could
 print("Configuration file: ", config)
 
 # from exp config fetch spatial calib, channel names
-movie_prefix = ConfigSectionMap(config, "MovieSettings")["movie_prefix"]
-spatial_calibration = float(ConfigSectionMap(config, "MovieSettings")["pxtoum"])
-time_calibration = float(ConfigSectionMap(config, "MovieSettings")["frametomin"])
-len_movie = float(ConfigSectionMap(config, "MovieSettings")["len_movie"])
+movie_prefix = config_section_to_dict(config, "MovieSettings")["movie_prefix"]
+spatial_calibration = float(config_section_to_dict(config, "MovieSettings")["pxtoum"])
+time_calibration = float(config_section_to_dict(config, "MovieSettings")["frametomin"])
+len_movie = float(config_section_to_dict(config, "MovieSettings")["len_movie"])
 channel_names, channel_indices = extract_experiment_channels(expfolder)
 nbr_channels = len(channel_names)
 
+populations = get_experiment_populations(expfolder, dtype=str)
+
 # from tracking instructions, fetch btrack config, features, haralick, clean_traj, idea: fetch custom timeline?
 instr_path = PurePath(expfolder, Path(f"{instruction_file}"))
 previous_pair_table_path = pos + os.sep.join(['output', 'tables', 'trajectories_pairs.csv'])
@@ -46,7 +49,7 @@ previous_neighborhoods = []
 associated_reference_population = []
 
 
-neighborhoods_to_measure = extract_neighborhoods_from_pickles(pos)
+neighborhoods_to_measure = extract_neighborhoods_from_pickles(pos, populations=populations)
 all_df_pairs = []
 if os.path.exists(previous_pair_table_path):
 	df_0 = pd.read_csv(previous_pair_table_path)
@@ -76,9 +79,14 @@ if len(all_df_pairs)>1:
 		df_pairs = pd.merge(df_pairs.round(decimals=6), all_df_pairs[i].round(decimals=6), how="outer", on=cols)
 elif len(all_df_pairs)==1:
 	df_pairs = all_df_pairs[0]
-
-print('Writing table...')
-df_pairs = df_pairs.sort_values(by=['reference_population', 'neighbor_population', 'REFERENCE_ID', 'NEIGHBOR_ID', 'FRAME'])
-df_pairs.to_csv(previous_pair_table_path, index=False)
-print('Done.')
-
+else:
+	df_pairs = None
+	print('No dataframe could be computed for the pairs...')
+
+if df_pairs is not None:
+	print('Writing table...')
+	if "reference_population" in list(df_pairs.columns) and "neighbor_population" in list(df_pairs.columns):
+		df_pairs = df_pairs.sort_values(by=['reference_population', 'neighbor_population', 'REFERENCE_ID', 'NEIGHBOR_ID', 'FRAME'])
+	df_pairs.to_csv(previous_pair_table_path, index=False)
+	print('Done.')
+	

celldetective/scripts/segment_cells.py

@@ -7,7 +7,7 @@ import datetime
 import os
 import json
 from celldetective.io import locate_segmentation_model, auto_load_number_of_frames, extract_position_name, _load_frames_to_segment, _check_label_dims
-from celldetective.utils import _prep_stardist_model, _prep_cellpose_model, _rescale_labels, _segment_image_with_stardist_model,_segment_image_with_cellpose_model,_get_normalize_kwargs_from_config, _estimate_scale_factor, _extract_channel_indices_from_config, ConfigSectionMap, _extract_nbr_channels_from_config, _get_img_num_per_channel
+from celldetective.utils import _prep_stardist_model, _prep_cellpose_model, _rescale_labels, _segment_image_with_stardist_model,_segment_image_with_cellpose_model,_get_normalize_kwargs_from_config, _estimate_scale_factor, _extract_channel_indices_from_config, config_section_to_dict, _extract_nbr_channels_from_config, _get_img_num_per_channel
 from pathlib import Path, PurePath
 from glob import glob
 from shutil import rmtree
@@ -91,9 +91,9 @@ normalize_kwargs = _get_normalize_kwargs_from_config(input_config)
 
 model_type = input_config['model_type']
 
-movie_prefix = ConfigSectionMap(config,"MovieSettings")["movie_prefix"]
-spatial_calibration = float(ConfigSectionMap(config,"MovieSettings")["pxtoum"])
-len_movie = float(ConfigSectionMap(config,"MovieSettings")["len_movie"])
+movie_prefix = config_section_to_dict(config, "MovieSettings")["movie_prefix"]
+spatial_calibration = float(config_section_to_dict(config, "MovieSettings")["pxtoum"])
+len_movie = float(config_section_to_dict(config, "MovieSettings")["len_movie"])
 
 # Try to find the file
 try:
@@ -183,12 +183,6 @@ with concurrent.futures.ThreadPoolExecutor() as executor:
 		print("Exception: ", e)
 
 print('Done.')
-
-try:
-	del model
-except:
-	pass
-
 gc.collect()
 
 

celldetective/scripts/segment_cells_thresholds.py

@@ -7,7 +7,7 @@ import os
 import json
 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 celldetective.utils import _extract_channel_indices_from_config, config_section_to_dict, _extract_nbr_channels_from_config, _get_img_num_per_channel, extract_experiment_channels
 from pathlib import Path, PurePath
 from glob import glob
 from shutil import rmtree
@@ -70,8 +70,8 @@ print(f'Required channels: {required_channels} located at channel indices {chann
 
 threshold_instructions.update({'target_channel': channel_indices[0]})
 
-movie_prefix = ConfigSectionMap(config,"MovieSettings")["movie_prefix"]
-len_movie = float(ConfigSectionMap(config,"MovieSettings")["len_movie"])
+movie_prefix = config_section_to_dict(config, "MovieSettings")["movie_prefix"]
+len_movie = float(config_section_to_dict(config, "MovieSettings")["len_movie"])
 channel_names, channel_indices = extract_experiment_channels(expfolder)
 threshold_instructions.update({'channel_names': channel_names})
 

celldetective/scripts/track_cells.py

@@ -6,8 +6,10 @@ import argparse
 import datetime
 import os
 import json
-from celldetective.io import auto_load_number_of_frames, interpret_tracking_configuration, extract_position_name
-from celldetective.utils import _mask_intensity_measurements, extract_experiment_channels, ConfigSectionMap, _get_img_num_per_channel, extract_experiment_channels
+from celldetective.io import _load_frames_to_measure, auto_load_number_of_frames, interpret_tracking_configuration, \
+	extract_position_name, \
+	locate_labels
+from celldetective.utils import _mask_intensity_measurements, extract_experiment_channels, config_section_to_dict, _get_img_num_per_channel, extract_experiment_channels
 from celldetective.measure import drop_tonal_features, measure_features
 from celldetective.tracking import track
 from pathlib import Path, PurePath
@@ -65,12 +67,12 @@ 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"])
-time_calibration = float(ConfigSectionMap(config,"MovieSettings")["frametomin"])
-len_movie = float(ConfigSectionMap(config,"MovieSettings")["len_movie"])
-shape_x = int(ConfigSectionMap(config,"MovieSettings")["shape_x"])
-shape_y = int(ConfigSectionMap(config,"MovieSettings")["shape_y"])
+movie_prefix = config_section_to_dict(config, "MovieSettings")["movie_prefix"]
+spatial_calibration = float(config_section_to_dict(config, "MovieSettings")["pxtoum"])
+time_calibration = float(config_section_to_dict(config, "MovieSettings")["frametomin"])
+len_movie = float(config_section_to_dict(config, "MovieSettings")["len_movie"])
+shape_x = int(config_section_to_dict(config, "MovieSettings")["shape_x"])
+shape_y = int(config_section_to_dict(config, "MovieSettings")["shape_y"])
 
 channel_names, channel_indices = extract_experiment_channels(expfolder)
 nbr_channels = len(channel_names)

celldetective/scripts/train_segmentation_model.py

@@ -124,15 +124,18 @@ if model_type=='cellpose':
 		device = torch.device("cpu")
 	else:
 		print('Using GPU for training...')
-		
+	
+	diam_mean = 30.0
 	logger, log_file = logger_setup()
 	print(f'Pretrained model: ',pretrained)
 	if pretrained is not None:
+		if pretrained.endswith('CP_nuclei'):
+			diam_mean = 17.0
 		pretrained_path = os.sep.join([pretrained,os.path.split(pretrained)[-1]])
 	else:
 		pretrained_path = pretrained
 	
-	model = CellposeModel(gpu=use_gpu, model_type=None, pretrained_model=pretrained_path, diam_mean=30.0, nchan=X_aug[0].shape[0],) 
+	model = CellposeModel(gpu=use_gpu, model_type=None, pretrained_model=pretrained_path, diam_mean=diam_mean, nchan=X_aug[0].shape[0],) 
 	model.train(train_data=X_aug, train_labels=Y_aug, normalize=False, channels=None, batch_size=batch_size,
 				min_train_masks=1,save_path=target_directory+os.sep+model_name,n_epochs=epochs, model_name=model_name, learning_rate=learning_rate, test_data = X_val, test_labels=Y_val)
 
@@ -152,7 +155,7 @@ if model_type=='cellpose':
 	config_inputs = {"channels": target_channels, "diameter": standard_diameter, 'cellprob_threshold': 0., 'flow_threshold': 0.4,
 	'normalization_percentile': normalization_percentile, 'normalization_clip': normalization_clip,
 	'normalization_values': normalization_values, 'model_type': 'cellpose',
-	'spatial_calibration': input_spatial_calibration, 'dataset': {'train': files_train, 'validation': files_val}}
+	'spatial_calibration': input_spatial_calibration, 'cell_size_um': round(diameter*input_spatial_calibration,4), 'dataset': {'train': files_train, 'validation': files_val}}
 	json_input_config = json.dumps(config_inputs, indent=4)
 	with open(os.sep.join([target_directory, model_name, "config_input.json"]), "w") as outfile:
 		outfile.write(json_input_config)
@@ -227,9 +230,18 @@ elif model_type=='stardist':
 
 	config_inputs = {"channels": target_channels, 'normalization_percentile': normalization_percentile,
 	'normalization_clip': normalization_clip, 'normalization_values': normalization_values, 
-	'model_type': 'stardist', 'spatial_calibration': spatial_calibration, 'dataset': {'train': files_train, 'validation': files_val}}
-
-	json_input_config = json.dumps(config_inputs, indent=4)
+	'model_type': 'stardist', 'spatial_calibration': spatial_calibration,'cell_size_um': median_size * spatial_calibration, 'dataset': {'train': files_train, 'validation': files_val}}
+
+	def make_json_safe(obj):
+		if isinstance(obj, np.ndarray):
+			return obj.tolist()  # convert to list
+		if isinstance(obj, (np.int64, np.int32)):
+			return int(obj)
+		if isinstance(obj, (np.float32, np.float64)):
+			return float(obj)
+		return str(obj)  # fallback
+
+	json_input_config = json.dumps(config_inputs, indent=4, default=make_json_safe)
 	with open(os.sep.join([target_directory, model_name, "config_input.json"]), "w") as outfile:
 		outfile.write(json_input_config)