celldetective 1.4.0__py3-none-any.whl → 1.4.1.post1__py3-none-any.whl

celldetective/measure.py

@@ -17,6 +17,7 @@ from math import ceil
 from skimage.draw import disk as dsk
 from skimage.feature import blob_dog, blob_log
 
+from celldetective.exceptions import EmptyQueryError, MissingColumnsError, QueryError
 from celldetective.utils import rename_intensity_column, create_patch_mask, remove_redundant_features, \
 	remove_trajectory_measurements, contour_of_instance_segmentation, extract_cols_from_query, step_function, interpolate_nan, _remove_invalid_cols
 from celldetective.preprocessing import field_correction
@@ -1432,35 +1433,39 @@ def classify_cells_from_query(df, status_attr, query):
 		If the query is invalid or if there are issues with the DataFrame or query syntax, an error message is printed, and `None` is returned.
 	
 	"""
-
-
-	# Initialize all states to 0
-	if not status_attr.startswith('status_'):
-		status_attr = 'status_'+status_attr
-
+	
+	if not status_attr.startswith("status_"):
+		status_attr = "status_" + status_attr
+	
 	df = df.copy()
-	df.loc[:,status_attr] = 0
+	df = df.replace([np.inf, -np.inf, None], np.nan)
+	#df = df.convert_dtypes()
+	
+	df.loc[:, status_attr] = 0
 	df[status_attr] = df[status_attr].astype(float)
-
+	
 	cols = extract_cols_from_query(query)
-	print(f"{cols=}")
-
-	cols_in_df = np.all([c in list(df.columns) for c in cols], axis=0)
-	if query=='':
-		print('The provided query is empty...')
-	else:
-		try:
-			if cols_in_df:
-				selection = df.dropna(subset=cols).query(query).index
-				null_selection = df[df.loc[:,cols].isna().any(axis=1)].index
-				# Set NaN to invalid cells, 1 otherwise
-				df.loc[null_selection, status_attr] = np.nan
-				df.loc[selection, status_attr] = 1
-			else:
-				df.loc[:, status_attr] = np.nan
-		except Exception as e:
-			print(f"The query could not be understood. No filtering was applied. {e}...")
-			return None
+	print(f"The following DataFrame measurements were identified in the query: {cols=}...")
+	
+	if query.strip() == "":
+		raise EmptyQueryError("The provided query is empty.")
+	
+	missing_cols = [c for c in cols if c not in df.columns]
+	if missing_cols:
+		raise MissingColumnsError(missing_cols)
+	
+	try:
+		sub_df = df.dropna(subset=cols)
+		if len(sub_df) > 0:
+			selection = sub_df.query(query).index
+			null_selection = df[df.loc[:, cols].isna().any(axis=1)].index
+			df.loc[null_selection, status_attr] = np.nan
+			df.loc[selection, status_attr] = 1
+		else:
+			df.loc[:, status_attr] = np.nan
+	except Exception as e:
+		raise QueryError(f"The query could not be understood: {e}")
+	
 	return df.copy()
 
 def classify_tracks_from_query(df, event_name, query, irreversible_event=True, unique_state=False, r2_threshold=0.5, percentile_recovery=50):

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, offset=None):
+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, "*")
 
@@ -152,6 +153,8 @@ def estimate_background_per_condition(experiment, threshold_on_std=1, well_optio
 			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:
@@ -179,6 +182,7 @@ def correct_background_model_free(
 					   export = False,
 					   return_stacks = False,
 					   movie_prefix=None,
+					   fix_nan=False,
 					   activation_protocol=[['gauss',2],['std',4]],
 					   export_prefix='Corrected',
 					   **kwargs,
@@ -247,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])
@@ -263,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, offset=offset)
+			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:
@@ -298,6 +302,7 @@ def correct_background_model_free(
 															clip = clip,
 															offset = offset,
 															export = export,
+															fix_nan=fix_nan,
 															activation_protocol = activation_protocol,
 															prefix = export_prefix,
 														  )
@@ -315,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, 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"):
+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.
@@ -420,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:
@@ -430,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)
 
@@ -771,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])
@@ -793,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:
@@ -909,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:
@@ -930,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)
@@ -945,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.
@@ -958,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
@@ -997,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":
@@ -1086,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/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,7 @@
 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
@@ -31,10 +31,10 @@ 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)
 
@@ -79,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:

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

@@ -9,7 +9,7 @@ import json
 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, ConfigSectionMap, _get_img_num_per_channel, extract_experiment_channels
+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
@@ -67,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

@@ -232,7 +232,16 @@ elif model_type=='stardist':
 	'normalization_clip': normalization_clip, 'normalization_values': normalization_values, 
 	'model_type': 'stardist', 'spatial_calibration': spatial_calibration,'cell_size_um': median_size * spatial_calibration, 'dataset': {'train': files_train, 'validation': files_val}}
 
-	json_input_config = json.dumps(config_inputs, indent=4)
+	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)
 

celldetective/tracking.py

@@ -189,7 +189,8 @@ def track(labels, configuration=None, stack=None, spatial_calibration=1, feature
 
 	if clean_trajectories_kwargs is not None:
 		df = clean_trajectories(df.copy(),**clean_trajectories_kwargs)
-
+	
+	df.loc[df["status_firstdetection"].isna(), "status_firstdetection"] = 0
 	df['ID'] = np.arange(len(df)).astype(int)
 
 	invalid_cols = [c for c in list(df.columns) if c.startswith('Unnamed')]
@@ -1002,7 +1003,10 @@ def write_first_detection_class(df, img_shape=None, edge_threshold=20, column_la
 		positions_x = track_group[column_labels['x']].values
 		positions_y = track_group[column_labels['y']].values
 		dt = 1
-
+		
+		timeline = track_group['FRAME'].to_numpy()
+		status = np.ones_like(timeline)
+		
 		# Initialize
 		cclass = 2; t_first = np.nan;
 
@@ -1023,16 +1027,18 @@ def write_first_detection_class(df, img_shape=None, edge_threshold=20, column_la
 				t_first =  float(t_first) - float(dt)
 				if t_first==0:
 					t_first += 0.01
-
+			
 			if edge_test:
 				cclass = 2
 				# switch to class 2 but keep time/status information
 		else:
 			t_first = -1
 			cclass = 2
-
+		
+		status[timeline < t_first] = 0.
 		df.loc[indices, 'class_firstdetection'] = cclass
 		df.loc[indices, 't_firstdetection'] = t_first
+		df.loc[indices, 'status_firstdetection'] = status
 
 	return df