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

celldetective/io.py

@@ -24,12 +24,17 @@ from magicgui import magicgui
 from pathlib import Path, PurePath
 from shutil import copyfile, rmtree
 
-from celldetective.utils import _rearrange_multichannel_frame, _fix_no_contrast, zoom_multiframes,ConfigSectionMap, extract_experiment_channels, _extract_labels_from_config, get_zenodo_files, download_zenodo_file
-from celldetective.utils import interpolate_nan_multichannel, _estimate_scale_factor, _extract_channel_indices_from_config, _extract_channel_indices, _extract_nbr_channels_from_config, _get_img_num_per_channel, normalize_per_channel, get_config
+from celldetective.utils import _rearrange_multichannel_frame, _fix_no_contrast, zoom_multiframes, \
+	config_section_to_dict, extract_experiment_channels, _extract_labels_from_config, get_zenodo_files, \
+	download_zenodo_file
+from celldetective.utils import interpolate_nan_multichannel, get_config
 
 from stardist import fill_label_holes
 from skimage.transform import resize
+import re
 
+from typing import List, Tuple, Union
+import numbers
 
 def extract_experiment_from_well(well_path):
 
@@ -202,6 +207,9 @@ def collect_experiment_metadata(pos_path=None, well_path=None):
 		if not well_path.endswith(os.sep):
 			well_path += os.sep
 		experiment = extract_experiment_from_well(well_path)
+	else:
+		print("Please provide a position or well path...")
+		return None
 		
 	wells = list(get_experiment_wells(experiment))
 	idx = wells.index(well_path)
@@ -211,7 +219,14 @@ def collect_experiment_metadata(pos_path=None, well_path=None):
 	else:
 		pos_name = 0
 
-	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}
+	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,
+			}
 
 	meta = get_experiment_metadata(experiment) # None or dict of metadata
 	if meta is not None:
@@ -306,9 +321,9 @@ def get_spatial_calibration(experiment):
 	"""
 
 	config = get_config(experiment)
-	PxToUm = float(ConfigSectionMap(config, "MovieSettings")["pxtoum"])
+	px_to_um = float(config_section_to_dict(config, "MovieSettings")["pxtoum"])
 
-	return PxToUm
+	return px_to_um
 
 
 def get_temporal_calibration(experiment):
@@ -351,14 +366,14 @@ def get_temporal_calibration(experiment):
 	"""
 
 	config = get_config(experiment)
-	FrameToMin = float(ConfigSectionMap(config, "MovieSettings")["frametomin"])
+	frame_to_min = float(config_section_to_dict(config, "MovieSettings")["frametomin"])
 
-	return FrameToMin
+	return frame_to_min
 
 def get_experiment_metadata(experiment):
 
 	config = get_config(experiment)
-	metadata = ConfigSectionMap(config, "Metadata")
+	metadata = config_section_to_dict(config, "Metadata")
 	return metadata
 
 def get_experiment_labels(experiment):
@@ -367,12 +382,12 @@ def get_experiment_labels(experiment):
 	wells = get_experiment_wells(experiment)
 	nbr_of_wells = len(wells)
 
-	labels = ConfigSectionMap(config, "Labels")
+	labels = config_section_to_dict(config, "Labels")
 	for k in list(labels.keys()):
 		values = labels[k].split(',')
 		if nbr_of_wells != len(values):
 			values = [str(s) for s in np.linspace(0, nbr_of_wells - 1, nbr_of_wells)]
-		if np.all([s.isnumeric() for s in values]):
+		if np.all(np.array([s.isnumeric() for s in values])):
 			values = [float(s) for s in values]
 		labels.update({k: values})
 
@@ -427,7 +442,7 @@ def get_experiment_concentrations(experiment, dtype=str):
 	wells = get_experiment_wells(experiment)
 	nbr_of_wells = len(wells)
 
-	concentrations = ConfigSectionMap(config, "Labels")["concentrations"].split(",")
+	concentrations = config_section_to_dict(config, "Labels")["concentrations"].split(",")
 	if nbr_of_wells != len(concentrations):
 		concentrations = [str(s) for s in np.linspace(0, nbr_of_wells - 1, nbr_of_wells)]
 
@@ -482,7 +497,7 @@ def get_experiment_cell_types(experiment, dtype=str):
 	wells = get_experiment_wells(experiment)
 	nbr_of_wells = len(wells)
 
