celldetective 1.3.6.post1__py3-none-any.whl → 1.3.7__py3-none-any.whl

celldetective/io.py

@@ -19,16 +19,16 @@ from csbdeep.io import save_tiff_imagej_compatible
 import skimage.io as skio
 from skimage.measure import regionprops_table, label
 
-from scipy.ndimage import zoom
 from btrack.datasets import cell_config
 from magicgui import magicgui
 from pathlib import Path, PurePath
 from shutil import copyfile, rmtree
 
-from celldetective.utils import ConfigSectionMap, extract_experiment_channels, _extract_labels_from_config, get_zenodo_files, download_zenodo_file
-from celldetective.utils import _estimate_scale_factor, _extract_channel_indices_from_config, _extract_channel_indices, _extract_nbr_channels_from_config, _get_img_num_per_channel, normalize_per_channel
+from 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
 
 from stardist import fill_label_holes
+from skimage.transform import resize
 
 
 def extract_experiment_from_well(well_path):
@@ -1190,7 +1190,11 @@ def locate_labels(position, population='target', frames=None):
 	elif isinstance(frames, (int,float, np.int_)):
 
 		tzfill = str(int(frames)).zfill(4)
-		idx = label_names.index(f"{tzfill}.tif")
+		try:
+			idx = label_names.index(f"{tzfill}.tif")
+		except:
+			idx = -1
+
 		if idx==-1:
 			labels = None
 		else:
@@ -1200,7 +1204,11 @@ def locate_labels(position, population='target', frames=None):
 		labels = []
 		for f in frames:
 			tzfill = str(int(f)).zfill(4)
-			idx = label_names.index(f"{tzfill}.tif")
+			try:
+				idx = label_names.index(f"{tzfill}.tif")
+			except:
+				idx = -1
+			
 			if idx==-1:
 				labels.append(None)
 			else:
@@ -2842,7 +2850,7 @@ def get_segmentation_models_list(mode='targets', return_path=False):
 		return available_models, modelpath
 
 
