celldetective 1.3.8.post1__py3-none-any.whl → 1.3.9.post1__py3-none-any.whl

celldetective/measure.py

@@ -6,7 +6,7 @@ from sklearn.metrics import r2_score
 from scipy.optimize import curve_fit
 from scipy import ndimage
 from tqdm import tqdm
-from skimage.measure import regionprops_table
+#from skimage.measure import regionprops_table
 from functools import reduce
 from mahotas.features import haralick
 from scipy.ndimage import zoom
@@ -18,18 +18,20 @@ from skimage.draw import disk as dsk
 from skimage.feature import blob_dog, blob_log
 
 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_trajectory_measurements, contour_of_instance_segmentation, extract_cols_from_query, step_function, interpolate_nan, _remove_invalid_cols
 from celldetective.preprocessing import field_correction
-import celldetective.extra_properties as extra_properties
 from celldetective.extra_properties import *
 from inspect import getmembers, isfunction
 from skimage.morphology import disk
 from scipy.signal import find_peaks, peak_widths
 
 from celldetective.segmentation import filter_image
+from celldetective.regionprops import regionprops_table
 
 abs_path = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], 'celldetective'])
 
+
+
 def measure(stack=None, labels=None, trajectories=None, channel_names=None,
 			features=None, intensity_measurement_radii=None, isotropic_operations=['mean'], border_distances=None,
 			haralick_options=None, column_labels={'track': "TRACK_ID", 'time': 'FRAME', 'x': 'POSITION_X', 'y': 'POSITION_Y'}, clear_previous=False):