-	cell_types = ConfigSectionMap(config, "Labels")["cell_types"].split(",")
+	cell_types = config_section_to_dict(config, "Labels")["cell_types"].split(",")
 	if nbr_of_wells != len(cell_types):
 		cell_types = [str(s) for s in np.linspace(0, nbr_of_wells - 1, nbr_of_wells)]
 
@@ -534,7 +549,7 @@ def get_experiment_antibodies(experiment, dtype=str):
 	wells = get_experiment_wells(experiment)
 	nbr_of_wells = len(wells)
 
-	antibodies = ConfigSectionMap(config, "Labels")["antibodies"].split(",")
+	antibodies = config_section_to_dict(config, "Labels")["antibodies"].split(",")
 	if nbr_of_wells != len(antibodies):
 		antibodies = [str(s) for s in np.linspace(0, nbr_of_wells - 1, nbr_of_wells)]
 
@@ -589,14 +604,25 @@ def get_experiment_pharmaceutical_agents(experiment, dtype=str):
 	wells = get_experiment_wells(experiment)
 	nbr_of_wells = len(wells)
 
-	pharmaceutical_agents = ConfigSectionMap(config, "Labels")["pharmaceutical_agents"].split(",")
+	pharmaceutical_agents = config_section_to_dict(config, "Labels")["pharmaceutical_agents"].split(",")
 	if nbr_of_wells != len(pharmaceutical_agents):
 		pharmaceutical_agents = [str(s) for s in np.linspace(0, nbr_of_wells - 1, nbr_of_wells)]
 
 	return np.array([dtype(c) for c in pharmaceutical_agents])
 
 