-def locate_segmentation_model(name):
+def locate_segmentation_model(name, download=True):
 	
 	"""
 	Locates a specified segmentation model within the local 'celldetective' directory or
@@ -2874,7 +2882,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
@@ -2882,13 +2890,15 @@ def locate_segmentation_model(name):
 		if name == m.replace('\\', os.sep).split(os.sep)[-2]:
 			match = m
 			return match
-	# else no match, try zenodo
-	files, categories = get_zenodo_files()
-	if name in files:
-		index = files.index(name)
-		cat = categories[index]
-		download_zenodo_file(name, os.sep.join([main_dir, cat]))
-		match = os.sep.join([main_dir, cat, name]) + os.sep
+	if download:
+		# else no match, try zenodo
+		files, categories = get_zenodo_files()
+		if name in files:
+			index = files.index(name)
+			cat = categories[index]
+			download_zenodo_file(name, os.sep.join([main_dir, cat]))
+			match = os.sep.join([main_dir, cat, name]) + os.sep
+
 	return match
 
 
@@ -3306,27 +3316,16 @@ def load_frames(img_nums, stack_path, scale=None, normalize_input=True, dtype=fl
 			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
 
-	if frames.ndim == 3:
-		# Systematically move channel axis to the end
-		channel_axis = np.argmin(frames.shape)
-		frames = np.moveaxis(frames, channel_axis, -1)
-
-	if frames.ndim==2:
-		frames = frames[:,:,np.newaxis].astype(float)
+	frames = _rearrange_multichannel_frame(frames)
 
 	if normalize_input:
 		frames = normalize_multichannel(frames, **normalize_kwargs)
 
 	if scale is not None:
-		frames = [zoom(frames[:,:,c].copy(), [scale,scale], order=3, prefilter=False) for c in range(frames.shape[-1])]
-		frames = np.moveaxis(frames,0,-1)
+		frames = zoom_multiframes(frames, scale)
 
 	# add a fake pixel to prevent auto normalization errors on images that are uniform
-	# to revisit
-	for k in range(frames.shape[2]):
-		unique_values = np.unique(frames[:, :, k])
-		if len(unique_values) == 1:
-			frames[0, 0, k] += 1
+	frames = _fix_no_contrast(frames)
 
 	return frames.astype(dtype)
 
@@ -3532,6 +3531,33 @@ def extract_experiment_folder_output(experiment_folder, destination_folder):
 			for t in tab_path:
 				copyfile(t, os.sep.join([output_tables_folder, os.path.split(t)[-1]]))
 
+def _load_frames_to_segment(file, indices, scale_model=None, normalize_kwargs=None):
+	
+	frames = load_frames(indices, file, scale=scale_model, normalize_input=True, normalize_kwargs=normalize_kwargs)
+	frames = interpolate_nan_multichannel(frames)
+
+	if np.any(indices==-1):
+		frames[:,:,np.where(indices==-1)[0]] = 0.
+
+	return frames
+
+def _load_frames_to_measure(file, indices):
+	return load_frames(indices, file, scale=None, normalize_input=False)
+
+
+def _check_label_dims(lbl, file=None, template=None):
+	
+	if file is not None:
+		template = load_frames(0,file,scale=1,normalize_input=False)
+	elif template is not None:
+		template = template
+	else:
+		return lbl
+
+	if lbl.shape != template.shape[:2]:
+		lbl = resize(lbl, template.shape[:2], order=0)
+	return lbl
+
 
 if __name__ == '__main__':
 	control_segmentation_napari("/home/limozin/Documents/Experiments/MinimumJan/W4/401/", prefix='Aligned',

celldetective/measure.py

@@ -311,7 +311,7 @@ def measure_features(img, label, features=['area', 'intensity_mean'], channels=N
 
 	if isinstance(features, list):
 		features = features.copy()
-		
+
 	if features is None:
 		features = []
 
@@ -986,6 +986,69 @@ def blob_detection(image, label, diameter, threshold=0., channel_name=None, targ
 
 	return detections
 
+
+# def blob_detectionv0(image, label, threshold, diameter):
+# 	"""
+# 	Perform blob detection on an image based on labeled regions.
+
+# 	Parameters:
+# 	- image (numpy.ndarray): The input image data.
+# 	- label (numpy.ndarray): An array specifying labeled regions in the image.
+# 	- threshold (float): The threshold value for blob detection.
+# 	- diameter (float): The expected diameter of blobs.
+
+# 	Returns:
+# 	- dict: A dictionary containing information about detected blobs.
+
+# 	This function performs blob detection on an image based on labeled regions. It iterates over each labeled region
+# 	and detects blobs within the region using the Difference of Gaussians (DoG) method. Detected blobs are filtered
+# 	based on the specified threshold and expected diameter. The function returns a dictionary containing the number of
+# 	detected blobs and their mean intensity for each labeled region.
+
+# 	Example:
+# 	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+# 	>>> label = np.array([[0, 1, 1], [2, 2, 0], [3, 3, 0]])
+# 	>>> threshold = 0.1
+# 	>>> diameter = 5.0
+# 	>>> result = blob_detection(image, label, threshold, diameter)
+# 	>>> print(result)
+# 	{1: [1, 4.0], 2: [0, nan], 3: [0, nan]}
+
+# 	Note:
+# 	- Blobs are detected using the Difference of Gaussians (DoG) method.
+# 	- Detected blobs are filtered based on the specified threshold and expected diameter.
+# 	- The returned dictionary contains information about the number of detected blobs and their mean intensity
+# 	  for each labeled region.
+# 	"""
+# 	blob_labels = {}
+# 	dilated_image = ndimage.grey_dilation(label, footprint=disk(10))
+# 	for mask_index in np.unique(label):
+# 		if mask_index == 0:
+# 			continue
+# 		removed_background = image.copy()
+# 		one_mask = label.copy()
+# 		one_mask[np.where(label != mask_index)] = 0
+# 		dilated_copy = dilated_image.copy()
+# 		dilated_copy[np.where(dilated_image != mask_index)] = 0
+# 		removed_background[np.where(dilated_copy == 0)] = 0
+# 		min_sigma = (1 / (1 + math.sqrt(2))) * diameter
+# 		max_sigma = math.sqrt(2) * min_sigma
+# 		blobs = blob_dog(removed_background, threshold=threshold, min_sigma=min_sigma,
+# 										 max_sigma=max_sigma)
+
+# 		mask = np.array([one_mask[int(y), int(x)] != 0 for y, x, r in blobs])
+# 		if not np.any(mask):
+# 			continue
+# 		blobs_filtered = blobs[mask]
+# 		binary_blobs = np.zeros_like(label)
+# 		for blob in blobs_filtered:
+# 			y, x, r = blob
+# 			rr, cc = dsk((y, x), r, shape=binary_blobs.shape)
+# 			binary_blobs[rr, cc] = 1
+# 		spot_intensity = regionprops_table(binary_blobs, removed_background, ['intensity_mean'])
+# 		blob_labels[mask_index] = [blobs_filtered.shape[0], spot_intensity['intensity_mean'][0]]
+# 	return blob_labels
+
 ### Classification ####
 
 def estimate_time(df, class_attr, model='step_function', class_of_interest=[2], r2_threshold=0.5):
