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

celldetective/gui/viewers.py

@@ -3,7 +3,7 @@ from celldetective.io import auto_load_number_of_frames, load_frames
 from celldetective.filters import *
 from celldetective.segmentation import filter_image, threshold_image
 from celldetective.measure import contour_of_instance_segmentation, extract_blobs_in_image
-from celldetective.utils import _get_img_num_per_channel, estimate_unreliable_edge
+from celldetective.utils import _get_img_num_per_channel, estimate_unreliable_edge, is_integer_array
 from tifffile import imread
 import matplotlib.pyplot as plt 
 from pathlib import Path
@@ -11,11 +11,11 @@ from natsort import natsorted
 from glob import glob
 import os
 
-from PyQt5.QtWidgets import QWidget, QHBoxLayout, QPushButton, QLabel, QComboBox, QLineEdit, QListWidget, QShortcut
+from PyQt5.QtWidgets import QHBoxLayout, QPushButton, QLabel, QComboBox, QLineEdit, QListWidget, QShortcut
 from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QKeySequence, QDoubleValidator
 from celldetective.gui.gui_utils import FigureCanvas, center_window, QuickSliderLayout, QHSeperationLine, ThresholdLineEdit, PreprocessingLayout2
-from celldetective.gui import Styles
+from celldetective.gui import Styles, CelldetectiveWidget
 from superqt import QLabeledDoubleSlider, QLabeledSlider, QLabeledDoubleRangeSlider
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
@@ -24,7 +24,7 @@ import gc
 from celldetective.utils import mask_edges
 from scipy.ndimage import shift
 
-class StackVisualizer(QWidget, Styles):
+class StackVisualizer(CelldetectiveWidget):
 
 	"""
 	A widget for visualizing image stacks with interactive sliders and channel selection.
@@ -92,8 +92,7 @@ class StackVisualizer(QWidget, Styles):
 			self.generate_frame_slider()
 
 		self.canvas.layout.setContentsMargins(15,15,15,30)
-		self.setAttribute(Qt.WA_DeleteOnClose)
-		center_window(self)
+		#center_window(self)
 
 	def show(self):
 		# Display the widget
@@ -136,6 +135,7 @@ class StackVisualizer(QWidget, Styles):
 									  self.stack_path,
 									  normalize_input=False).astype(float)[:,:,0]
 
+
 	def generate_figure_canvas(self):
 		# Generate the figure canvas for displaying images
 
@@ -187,6 +187,16 @@ class StackVisualizer(QWidget, Styles):
 		channel_layout.addWidget(self.channels_cb, 75)
 		self.canvas.layout.addLayout(channel_layout)
 
+	def set_contrast_decimals(self):
+		if is_integer_array(self.init_frame):
+			self.contrast_slider.setDecimals(0)
+			self.contrast_slider.setSingleStep(1.0)
+			self.contrast_slider.setTickInterval(1.0)
+		else:
+			self.contrast_slider.setDecimals(3)
+			self.contrast_slider.setSingleStep(1.0E-03)
+			self.contrast_slider.setTickInterval(1.0E-03)
+
 	def generate_contrast_slider(self):
 		# Generate the contrast slider if enabled
 		
@@ -197,15 +207,15 @@ class StackVisualizer(QWidget, Styles):
 											slider_initial_value=[np.nanpercentile(self.init_frame, 0.1),np.nanpercentile(self.init_frame, 99.99)],
 											slider_range=(np.nanmin(self.init_frame),np.nanmax(self.init_frame)),
 											decimal_option=True,
-											precision=1.0E-05,
+											precision=2,
 											)
+		self.set_contrast_decimals()
+
 		contrast_layout.setContentsMargins(15,0,15,0)
 		self.im.set_clim(vmin=np.nanpercentile(self.init_frame, 0.1),vmax=np.nanpercentile(self.init_frame, 99.99))
 		self.contrast_slider.valueChanged.connect(self.change_contrast)
 		self.canvas.layout.addLayout(contrast_layout)
 
-
-
 	def generate_frame_slider(self):
 		# Generate the frame slider if enabled
 	
@@ -250,6 +260,8 @@ class StackVisualizer(QWidget, Styles):
 		self.channel_trigger = False
 		self.init_contrast = False
 
+		self.set_contrast_decimals()
+
 	def change_frame_from_channel_switch(self, value):
 		
 		self.channel_trigger = True
@@ -275,15 +287,17 @@ class StackVisualizer(QWidget, Styles):
 		self.im.set_data(self.init_frame)
 		
 		if self.init_contrast:
-			self.im.autoscale()
-			I_min, I_max = self.im.get_clim()
-			self.contrast_slider.setRange(np.nanmin([self.init_frame,self.last_frame]),np.nanmax([self.init_frame,self.last_frame]))
-			self.contrast_slider.setValue((I_min,I_max))
+			imgs = np.array([self.init_frame,self.last_frame])
+			vmin = np.nanpercentile(imgs.flatten(), 1.0)
+			vmax = np.nanpercentile(imgs.flatten(), 99.99)
+			self.contrast_slider.setRange(np.nanmin(imgs),np.nanmax(imgs))
+			self.contrast_slider.setValue((vmin,vmax))
+			self.im.set_clim(vmin,vmax)
 
 		if self.create_contrast_slider:
 			self.change_contrast(self.contrast_slider.value())
 
-	
+
 	def closeEvent(self, event):
 		# Event handler for closing the widget
 		self.canvas.close()	
@@ -318,16 +332,27 @@ class ThresholdedStackVisualizer(StackVisualizer):
 	  with interactive sliders for threshold and mask opacity adjustment.
 	"""
 