-def interpret_wells_and_positions(experiment, well_option, position_option):
+def get_experiment_populations(experiment, dtype=str):
+
+	config = get_config(experiment)
+	populations_str = config_section_to_dict(config, "Populations")
+	if populations_str is not None:
+		populations = populations_str['populations'].split(',')
+	else:
+		populations = ['effectors','targets']
+	return list([dtype(c) for c in populations])
+
+
+def interpret_wells_and_positions(experiment: str, well_option: Union[str,int,List[int]], position_option: Union[str,int,List[int]]) -> Union[Tuple[List[int], List[int]], None]:
 	"""
 	Interpret well and position options for a given experiment.
 
@@ -606,8 +632,8 @@ def interpret_wells_and_positions(experiment, well_option, position_option):
 
 	Parameters
 	----------
-	experiment : object
-		The experiment object containing well information.
+	experiment : str
+		The experiment path containing well information.
 	well_option : str, int, or list of int
 		The well selection option:
 		- '*' : Select all wells.
@@ -649,6 +675,9 @@ def interpret_wells_and_positions(experiment, well_option, position_option):
 		well_indices = [int(well_option)]
 	elif isinstance(well_option, list):
 		well_indices = well_option
+	else:
+		print("Well indices could not be interpreted...")
+		return None
 
 	if position_option == '*':
 		position_indices = None
@@ -656,6 +685,9 @@ def interpret_wells_and_positions(experiment, well_option, position_option):
 		position_indices = np.array([position_option], dtype=int)
 	elif isinstance(position_option, list):
 		position_indices = position_option
+	else:
+		print("Position indices could not be interpreted...")
+		return None
 
 	return well_indices, position_indices
 
@@ -784,7 +816,11 @@ def get_position_table(pos, population, return_path=False):
 		table = pos + os.sep.join(['output', 'tables', f'trajectories_{population}.csv'])
 
 	if os.path.exists(table):
-		df_pos = pd.read_csv(table, low_memory=False)
+		try:
+			df_pos = pd.read_csv(table, low_memory=False)
+		except Exception as e:
+			print(e)
+			df_pos = None
 	else:
 		df_pos = None
 	
@@ -959,7 +995,7 @@ def load_experiment_tables(experiment, population='targets', well_option='*', po
 	config = get_config(experiment)
 	wells = get_experiment_wells(experiment)
 
-	movie_prefix = ConfigSectionMap(config, "MovieSettings")["movie_prefix"]
+	movie_prefix = config_section_to_dict(config, "MovieSettings")["movie_prefix"]
 
 	labels = get_experiment_labels(experiment)
 	metadata = get_experiment_metadata(experiment) # None or dict of metadata
@@ -1016,15 +1052,23 @@ def load_experiment_tables(experiment, population='targets', well_option='*', po
 
 				if metadata is not None:
 					keys = list(metadata.keys())
-					for k in keys:
-						df_pos[k] = metadata[k]
+					for key in keys:
+						df_pos[key] = metadata[key]
 
 				df.append(df_pos)
 				any_table = True
 
-				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}
+				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,
+							}
 
 				df_pos_info.append(pos_dict)
 
@@ -1087,7 +1131,9 @@ def locate_stack(position, prefix='Aligned'):
 		position += os.sep
 
 	stack_path = glob(position + os.sep.join(['movie', f'{prefix}*.tif']))
-	assert len(stack_path) > 0, f"No movie with prefix {prefix} found..."
+	if not stack_path:
+		raise FileNotFoundError(f"No movie with prefix {prefix} found...")
+
 	stack = imread(stack_path[0].replace('\\', '/'))
 	stack_length = auto_load_number_of_frames(stack_path[0])
 
@@ -1165,6 +1211,9 @@ def locate_labels(position, population='target', frames=None):
 		label_path = natsorted(glob(position + os.sep.join(["labels_targets", "*.tif"])))
 	elif population.lower() == "effector" or population.lower() == "effectors":
 		label_path = natsorted(glob(position + os.sep.join(["labels_effectors", "*.tif"])))
+	else:
+		label_path = natsorted(glob(position + os.sep.join([f"labels_{population}", "*.tif"])))
+
 
 	label_names = [os.path.split(lbl)[-1] for lbl in label_path]
 
@@ -1242,6 +1291,9 @@ def fix_missing_labels(position, population='target', prefix='Aligned'):
 	elif population.lower() == "effector" or population.lower() == "effectors":
 		label_path = natsorted(glob(position + os.sep.join(["labels_effectors", "*.tif"])))
 		path = position + os.sep + "labels_effectors"
+	else:
+		label_path = natsorted(glob(position + os.sep.join([f"labels_{population}", "*.tif"])))
+		path = position + os.sep + f"labels_{population}"		
 
 	if label_path!=[]:
 		#path = os.path.split(label_path[0])[0]
@@ -1348,6 +1400,9 @@ def load_tracking_data(position, prefix="Aligned", population="target"):
 		trajectories = pd.read_csv(position + os.sep.join(['output', 'tables', 'trajectories_targets.csv']))
 	elif population.lower() == "effector" or population.lower() == "effectors":
 		trajectories = pd.read_csv(position + os.sep.join(['output', 'tables', 'trajectories_effectors.csv']))
+	else:
+		trajectories = pd.read_csv(position + os.sep.join(['output', 'tables', f'trajectories_{population}.csv']))
+
 
 	stack, labels = locate_stack_and_labels(position, prefix=prefix, population=population)
 
@@ -1397,7 +1452,7 @@ def auto_load_number_of_frames(stack_path):
 
 	Handle invalid or missing paths gracefully:
 
-	>>> frames = auto_load_number_of_frames(None)
+	>>> frames = auto_load_number_of_frames("stack.tif")
 	>>> print(frames)
 	None
 
@@ -1500,7 +1555,7 @@ def parse_isotropic_radii(string):
 
 	"""
 
-	sections = re.split(',| ', string)
+	sections = re.split(r"[ ,]", string)
 	radii = []
 	for k, s in enumerate(sections):
 		if s.isdigit():
