celldetective 1.3.9.post3__tar.gz → 1.3.9.post5__tar.gz

{celldetective-1.3.9.post3 → celldetective-1.3.9.post5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: celldetective
-Version: 1.3.9.post3
+Version: 1.3.9.post5
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro

celldetective-1.3.9.post5/celldetective/_version.py

@@ -0,0 +1 @@
+__version__ = "1.3.9.post5"

celldetective-1.3.9.post5/celldetective/extra_properties.py

@@ -0,0 +1,437 @@
+"""
+Copyright © 2022 Laboratoire Adhesion et Inflammation  
+Authored by R. Torro, K. Dervanova, L. Limozin
+
+This module defines additional measurement functions for use with `regionprops` via `measure_features`.  
+
+Usage
+-----
+Each function must follow these conventions:
+
+- **First argument:** `regionmask` (numpy array)  
+  A binary mask of the cell of interest, as provided by `regionprops`.
+- **Optional second argument:** `intensity_image` (numpy array)  
+  An image crop/bounding box associated with the cell (single-channel at a time).  
+
+Unlike the default `regionprops` from `scikit-image`, the cell image is **not** masked with zeros outside its boundaries.  
+This allows thresholding techniques to be used in measurements.  
+
+Naming Conventions & Indexing
+------------------------------
+- The measurement name is derived from the function name.  
+- If a function returns multiple values (e.g., for multichannel images), outputs are labeled sequentially:  
+  `function-0`, `function-1`, etc.  
+- To rename these outputs, use `rename_intensity_column` from `celldetective.utils`.  
+- `"intensity"` in function names is automatically replaced with the actual channel name:  
+  - Example: `"intensity-0"` → `"brightfield_channel"`.  
+- **Avoid digits smaller than the number of channels in function names** to prevent indexing conflicts.  
+  Prefer text-based names instead:  
+
+  .. code-block:: python
+
+	  # Bad practice:
+	  def intensity2(regionmask, intensity_image):
+		  pass
+
+	  # Recommended:
+	  def intensity_two(regionmask, intensity_image):
+		  pass
+
+GUI Integration
+---------------
+New functions are **automatically** added to the list of available measurements in the graphical interface.  
+"""
+
+import warnings
+
+import numpy as np
+from scipy.ndimage import distance_transform_edt, center_of_mass
+from scipy.spatial.distance import euclidean
+from celldetective.utils import interpolate_nan, contour_of_instance_segmentation
+import skimage.measure as skm
+from stardist import fill_label_holes
+from celldetective.segmentation import segment_frame_from_thresholds
+from sklearn.metrics import r2_score
+
+
+# def area_detected_in_ricm(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+# 	instructions = {
+# 		"thresholds": [
+# 			0.02,
+# 			1000
+# 		],
+# 		"filters": [
+# 			[
+# 				"subtract",
+# 				1
+# 			],
+# 			[
+# 				"abs",
+# 				2
+# 			],
+# 			[
+# 				"gauss",
+# 				0.8
+# 			]
+# 		],
+# 		#"marker_min_distance": 1,
+# 		#"marker_footprint_size": 10,
+# 		"feature_queries": [
+# 			"eccentricity > 0.99 or area < 60"
+# 		],
+# 	}
+	
+# 	lbl = segment_frame_from_thresholds(intensity_image, fill_holes=True, do_watershed=False, equalize_reference=None, edge_exclusion=False, **instructions)
+# 	lbl[lbl>0] = 1 # instance to binary
+# 	lbl[~regionmask] = 0 # make sure we don't measure stuff outside cell
+
+# 	return np.sum(lbl)
+
+def fraction_of_area_detected_in_intensity(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+	instructions = {
+		"thresholds": [
+			0.02,
+			1000
+		],
+		"filters": [
+			[
+				"subtract",
+				1
+			],
+			[
+				"abs",
+				2
+			],
+			[
+				"gauss",
+				0.8
+			]
+		],
+	}
+	
+	lbl = segment_frame_from_thresholds(intensity_image, do_watershed=False, fill_holes=True, equalize_reference=None, edge_exclusion=False, **instructions)
+	lbl[lbl>0] = 1 # instance to binary
+	lbl[~regionmask] = 0 # make sure we don't measure stuff outside cell
+	
+	return float(np.sum(lbl)) / float(np.sum(regionmask))
+
+def area_detected_in_intensity(regionmask, intensity_image, target_channel='adhesion_channel'):
+
+	"""
+	Computes the detected area within the regionmask based on threshold-based segmentation.
+
+	The function applies a predefined filtering and thresholding pipeline to the intensity image (normalized adhesion channel)
+	to detect significant regions. The resulting segmented regions are restricted to the 
+	`regionmask`, ensuring that only the relevant area is measured.
+
+	Parameters
+	----------
+	regionmask : ndarray
+		A binary mask (2D array) where nonzero values define the region of interest.
+	intensity_image : ndarray
+		A 2D array of the same shape as `regionmask`, representing the intensity 
+		values associated with the region.
+	target_channel : str, optional
+		Name of the intensity channel used for measurement. Defaults to `'adhesion_channel'`.
+
+	Returns
+	-------
+	detected_area : float
+		The total area (number of pixels) detected based on intensity-based segmentation.
+
+	Notes
+	-----
+	- The segmentation is performed using `segment_frame_from_thresholds()` with predefined parameters:
+	  
+	  - Thresholding range: `[0.02, 1000]`
+	  - Filters applied in sequence:
+
+		- `"subtract"` with value `1` (subtract 1 from intensity values)
+		- `"abs"` (take absolute value of intensities)
+		- `"gauss"` with sigma `0.8` (apply Gauss filter with sigma `0.8`)
+
+	- The segmentation includes hole filling.
+	- The detected regions are converted to a binary mask (`lbl > 0`).
+	- Any pixels outside the `regionmask` are excluded from the measurement.
+
+	"""
+
+	instructions = {
+		"thresholds": [
+			0.02,
+			1000
+		],
+		"filters": [
+			[
+				"subtract",
+				1
+			],
+			[
+				"abs",
+				2
+			],
+			[
+				"gauss",
+				0.8
+			]
+		],
+	}
+	
+	lbl = segment_frame_from_thresholds(intensity_image, do_watershed=False, fill_holes=True, equalize_reference=None, edge_exclusion=False, **instructions)
+	lbl[lbl>0] = 1 # instance to binary
+	lbl[~regionmask] = 0 # make sure we don't measure stuff outside cell
+	
+	return float(np.sum(lbl))
+
+
+def area_dark_intensity(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True, threshold=0.95): #, target_channel='adhesion_channel'
+	
+	"""
+	Computes the absolute area within the regionmask where the intensity is below a given threshold.
+
+	This function identifies pixels in the region where the intensity is lower than `threshold`. 
+	If `fill_holes` is `True`, small enclosed holes in the detected dark regions are filled before 
+	computing the total area.
+
+	Parameters
+	----------
+	regionmask : ndarray
+		A binary mask (2D array) where nonzero values define the region of interest.
+	intensity_image : ndarray
+		A 2D array of the same shape as `regionmask`, representing the intensity 
+		values associated with the region.
+	target_channel : str, optional
+		Name of the intensity channel used for measurement. Defaults to `'adhesion_channel'`.
+	fill_holes : bool, optional
+		If `True`, fills enclosed holes in the detected dark intensity regions before computing 
+		the area. Defaults to `True`.
+	threshold : float, optional
+		Intensity threshold below which a pixel is considered part of a dark region. 
+		Defaults to `0.95`.
+
+	Returns
+	-------
+	dark_area : float
+		The absolute area (number of pixels) where intensity values are below `threshold`, within the regionmask.
+
+	Notes
+	-----
+	- The default threshold for defining "dark" intensity regions is `0.95`, but it can be adjusted.
+	- If `fill_holes` is `True`, the function applies hole-filling to the detected dark regions
+	  using `skimage.measure.label` and `fill_label_holes()`.
+	- The `target_channel` parameter tells regionprops to only measure this channel.
+
+	"""
+
+	subregion = (intensity_image < threshold)*regionmask # under one, under 0.8, under 0.6, whatever value!
+	if fill_holes:
+		subregion = skm.label(subregion, connectivity=2, background=0)
+		subregion = fill_label_holes(subregion)
+		subregion[subregion>0] = 1
+	
+	return float(np.sum(subregion))
+
+
+def fraction_of_area_dark_intensity(regionmask, intensity_image, target_channel='adhesion_channel', fill_holes=True, threshold=0.95): #, target_channel='adhesion_channel'
+	
+	subregion = (intensity_image < threshold)*regionmask # under one, under 0.8, under 0.6, whatever value!
+	if fill_holes:
+		subregion = skm.label(subregion, connectivity=2, background=0)
+		subregion = fill_label_holes(subregion)
+		subregion[subregion>0] = 1
+	
+	return float(np.sum(subregion)) / float(np.sum(regionmask))
+
+
+def intensity_percentile_ninety_nine(regionmask, intensity_image):
+	return np.nanpercentile(intensity_image[regionmask],99)
+
+def intensity_percentile_ninety_five(regionmask, intensity_image):
+	return np.nanpercentile(intensity_image[regionmask],95)
+
+def intensity_percentile_ninety(regionmask, intensity_image):
+	return np.nanpercentile(intensity_image[regionmask],90)
+
+def intensity_percentile_seventy_five(regionmask, intensity_image):
+	return np.nanpercentile(intensity_image[regionmask],75)
+
+def intensity_percentile_fifty(regionmask, intensity_image):
+	return np.nanpercentile(intensity_image[regionmask],50)
+
+def intensity_percentile_twenty_five(regionmask, intensity_image):
+	return np.nanpercentile(intensity_image[regionmask],25)
+
+# STD
+
+def intensity_std(regionmask, intensity_image):
+	return np.nanstd(intensity_image[regionmask])
+
+
+def intensity_median(regionmask, intensity_image):
+	return np.nanmedian(intensity_image[regionmask])
+
+def intensity_nanmean(regionmask, intensity_image):
+	
+	if np.all(intensity_image==0):
+		return np.nan
+	else:
+		return np.nanmean(intensity_image[regionmask])
+
+def intensity_center_of_mass_displacement(regionmask, intensity_image):
+
+	"""
+	Computes the displacement between the geometric centroid and the 
+	intensity-weighted center of mass of a region.
+
+	Parameters
+	----------
+	regionmask : ndarray
+		A binary mask (2D array) where nonzero values indicate the region of interest.
+	intensity_image : ndarray
+		A 2D array of the same shape as `regionmask`, representing the intensity 
+		values associated with the region.
+
+	Returns
+	-------
+	distance : float
+		Euclidean distance between the geometric centroid and the intensity-weighted center of mass.
+	direction_arctan : float
+		Angle (in degrees) of displacement from the geometric centroid to the intensity-weighted center of mass,
+		computed using `arctan2(delta_y, delta_x)`.
+	delta_x : float
+		Difference in x-coordinates (intensity-weighted centroid - geometric centroid).
+	delta_y : float
+		Difference in y-coordinates (intensity-weighted centroid - geometric centroid).
+
+	Notes
+	-----
+	- If the `intensity_image` contains NaN values, it is first processed using `interpolate_nan()`.
+	- Negative intensity values are set to zero to prevent misbehavior in center of mass calculation.
+	- If the intensity image is entirely zero, all outputs are `NaN`.
+
+	"""
+
+	if np.any(intensity_image!=intensity_image):
+		intensity_image = interpolate_nan(intensity_image.copy())
+
+	if not np.all(intensity_image.flatten()==0):
+		
+		y, x = np.mgrid[:regionmask.shape[0], :regionmask.shape[1]]
+		xtemp = x.copy()
+		ytemp = y.copy()
+
+		intensity_image[intensity_image<=0.] = 0. #important to clip as negative intensities misbehave with center of mass
+		intensity_weighted_center = center_of_mass(intensity_image*regionmask, regionmask, 1)
+		centroid_x = intensity_weighted_center[1]
+		centroid_y = intensity_weighted_center[0]
+
+		geometric_centroid_x = np.sum(xtemp * regionmask) / np.sum(regionmask)
+		geometric_centroid_y = np.sum(ytemp * regionmask) / np.sum(regionmask)
+		distance = np.sqrt((geometric_centroid_y - centroid_y)**2 + (geometric_centroid_x - centroid_x)**2)
+
+		delta_x = geometric_centroid_x - centroid_x
+		delta_y = geometric_centroid_y - centroid_y
+		direction_arctan = np.arctan2(delta_y, delta_x) * 180 / np.pi
+
+		return distance, direction_arctan, centroid_x - geometric_centroid_x, centroid_y - geometric_centroid_y
+
+	else:
+		return np.nan, np.nan, np.nan, np.nan
+
+
+def intensity_center_of_mass_displacement_edge(regionmask, intensity_image):
+
+	if np.any(intensity_image!=intensity_image):
+		intensity_image = interpolate_nan(intensity_image.copy())
+
+	edge_mask = contour_of_instance_segmentation(regionmask, 3)
+	
+	if not np.all(intensity_image.flatten()==0) and np.sum(edge_mask)>0:
+		
+		y, x = np.mgrid[:edge_mask.shape[0], :edge_mask.shape[1]]
+		xtemp = x.copy()
+		ytemp = y.copy()
+		
+		intensity_image[intensity_image<=0.] = 0. #important to clip as negative intensities misbehave with center of mass
+		intensity_weighted_center = center_of_mass(intensity_image*edge_mask, edge_mask, 1)
+		centroid_x = intensity_weighted_center[1]
+		centroid_y = intensity_weighted_center[0]
+
+		#centroid_x = np.sum(xtemp * intensity_image) / np.sum(intensity_image)
+		geometric_centroid_x = np.sum(xtemp * regionmask) / np.sum(regionmask)
+		geometric_centroid_y = np.sum(ytemp * regionmask) / np.sum(regionmask)
+		
+		distance = np.sqrt((geometric_centroid_y - centroid_y)**2 + (geometric_centroid_x - centroid_x)**2)
+
+		delta_x = geometric_centroid_x - centroid_x
+		delta_y = geometric_centroid_y - centroid_y
+		direction_arctan = np.arctan2(delta_y, delta_x) * 180 / np.pi
+
+		return distance, direction_arctan, centroid_x - geometric_centroid_x, centroid_y - geometric_centroid_y
+	else:
+		return np.nan, np.nan, np.nan, np.nan
+
+
+def intensity_radial_gradient(regionmask, intensity_image):
+
+	"""
+	Determines whether the intensity follows a radial gradient from the center to the edge of the cell.
+
+	The function fits a linear model to the intensity values as a function of distance from the center
+	(computed via the Euclidean distance transform). The slope of the fitted line indicates whether 
+	the intensity is higher at the center or at the edges.
+
+	Parameters
+	----------
+	regionmask : ndarray
+		A binary mask (2D array) where nonzero values define the region of interest.
+	intensity_image : ndarray
+		A 2D array of the same shape as `regionmask`, representing the intensity 
+		values associated with the region.
+
+	Returns
+	-------
+	slope : float
+		Slope of the fitted linear model.  
+
+		- If `slope > 0`: Intensity increases towards the edge.  
+		- If `slope < 0`: Intensity is higher at the center.  
+
+	intercept : float
+		Intercept of the fitted linear model.
+	r2 : float
+		Coefficient of determination (R²), indicating how well the linear model fits the intensity profile.
+
+	Notes
+	-----
+	- If the `intensity_image` contains NaN values, they are interpolated using `interpolate_nan()`.
+	- The Euclidean distance transform (`distance_transform_edt`) is used to compute the distance 
+	  of each pixel from the edge.
+	- The x-values for the linear fit are reversed so that the origin is at the center.
+	- A warning suppression is applied to ignore messages about poorly conditioned polynomial fits.
+
+	"""
+	
+	if np.any(intensity_image!=intensity_image):
+		intensity_image = interpolate_nan(intensity_image.copy())
+	
+	# try:
+	warnings.filterwarnings('ignore', message="Polyfit may be poorly conditioned")
+	
+	# intensities
+	y = intensity_image[regionmask].flatten()
+
+	# distance to edge
+	x = distance_transform_edt(regionmask.copy())
+	x = x[regionmask].flatten()
+	x = max(x) - x # origin at center of cells
+
+	params = np.polyfit(x, y, 1)
+	line = np.poly1d(params)
+	# coef > 0 --> more signal at edge than center, coef < 0 --> more signal at center than edge
+
+	r2 = r2_score(y, line(x))
+	
+	return line.coefficients[0], line.coefficients[1], r2

{celldetective-1.3.9.post3 → celldetective-1.3.9.post5}/celldetective/gui/classifier_widget.py

@@ -482,8 +482,12 @@ class ClassifierWidget(QWidget, Styles):
 
 		if 'custom' in list(self.df.columns):
 			self.df = self.df.drop(['custom'],axis=1)
-
+		
+		self.fig_props.set_size_inches(4,3)
+		self.fig_props.suptitle(self.property_query_le.text(), fontsize=10)
+		self.fig_props.tight_layout()
 		for pos,pos_group in self.df.groupby('position'):
+			self.fig_props.savefig(pos+os.sep.join(['output',f'{self.class_name}.png']), bbox_inches='tight', dpi=300)
 			pos_group.to_csv(pos+os.sep.join(['output', 'tables', f'trajectories_{self.mode}.csv']), index=False)
 
 		self.parent_window.parent_window.update_position_options()

{celldetective-1.3.9.post3 → celldetective-1.3.9.post5}/celldetective/gui/plot_signals_ui.py

@@ -297,9 +297,12 @@ class ConfigSignalPlot(QWidget, Styles):
 			self.compute_signal_functions()
 			if self.open_widget:
 				self.interpret_pos_location()
-				self.plot_window = GenericSignalPlotWidget(parent_window=self, df=self.df, df_pos_info = self.df_pos_info, df_well_info = self.df_well_info, feature_selected=self.feature_selected, title='plot signals')
-				self.plot_window.show()
-
+				try:
+					self.plot_window = GenericSignalPlotWidget(parent_window=self, df=self.df, df_pos_info = self.df_pos_info, df_well_info = self.df_well_info, feature_selected=self.feature_selected, title='plot signals')
+					self.plot_window.show()
+				except Exception as e:
+					print(f"{e=}")
+		
 	def process_signal(self):
 
 		self.FrameToMin = float(self.time_calibration_le.text().replace(',','.'))

{celldetective-1.3.9.post3 → celldetective-1.3.9.post5}/celldetective/gui/signal_annotator.py

@@ -807,8 +807,6 @@ class SignalAnnotator(QMainWindow, Styles):
 			cols_to_remove += time_cols
 			#cols_to_remove.extend(self.df_tracks.select_dtypes(include=['object']).columns)
 
-			print(f"{cols_to_remove=}")
-
 			for tr in cols_to_remove:
 				try:
 					self.columns_to_rescale.remove(tr)
@@ -856,6 +854,16 @@ class SignalAnnotator(QMainWindow, Styles):
 					 'class', 't0', 'POSITION_X', 'POSITION_Y', 'position', 'well', 'well_index', 'well_name',
 					 'pos_name', 'index','class_color','status_color']
 
+		meta = get_experiment_metadata(self.exp_dir)
+		if meta is not None:
+			keys = list(meta.keys())
+			to_remove.extend(keys)
+
+		labels = get_experiment_labels(self.exp_dir)
+		if labels is not None:
+			keys = list(labels.keys())
+			to_remove.extend(labels)
+
 		for c in to_remove:
 			if c in signals:
 				signals.remove(c)

{celldetective-1.3.9.post3 → celldetective-1.3.9.post5}/celldetective/io.py

@@ -1941,10 +1941,10 @@ def relabel_segmentation(labels, df, exclude_nans=True, column_labels={'track':
 
 	def rewrite_labels(indices):
 
-		all_track_ids = df[column_labels['track']].unique()
+		all_track_ids = df[column_labels['track']].dropna().unique()
 		
 		for t in tqdm(indices):
-
+			
 			f = int(t)
 			cells = df.loc[df[column_labels['frame']] == f, [column_labels['track'], column_labels['label']]].to_numpy()
 			tracks_at_t = list(cells[:,0])
@@ -1974,15 +1974,23 @@ def relabel_segmentation(labels, df, exclude_nans=True, column_labels={'track':
 				
 				loc_i, loc_j = np.where(labels[f] == identities[k])
 				track_id = tracks_at_t[k]
-				new_labels[f, loc_i, loc_j] = round(track_id)
+
+				if track_id==track_id:
+					new_labels[f, loc_i, loc_j] = round(track_id)
 
 	# Multithreading
-	indices = list(df[column_labels['frame']].unique())
+	indices = list(df[column_labels['frame']].dropna().unique())
 	chunks = np.array_split(indices, n_threads)
 
-	with concurrent.futures.ThreadPoolExecutor() as executor:
-		executor.map(rewrite_labels, chunks)
-	
+	with concurrent.futures.ThreadPoolExecutor(max_workers=threads) as executor:
+		
+		results = executor.map(rewrite_labels, chunks) #list(map(lambda x: executor.submit(self.parallel_job, x), 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("\nDone.")
 
 	return new_labels
@@ -2088,6 +2096,7 @@ def tracks_to_btrack(df, exclude_nans=False):
 	graph = {}
 	if exclude_nans:
 		df.dropna(subset='class_id',inplace=True)
+		df.dropna(subset='TRACK_ID',inplace=True)
 
 	df["z"] = 0.
 	data = df[["TRACK_ID","FRAME","z","POSITION_Y","POSITION_X"]].to_numpy()

{celldetective-1.3.9.post3 → celldetective-1.3.9.post5}/celldetective/regionprops/_regionprops.py

@@ -108,10 +108,17 @@ class CustomRegionProps(RegionProperties):
 								
 								idx = self.channel_names.index(default_channel)
 								res = func(self.image, self.image_intensity[..., idx])
-								len_output = len(res)
+								if isinstance(res, tuple):
+									len_output = len(res)
+								else:
+									len_output = 1
 
-								multichannel_list = [[np.nan]*len_output for c in range(len(self.channel_names))]
-								multichannel_list[idx] = res
+								if len_output > 1:
+									multichannel_list = [[np.nan]*len_output for c in range(len(self.channel_names))]
+									multichannel_list[idx] = res
+								else:
+									multichannel_list = [np.nan for c in range(len(self.channel_names))]
+									multichannel_list[idx] = res
 
 							else:
 								print(f'Warning... Channel required by custom measurement ({default_channel}) could not be found in your data...')

{celldetective-1.3.9.post3 → celldetective-1.3.9.post5}/celldetective/utils.py

@@ -1264,7 +1264,6 @@ def rename_intensity_column(df, channels):
 			if s.isdigit():
 				if int(s)<len(channel_names):
 					test_digit[j] = True
-		print(f"{test_digit=}")
 			
 		if np.any(test_digit):
 			index = int(sections[np.where(test_digit)[0]][-1])
@@ -1289,36 +1288,36 @@ def rename_intensity_column(df, channels):
 				new_name = np.delete(measure, -1)
 				new_name = '_'.join(list(new_name))
 				if 'edge' in intensity_cols[k]:
-					new_name = new_name.replace('centre_of_mass_displacement', "edge_centre_of_mass_displacement_in_px")
+					new_name = new_name.replace('center_of_mass_displacement', "edge_center_of_mass_displacement_in_px")
 				else:
-					new_name = new_name.replace('centre_of_mass', "centre_of_mass_displacement_in_px")
+					new_name = new_name.replace('center_of_mass', "center_of_mass_displacement_in_px")
 				to_rename.update({intensity_cols[k]: new_name.replace('-', '_')})
 			
 			elif sections[-2] == "1":
 				new_name = np.delete(measure, -1)
 				new_name = '_'.join(list(new_name))
 				if 'edge' in intensity_cols[k]:
-					new_name = new_name.replace('centre_of_mass_displacement', "edge_centre_of_mass_orientation")
+					new_name = new_name.replace('center_of_mass_displacement', "edge_center_of_mass_orientation")
 				else:
-					new_name = new_name.replace('centre_of_mass', "centre_of_mass_orientation")
+					new_name = new_name.replace('center_of_mass', "center_of_mass_orientation")
 				to_rename.update({intensity_cols[k]: new_name.replace('-', '_')})
 				
 			elif sections[-2] == "2":
 				new_name = np.delete(measure, -1)
 				new_name = '_'.join(list(new_name))
 				if 'edge' in intensity_cols[k]:
-					new_name = new_name.replace('centre_of_mass_displacement', "edge_centre_of_mass_x")
+					new_name = new_name.replace('center_of_mass_displacement', "edge_center_of_mass_x")
 				else:
-					new_name = new_name.replace('centre_of_mass', "centre_of_mass_x")
+					new_name = new_name.replace('center_of_mass', "center_of_mass_x")
 				to_rename.update({intensity_cols[k]: new_name.replace('-', '_')})
 			
 			elif sections[-2] == "3":
 				new_name = np.delete(measure, -1)
 				new_name = '_'.join(list(new_name))
 				if 'edge' in intensity_cols[k]:
-					new_name = new_name.replace('centre_of_mass_displacement', "edge_centre_of_mass_y")
+					new_name = new_name.replace('center_of_mass_displacement', "edge_center_of_mass_y")
 				else:
-					new_name = new_name.replace('centre_of_mass', "centre_of_mass_y")
+					new_name = new_name.replace('center_of_mass', "center_of_mass_y")
 				to_rename.update({intensity_cols[k]: new_name.replace('-', '_')})
 		
 		if 'radial_gradient' in intensity_cols[k]:

{celldetective-1.3.9.post3 → celldetective-1.3.9.post5}/celldetective.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: celldetective
-Version: 1.3.9.post3
+Version: 1.3.9.post5
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro

celldetective-1.3.9.post3/celldetective/_version.py

@@ -1 +0,0 @@
-__version__ = "1.3.9.post3"