@@ -212,6 +214,7 @@ def measure(stack=None, labels=None, trajectories=None, channel_names=None,
 		measurements['ID'] = np.arange(len(df))
 
 	measurements = measurements.reset_index(drop=True)
+	measurements = _remove_invalid_cols(measurements)
 
 	return measurements
 
@@ -361,27 +364,29 @@ def measure_features(img, label, features=['area', 'intensity_mean'], channels=N
 				else:
 					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
+	
+	import celldetective.extra_properties as extra_props
 
-	extra_props = getmembers(extra_properties, isfunction)
-	extra_props = [extra_props[i][0] for i in range(len(extra_props))]
+	extra = getmembers(extra_props, isfunction)
+	extra = [extra[i][0] for i in range(len(extra))]
 
 	extra_props_list = []
 	feats = features.copy()
 	for f in features:
-		if f in extra_props:
+		if f in extra:
 			feats.remove(f)
-			extra_props_list.append(getattr(extra_properties, f))
+			extra_props_list.append(getattr(extra_props, f))
 
 	# Add intensity nan mean if need to measure mean intensities
 	if measure_mean_intensities:
-		extra_props_list.append(getattr(extra_properties, 'intensity_nanmean'))
+		extra_props_list.append(getattr(extra_props, 'intensity_nanmean'))
 
 	if len(extra_props_list) == 0:
 		extra_props_list = None
 	else:
 		extra_props_list = tuple(extra_props_list)
 
-	props = regionprops_table(label, intensity_image=img, properties=feats, extra_properties=extra_props_list)
+	props = regionprops_table(label, intensity_image=img, properties=feats, extra_properties=extra_props_list, channel_names=channels)
 	df_props = pd.DataFrame(props)
 	if spot_detection is not None:
 		if df_spots is not None:
@@ -395,8 +400,8 @@ def measure_features(img, label, features=['area', 'intensity_mean'], channels=N
 		intensity_features = list(np.array(features)[np.array(intensity_features_test)])
 		intensity_extra = []
 		for s in intensity_features:
-			if s in extra_props:
-				intensity_extra.append(getattr(extra_properties, s))
+			if s in extra:
+				intensity_extra.append(getattr(extra_props, s))
 				intensity_features.remove(s)
 
 		if len(intensity_features) == 0:
@@ -407,13 +412,13 @@ def measure_features(img, label, features=['area', 'intensity_mean'], channels=N
 
 		new_intensity_features = intensity_features.copy()
 		for int_feat in intensity_features:
-			if int_feat in extra_props:
+			if int_feat in extra:
 				new_intensity_features.remove(int_feat)
 		intensity_features = new_intensity_features
 
 		if (isinstance(border_dist, int) or isinstance(border_dist, float)):
 			border_label = contour_of_instance_segmentation(label, border_dist)
-			props_border = regionprops_table(border_label, intensity_image=img, properties=intensity_features)
+			props_border = regionprops_table(border_label, intensity_image=img, properties=intensity_features, channel_names=channels)
 			df_props_border = pd.DataFrame(props_border)
 			for c in df_props_border.columns:
 				if 'intensity' in c:
@@ -423,7 +428,7 @@ def measure_features(img, label, features=['area', 'intensity_mean'], channels=N
 			df_props_border_list = []
 			for d in border_dist:
 				border_label = contour_of_instance_segmentation(label, d)
-				props_border = regionprops_table(border_label, intensity_image=img, properties=intensity_features)
+				props_border = regionprops_table(border_label, intensity_image=img, properties=intensity_features, channel_names=channels)
 				df_props_border_d = pd.DataFrame(props_border)
 				for c in df_props_border_d.columns:
 					if 'intensity' in c:
@@ -832,16 +837,17 @@ def local_normalisation(image, labels, background_intensity, measurement='intens
 
 def normalise_by_cell(image, labels, distance=5, model='median', operation='subtract', clip=False):
 
+	import celldetective.extra_properties as extra_props
 
 	border = contour_of_instance_segmentation(label=labels, distance=distance * (-1))
 	if model == 'mean':
 		measurement = 'intensity_nanmean'
-		extra_props = [getattr(extra_properties, measurement)]
+		extra_props = [getattr(extra_props, measurement)]
 		background_intensity = regionprops_table(intensity_image=image, label_image=border,
 												 extra_properties=extra_props)
 	elif model == 'median':
 		measurement = 'intensity_median'
-		extra_props = [getattr(extra_properties, measurement)]
+		extra_props = [getattr(extra_props, measurement)]
 		background_intensity = regionprops_table(intensity_image=image, label_image=border,
 												 extra_properties=extra_props)
 

celldetective/regionprops/__init__.py

@@ -0,0 +1 @@
+from ._regionprops import regionprops_table

celldetective/regionprops/_regionprops.py

@@ -0,0 +1,310 @@
+from skimage.measure._regionprops import RegionProperties, regionprops, _cached, _props_to_dict, _infer_number_of_required_args
+import numpy as np
+import inspect
+import json
+import os
+from scipy.ndimage import find_objects
+
+abs_path = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]])
+
+with open(os.sep.join([abs_path, 'regionprops', 'props.json'])) as f:
+	PROPS = json.load(f)
+
+COL_DTYPES = {
+	'area': float,
+	'area_bbox': float,
+	'area_convex': float,
+	'area_filled': float,
+	'axis_major_length': float,
+	'axis_minor_length': float,
+	'bbox': int,
+	'centroid': float,
+	'centroid_local': float,
+	'centroid_weighted': float,
+	'centroid_weighted_local': float,
+	'coords': object,
+	'coords_scaled': object,
+	'eccentricity': float,
+	'equivalent_diameter_area': float,
+	'euler_number': int,
+	'extent': float,
+	'feret_diameter_max': float,
+	'image': object,
+	'image_convex': object,
+	'image_filled': object,
+	'image_intensity': object,
+	'inertia_tensor': float,
+	'inertia_tensor_eigvals': float,
+	'intensity_max': float,
+	'intensity_mean': float,
+	'intensity_min': float,
+	'intensity_std': float,
+	'label': int,
+	'moments': float,
+	'moments_central': float,
+	'moments_hu': float,
+	'moments_normalized': float,
+	'moments_weighted': float,
+	'moments_weighted_central': float,
+	'moments_weighted_hu': float,
+	'moments_weighted_normalized': float,
+	'num_pixels': int,
+	'orientation': float,
+	'perimeter': float,
+	'perimeter_crofton': float,
+	'slice': object,
+	'solidity': float,
+}
+
+OBJECT_COLUMNS = [col for col, dtype in COL_DTYPES.items() if dtype == object]
+PROP_VALS = set(PROPS.values())
+
+class CustomRegionProps(RegionProperties):
+
+	"""
+	From https://github.com/scikit-image/scikit-image/blob/main/skimage/measure/_regionprops.py with a modification to not mask the intensity image itself before measurements
+	"""
+
+	def __init__(self, channel_names, *args, **kwargs):
+
+		self.channel_names = channel_names
+		if isinstance(self.channel_names, np.ndarray):
+			self.channel_names = list(self.channel_names)
+		super().__init__(*args, **kwargs)
+
+
+	def __getattr__(self, attr):
+
+		if self.channel_names is not None and self._multichannel:
+			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:
+			raise AttributeError(
+				f"Attribute '{attr}' unavailable when `intensity_image` "
+				f"has not been specified."
+			)
+		if attr in self._extra_properties:
+			func = self._extra_properties[attr]
+			n_args = _infer_number_of_required_args(func)
+			# determine whether func requires intensity image
+			if n_args == 2:
+				if self._intensity_image is not None:
+					if self._multichannel:
+						arg_dict = dict(inspect.signature(func).parameters)
+						if self.channel_names is not None and 'target_channel' in arg_dict:
+							multichannel_list = [np.nan for i in range(self.image_intensity.shape[-1])]
+							default_channel = arg_dict['target_channel']._default
+							if default_channel in self.channel_names:
+								idx = self.channel_names.index(default_channel)
+								multichannel_list[idx] = func(self.image, self.image_intensity[..., idx])
+							else:
+								print(f'Warning... Channel required by custom measurement ({default_channel}) could not be found in your data...')
+							return np.stack(multichannel_list, axis=-1)
+						else:
+							multichannel_list = [
+								func(self.image, self.image_intensity[..., i])
+								for i in range(self.image_intensity.shape[-1])
+							]
+							return np.stack(multichannel_list, axis=-1)
+					else:
+						return func(self.image, self.image_intensity)
+				else:
+					raise AttributeError(
+						f'intensity image required to calculate {attr}'
+					)
+			elif n_args == 1:
+				return func(self.image)
+			else:
+				raise AttributeError(
+					f'Custom regionprop function\'s number of arguments must '
+					f'be 1 or 2, but {attr} takes {n_args} arguments.'
+				)
+		elif attr in PROPS and attr.lower() == attr:
+			if (
+				self._intensity_image is None
+				and PROPS[attr] in _require_intensity_image
+			):
+				raise AttributeError(
+					f"Attribute '{attr}' unavailable when `intensity_image` "
+					f"has not been specified."
+				)
+			# retrieve deprecated property (excluding old CamelCase ones)
+			return getattr(self, PROPS[attr])
+		else:
+			raise AttributeError(f"'{type(self)}' object has no attribute '{attr}'")
+
+	@property
+	@_cached
+	def image_intensity(self):
+		if self._intensity_image is None:
+			raise AttributeError('No intensity image specified.')
+		image = (
+			self.image
+			if not self._multichannel
+			else np.expand_dims(self.image, self._ndim)
+		)
+		return self._intensity_image[self.slice]
+
+def regionprops(label_image, intensity_image=None,cache=True,channel_names=None,*,extra_properties=None,spacing=None,offset=None):
+
+	"""
+	From https://github.com/scikit-image/scikit-image/blob/main/skimage/measure/_regionprops.py with a modification to use CustomRegionProps
+	"""
+	
+	if label_image.ndim not in (2, 3):
+		raise TypeError('Only 2-D and 3-D images supported.')
+	
+	if not np.issubdtype(label_image.dtype, np.integer):
+		if np.issubdtype(label_image.dtype, bool):
+			raise TypeError(
+				'Non-integer image types are ambiguous: '
+				'use skimage.measure.label to label the connected '
+				'components of label_image, '
+				'or label_image.astype(np.uint8) to interpret '
+				'the True values as a single label.'
+			)
+		else:
+			raise TypeError('Non-integer label_image types are ambiguous')
+	
+	if offset is None:
+		offset_arr = np.zeros((label_image.ndim,), dtype=int)
+	else:
+		offset_arr = np.asarray(offset)
+		if offset_arr.ndim != 1 or offset_arr.size != label_image.ndim:
+			raise ValueError(
+				'Offset should be an array-like of integers '
+				'of shape (label_image.ndim,); '
+				f'{offset} was provided.'
+			)
+	
+	regions = []
+	
+	objects = find_objects(label_image)
+	for i, sl in enumerate(objects):
+		if sl is None:
+			continue
+	
+		label = i + 1
+
+		props = CustomRegionProps(
+			channel_names,
+			sl,
+			label,
+			label_image,
+			intensity_image,
+			cache,
+			spacing=spacing,
+			extra_properties=extra_properties,
+			offset=offset_arr,
+		)
+		regions.append(props)
+	
+	return regions
+
+
+def _props_to_dict(regions, properties=('label', 'bbox'), separator='-'):
+
+
+	out = {}
+	n = len(regions)
+	for prop in properties:
+		r = regions[0]
+		# Copy the original property name so the output will have the
+		# user-provided property name in the case of deprecated names.
+		orig_prop = prop
+		# determine the current property name for any deprecated property.
+		prop = PROPS.get(prop, prop)
+		rp = getattr(r, prop)
+		if prop in COL_DTYPES:
+			dtype = COL_DTYPES[prop]
+		else:
+			func = r._extra_properties[prop]
+			# dtype = _infer_regionprop_dtype(
+			# 	func,
+			# 	intensity=r._intensity_image is not None,
+			# 	ndim=r.image.ndim,
+			# )
+			dtype = np.float64
+
+		# scalars and objects are dedicated one column per prop
+		# array properties are raveled into multiple columns
+		# for more info, refer to notes 1
+		if np.isscalar(rp) or prop in OBJECT_COLUMNS or dtype is np.object_:
+			column_buffer = np.empty(n, dtype=dtype)
+			for i in range(n):
+				column_buffer[i] = regions[i][prop]
+			out[orig_prop] = np.copy(column_buffer)
+		else:
+			# precompute property column names and locations
+			modified_props = []
+			locs = []
+			for ind in np.ndindex(np.shape(rp)):
+				modified_props.append(separator.join(map(str, (orig_prop,) + ind)))
+				locs.append(ind if len(ind) > 1 else ind[0])
+
+			# fill temporary column data_array
+			n_columns = len(locs)
+			column_data = np.empty((n, n_columns), dtype=dtype)
+			for k in range(n):
+				# we coerce to a numpy array to ensure structures like
+				# tuple-of-arrays expand correctly into columns
+				rp = np.asarray(regions[k][prop])
+				for i, loc in enumerate(locs):
+					column_data[k, i] = rp[loc]
+
+			# add the columns to the output dictionary
+			for i, modified_prop in enumerate(modified_props):
+				out[modified_prop] = column_data[:, i]
+	return out
+
+
+def regionprops_table(label_image,intensity_image=None,properties=('label', 'bbox'),*,cache=True,separator='-',extra_properties=None,spacing=None,channel_names=None):
+	
+	"""
+	From https://github.com/scikit-image/scikit-image/blob/main/skimage/measure/_regionprops.py
+	"""
+	regions = regionprops(
+		label_image,
+		intensity_image=intensity_image,
+		cache=cache,
+		extra_properties=extra_properties,
+		spacing=spacing,
+		channel_names=channel_names,
+	)
+	if extra_properties is not None:
+		properties = list(properties) + [prop.__name__ for prop in extra_properties]
+	if len(regions) == 0:
+		ndim = label_image.ndim
+		label_image = np.zeros((3,) * ndim, dtype=int)
+		label_image[(1,) * ndim] = 1
+		if intensity_image is not None:
+			intensity_image = np.zeros(
+				label_image.shape + intensity_image.shape[ndim:],
+				dtype=intensity_image.dtype,
+			)
+		regions = regionprops(
+			label_image,
+			intensity_image=intensity_image,
+			cache=cache,
+			extra_properties=extra_properties,
+			spacing=spacing,
+			channel_names=channel_names,
+		)
+		out_d = _props_to_dict(regions, properties=properties, separator=separator)
+		return {k: v[:0] for k, v in out_d.items()}
+
+	good_props = []
+	for prop in properties:
+		nan_test = [np.isnan(getattr(r,prop)) for r in regions]
+		if not np.all(nan_test):
+			good_props.append(prop)
+
+	return _props_to_dict(regions, properties=good_props, separator=separator)

celldetective/regionprops/props.json

@@ -0,0 +1,63 @@
+{
+    "Area": "area",
+    "BoundingBox": "bbox",
+    "BoundingBoxArea": "area_bbox",
+    "bbox_area": "area_bbox",
+    "CentralMoments": "moments_central",
+    "Centroid": "centroid",
+    "ConvexArea": "area_convex",
+    "convex_area": "area_convex",
+    "ConvexImage": "image_convex",
+    "convex_image": "image_convex",
+    "Coordinates": "coords",
+    "Eccentricity": "eccentricity",
+    "EquivDiameter": "equivalent_diameter_area",
+    "equivalent_diameter": "equivalent_diameter_area",
+    "EulerNumber": "euler_number",
+    "Extent": "extent",
+    "FeretDiameter": "feret_diameter_max",
+    "FeretDiameterMax": "feret_diameter_max",
+    "FilledArea": "area_filled",
+    "filled_area": "area_filled",
+    "FilledImage": "image_filled",
+    "filled_image": "image_filled",
+    "HuMoments": "moments_hu",
+    "Image": "image",
+    "InertiaTensor": "inertia_tensor",
+    "InertiaTensorEigvals": "inertia_tensor_eigvals",
+    "IntensityImage": "image_intensity",
+    "intensity_image": "image_intensity",
+    "Label": "label",
+    "LocalCentroid": "centroid_local",
+    "local_centroid": "centroid_local",
+    "MajorAxisLength": "axis_major_length",
+    "major_axis_length": "axis_major_length",
+    "MaxIntensity": "intensity_max",
+    "max_intensity": "intensity_max",
+    "MeanIntensity": "intensity_mean",
+    "mean_intensity": "intensity_mean",
+    "MinIntensity": "intensity_min",
+    "min_intensity": "intensity_min",
+    "std_intensity": "intensity_std",
+    "MinorAxisLength": "axis_minor_length",
+    "minor_axis_length": "axis_minor_length",
+    "Moments": "moments",
+    "NormalizedMoments": "moments_normalized",
+    "Orientation": "orientation",
+    "Perimeter": "perimeter",
+    "CroftonPerimeter": "perimeter_crofton",
+    "Slice": "slice",
+    "Solidity": "solidity",
+    "WeightedCentralMoments": "moments_weighted_central",
+    "weighted_moments_central": "moments_weighted_central",
+    "WeightedCentroid": "centroid_weighted",
+    "weighted_centroid": "centroid_weighted",
+    "WeightedHuMoments": "moments_weighted_hu",
+    "weighted_moments_hu": "moments_weighted_hu",
+    "WeightedLocalCentroid": "centroid_weighted_local",
+    "weighted_local_centroid": "centroid_weighted_local",
+    "WeightedMoments": "moments_weighted",
+    "weighted_moments": "moments_weighted",
+    "WeightedNormalizedMoments": "moments_weighted_normalized",
+    "weighted_moments_normalized": "moments_weighted_normalized"
+}

celldetective/scripts/measure_relative.py

@@ -34,36 +34,18 @@ 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"])
-channel_names, channel_inneigh_protocoles = extract_experiment_channels(config)
+channel_names, channel_indices = extract_experiment_channels(expfolder)
 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}"))
 previous_pair_table_path = pos + os.sep.join(['output', 'tables', 'trajectories_pairs.csv'])
 
-# if os.path.exists(instr_path):
-# 	print(f"Neighborhood instructions has been successfully located.")
-# 	with open(instr_path, 'r') as f:
-# 		instructions = json.load(f)
-# 		print("Reading the following instructions: ", instructions)
-
-# 	if 'distance' in instructions:
-# 		distance = instructions['distance'][0]
-# 	else:
-# 		distance = None
-# else:
-# 	print('No measurement instructions found')
-# 	os.abort()
 
 previous_neighborhoods = []
 associated_reference_population = []
 
-# if distance is None:
-# 	print('No measurement could be performed. Check your inputs.')
-# 	print('Done.')
-# 	os.abort()
-# 	#distance = 0
-# else:
+
 neighborhoods_to_measure = extract_neighborhoods_from_pickles(pos)
 all_df_pairs = []
 if os.path.exists(previous_pair_table_path):

celldetective/segmentation.py

@@ -229,7 +229,7 @@ def segment_from_thresholds(stack, target_channel=0, thresholds=None, view_on_na
 	return masks
 
 def segment_frame_from_thresholds(frame, target_channel=0, thresholds=None, equalize_reference=None,
-								  filters=None, marker_min_distance=30, marker_footprint_size=20, marker_footprint=None, feature_queries=None, channel_names=None, do_watershed=True):
+								  filters=None, marker_min_distance=30, marker_footprint_size=20, marker_footprint=None, feature_queries=None, channel_names=None, do_watershed=True, edge_exclusion=True, fill_holes=True):
 	
 	"""
 	Segments objects within a single frame based on intensity thresholds and optional image processing steps.
@@ -269,14 +269,24 @@ def segment_frame_from_thresholds(frame, target_channel=0, thresholds=None, equa
 
 	"""
 
+	if frame.ndim==2:
+		frame = frame[:,:,np.newaxis]
 	img = frame[:,:,target_channel]
-	img = interpolate_nan(img)
+
+	if np.any(img!=img):
+		img = interpolate_nan(img)
+
 	if equalize_reference is not None:
 		img = match_histograms(img, equalize_reference)
+
 	img_mc = frame.copy()
 	img = filter_image(img, filters=filters)
-	edge = estimate_unreliable_edge(filters)
-	binary_image = threshold_image(img, thresholds[0], thresholds[1], fill_holes=True, edge_exclusion=edge)
+	if edge_exclusion:
+		edge = estimate_unreliable_edge(filters)
+	else:
+		edge = None
+
+	binary_image = threshold_image(img, thresholds[0], thresholds[1], fill_holes=fill_holes, edge_exclusion=edge)
 	
 	if do_watershed:
 		coords,distance = identify_markers_from_binary(binary_image, marker_min_distance, footprint_size=marker_footprint_size, footprint=marker_footprint, return_edt=True)