@@ -2324,7 +2379,7 @@ def load_napari_data(position, prefix="Aligned", population="target", return_sta
 	position : str
 		The path to the position or experiment directory.
 	prefix : str, optional
-		The prefix used to identify the the movie file. The default is "Aligned".
+		The prefix used to identify the movie file. The default is "Aligned".
 	population : str, optional
 		The population type to load, either "target" or "effector". The default is "target".
 
@@ -2354,6 +2409,11 @@ def load_napari_data(position, prefix="Aligned", population="target", return_sta
 			napari_data = np.load(position+os.sep.join(['output', 'tables', 'napari_effector_trajectories.npy']), allow_pickle=True)
 		else:
 			napari_data = None
+	else:
+		if os.path.exists(position+os.sep.join(['output', 'tables', f'napari_{population}_trajectories.npy'])):
+			napari_data = np.load(position+os.sep.join(['output', 'tables', f'napari_{population}_trajectories.npy']), allow_pickle=True)
+		else:
+			napari_data = None	
 
 	if napari_data is not None:
 		data = napari_data.item()['data']
@@ -2371,7 +2431,7 @@ def load_napari_data(position, prefix="Aligned", population="target", return_sta
 	return data, properties, graph, labels, stack
 
 
-def auto_correct_masks(masks, bbox_factor = 1.75, min_area=9, fill_labels=False):
+def auto_correct_masks(masks, bbox_factor: float = 1.75, min_area: int = 9, fill_labels: bool = False):
 
 	"""
 	Correct segmentation masks to ensure consistency and remove anomalies.
@@ -2391,6 +2451,13 @@ def auto_correct_masks(masks, bbox_factor = 1.75, min_area=9, fill_labels=False)
 	masks : np.ndarray
 		A 2D array representing the segmented mask image with labeled regions. Each unique value 
 		in the array represents a different object or cell.
+	bbox_factor : float, optional
+		A factor on cell area that is compared directly to the bounding box area of the cell, to detect remote cells
+		sharing a same label value. The default is `1.75`.
+	min_area : int, optional
+		Discard cells that have an area smaller than this minimum area (px²). The default is `9` (3x3 pixels).
+	fill_labels : bool, optional
+		Fill holes within cell masks automatically. The default is `False`.
 
 	Returns
 	-------
@@ -2414,6 +2481,8 @@ def auto_correct_masks(masks, bbox_factor = 1.75, min_area=9, fill_labels=False)
 		   [0, 2, 2, 1],
 		   [0, 2, 0, 0]])
 	"""
+	
+	assert masks.ndim==2,"`masks` should be a 2D numpy array..."
 
 	# Avoid negative mask values
 	masks[masks<0] = np.abs(masks[masks<0])
@@ -2478,6 +2547,8 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 		The prefix used to identify the stack. The default is 'Aligned'.
 	population : str, optional
 		The population type for which the segmentation is performed. The default is 'target'.
+	flush_memory : bool, optional
+		Pop napari layers upon closing the viewer to empty the memory footprint. The default is `False`.
 
 	Notes
 	-----
@@ -2493,6 +2564,9 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 
 	def export_labels():
 		labels_layer = viewer.layers['segmentation'].data
+		if not os.path.exists(output_folder):
+			os.mkdir(output_folder)
+
 		for t, im in enumerate(tqdm(labels_layer)):
 
 			try:
@@ -2531,7 +2605,7 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 			for k in keys:
 				info.update({k: metadata_info[k]})
 
-		spatial_calibration = float(ConfigSectionMap(config,"MovieSettings")["pxtoum"])
+		spatial_calibration = float(config_section_to_dict(config, "MovieSettings")["pxtoum"])
 		channel_names, channel_indices = extract_experiment_channels(expfolder)
 
 		annotation_folder = expfolder + os.sep + f'annotations_{population}' + os.sep
@@ -2639,12 +2713,9 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 		return export_annotation()
 
 	stack, labels = locate_stack_and_labels(position, prefix=prefix, population=population)
-
-	if not population.endswith('s'):
-		population += 's'
 	output_folder = position + f'labels_{population}{os.sep}'
+	print(f"Shape of the loaded image stack: {stack.shape}...")
 
-	print(f"{stack.shape}")
 	viewer = napari.Viewer()
 	viewer.add_image(stack, channel_axis=-1, colormap=["gray"] * stack.shape[-1])
 	viewer.add_labels(labels.astype(int), name='segmentation', opacity=0.4)
@@ -2678,6 +2749,8 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 		del labels
 		gc.collect()
 
+	print("napari viewer was successfully closed...")
+
 def correct_annotation(filename):
 
 	"""
@@ -2700,6 +2773,12 @@ def correct_annotation(filename):
 	def save_widget():
 		return export_labels()
 
+	if filename.endswith("_labelled.tif"):
+		filename = filename.replace("_labelled.tif",".tif")
+	if filename.endswith(".json"):
+		filename = filename.replace('.json',".tif")
+	assert os.path.exists(filename),f"Image {filename} does not seem to exist..."
+	
 	img = imread(filename.replace('\\','/'))
 	if img.ndim==3:
 		img = np.moveaxis(img, 0, -1)
@@ -2764,7 +2843,7 @@ def _view_on_napari(tracks=None, stack=None, labels=None):
 	...                        'x': [10, 20, 30], 'y': [15, 25, 35]})
 	>>> stack = np.random.rand(100, 100, 3)
 	>>> labels = np.random.randint(0, 2, (100, 100))
-	>>> view_on_napari(tracks, stack=stack, labels=labels)
+	>>> _view_on_napari(tracks, stack=stack, labels=labels)
 	# Visualize tracks, stack, and labels using Napari.
 
 	"""
@@ -2827,21 +2906,15 @@ def control_tracking_table(position, calibration=1, prefix="Aligned", population
 
 
 def get_segmentation_models_list(mode='targets', return_path=False):
-	if mode == 'targets':
-		modelpath = os.sep.join(
-			[os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], "celldetective", "models",
-			 "segmentation_targets", os.sep])
-		repository_models = get_zenodo_files(cat=os.sep.join(["models", "segmentation_targets"]))
-	elif mode == 'effectors':
-		modelpath = os.sep.join(
-			[os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], "celldetective", "models",
-			 "segmentation_effectors", os.sep])
-		repository_models = get_zenodo_files(cat=os.sep.join(["models", "segmentation_effectors"]))
-	elif mode == 'generic':
-		modelpath = os.sep.join(
+
+	modelpath = os.sep.join(
 			[os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], "celldetective", "models",
-			 "segmentation_generic", os.sep])
-		repository_models = get_zenodo_files(cat=os.sep.join(["models", "segmentation_generic"]))
+			 f"segmentation_{mode}", os.sep])
+	if not os.path.exists(modelpath):
+		os.mkdir(modelpath)
+		repository_models = []
+	else:
+		repository_models = get_zenodo_files(cat=os.sep.join(["models", f"segmentation_{mode}"]))
 
 	available_models = natsorted(glob(modelpath + '*/'))
 	available_models = [m.replace('\\', '/').split('/')[-2] for m in available_models]