-	def __init__(self, preprocessing=None, parent_le=None, initial_threshold=5, initial_mask_alpha=0.5, *args, **kwargs):
+	def __init__(self, preprocessing=None, parent_le=None, initial_threshold=5, initial_mask_alpha=0.5, show_opacity_slider=True, show_threshold_slider=True, *args, **kwargs):
 		# Initialize the widget and its attributes		
 		super().__init__(*args, **kwargs)
 		self.preprocessing = preprocessing
 		self.thresh = initial_threshold
 		self.mask_alpha = initial_mask_alpha
 		self.parent_le = parent_le
-		self.compute_mask(self.thresh)
-		self.generate_mask_imshow()
+		self.show_opacity_slider = show_opacity_slider
+		self.show_threshold_slider = show_threshold_slider
+		self.thresholded = False
+		self.mask = np.zeros_like(self.init_frame)
+		self.thresh_min = 0.0
+		self.thresh_max = 30.0
+
 		self.generate_threshold_slider()
+
+		if self.thresh is not None:
+			self.compute_mask(self.thresh)
+
+		self.generate_mask_imshow()
+		self.generate_scatter()
 		self.generate_opacity_slider()
 		if isinstance(self.parent_le, QLineEdit):
 			self.generate_apply_btn()
@@ -349,23 +374,32 @@ class ThresholdedStackVisualizer(StackVisualizer):
 		self.close()
 
 	def generate_mask_imshow(self):
-		# Generate the mask imshow		
+		# Generate the mask imshow
+
 		self.im_mask = self.ax.imshow(np.ma.masked_where(self.mask==0, self.mask), alpha=self.mask_alpha, interpolation='none')
 		self.canvas.canvas.draw()
 
+	def generate_scatter(self):
+		self.scat_markers = self.ax.scatter([], [], color="tab:red")
+
 	def generate_threshold_slider(self):
 		# Generate the threshold slider
 		self.threshold_slider = QLabeledDoubleSlider()
+		if self.thresh is None:
+			init_value = 1.0E5
+		else:
+			init_value = self.thresh
 		thresh_layout = QuickSliderLayout(label='Threshold: ',
 										slider=self.threshold_slider,
-										slider_initial_value=self.thresh,
-										slider_range=(0,30),
+										slider_initial_value=init_value,
+										slider_range=(self.thresh_min,np.amax([self.thresh_max, init_value])),
 										decimal_option=True,
-										precision=1.0E-05,
+										precision=4,
 										)
 		thresh_layout.setContentsMargins(15,0,15,0)
 		self.threshold_slider.valueChanged.connect(self.change_threshold)
