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

celldetective/measure.py

@@ -17,16 +17,25 @@ from math import ceil
 from skimage.draw import disk as dsk
 from skimage.feature import blob_dog, blob_log
 
+from celldetective.exceptions import EmptyQueryError, MissingColumnsError, QueryError
 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_invalid_cols
 from celldetective.preprocessing import field_correction
-from celldetective.extra_properties import *
+
+# try:
+# 	from celldetective.extra_properties import *
+# 	extra_props = True
+# except Exception as e:
+# 	print(f"The module extra_properties seems corrupted: {e}... Skip...")
+# 	extra_props = False
+
 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
+from celldetective.utils import pretty_table
 
 abs_path = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], 'celldetective'])
 
@@ -211,7 +220,7 @@ def measure(stack=None, labels=None, trajectories=None, channel_names=None,
 		measurements = measurements.sort_values(by=[column_labels['track'],column_labels['time']])
 		measurements = measurements.dropna(subset=[column_labels['track']])
 	else:
-		measurements['ID'] = np.arange(len(df))
+		measurements['ID'] = np.arange(len(measurements))
 
 	measurements = measurements.reset_index(drop=True)
 	measurements = _remove_invalid_cols(measurements)
@@ -365,26 +374,35 @@ def measure_features(img, label, features=['area', 'intensity_mean'], channels=N
 					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 = 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:
-			feats.remove(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_props, 'intensity_nanmean'))
-
-	if len(extra_props_list) == 0:
-		extra_props_list = None
+	try:
+		import celldetective.extra_properties as extra_props
+		extraprops = True
+	except Exception as e:
+		print(f"The module extra_properties seems corrupted: {e}... Skip...")
+		extraprops = False
+
+	if extraprops:
+		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:
+				feats.remove(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_props, 'intensity_nanmean'))
+
+		if len(extra_props_list) == 0:
+			extra_props_list = None
+		else:
+			extra_props_list = tuple(extra_props_list)
 	else:
-		extra_props_list = tuple(extra_props_list)
+		extra_props_list = []
+		feats = features.copy()
 
 	props = regionprops_table(label, intensity_image=img, properties=feats, extra_properties=extra_props_list, channel_names=channels)
 	df_props = pd.DataFrame(props)
@@ -837,17 +855,32 @@ 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
+	try:
+		import celldetective.extra_properties as extra_props
+		extraprops = True
+	except Exception as e:
+		print(f"The module extra_properties seems corrupted: {e}... Skip...")
+		extraprops = False
 
 	border = contour_of_instance_segmentation(label=labels, distance=distance * (-1))
 	if model == 'mean':
+		
 		measurement = 'intensity_nanmean'
-		extra_props = [getattr(extra_props, measurement)]
+		if extraprops:
+			extra_props = [getattr(extra_props, measurement)]
+		else:
+			extra_props = []
+
 		background_intensity = regionprops_table(intensity_image=image, label_image=border,
 												 extra_properties=extra_props)
 	elif model == 'median':
+		
 		measurement = 'intensity_median'
-		extra_props = [getattr(extra_props, measurement)]
+		if extraprops:
+			extra_props = [getattr(extra_props, measurement)]
+		else:
+			extra_props = []
+
 		background_intensity = regionprops_table(intensity_image=image, label_image=border,
 												 extra_properties=extra_props)
 
@@ -1250,16 +1283,20 @@ def classify_irreversible_events(data, class_attr, r2_threshold=0.5, percentile_
 			# 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())
+	print("Number of cells per class after the initial pass: ")
+	pretty_table(df.loc[df['FRAME']==0,class_attr].value_counts().to_dict())
 
 	df.loc[df[class_attr]!=2, class_attr.replace('class', 't')] = -1
 	# Try to fit time on class 2 cells (ambiguous)
 	df = estimate_time(df, class_attr, model='step_function', class_of_interest=[2], r2_threshold=r2_threshold)
-	print("Classes after fit: ", df.loc[df['FRAME']==0,class_attr].value_counts())
+	
+	print("Number of cells per class after conditional signal fit: ")
+	pretty_table(df.loc[df['FRAME']==0,class_attr].value_counts().to_dict())
 
 	# Revisit class 2 cells to classify as neg/pos with percentile tolerance
 	df.loc[df[class_attr]==2,:] = classify_unique_states(df.loc[df[class_attr]==2,:].copy(), class_attr, percentile_recovery)
-	print("Classes after unique state recovery: ",df.loc[df['FRAME']==0,class_attr].value_counts())
+	print("Number of cells per class after recovery pass (median state): ")
+	pretty_table(df.loc[df['FRAME']==0,class_attr].value_counts().to_dict())
 	
 	return df
 
@@ -1396,35 +1433,39 @@ def classify_cells_from_query(df, status_attr, query):
 		If the query is invalid or if there are issues with the DataFrame or query syntax, an error message is printed, and `None` is returned.
 	
 	"""
-
-
-	# Initialize all states to 0
-	if not status_attr.startswith('status_'):
-		status_attr = 'status_'+status_attr
-
+	
+	if not status_attr.startswith("status_"):
+		status_attr = "status_" + status_attr
+	
 	df = df.copy()
-	df.loc[:,status_attr] = 0
+	df = df.replace([np.inf, -np.inf, None], np.nan)
+	#df = df.convert_dtypes()
+	
+	df.loc[:, status_attr] = 0
 	df[status_attr] = df[status_attr].astype(float)
-
+	
 	cols = extract_cols_from_query(query)
-	print(f"{cols=}")
-
-	cols_in_df = np.all([c in list(df.columns) for c in cols], axis=0)
-	if query=='':
-		print('The provided query is empty...')
-	else:
-		try:
-			if cols_in_df:
-				selection = df.dropna(subset=cols).query(query).index
-				null_selection = df[df.loc[:,cols].isna().any(axis=1)].index
-				# Set NaN to invalid cells, 1 otherwise
-				df.loc[null_selection, status_attr] = np.nan
-				df.loc[selection, status_attr] = 1
-			else:
-				df.loc[:, status_attr] = np.nan
-		except Exception as e:
-			print(f"The query could not be understood. No filtering was applied. {e}...")
-			return None
+	print(f"The following DataFrame measurements were identified in the query: {cols=}...")
+	
+	if query.strip() == "":
+		raise EmptyQueryError("The provided query is empty.")
+	
+	missing_cols = [c for c in cols if c not in df.columns]
+	if missing_cols:
+		raise MissingColumnsError(missing_cols)
+	
+	try:
+		sub_df = df.dropna(subset=cols)
+		if len(sub_df) > 0:
+			selection = sub_df.query(query).index
+			null_selection = df[df.loc[:, cols].isna().any(axis=1)].index
+			df.loc[null_selection, status_attr] = np.nan
+			df.loc[selection, status_attr] = 1
+		else:
+			df.loc[:, status_attr] = np.nan
+	except Exception as e:
+		raise QueryError(f"The query could not be understood: {e}")
+	
 	return df.copy()
 
 def classify_tracks_from_query(df, event_name, query, irreversible_event=True, unique_state=False, r2_threshold=0.5, percentile_recovery=50):