celldetective 1.0.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

celldetective/io.py

@@ -19,7 +19,12 @@ from celldetective.utils import ConfigSectionMap, extract_experiment_channels, _
 import json
 import threading
 from skimage.measure import regionprops_table
-
+from celldetective.utils import _estimate_scale_factor, _extract_channel_indices_from_config, _extract_channel_indices, ConfigSectionMap, _extract_nbr_channels_from_config, _get_img_num_per_channel, normalize_per_channel
+import matplotlib.pyplot as plt
+from celldetective.filters import std_filter, median_filter, gauss_filter
+from stardist import fill_label_holes
+from celldetective.utils import interpolate_nan
+from scipy.interpolate import griddata
 
 def get_experiment_wells(experiment):
 	
@@ -131,15 +136,58 @@ def get_experiment_pharmaceutical_agents(experiment, dtype=str):
 	return np.array([dtype(c) for c in pharmaceutical_agents])
 
 
-def _interpret_wells_and_positions(experiment, well_option, position_option):
+def interpret_wells_and_positions(experiment, well_option, position_option):
 	
-	wells = get_experiment_wells(experiment)
-	nbr_of_wells = len(wells)    
+	"""
+	Interpret well and position options for a given experiment.
+
+	This function takes an experiment and well/position options to return the selected
+	wells and positions. It supports selection of all wells or specific wells/positions
+	as specified. The well numbering starts from 0 (i.e., Well 0 is W1 and so on).
+
+	Parameters
+	----------
+	experiment : object
+		The experiment object containing well information.
+	well_option : str, int, or list of int
+		The well selection option:
+		- '*' : Select all wells.
+		- int : Select a specific well by its index.
+		- list of int : Select multiple wells by their indices.
+	position_option : str, int, or list of int
+		The position selection option:
+		- '*' : Select all positions (returns None).
+		- int : Select a specific position by its index.
+		- list of int : Select multiple positions by their indices.
+
+	Returns
+	-------
+	well_indices : numpy.ndarray or list of int
+		The indices of the selected wells.
+	position_indices : numpy.ndarray or list of int or None
+		The indices of the selected positions. Returns None if all positions are selected.
+
+	Examples
+	--------
+	>>> experiment = ...  # Some experiment object
+	>>> interpret_wells_and_positions(experiment, '*', '*')
+	(array([0, 1, 2, ..., n-1]), None)
+	
+	>>> interpret_wells_and_positions(experiment, 2, '*')
+	([2], None)
+	
+	>>> interpret_wells_and_positions(experiment, [1, 3, 5], 2)
+	([1, 3, 5], array([2]))
+
+	"""
 	
+	wells = get_experiment_wells(experiment)
+	nbr_of_wells = len(wells)
+
 	if well_option=='*':
-		well_indices = np.arange(len(wells))
-	elif isinstance(well_option, int):
-		well_indices = np.array([well_option], dtype=int)
+		well_indices = np.arange(nbr_of_wells)
+	elif isinstance(well_option, int) or isinstance(well_option, np.int_):
+		well_indices = [int(well_option)]
 	elif isinstance(well_option, list):
 		well_indices = well_option
 		
@@ -149,11 +197,43 @@ 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
-	
+
 	return well_indices, position_indices
 		
 def extract_well_name_and_number(well):
 	
+	"""
+	Extract the well name and number from a given well path.
+
+	This function takes a well path string, splits it by the OS-specific path separator,
+	and extracts the well name and number. The well name is the last component of the path,
+	and the well number is derived by removing the 'W' prefix and converting the remaining
+	part to an integer.
+
+	Parameters
+	----------
+	well : str
+		The well path string, where the well name is the last component.
+
+	Returns
+	-------
+	well_name : str
+		The name of the well, extracted from the last component of the path.
+	well_number : int
+		The well number, obtained by stripping the 'W' prefix from the well name
+		and converting the remainder to an integer.
+
+	Examples
+	--------
+	>>> well_path = "path/to/W23"
+	>>> extract_well_name_and_number(well_path)
+	('W23', 23)
+
+	>>> well_path = "another/path/W1"
+	>>> extract_well_name_and_number(well_path)
+	('W1', 1)
+	"""
+
 	split_well_path = well.split(os.sep)
 	split_well_path = list(filter(None, split_well_path))
 	well_name = split_well_path[-1]
@@ -163,6 +243,34 @@ def extract_well_name_and_number(well):
 
 def extract_position_name(pos):
 	