-		self.canvas.layout.addLayout(thresh_layout)
+		if self.show_threshold_slider:
+			self.canvas.layout.addLayout(thresh_layout)
 
 	def generate_opacity_slider(self):
 		# Generate the opacity slider for the mask
@@ -375,11 +409,12 @@ class ThresholdedStackVisualizer(StackVisualizer):
 										slider_initial_value=0.5,
 										slider_range=(0,1),
 										decimal_option=True,
-										precision=1.0E-03
+										precision=3,
 										)
 		opacity_layout.setContentsMargins(15,0,15,0)
 		self.opacity_slider.valueChanged.connect(self.change_mask_opacity)
-		self.canvas.layout.addLayout(opacity_layout)
+		if self.show_opacity_slider:
+			self.canvas.layout.addLayout(opacity_layout)
 
 	def change_mask_opacity(self, value):
 		# Change the opacity of the mask
@@ -390,28 +425,61 @@ class ThresholdedStackVisualizer(StackVisualizer):
 	def change_threshold(self, value):
 		# Change the threshold value		
 		self.thresh = value
-		self.compute_mask(self.thresh)
-		mask = np.ma.masked_where(self.mask == 0, self.mask)
-		self.im_mask.set_data(mask)
-		self.canvas.canvas.draw_idle()
+		if self.thresh is not None:
+			self.compute_mask(self.thresh)
+			mask = np.ma.masked_where(self.mask == 0, self.mask)
+			self.im_mask.set_data(mask)
+			self.canvas.canvas.draw_idle()
 
 	def change_frame(self, value):
-		# Change the displayed frame and update the threshold		
+		# Change the displayed frame and update the threshold
+		if self.thresholded:
+			self.init_contrast = True
 		super().change_frame(value)
 		self.change_threshold(self.threshold_slider.value())
+		if self.thresholded:
+			self.thresholded = False
+			self.init_contrast = False
 
 	def compute_mask(self, threshold_value):
 		# Compute the mask based on the threshold value
 		self.preprocess_image()
 		edge = estimate_unreliable_edge(self.preprocessing)
-		self.mask = threshold_image(self.processed_image, threshold_value, np.inf, foreground_value=1, edge_exclusion=edge).astype(int)
+		if isinstance(threshold_value, (list,np.ndarray,tuple)):
+			self.mask = threshold_image(self.processed_image, threshold_value[0], threshold_value[1], foreground_value=1, fill_holes=True, edge_exclusion=edge).astype(int)
+		else:
+			self.mask = threshold_image(self.processed_image, threshold_value, np.inf, foreground_value=1, fill_holes=True, edge_exclusion=edge).astype(int)
 
 	def preprocess_image(self):
 		# Preprocess the image before thresholding		
 		if self.preprocessing is not None:
 
 			assert isinstance(self.preprocessing, list)
-			self.processed_image = filter_image(self.init_frame.copy(),filters=self.preprocessing)
+			self.processed_image = filter_image(self.init_frame.copy().astype(float),filters=self.preprocessing)
+			min_ = np.amin(self.processed_image)
+			max_ = np.amax(self.processed_image)
+
+			if min_ < self.thresh_min:
+				self.thresh_min = min_
+			if max_ > self.thresh_max:
+				self.thresh_max = max_
+
+			self.threshold_slider.setRange(self.thresh_min, self.thresh_max)
+
+	def set_preprocessing(self, activation_protocol):
+
+		self.preprocessing = activation_protocol
+		self.preprocess_image()
+
+		self.im.set_data(self.processed_image)
+		vmin = np.nanpercentile(self.processed_image, 1.0)
+		vmax = np.nanpercentile(self.processed_image, 99.99)
+		self.contrast_slider.setRange(np.nanmin(self.processed_image),
+									  np.nanmax(self.processed_image))
+		self.contrast_slider.setValue((vmin, vmax))
+		self.im.set_clim(vmin,vmax)
+		self.canvas.canvas.draw_idle()
+		self.thresholded = True
 
 
 class CellEdgeVisualizer(StackVisualizer):