@@ -3162,7 +3235,7 @@ def normalize(frame, percentiles=(0.0,99.99), values=None, ignore_gray_value=0.,
 		subframe = frame.copy()
 
 	if values is not None:
-		mi = values[0];
+		mi = values[0]
 		ma = values[1]
 	else:
 		mi = np.nanpercentile(subframe.flatten(), percentiles[0], keepdims=True)
@@ -3183,9 +3256,14 @@ def normalize(frame, percentiles=(0.0,99.99), values=None, ignore_gray_value=0.,
 	return frame.copy().astype(dtype)
 
 
-def normalize_multichannel(multichannel_frame, percentiles=None,
-						   values=None, ignore_gray_value=0., clip=False,
-						   amplification=None, dtype=float):
+def normalize_multichannel(multichannel_frame: np.ndarray,
+						   percentiles=None,
+						   values=None,
+						   ignore_gray_value=0.,
+						   clip=False,
+						   amplification=None,
+						   dtype=float,
+						   ):
 	
 	"""
 	Normalizes a multichannel frame by adjusting the intensity values of each channel based on specified percentiles,
@@ -3234,13 +3312,11 @@ def normalize_multichannel(multichannel_frame, percentiles=None,
 	Examples
 	--------
 	>>> multichannel_frame = np.random.rand(100, 100, 3)  # Example multichannel frame
-	>>> normalized_frame = normalize_multichannel(multichannel_frame, percentiles=((1, 99), (2, 98), (0, 100)))
+	>>> normalized_frame = normalize_multichannel(multichannel_frame, percentiles=[(1, 99), (2, 98), (0, 100)])
 	# Normalizes each channel of the frame using specified percentile ranges.
 
 	"""
 
-
-
 	mf = multichannel_frame.copy().astype(float)
 	assert mf.ndim == 3, f'Wrong shape for the multichannel frame: {mf.shape}.'
 	if percentiles is None:
@@ -3275,7 +3351,7 @@ def normalize_multichannel(multichannel_frame, percentiles=None,
 
 	return np.moveaxis(mf_new,0,-1)
 
-def load_frames(img_nums, stack_path, scale=None, normalize_input=True, dtype=float, normalize_kwargs={"percentiles": (0.,99.99)}):
+def load_frames(img_nums, stack_path, scale=None, normalize_input=True, dtype=np.float64, normalize_kwargs={"percentiles": (0.,99.99)}):
 
 	"""
 	Loads and optionally normalizes and rescales specified frames from a stack located at a given path.
@@ -3334,6 +3410,10 @@ def load_frames(img_nums, stack_path, scale=None, normalize_input=True, dtype=fl
 		print(
 			f'Error in loading the frame {img_nums} {e}. Please check that the experiment channel information is consistent with the movie being read.')
 		return None
+	try:
+		frames[np.isinf(frames)] = np.nan
+	except Exception as e:
+		print(e)
 
 	frames = _rearrange_multichannel_frame(frames)