+	"""
+	Extract the position name from a given position path.
+
+	This function takes a position path string, splits it by the OS-specific path separator,
+	filters out any empty components, and extracts the position name, which is the last
+	component of the path.
+
+	Parameters
+	----------
+	pos : str
+		The position path string, where the position name is the last component.
+
+	Returns
+	-------
+	pos_name : str
+		The name of the position, extracted from the last component of the path.
+
+	Examples
+	--------
+	>>> pos_path = "path/to/position1"
+	>>> extract_position_name(pos_path)
+	'position1'
+
+	>>> pos_path = "another/path/positionA"
+	>>> extract_position_name(pos_path)
+	'positionA'
+	"""
+
 	split_pos_path = pos.split(os.sep)
 	split_pos_path = list(filter(None, split_pos_path))
 	pos_name = split_pos_path[-1]
@@ -222,18 +330,109 @@ def get_position_table(pos, population, return_path=False):
 	else:
 		return df_pos
 
+def get_position_pickle(pos, population, return_path=False):
+	
+	"""
+	Retrieves the data table for a specified population at a given position, optionally returning the table's file path.
+
+	This function locates and loads a CSV data table associated with a specific population (e.g., 'targets', 'cells') 
+	from a specified position directory. The position directory should contain an 'output/tables' subdirectory where 
+	the CSV file named 'trajectories_{population}.csv' is expected to be found. If the file exists, it is loaded into 
+	a pandas DataFrame; otherwise, None is returned.
+
+	Parameters
+	----------
+	pos : str
+		The path to the position directory from which to load the data table.
+	population : str
+		The name of the population for which the data table is to be retrieved. This name is used to construct the 
+		file name of the CSV file to be loaded.
+	return_path : bool, optional
+		If True, returns a tuple containing the loaded data table (or None) and the path to the CSV file. If False, 
+		only the loaded data table (or None) is returned (default is False).
+
+	Returns
+	-------
+	pandas.DataFrame or None, or (pandas.DataFrame or None, str)
+		If return_path is False, returns the loaded data table as a pandas DataFrame, or None if the table file does 
+		not exist. If return_path is True, returns a tuple where the first element is the data table (or None) and the 
+		second element is the path to the CSV file.
+
+	Examples
+	--------
+	>>> df_pos = get_position_table('/path/to/position', 'targets')
+	# This will load the 'trajectories_targets.csv' table from the specified position directory into a pandas DataFrame.
+
+	>>> df_pos, table_path = get_position_table('/path/to/position', 'targets', return_path=True)
+	# This will load the 'trajectories_targets.csv' table and also return the path to the CSV file.
+	
+	"""
+	
+	if not pos.endswith(os.sep):
+		table = os.sep.join([pos,'output','tables',f'trajectories_{population}.pkl'])
+	else:
+		table = pos + os.sep.join(['output','tables',f'trajectories_{population}.pkl'])		
+
+	if os.path.exists(table):
+		df_pos = np.load(table, allow_pickle=True)
+	else:
+		df_pos = None
+	
+	if return_path:
+		return df_pos, table
+	else:
+		return df_pos
+
+
 def get_position_movie_path(pos, prefix=''):
 
+	"""
+	Get the path of the movie file for a given position.
+
+	This function constructs the path to a movie file within a given position directory.
+	It searches for TIFF files that match the specified prefix. If multiple matching files
+	are found, the first one is returned.
+
+	Parameters
+	----------
+	pos : str
+		The directory path for the position.
+	prefix : str, optional
+		The prefix to filter movie files. Defaults to an empty string.
+
+	Returns
+	-------
+	stack_path : str or None
+		The path to the first matching movie file, or None if no matching file is found.
+
+	Examples
+	--------
+	>>> pos_path = "path/to/position1"
+	>>> get_position_movie_path(pos_path, prefix='experiment_')
+	'path/to/position1/movie/experiment_001.tif'
+
+	>>> pos_path = "another/path/positionA"
+	>>> get_position_movie_path(pos_path)
+	'another/path/positionA/movie/001.tif'
+
+	>>> pos_path = "nonexistent/path"
+	>>> get_position_movie_path(pos_path)
+	None
+	"""
+	
+
 	if not pos.endswith(os.sep):
 		pos+=os.sep
 	movies = glob(pos+os.sep.join(['movie',prefix+'*.tif']))
 	if len(movies)>0:
 		stack_path = movies[0]
 	else:
-		stack_path = np.nan
+		stack_path = None
 	
 	return stack_path
-					
+
+
+
 def load_experiment_tables(experiment, population='targets', well_option='*',position_option='*', return_pos_info=False):
 	
 
@@ -303,18 +502,19 @@ def load_experiment_tables(experiment, population='targets', well_option='*',pos
 	pharmaceutical_agents = get_experiment_pharmaceutical_agents(experiment)
 	well_labels = _extract_labels_from_config(config,len(wells))
 	
-	well_indices, position_indices = _interpret_wells_and_positions(experiment, well_option, position_option)
+	well_indices, position_indices = interpret_wells_and_positions(experiment, well_option, position_option)
 
 	df = []
 	df_pos_info = []
 	real_well_index = 0
 	
-	for widx, well_path in enumerate(tqdm(wells[well_indices])):
+	for k, well_path in enumerate(tqdm(wells[well_indices])):
 		
 		any_table = False # assume no table
 		
-		well_index = widx
 		well_name, well_number = extract_well_name_and_number(well_path)
+		widx = well_indices[k]
+
 		well_alias = well_labels[widx]
 		
 		well_concentration = concentrations[widx]
@@ -322,7 +522,7 @@ def load_experiment_tables(experiment, population='targets', well_option='*',pos
 		well_cell_type = cell_types[widx]
 		well_pharmaceutical_agent = pharmaceutical_agents[widx]
 		
-		positions = np.array(natsorted(glob(well_path+'*'+os.sep)),dtype=str)
+		positions = get_positions_in_well(well_path)
 		if position_indices is not None:
 			try:
 				positions = positions[position_indices]
@@ -413,6 +613,9 @@ def locate_stack(position, prefix='Aligned'):
 
 	"""
 
+	if not position.endswith(os.sep):
+		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..."
 	stack = imread(stack_path[0].replace('\\','/'))
@@ -457,7 +660,9 @@ def locate_labels(position, population='target'):
 
 	"""
 
-
+	if not position.endswith(os.sep):
+		position+=os.sep
+	
 	if population.lower()=="target" or population.lower()=="targets":
 		label_path = natsorted(glob(position+os.sep.join(["labels_targets", "*.tif"])))
 	elif population.lower()=="effector" or population.lower()=="effectors":
@@ -758,12 +963,16 @@ def get_signal_models_list(return_path=False):
 		return available_models, modelpath
 
 
-def locate_signal_model(name):
+def locate_signal_model(name, path=None):
 	
 	main_dir = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0],"celldetective"])
 	modelpath = os.sep.join([main_dir, "models", "signal_detection", os.sep])
 	print(f'Looking for {name} in {modelpath}')
 	models = glob(modelpath+f'*{os.sep}')
+	if path is not None:
+		if not path.endswith(os.sep):
+			path += os.sep
+		models += glob(path+f'*{os.sep}')
 
 	match=None
 	for m in models:
@@ -1002,7 +1211,7 @@ def view_on_napari_btrack(data,properties,graph,stack=None,labels=None,relabel=T
 		del labels
 		gc.collect()
 
-def load_napari_data(position, prefix="Aligned", population="target"):
+def load_napari_data(position, prefix="Aligned", population="target", return_stack=True):
 
 	"""
 	Load the necessary data for visualization in napari.
@@ -1035,9 +1244,11 @@ def load_napari_data(position, prefix="Aligned", population="target"):
 	data = napari_data.item()['data']
 	properties = napari_data.item()['properties']
 	graph = napari_data.item()['graph']
-
-	stack,labels = locate_stack_and_labels(position, prefix=prefix, population=population)
-
+	if return_stack:
+		stack,labels = locate_stack_and_labels(position, prefix=prefix, population=population)
+	else:
+		labels=locate_labels(position,population=population)
+		stack = None
 	return data,properties,graph,labels,stack
 
 from skimage.measure import label
@@ -1828,11 +2039,11 @@ def load_frames(img_nums, stack_path, scale=None, normalize_input=True, dtype=fl
 		channel_axis = np.argmin(frames.shape)
 		frames = np.moveaxis(frames, channel_axis, -1)
 	if frames.ndim==2:
-		frames = frames[:,:,np.newaxis]
+		frames = frames[:,:,np.newaxis].astype(float)
 	if normalize_input:
 		frames = normalize_multichannel(frames, **normalize_kwargs)
 	if scale is not None:
-		frames = zoom(frames, [scale,scale,1], order=3)
+		frames = zoom(frames, [scale,scale,1], order=3, prefilter=False)
 	
 	# add a fake pixel to prevent auto normalization errors on images that are uniform
 	# to revisit
@@ -1955,7 +2166,7 @@ def get_positions_in_well(well):
 		well = well[:-1]
 
 	w_numeric = os.path.split(well)[-1].replace('W','')
-	positions = glob(os.sep.join([well,f'{w_numeric}*{os.sep}']))		
+	positions = natsorted(glob(os.sep.join([well,f'{w_numeric}*{os.sep}'])))
 
 	return np.array(positions,dtype=str)
 

celldetective/measure.py

@@ -308,10 +308,11 @@ def drop_tonal_features(features):
 
     """
 
+    feat2 = features[:]
     for f in features:
         if 'intensity' in f:
-            features.remove(f)
-    return features
+            feat2.remove(f)
+    return feat2
 
 def measure_features(img, label, features=['area', 'intensity_mean'], channels=None,
                      border_dist=None, haralick_options=None, verbose=True, normalisation_list=None,
@@ -389,26 +390,20 @@ def measure_features(img, label, features=['area', 'intensity_mean'], channels=N
                                                       columns=['count', 'spot_mean_intensity']).reset_index()
             # Rename columns
             df_spots.columns = ['label', 'spot_count', 'spot_mean_intensity']
+        
         if normalisation_list:
             for norm in normalisation_list:
                 for index, channel in enumerate(channels):
-                    if channel == norm['target channel']:
+                    if channel == norm['target_channel']:
                         ind = index
-                if norm['mode'] == 'local':
+                if norm['correction_type'] == 'local':
                     normalised_image = normalise_by_cell(img[:, :, ind].copy(), label,
-                                                         distance=int(norm['distance']), mode=norm['type'],
-                                                         operation=norm['operation'])
+                                                         distance=int(norm['distance']), model=norm['model'],
+                                                         operation=norm['operation'], clip=norm['clip'])
                     img[:, :, ind] = normalised_image
                 else:
-                    if norm['operation'] == 'Divide':
-                        normalised_image, bg = field_normalisation(img[:, :, ind].copy(), threshold=norm['threshold'],
-                                                                   normalisation_operation=norm['operation'],
-                                                                   clip=False, mode=norm['type'])
-                    else:
-                        normalised_image, bg = field_normalisation(img[:, :, ind].copy(), threshold=norm['threshold'],
-                                                                   normalisation_operation=norm['operation'],
-                                                                   clip=norm['clip'], mode=norm['type'])
-                    img[:, :, ind] = normalised_image
+                    corrected_image = field_correction(img[:,:,ind].copy(), threshold_on_std=norm['threshold_on_std'], operation=norm['operation'], model=norm['model'], clip=norm['clip'])
+                    img[:, :, ind] = corrected_image
 
     extra_props = getmembers(extra_properties, isfunction)
     extra_props = [extra_props[i][0] for i in range(len(extra_props))]
@@ -725,7 +720,7 @@ def measure_isotropic_intensity(positions, # Dataframe of cell positions @ t
 
     """
 
-
+    epsilon = -10000
     assert ((img.ndim==2)|(img.ndim==3)),f'Invalid image shape to compute the Haralick features. Expected YXC, got {img.shape}...'
 
     if img.ndim==2:
@@ -753,7 +748,7 @@ def measure_isotropic_intensity(positions, # Dataframe of cell positions @ t
 
             pad_value_x = mask.shape[0]//2 + 1
             pad_value_y = mask.shape[1]//2 + 1
-            frame_padded = np.pad(img, [(pad_value_x,pad_value_x),(pad_value_y,pad_value_y),(0,0)])
+            frame_padded = np.pad(img.astype(float), [(pad_value_x,pad_value_x),(pad_value_y,pad_value_y),(0,0)], constant_values=[(epsilon,epsilon),(epsilon,epsilon),(0,0)])
 
             # Find a way to measure intensity in mask
             for tid,group in positions.groupby(column_labels['track']):
@@ -770,11 +765,17 @@ def measure_isotropic_intensity(positions, # Dataframe of cell positions @ t
 
                 expanded_mask = np.expand_dims(mask, axis=-1)  # shape: (X, Y, 1)
                 crop = frame_padded[ymin:ymax,xmin:xmax]
-                projection = np.multiply(crop, expanded_mask)
+
+                crop_temp = crop.copy()
+                crop_temp[crop_temp==epsilon] = 0.
+                projection = np.multiply(crop_temp, expanded_mask)
+
+                projection[crop==epsilon] = epsilon
+                projection[expanded_mask==0.] = epsilon
 
                 for op in operations:
                     func = eval('np.'+op)
-                    intensity_values = func(projection, axis=(0,1), where=projection!=0.)
+                    intensity_values = func(projection, axis=(0,1), where=projection>epsilon)
                     for k in range(crop.shape[-1]):
                         if isinstance(r,list):
                             positions.loc[group.index, f'{channels[k]}_ring_{min(r)}_{max(r)}_{op}'] = intensity_values[k]
@@ -806,7 +807,7 @@ def measure_isotropic_intensity(positions, # Dataframe of cell positions @ t
 
             for op in operations:
                 func = eval('np.'+op)
-                intensity_values = func(projection, axis=(0,1), where=projection!=0.)
+                intensity_values = func(projection, axis=(0,1), where=projection==projection)
                 for k in range(crop.shape[-1]):
                     positions.loc[group.index, f'{channels[k]}_custom_kernel_{op}'] = intensity_values[k]
 
@@ -860,7 +861,7 @@ def measure_at_position(pos, mode, return_measurements=False, threads=1):
         return None
 
 
-def local_normalisation(image, labels, background_intensity, mode, operation):
+def local_normalisation(image, labels, background_intensity, model='median', operation='subtract', clip=False):
     """
      Perform local normalization on an image based on labels.
 
@@ -900,19 +901,23 @@ def local_normalisation(image, labels, background_intensity, mode, operation):
        based on the mode specified.
      - The background intensity values should be provided in the same order as the labels.
      """
+    
     for index, cell in enumerate(np.unique(labels)):
         if cell == 0:
             continue
-        if operation == 'Subtract':
+        if operation == 'subtract':
             image[np.where(labels == cell)] = image[np.where(labels == cell)].astype(float) - \
-                                              background_intensity[f'intensity_{mode.lower()}'][index-1].astype(float)
-        elif operation == 'Divide':
+                                              background_intensity[f'intensity_{model.lower()}'][index-1].astype(float)
+        elif operation == 'divide':
             image[np.where(labels == cell)] = image[np.where(labels == cell)].astype(float) / \
-                                              background_intensity[f'intensity_{mode.lower()}'][index-1].astype(float)
+                                              background_intensity[f'intensity_{model.lower()}'][index-1].astype(float)
+    if clip:
+        image[image<=0.] = 0.
+
     return image.astype(float)
 
 
-def normalise_by_cell(image, labels, distance, mode, operation):
+def normalise_by_cell(image, labels, distance=5, model='median', operation='subtract', clip=False):
     """
     Normalize an image based on cell regions.
 
@@ -950,17 +955,17 @@ def normalise_by_cell(image, labels, distance, mode, operation):
     - The operation determines whether to subtract or divide the background intensity from the image.
     """
     border = contour_of_instance_segmentation(label=labels, distance=distance * (-1))
-    if mode == 'Mean':
+    if model == 'mean':
         background_intensity = regionprops_table(intensity_image=image, label_image=border,
                                                  properties=['intensity_mean'])
-    elif mode == 'Median':
+    elif model == 'median':
         median = []
         median.append(getattr(extra_properties, 'intensity_median'))
         background_intensity = regionprops_table(intensity_image=image, label_image=border,
                                                  extra_properties=median)
     normalised_frame = local_normalisation(image=image.astype(float).copy(),
-                                           labels=labels, background_intensity=background_intensity, mode=mode,
-                                           operation=operation)
+                                           labels=labels, background_intensity=background_intensity, model=model,
+                                           operation=operation, clip=clip)
 
     return normalised_frame
 
@@ -1015,7 +1020,7 @@ def fit_plane(image, cell_masks=None):
                        x=xx,
                        y=yy,
                        weights=weights,
-                       params=params, max_nfev=100)
+                       params=params, max_nfev=3000)
     a = result.params['a'].value
     b = result.params['b'].value
     c = result.params['c'].value
@@ -1069,7 +1074,7 @@ def fit_paraboloid(image, cell_masks=None):
                        x=xx,
                        y=yy,
                        weights=weights,
-                       params=params, max_nfev=100)
+                       params=params, max_nfev=3000)
     a = result.params['a'].value
     b = result.params['b'].value
     c = result.params['c'].value