@@ -1163,13 +1226,15 @@ def classify_transient_events(data, class_attr, pre_event=None):
 		assert 'class_'+pre_event in cols,"Pre-event class does not seem to be a valid column in the DataFrame..."
 
 	stat_col = class_attr.replace('class','status')
+	continuous_stat_col = stat_col.replace('status_','smooth_status_')
+	df[continuous_stat_col] = df[stat_col].copy()
 
 	for tid,track in df.groupby(sort_cols):
 
 		indices = track[class_attr].index
 
 		if pre_event is not None:
-			
+
 			if track['class_'+pre_event].values[0]==1:
 				df.loc[indices, class_attr] = np.nan
 				df.loc[indices, stat_col] = np.nan
@@ -1180,7 +1245,8 @@ def classify_transient_events(data, class_attr, pre_event=None):
 				indices_pre = track.loc[track['FRAME']<=t_pre_event,class_attr].index
 				df.loc[indices_pre, stat_col] = np.nan # set to NaN all statuses before pre-event
 				track.loc[track['FRAME']<=t_pre_event, stat_col] = np.nan
-		
+				track.loc[track['FRAME']<=t_pre_event, continuous_stat_col] = np.nan
+
 		status = track[stat_col].to_numpy()
 		timeline = track['FRAME'].to_numpy()
 		timeline_safe = timeline[status==status]
@@ -1189,24 +1255,35 @@ def classify_transient_events(data, class_attr, pre_event=None):
 		peaks, _ = find_peaks(status_safe)
 		widths, _, left, right = peak_widths(status_safe, peaks, rel_height=1)
 		minimum_weight = 0
-
+		
 		if len(peaks)>0:
 			idx = np.argmax(widths)
-			peak = peaks[idx]; width = widths[idx]; 
+			peak = peaks[idx]; width = widths[idx];
 			if width >= minimum_weight:
 				left = left[idx]; right = right[idx];
 				left = timeline_safe[int(left)]; right = timeline_safe[int(right)];
-				
+
 				df.loc[indices, class_attr] = 0
-				df.loc[indices, class_attr.replace('class_','t_')] = left + (right - left)/2.0
+				t0 = left #take onset + (right - left)/2.0
+				df.loc[indices, class_attr.replace('class_','t_')] = t0
+				df.loc[track.loc[track[stat_col].isnull(),class_attr].index, continuous_stat_col] = np.nan
+				df.loc[track.loc[track['FRAME']<t0,class_attr].index, continuous_stat_col] = 0
+				df.loc[track.loc[track['FRAME']>=t0,class_attr].index, continuous_stat_col] = 1
 			else:
 				df.loc[indices, class_attr] = 1
-				df.loc[indices, class_attr.replace('class_','t_')] = -1				
+				df.loc[indices, class_attr.replace('class_','t_')] = -1
+				df.loc[indices, continuous_stat_col] = 0
 		else:
 			df.loc[indices, class_attr] = 1
 			df.loc[indices, class_attr.replace('class_','t_')] = -1