@@ -578,7 +646,7 @@ class CellEdgeVisualizer(StackVisualizer):
 										slider_initial_value=0.5,
 										slider_range=(0,1),
 										decimal_option=True,
-										precision=1.0E-03
+										precision=3,
 										)
 		opacity_layout.setContentsMargins(15,0,15,0)
 		self.opacity_slider.valueChanged.connect(self.change_mask_opacity)
@@ -952,7 +1020,7 @@ class CellSizeViewer(StackVisualizer):
 	def generate_circle(self):
 		# Generate the circle for visualization
 
-		self.circ = plt.Circle((self.init_frame.shape[0]//2,self.init_frame.shape[1]//2), self.diameter//2, ec="tab:red",fill=False)
+		self.circ = plt.Circle((self.init_frame.shape[0]//2,self.init_frame.shape[1]//2), self.diameter//2 / self.PxToUm, ec="tab:red",fill=False)
 		self.ax.add_patch(self.circ)
 
 		self.ax.callbacks.connect('xlim_changed',self.on_xlims_or_ylims_change)
@@ -978,7 +1046,7 @@ class CellSizeViewer(StackVisualizer):
 		if self.set_radius_in_list:
 			val = int(self.diameter_slider.value()//2)
 		else:
-			val = int(self.diameter_slider.value())
+			val = int(self.diameter_slider.value()) 
 		
 		self.parent_list_widget.addItems([str(val)])
 		self.close()
@@ -1017,7 +1085,7 @@ class CellSizeViewer(StackVisualizer):
 										slider_initial_value=self.diameter,
 										slider_range=self.diameter_slider_range,
 										decimal_option=True,
-										precision=1.0E-05,
+										precision=5,
 										)
 		diameter_layout.setContentsMargins(15,0,15,0)
 		self.diameter_slider.valueChanged.connect(self.change_diameter)
@@ -1025,9 +1093,8 @@ class CellSizeViewer(StackVisualizer):
 
 	def change_diameter(self, value):
 		# Change the diameter of the circle
-		
 		self.diameter = value
-		self.circ.set_radius(self.diameter//2)
+		self.circ.set_radius(self.diameter//2 / self.PxToUm)
 		self.canvas.canvas.draw_idle()
 
 
@@ -1080,7 +1147,7 @@ class ChannelOffsetViewer(StackVisualizer):
 											slider_initial_value=0.5,
 											slider_range=(0,1.0),
 											decimal_option=True,
-											precision=1.0E-05,
+											precision=5,
 											)
 		alpha_layout.setContentsMargins(15,0,15,0)
 		self.overlay_alpha_slider.valueChanged.connect(self.change_alpha_overlay)
@@ -1097,7 +1164,7 @@ class ChannelOffsetViewer(StackVisualizer):
 											slider_initial_value=[np.nanpercentile(self.overlay_init_frame, 0.1),np.nanpercentile(self.overlay_init_frame, 99.99)],
 											slider_range=(np.nanmin(self.overlay_init_frame),np.nanmax(self.overlay_init_frame)),
 											decimal_option=True,
-											precision=1.0E-05,
+											precision=5,
 											)
 		contrast_layout.setContentsMargins(15,0,15,0)
 		self.im_overlay.set_clim(vmin=np.nanpercentile(self.overlay_init_frame, 0.1),vmax=np.nanpercentile(self.overlay_init_frame, 99.99))

celldetective/gui/workers.py

@@ -1,18 +1,24 @@
 from multiprocessing import Queue
-from PyQt5.QtWidgets import QDialog, QPushButton, QVBoxLayout, QHBoxLayout, QWidget, QLabel, QProgressBar
+from PyQt5.QtWidgets import QPushButton, QVBoxLayout, QHBoxLayout, QLabel, QProgressBar
 from PyQt5.QtCore import QRunnable, QObject, pyqtSignal, QThreadPool, QSize, Qt
+
+from celldetective.gui.base_components import CelldetectiveDialog
 from celldetective.gui.gui_utils import center_window
+from celldetective.gui import Styles
 import time
 import math
 
-class ProgressWindow(QDialog):
+class ProgressWindow(CelldetectiveDialog):
 
 	def __init__(self, process=None, parent_window=None, title="", position_info=True, process_args=None):
-		QDialog.__init__(self)
+
+		super().__init__()
+		#QDialog.__init__(self)
 
 		self.setWindowTitle(f'{title} Progress')
 		self.__process = process
 		self.parent_window = parent_window
+
 		self.position_info = position_info
 		if self.position_info:
 			self.pos_name = self.parent_window.pos_name

celldetective/io.py

@@ -29,7 +29,7 @@ from celldetective.utils import interpolate_nan_multichannel, _estimate_scale_fa
 
 from stardist import fill_label_holes
 from skimage.transform import resize
-
+import re
 
 def extract_experiment_from_well(well_path):
 
@@ -596,6 +596,17 @@ def get_experiment_pharmaceutical_agents(experiment, dtype=str):
 	return np.array([dtype(c) for c in pharmaceutical_agents])
 
 
+def get_experiment_populations(experiment, dtype=str):
+
+	config = get_config(experiment)
+	populations_str = ConfigSectionMap(config, "Populations")
+	if populations_str is not None:
+		populations = populations_str['populations'].split(',')
+	else:
+		populations = ['effectors','targets']
+	return list([dtype(c) for c in populations])
+
+
 def interpret_wells_and_positions(experiment, well_option, position_option):
 	"""
 	Interpret well and position options for a given experiment.
@@ -1165,6 +1176,9 @@ def locate_labels(position, population='target', frames=None):
 		label_path = natsorted(glob(position + os.sep.join(["labels_targets", "*.tif"])))
 	elif population.lower() == "effector" or population.lower() == "effectors":
 		label_path = natsorted(glob(position + os.sep.join(["labels_effectors", "*.tif"])))
+	else:
+		label_path = natsorted(glob(position + os.sep.join([f"labels_{population}", "*.tif"])))
+
 
 	label_names = [os.path.split(lbl)[-1] for lbl in label_path]
 
@@ -1242,6 +1256,9 @@ def fix_missing_labels(position, population='target', prefix='Aligned'):
 	elif population.lower() == "effector" or population.lower() == "effectors":
 		label_path = natsorted(glob(position + os.sep.join(["labels_effectors", "*.tif"])))
 		path = position + os.sep + "labels_effectors"
+	else:
+		label_path = natsorted(glob(position + os.sep.join([f"labels_{population}", "*.tif"])))
+		path = position + os.sep + f"labels_{population}"		
 
 	if label_path!=[]:
 		#path = os.path.split(label_path[0])[0]
@@ -1348,6 +1365,9 @@ def load_tracking_data(position, prefix="Aligned", population="target"):
 		trajectories = pd.read_csv(position + os.sep.join(['output', 'tables', 'trajectories_targets.csv']))
 	elif population.lower() == "effector" or population.lower() == "effectors":
 		trajectories = pd.read_csv(position + os.sep.join(['output', 'tables', 'trajectories_effectors.csv']))
+	else:
+		trajectories = pd.read_csv(position + os.sep.join(['output', 'tables', f'trajectories_{population}.csv']))
+
 
 	stack, labels = locate_stack_and_labels(position, prefix=prefix, population=population)
 
@@ -2354,6 +2374,11 @@ def load_napari_data(position, prefix="Aligned", population="target", return_sta
 			napari_data = np.load(position+os.sep.join(['output', 'tables', 'napari_effector_trajectories.npy']), allow_pickle=True)
 		else:
 			napari_data = None
+	else:
+		if os.path.exists(position+os.sep.join(['output', 'tables', f'napari_{population}_trajectories.npy'])):
+			napari_data = np.load(position+os.sep.join(['output', 'tables', f'napari_{population}_trajectories.npy']), allow_pickle=True)
+		else:
+			napari_data = None	
 
 	if napari_data is not None:
 		data = napari_data.item()['data']
@@ -2493,6 +2518,9 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 
 	def export_labels():
 		labels_layer = viewer.layers['segmentation'].data
+		if not os.path.exists(output_folder):
+			os.mkdir(output_folder)
+
 		for t, im in enumerate(tqdm(labels_layer)):
 
 			try:
@@ -2639,12 +2667,9 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 		return export_annotation()
 
 	stack, labels = locate_stack_and_labels(position, prefix=prefix, population=population)
-
-	if not population.endswith('s'):
-		population += 's'
 	output_folder = position + f'labels_{population}{os.sep}'
+	print(f"Shape of the loaded image stack: {stack.shape}...")
 
-	print(f"{stack.shape}")
 	viewer = napari.Viewer()
 	viewer.add_image(stack, channel_axis=-1, colormap=["gray"] * stack.shape[-1])
 	viewer.add_labels(labels.astype(int), name='segmentation', opacity=0.4)
@@ -2678,6 +2703,8 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 		del labels
 		gc.collect()
 
+	print("napari viewer was successfully closed...")
+
 def correct_annotation(filename):
 
 	"""
@@ -2827,21 +2854,31 @@ def control_tracking_table(position, calibration=1, prefix="Aligned", population
 
 
 def get_segmentation_models_list(mode='targets', return_path=False):
-	if mode == 'targets':
-		modelpath = os.sep.join(
-			[os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], "celldetective", "models",
-			 "segmentation_targets", os.sep])
-		repository_models = get_zenodo_files(cat=os.sep.join(["models", "segmentation_targets"]))
-	elif mode == 'effectors':
-		modelpath = os.sep.join(
-			[os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], "celldetective", "models",
-			 "segmentation_effectors", os.sep])
-		repository_models = get_zenodo_files(cat=os.sep.join(["models", "segmentation_effectors"]))
-	elif mode == 'generic':
-		modelpath = os.sep.join(
+
+	modelpath = os.sep.join(
 			[os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], "celldetective", "models",
-			 "segmentation_generic", os.sep])
-		repository_models = get_zenodo_files(cat=os.sep.join(["models", "segmentation_generic"]))
+			 f"segmentation_{mode}", os.sep])
+	if not os.path.exists(modelpath):
+		os.mkdir(modelpath)
+		repository_models = []
+	else:
+		repository_models = get_zenodo_files(cat=os.sep.join(["models", f"segmentation_{mode}"]))
+
+	# if mode == 'targets':
+	# 	modelpath = os.sep.join(
+	# 		[os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], "celldetective", "models",
+	# 		 "segmentation_targets", os.sep])
+	# 	repository_models = get_zenodo_files(cat=os.sep.join(["models", "segmentation_targets"]))
+	# elif mode == 'effectors':
+	# 	modelpath = os.sep.join(
+	# 		[os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], "celldetective", "models",
+	# 		 "segmentation_effectors", os.sep])
+	# 	repository_models = get_zenodo_files(cat=os.sep.join(["models", "segmentation_effectors"]))
+	# elif mode == 'generic':
+	# 	modelpath = os.sep.join(
+	# 		[os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], "celldetective", "models",
+	# 		 "segmentation_generic", os.sep])
+	# 	repository_models = get_zenodo_files(cat=os.sep.join(["models", "segmentation_generic"]))
 
 	available_models = natsorted(glob(modelpath + '*/'))
 	available_models = [m.replace('\\', '/').split('/')[-2] for m in available_models]
@@ -3275,7 +3312,7 @@ def normalize_multichannel(multichannel_frame, percentiles=None,
 
 	return np.moveaxis(mf_new,0,-1)
 
-def load_frames(img_nums, stack_path, scale=None, normalize_input=True, dtype=float, normalize_kwargs={"percentiles": (0.,99.99)}):
+def load_frames(img_nums, stack_path, scale=None, normalize_input=True, dtype=np.float64, normalize_kwargs={"percentiles": (0.,99.99)}):
 
 	"""
 	Loads and optionally normalizes and rescales specified frames from a stack located at a given path.

celldetective/measure.py

@@ -20,13 +20,21 @@ 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_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 +219,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 +373,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 +854,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 +1282,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