-
-		
+			df.loc[indices, continuous_stat_col] = 0
+
+	# restate NaN for out of scope timepoints
+	df.loc[df[stat_col].isnull(),continuous_stat_col] = np.nan
+	if 'inst_'+stat_col in list(df.columns):
+		df = df.drop(columns=['inst_'+stat_col])
+	df = df.rename(columns={stat_col: 'inst_'+stat_col})
+	df = df.rename(columns={continuous_stat_col: stat_col})
 	print("Classes: ",df.loc[df['FRAME']==0,class_attr].value_counts())
 
 	return df
@@ -1286,7 +1363,7 @@ def classify_irreversible_events(data, class_attr, r2_threshold=0.5, percentile_
 			indices_pre_detection = track.loc[track['FRAME']<=t_firstdetection,class_attr].index
 			track.loc[indices_pre_detection,stat_col] = 0.0
 			df.loc[indices_pre_detection,stat_col] = 0.0
-		
+
 		# The non-NaN part of track (post pre-event)
 		track_valid = track.dropna(subset=stat_col, inplace=False)
 		status_values = track_valid[stat_col].to_numpy()
@@ -1300,7 +1377,7 @@ def classify_irreversible_events(data, class_attr, r2_threshold=0.5, percentile_
 		else:
 			# ambiguity, possible transition, use `unique_state` technique after
 			df.loc[indices, class_attr] = 2
-		
+
 	print("Classes after initial pass: ",df.loc[df['FRAME']==0,class_attr].value_counts())
 
 	df.loc[df[class_attr]!=2, class_attr.replace('class', 't')] = -1
@@ -1363,7 +1440,7 @@ def classify_unique_states(df, class_attr, percentile=50, pre_event=None):
 		assert 'class_'+pre_event in cols,"Pre-event class does not seem to be a valid column in the DataFrame..."
 
 	stat_col = class_attr.replace('class','status')
-	
+
 	for tid, track in df.groupby(sort_cols):
 
 		indices = track[class_attr].index
@@ -1488,4 +1565,25 @@ def classify_tracks_from_query(df, event_name, query, irreversible_event=True, u
 
 	df = interpret_track_classification(df, class_attr, irreversible_event=irreversible_event, unique_state=unique_state, r2_threshold=r2_threshold, percentile_recovery=percentile_recovery)
 
-	return df
+	return df
+
+def measure_radial_distance_to_center(df, volume, column_labels={'track': "TRACK_ID", 'time': 'FRAME', 'x': 'POSITION_X', 'y': 'POSITION_Y'}):
+
+	try:
+		df['radial_distance'] = np.sqrt((df[column_labels['x']] - volume[0] / 2) ** 2 + (df[column_labels['y']] - volume[1] / 2) ** 2)
+	except Exception as e:
+		print(f"{e=}")
+
+	return df
+
+def center_of_mass_to_abs_coordinates(df):
+	
+	center_of_mass_x_cols = [c for c in list(df.columns) if c.endswith('centre_of_mass_x')]
+	center_of_mass_y_cols = [c for c in list(df.columns) if c.endswith('centre_of_mass_y')]
+	for c in center_of_mass_x_cols:
+		df.loc[:,c.replace('_x','_POSITION_X')] = df[c] + df['POSITION_X']
+	for c in center_of_mass_y_cols:
+		df.loc[:,c.replace('_y','_POSITION_Y')] = df[c] + df['POSITION_Y']
+	df = df.drop(columns = center_of_mass_x_cols+center_of_mass_y_cols)
+
+	return df

celldetective/scripts/measure_cells.py

@@ -5,10 +5,10 @@ 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
+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
 from glob import glob
 from tqdm import tqdm
@@ -16,7 +16,6 @@ import numpy as np
 import pandas as pd
 from natsort import natsorted
 from art import tprint
-import threading
 import datetime
 
 tprint("Measure")
@@ -50,7 +49,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 +64,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 +150,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
@@ -164,14 +170,6 @@ else:
 	features += ['centroid']
 	do_iso_intensities = False
 
-# if 'centroid' not in features:
-# 	features += ['centroid']
-
-# if (features is not None) and (trajectories is not None):
-# 	features = remove_redundant_features(features, 
-# 										trajectories.columns,
-# 										channel_names=channel_names
-# 										)
 
 len_movie_auto = auto_load_number_of_frames(file)
 if len_movie_auto is not None:
@@ -229,7 +227,7 @@ with open(pos + f'log_{mode}.json', 'a') as f:
 
 def measure_index(indices):
 
-	global column_labels
+	#global column_labels
 
 	for t in tqdm(indices,desc="frame"):
 
@@ -251,10 +249,7 @@ def measure_index(indices):
 											 channels=channel_names, haralick_options=haralick_options, verbose=False,
 											 normalisation_list=background_correction, spot_detection=spot_detection)
 			if trajectories is None:
-				positions_at_t = feature_table[['centroid-1', 'centroid-0', 'class_id']].copy()
-				positions_at_t['ID'] = np.arange(len(positions_at_t))  # temporary ID for the cells, that will be reset at the end since they are not tracked
-				positions_at_t.rename(columns={'centroid-1': 'POSITION_X', 'centroid-0': 'POSITION_Y'}, inplace=True)
-				positions_at_t['FRAME'] = int(t)
+				positions_at_t = _extract_coordinates_from_features(feature_table, timepoint=t)
 				column_labels = {'track': "ID", 'time': column_labels['time'], 'x': column_labels['x'],
 								 'y': column_labels['y']}
 			feature_table.rename(columns={'centroid-1': 'POSITION_X', 'centroid-0': 'POSITION_Y'}, inplace=True)
@@ -271,36 +266,33 @@ def measure_index(indices):
 			measurements_at_t = positions_at_t.merge(feature_table, how='outer', on='class_id',suffixes=('_delme', ''))
 			measurements_at_t = measurements_at_t[[c for c in measurements_at_t.columns if not c.endswith('_delme')]]
 
-		center_of_mass_x_cols = [c for c in list(measurements_at_t.columns) if c.endswith('centre_of_mass_x')]
-		center_of_mass_y_cols = [c for c in list(measurements_at_t.columns) if c.endswith('centre_of_mass_y')]
-		for c in center_of_mass_x_cols:
-			measurements_at_t.loc[:,c.replace('_x','_POSITION_X')] = measurements_at_t[c] + measurements_at_t['POSITION_X']
-		for c in center_of_mass_y_cols:
-			measurements_at_t.loc[:,c.replace('_y','_POSITION_Y')] = measurements_at_t[c] + measurements_at_t['POSITION_Y']
-		measurements_at_t = measurements_at_t.drop(columns = center_of_mass_x_cols+center_of_mass_y_cols)
-		
-		try:
-			measurements_at_t['radial_distance'] = np.sqrt((measurements_at_t[column_labels['x']] - img.shape[0] / 2) ** 2 + (
-					measurements_at_t[column_labels['y']] - img.shape[1] / 2) ** 2)
-		except Exception as e:
-			print(f"{e=}")
+		measurements_at_t = center_of_mass_to_abs_coordinates(measurements_at_t)
+		measurements_at_t = measure_radial_distance_to_center(measurements_at_t, volume=img.shape, column_labels=column_labels)
 
 		if measurements_at_t is not None:
 			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:
@@ -312,15 +304,13 @@ if len(timestep_dataframes)>0:
 		df = df.dropna(subset=[column_labels['track']])
 	else:
 		df['ID'] = np.arange(len(df))
+		df = df.sort_values(by=[column_labels['time'], 'ID'])
 
 	df = df.reset_index(drop=True)
-	
-	invalid_cols = [c for c in list(df.columns) if c.startswith('Unnamed')]
-	if len(invalid_cols)>0:
-		df = df.drop(invalid_cols, axis=1)	
+	df = _remove_invalid_cols(df)
 
 	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.')