celldetective 1.2.1__py3-none-any.whl → 1.2.2__py3-none-any.whl

celldetective/__main__.py

@@ -27,10 +27,10 @@ class AppInitWindow(QMainWindow):
 
 		try:
 			subprocess.check_output('nvidia-smi')
-			print('Nvidia GPU detected')
+			print('NVIDIA GPU detected (activate or disable in Memory & Threads)...')
 			self.use_gpu = True
 		except Exception: # this command not being found can raise quite a few different errors depending on the configuration
-			print('No Nvidia GPU in system!')
+			print('No NVIDIA GPU detected...')
 			self.use_gpu = False
 			
 		self.soft_path = get_software_location()
@@ -170,13 +170,16 @@ class AppInitWindow(QMainWindow):
 
 		self.recentFileActs = []
 		self.threads_config_path = os.sep.join([self.soft_path,'celldetective','threads.json'])
+		print('Reading previous Memory & Threads settings...')
 		if os.path.exists(self.threads_config_path):
 			with open(self.threads_config_path, 'r') as f:
 				self.threads_config = json.load(f)
 			if 'use_gpu' in self.threads_config:
 				self.use_gpu = bool(self.threads_config['use_gpu'])
+				print(f'Use GPU: {self.use_gpu}...')
 			if 'n_threads' in self.threads_config:
 				self.n_threads = int(self.threads_config['n_threads'])
+				print(f'Number of threads: {self.n_threads}...')
 
 
 	def reload_previous_experiments(self):
@@ -250,9 +253,9 @@ class AppInitWindow(QMainWindow):
 			self.open_directory()
 
 	def load_recent_exp(self, path):
-		print('loading?')
-		print('you selected path ', path)
+		
 		self.experiment_path_selection.setText(path)
+		print(f'Attempt to load experiment folder: {path}...')
 		self.open_directory()
 
 	def open_about_window(self):
@@ -351,7 +354,7 @@ class AppInitWindow(QMainWindow):
 				print(f"Found {self.number_of_wells} wells...")
 			number_pos = []
 			for w in wells:
-				position_folders = glob(os.sep.join([w,f"{w.split(os.sep)[-2][1]}*", os.sep]))
+				position_folders = glob(os.sep.join([w,f"{w.split(os.sep)[-1][1]}*", os.sep]))
 				number_pos.append(len(position_folders))
 			print(f"Number of positions per well: {number_pos}")
 			
@@ -393,6 +396,7 @@ if __name__ == "__main__":
 	# myappid = 'mycompany.myproduct.subproduct.version' # arbitrary string
 	# ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
 	splash=True
+	print('Loading the libraries...')
 
 	App = QApplication(sys.argv)
 	#App.setWindowIcon(QIcon(os.sep.join([get_software_location(),'celldetective','icons','mexican-hat.png'])))
@@ -425,7 +429,10 @@ if __name__ == "__main__":
 	import psutil
 	import subprocess
 	import json
+	# import matplotlib
+	# matplotlib.rcParams.update({'font.size': 8})
 
+	print('Libraries successfully loaded...')
 
 	window = AppInitWindow(App)
 

celldetective/events.py

@@ -1,5 +1,5 @@
 import numpy as np
-
+from lifelines import KaplanMeierFitter
 
 def switch_to_events(classes, event_times, max_times, origin_times=None, left_censored=True, FrameToMin=None):
 	
@@ -104,4 +104,30 @@ def switch_to_events(classes, event_times, max_times, origin_times=None, left_ce
 	if FrameToMin is not None:
 		#print('convert to minutes!', FrameToMin)
 		survival_times = [s*FrameToMin for s in survival_times]
-	return events, survival_times
+	return events, survival_times
+
+def compute_survival(df, class_of_interest, t_event, t_reference=None, FrameToMin=1):
+
+	cols = list(df.columns)
+	assert class_of_interest in cols,"The requested class cannot be found in the dataframe..."
+	assert t_event in cols,"The event time cannot be found in the dataframe..."
+	left_censored = False
+
+	classes = df.groupby(['position','TRACK_ID'])[class_of_interest].min().values
+	event_times = df.groupby(['position','TRACK_ID'])[t_event].min().values
+	max_times = df.groupby(['position','TRACK_ID'])['FRAME'].max().values
+
+	if t_reference is not None:
+		left_censored = True
+		assert t_reference in cols,"The reference time cannot be found in the dataframe..."
+		first_detections = df.groupby(['position','TRACK_ID'])[t_reference].max().values
+	
+	events, survival_times = switch_to_events(classes, event_times, max_times, origin_times=first_detections, left_censored=left_censored, FrameToMin=FrameToMin)
+	ks = KaplanMeierFitter()
+	if len(events)>0:
+		ks.fit(survival_times, event_observed=events)
+	else:
+		ks = None
+
+	return ks
+

celldetective/gui/about.py

@@ -2,7 +2,6 @@ from PyQt5.QtWidgets import QWidget, QVBoxLayout, QLabel
 from PyQt5.QtGui import QPixmap
 from PyQt5.QtCore import Qt
 from celldetective.utils import get_software_location
-import celldetective
 import os
 from celldetective.gui.gui_utils import center_window
 

celldetective/gui/analyze_block.py

@@ -1,25 +1,10 @@
-from PyQt5.QtWidgets import QFrame, QGridLayout, QComboBox, QLabel, QPushButton, QVBoxLayout, QHBoxLayout, QCheckBox, \
-    QMessageBox, QSpacerItem, QSizePolicy
+from PyQt5.QtWidgets import QFrame, QLabel, QPushButton, QVBoxLayout, \
+    QSpacerItem, QSizePolicy
 from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QIcon
-
-from superqt.fonticon import icon
-from fonticon_mdi6 import MDI6
-import gc
-
 from celldetective.gui.plot_measurements import ConfigMeasurementsPlot
-from celldetective.io import get_segmentation_models_list, control_segmentation_napari, get_signal_models_list, control_tracking_btrack
 from celldetective.gui import ConfigSurvival, ConfigSignalPlot
-from celldetective.gui.gui_utils import QHSeperationLine
-from celldetective.segmentation import segment_at_position, segment_from_threshold_at_position
-from celldetective.tracking import track_at_position
-from celldetective.measure import measure_at_position
-from celldetective.signals import analyze_signals_at_position
-import numpy as np
-from glob import glob
-from natsort import natsorted
 import os
-import pandas as pd
 from celldetective.gui import Styles
 
 class AnalysisPanel(QFrame, Styles):
@@ -94,7 +79,7 @@ class AnalysisPanel(QFrame, Styles):
 		self.configSurvival.show()
 
 	def configure_plot_signals(self):
-		print('plot signal analysis starting!!!')
+		print('Configure a signal collapse representation...')
 		self.ConfigSignalPlot = ConfigSignalPlot(self)
 		self.ConfigSignalPlot.show()
 

celldetective/gui/btrack_options.py

@@ -1,7 +1,7 @@
 from PyQt5.QtWidgets import QMainWindow, QApplication, QMessageBox, QScrollArea, QComboBox, QFrame, QCheckBox, QFileDialog, QGridLayout, QTextEdit, QLineEdit, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
 from PyQt5.QtCore import Qt, QSize
-from celldetective.gui.gui_utils import center_window, FeatureChoice, ListWidget, QHSeperationLine, FigureCanvas
-from superqt import QLabeledDoubleRangeSlider, QLabeledDoubleSlider,QLabeledSlider
+from celldetective.gui.gui_utils import center_window, FeatureChoice, ListWidget, QHSeperationLine, FigureCanvas, help_generic
+from superqt import QLabeledDoubleSlider,QLabeledSlider
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
 from celldetective.utils import extract_experiment_channels, get_software_location
@@ -47,8 +47,9 @@ class ConfigTracking(QMainWindow, Styles):
 
 		center_window(self)
 		self.setMinimumWidth(540)
-		self.setMinimumHeight(int(0.3*self.screen_height))
-		self.setMaximumHeight(int(0.8*self.screen_height))
+		self.minimum_height = 300
+		# self.setMinimumHeight(int(0.3*self.screen_height))
+		# self.setMaximumHeight(int(0.8*self.screen_height))
 		self.populate_widget()
 		self.load_previous_tracking_instructions()
 
@@ -116,7 +117,6 @@ class ConfigTracking(QMainWindow, Styles):
 		self.select_post_proc_btn = QPushButton()
 		self.select_post_proc_btn.clicked.connect(self.activate_post_proc_options)
 		self.select_post_proc_btn.setStyleSheet(self.button_select_all)
-		grid.addWidget(self.select_post_proc_btn, 0,0,1,4,alignment=Qt.AlignLeft)
 
 		self.post_proc_lbl = QLabel("POST-PROCESSING")
 		self.post_proc_lbl.setStyleSheet("""
@@ -125,19 +125,100 @@ class ConfigTracking(QMainWindow, Styles):
 			""")
 		grid.addWidget(self.post_proc_lbl, 0, 0, 1, 4, alignment=Qt.AlignCenter)
 
+		title_hbox = QHBoxLayout()
+
 		self.collapse_post_proc_btn = QPushButton()
 		self.collapse_post_proc_btn.setIcon(icon(MDI6.chevron_down,color="black"))
 		self.collapse_post_proc_btn.setIconSize(QSize(20, 20))
 		self.collapse_post_proc_btn.setStyleSheet(self.button_select_all)
-		grid.addWidget(self.collapse_post_proc_btn, 0, 0, 1, 4, alignment=Qt.AlignRight)
+		#grid.addWidget(self.collapse_post_proc_btn, 0, 0, 1, 4, alignment=Qt.AlignRight)
+
+		self.help_post_btn = QPushButton()
+		self.help_post_btn.setIcon(icon(MDI6.help_circle,color=self.help_color))
+		self.help_post_btn.setIconSize(QSize(20, 20))
+		self.help_post_btn.clicked.connect(self.help_post)
+		self.help_post_btn.setStyleSheet(self.button_select_all)
+		self.help_post_btn.setToolTip("Help.")
+
+		title_hbox.addWidget(self.select_post_proc_btn, 5)
+		title_hbox.addWidget(QLabel(), 85, alignment=Qt.AlignCenter)
+		title_hbox.addWidget(self.help_post_btn, 5)
+		title_hbox.addWidget(self.collapse_post_proc_btn, 5)
+		grid.addLayout(title_hbox, 0,0,1,4)
 
 		self.generate_post_proc_panel_contents()
 		grid.addWidget(self.ContentsPostProc, 1, 0, 1, 4, alignment=Qt.AlignTop)
 		self.collapse_post_proc_btn.clicked.connect(lambda: self.ContentsPostProc.setHidden(not self.ContentsPostProc.isHidden()))
-		# self.collapse_post_proc_btn.clicked.connect(self.collapse_features_advanced)
+		self.collapse_post_proc_btn.clicked.connect(self.collapse_post_advanced)
 		self.ContentsPostProc.hide()
 		self.uncheck_post_proc()
 
+	def collapse_post_advanced(self):
+
+		features_open = not self.ContentsFeatures.isHidden()
+		config_open = not self.ContentsConfig.isHidden()
+		post_open = not self.ContentsPostProc.isHidden()
+		is_open = np.array([features_open, config_open, post_open])
+
+		if self.ContentsPostProc.isHidden():
+			self.collapse_post_proc_btn.setIcon(icon(MDI6.chevron_down,color="black"))
+			self.collapse_post_proc_btn.setIconSize(QSize(20, 20))
+			if len(is_open[is_open])==0:
+				self.scroll_area.setMinimumHeight(int(self.minimum_height))
+				self.adjustSize()
+		else:
+			self.collapse_post_proc_btn.setIcon(icon(MDI6.chevron_up,color="black"))
+			self.collapse_post_proc_btn.setIconSize(QSize(20, 20))
+			self.scroll_area.setMinimumHeight(min(int(930), int(0.9*self.screen_height)))
+
+
+	def help_post(self):
+		
+		"""
+		Helper for track post-processing strategy.
+		"""
+
+		dict_path = os.sep.join([get_software_location(),'celldetective','gui','help','track-postprocessing.json'])
+
+		with open(dict_path) as f:
+			d = json.load(f)
+
+		suggestion = help_generic(d)
+		if isinstance(suggestion, str):
+			print(f"{suggestion=}")
+			msgBox = QMessageBox()
+			msgBox.setIcon(QMessageBox.Information)
+			msgBox.setTextFormat(Qt.RichText)
+			msgBox.setText(rf"{suggestion}")
+			msgBox.setWindowTitle("Info")
+			msgBox.setStandardButtons(QMessageBox.Ok)
+			returnValue = msgBox.exec()
+			if returnValue == QMessageBox.Ok:
+				return None		
+
+	def help_feature(self):
+		
+		"""
+		Helper for track post-processing strategy.
+		"""
+
+		dict_path = os.sep.join([get_software_location(),'celldetective','gui','help','feature-btrack.json'])
+
+		with open(dict_path) as f:
+			d = json.load(f)
+
+		suggestion = help_generic(d)
+		if isinstance(suggestion, str):
+			print(f"{suggestion=}")
+			msgBox = QMessageBox()
+			msgBox.setIcon(QMessageBox.Information)
+			msgBox.setTextFormat(Qt.RichText)
+			msgBox.setText(rf"{suggestion}")
+			msgBox.setWindowTitle("Info")
+			msgBox.setStandardButtons(QMessageBox.Ok)
+			returnValue = msgBox.exec()
+			if returnValue == QMessageBox.Ok:
+				return None
 
 	def populate_features_frame(self):
 
@@ -146,12 +227,11 @@ class ConfigTracking(QMainWindow, Styles):
 		"""
 
 		grid = QGridLayout(self.features_frame)
-
+		title_hbox = QHBoxLayout()
+		
 		self.select_features_btn = QPushButton()
 		self.select_features_btn.clicked.connect(self.activate_feature_options)
 		self.select_features_btn.setStyleSheet(self.button_select_all)
-		grid.addWidget(self.select_features_btn, 0,0,1,4,alignment=Qt.AlignLeft)
-
 
 		self.feature_lbl = QLabel("FEATURES")
 		self.feature_lbl.setStyleSheet("""
@@ -164,7 +244,19 @@ class ConfigTracking(QMainWindow, Styles):
 		self.collapse_features_btn.setIcon(icon(MDI6.chevron_down,color="black"))
 		self.collapse_features_btn.setIconSize(QSize(20, 20))
 		self.collapse_features_btn.setStyleSheet(self.button_select_all)
-		grid.addWidget(self.collapse_features_btn, 0, 0, 1, 4, alignment=Qt.AlignRight)
+
+		self.help_feature_btn = QPushButton()
+		self.help_feature_btn.setIcon(icon(MDI6.help_circle,color=self.help_color))
+		self.help_feature_btn.setIconSize(QSize(20, 20))
+		self.help_feature_btn.clicked.connect(self.help_feature)
+		self.help_feature_btn.setStyleSheet(self.button_select_all)
+		self.help_feature_btn.setToolTip("Help.")
+
+		title_hbox.addWidget(self.select_features_btn, 5)
+		title_hbox.addWidget(QLabel(), 85, alignment=Qt.AlignCenter)
+		title_hbox.addWidget(self.help_feature_btn, 5)
+		title_hbox.addWidget(self.collapse_features_btn, 5)
+		grid.addLayout(title_hbox, 0,0,1,4)		
 
 		self.generate_feature_panel_contents()
 		grid.addWidget(self.ContentsFeatures, 1, 0, 1, 4, alignment=Qt.AlignTop)
@@ -179,16 +271,22 @@ class ConfigTracking(QMainWindow, Styles):
 		Switch the chevron icon and adjust the size for the FEATURES frame.
 		"""
 
+		features_open = not self.ContentsFeatures.isHidden()
+		config_open = not self.ContentsConfig.isHidden()
+		post_open = not self.ContentsPostProc.isHidden()
+		is_open = np.array([features_open, config_open, post_open])
+
 		if self.ContentsFeatures.isHidden():
 			self.collapse_features_btn.setIcon(icon(MDI6.chevron_down,color="black"))
 			self.collapse_features_btn.setIconSize(QSize(20, 20))
-			self.button_widget.adjustSize()
-			self.adjustSize()
+			if len(is_open[is_open])==0:
+				self.scroll_area.setMinimumHeight(int(self.minimum_height))
+				self.adjustSize()
 		else:
 			self.collapse_features_btn.setIcon(icon(MDI6.chevron_up,color="black"))
 			self.collapse_features_btn.setIconSize(QSize(20, 20))
-			self.button_widget.adjustSize()
-			self.adjustSize()	
+			self.scroll_area.setMinimumHeight(min(int(930), int(0.9*self.screen_height)))
+
 
 	def generate_post_proc_panel_contents(self):
 
@@ -273,7 +371,7 @@ class ConfigTracking(QMainWindow, Styles):
 		self.add_feature_btn.setToolTip("Add feature")
 		self.add_feature_btn.setIconSize(QSize(20, 20))		
 
-		self.features_list = ListWidget(self, FeatureChoice, initial_features=['area','intensity_mean',])
+		self.features_list = ListWidget(FeatureChoice, initial_features=['area','intensity_mean',])
 
 		self.del_feature_btn.clicked.connect(self.features_list.removeSel)
 		self.add_feature_btn.clicked.connect(self.features_list.addItem)
@@ -447,16 +545,22 @@ class ConfigTracking(QMainWindow, Styles):
 		Switch the chevron icon and adjust the size for the CONFIG frame.
 		"""
 
+		features_open = not self.ContentsFeatures.isHidden()
+		config_open = not self.ContentsConfig.isHidden()
+		post_open = not self.ContentsPostProc.isHidden()
+		is_open = np.array([features_open, config_open, post_open])
+
 		if self.ContentsConfig.isHidden():
 			self.collapse_config_btn.setIcon(icon(MDI6.chevron_down,color="black"))
 			self.collapse_config_btn.setIconSize(QSize(20, 20))
-			self.button_widget.adjustSize()
-			self.adjustSize()
+			if len(is_open[is_open])==0:
+				self.scroll_area.setMinimumHeight(int(self.minimum_height))
+				self.adjustSize()
 		else:
 			self.collapse_config_btn.setIcon(icon(MDI6.chevron_up,color="black"))
 			self.collapse_config_btn.setIconSize(QSize(20, 20))
-			self.button_widget.adjustSize()
-			self.adjustSize()	
+			self.scroll_area.setMinimumHeight(min(int(930), int(0.9*self.screen_height)))
+
 
 	def generate_config_panel_contents(self):
 		
@@ -884,7 +988,8 @@ class ConfigTracking(QMainWindow, Styles):
 			self.fig, self.ax = plt.subplots(1,1,figsize=(4,3))
 			self.hist_window = FigureCanvas(self.fig, title="Haralick: control digitized histogram")
 			self.ax.clear()
-			self.ax.hist(norm_img.flatten(), bins=self.haralick_options['n_intensity_bins'])
+			flat = norm_img.flatten()
+			self.ax.hist(flat[flat==flat], bins=self.haralick_options['n_intensity_bins'])
 			self.ax.set_xlabel('gray level value')
 			self.ax.set_ylabel('#')
 			plt.tight_layout()

celldetective/gui/classifier_widget.py

@@ -1,21 +1,19 @@
-from PyQt5.QtWidgets import QWidget, QLineEdit, QMessageBox, QHBoxLayout, QVBoxLayout, QPushButton, QLabel, QComboBox, \
+from PyQt5.QtWidgets import QWidget, QLineEdit, QMessageBox, QHBoxLayout, QVBoxLayout, QPushButton, QLabel, \
 	QCheckBox, QRadioButton, QButtonGroup
-from celldetective.gui.gui_utils import FigureCanvas, center_window, color_from_class
-import numpy as np
-import matplotlib.pyplot as plt
-from superqt import QLabeledSlider,QLabeledDoubleSlider
+from PyQt5.QtCore import Qt, QSize
+from superqt import QLabeledSlider,QLabeledDoubleSlider, QSearchableComboBox
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
-from PyQt5.QtCore import Qt, QSize
+
 import os
-from sklearn.metrics import r2_score
-from scipy.optimize import curve_fit
-from celldetective.gui import Styles
-from math import ceil
-from celldetective.utils import extract_cols_from_query
+import numpy as np
+import matplotlib.pyplot as plt
+import json
 
-def step_function(t, t_shift, dt):
-	return 1/(1+np.exp(-(t-t_shift)/dt))
+from celldetective.gui.gui_utils import FigureCanvas, center_window, color_from_status, help_generic
+from celldetective.gui import Styles
+from celldetective.utils import get_software_location
+from celldetective.measure import classify_cells_from_query, interpret_track_classification
 
 class ClassifierWidget(QWidget, Styles):
 
@@ -98,7 +96,7 @@ class ClassifierWidget(QWidget, Styles):
 
 
 
-		self.features_cb = [QComboBox() for i in range(2)]
+		self.features_cb = [QSearchableComboBox() for i in range(2)]
 		self.log_btns = [QPushButton() for i in range(2)]
 
 		for i in range(2):
@@ -121,6 +119,7 @@ class ClassifierWidget(QWidget, Styles):
 		hbox_classify.addWidget(QLabel('classify: '), 10)
 		self.property_query_le = QLineEdit()
 		self.property_query_le.setPlaceholderText('classify points using a query such as: area > 100 or eccentricity > 0.95')
+		self.property_query_le.setToolTip('Classify points using a query on measurements.\nYou can use "and" and "or" conditions to combine\nmeasurements (e.g. "area > 100 or eccentricity > 0.95").')
 		hbox_classify.addWidget(self.property_query_le, 70)
 		self.submit_query_btn = QPushButton('Submit...')
 		self.submit_query_btn.clicked.connect(self.apply_property_query)
@@ -133,7 +132,19 @@ class ClassifierWidget(QWidget, Styles):
 			self.time_corr.setEnabled(True)
 		else:
 			self.time_corr.setEnabled(False)
-		layout.addWidget(self.time_corr,alignment=Qt.AlignCenter)
+
+		time_prop_hbox = QHBoxLayout()
+		time_prop_hbox.addWidget(self.time_corr,alignment=Qt.AlignCenter)
+
+		self.help_propagate_btn = QPushButton()
+		self.help_propagate_btn.setIcon(icon(MDI6.help_circle,color=self.help_color))
+		self.help_propagate_btn.setIconSize(QSize(20, 20))
+		self.help_propagate_btn.clicked.connect(self.help_propagate)
+		self.help_propagate_btn.setStyleSheet(self.button_select_all)
+		self.help_propagate_btn.setToolTip("Help.")
+		time_prop_hbox.addWidget(self.help_propagate_btn,5,alignment=Qt.AlignRight)
+
+		layout.addLayout(time_prop_hbox)
 
 		self.irreversible_event_btn = QRadioButton('irreversible event')
 		self.unique_state_btn = QRadioButton('unique state')
@@ -233,7 +244,7 @@ class ClassifierWidget(QWidget, Styles):
 
 		if not self.project_times:
 			self.scat_props.set_offsets(self.df.loc[self.df['FRAME']==self.currentFrame,[self.features_cb[1].currentText(),self.features_cb[0].currentText()]].to_numpy())
-			colors = [color_from_class(c) for c in self.df.loc[self.df['FRAME']==self.currentFrame,self.class_name].to_numpy()]
+			colors = [color_from_status(c) for c in self.df.loc[self.df['FRAME']==self.currentFrame,self.class_name].to_numpy()]
 			self.scat_props.set_facecolor(colors)
 			self.scat_props.set_alpha(self.currentAlpha)
 			self.ax_props.set_xlabel(self.features_cb[1].currentText())
@@ -264,38 +275,18 @@ class ClassifierWidget(QWidget, Styles):
 		self.propscanvas.canvas.draw_idle()
 
 	def apply_property_query(self):
-
+		
 		query = self.property_query_le.text()
-		self.df[self.class_name] = 1
-
-		cols = extract_cols_from_query(query) 
-		print(cols)
-		cols_in_df = np.all([c in list(self.df.columns) for c in cols], axis=0)
-		print(f'Testing if columns from query are in the dataframe: {cols_in_df}...')
-
-		if query=='':
-			print('empty query')
-		else:
-			try:
-				if cols_in_df:
-					self.selection = self.df.dropna(subset=cols).query(query).index
-					null_selection = self.df[self.df.loc[:,cols].isna().any(axis=1)].index
-					self.df.loc[null_selection, self.class_name] = np.nan
-					self.df.loc[self.selection, self.class_name] = 0
-				else:
-					self.df.loc[:, self.class_name] = np.nan
-
-			except Exception as e:
-				print(e)
-				print(self.df.columns)
-				msgBox = QMessageBox()
-				msgBox.setIcon(QMessageBox.Warning)
-				msgBox.setText(f"The query could not be understood. No filtering was applied. {e}")
-				msgBox.setWindowTitle("Warning")
-				msgBox.setStandardButtons(QMessageBox.Ok)
-				returnValue = msgBox.exec()
-				if returnValue == QMessageBox.Ok:
-					return None
+		self.df = classify_cells_from_query(self.df, self.class_name, query)
+		if self.df is None:
+			msgBox = QMessageBox()
+			msgBox.setIcon(QMessageBox.Warning)
+			msgBox.setText(f"The query could not be understood. No filtering was applied. {e}")
+			msgBox.setWindowTitle("Warning")
+			msgBox.setStandardButtons(QMessageBox.Ok)
+			returnValue = msgBox.exec()
+			if returnValue == QMessageBox.Ok:
+				return None
 
 		self.update_props_scatter()
 
@@ -358,37 +349,8 @@ class ClassifierWidget(QWidget, Styles):
 			self.df = self.df.drop(list(set(name_map.values()) & set(self.df.columns)), axis=1).rename(columns=name_map)
 			self.df.reset_index(inplace=True, drop=True)
 
-			#self.df.reset_index(inplace=True)
-			if 'TRACK_ID' in self.df.columns:
-				print('Tracks detected... save a status column...')
-				stat_col = self.class_name_user.replace('class','status')
-				self.df.loc[:,stat_col] = 1 - self.df[self.class_name_user].values
-				for tid,track in self.df.groupby(['position','TRACK_ID']):
-					indices = track[self.class_name_user].index
-					status_values = track[stat_col].to_numpy()
-					if self.irreversible_event_btn.isChecked():
-						if np.all([s==0 for s in status_values]):
-							self.df.loc[indices, self.class_name_user] = 1
-						elif np.all([s==1 for s in status_values]):
-							self.df.loc[indices, self.class_name_user] = 2
-							self.df.loc[indices, self.class_name_user.replace('class','status')] = 2
-						else:
-							self.df.loc[indices, self.class_name_user] = 2
-					elif self.unique_state_btn.isChecked():
-						frames = track['FRAME'].to_numpy()
-						t_first = track['t_firstdetection'].to_numpy()[0]
-						median_status = np.nanmedian(status_values[frames>=t_first])
-						if median_status==median_status:
-							c = ceil(median_status)
-							if c==0:
-								self.df.loc[indices, self.class_name_user] = 1
-								self.df.loc[indices, self.class_name_user.replace('class','t')] = -1
-							elif c==1:
-								self.df.loc[indices, self.class_name_user] = 2
-								self.df.loc[indices, self.class_name_user.replace('class','t')] = -1
-				if self.irreversible_event_btn.isChecked():
-					self.df.loc[self.df[self.class_name_user]!=2, self.class_name_user.replace('class', 't')] = -1
-					self.estimate_time()
+			self.df = interpret_track_classification(self.df, self.class_name_user, irreversible_event=self.irreversible_event_btn.isChecked(), unique_state=self.unique_state_btn.isChecked(), r2_threshold=self.r2_slider.value())
+		
 		else:
 			self.group_name_user = 'group_' + self.name_le.text()
 			print(f'User defined characteristic group name: {self.group_name_user}.')
@@ -409,19 +371,41 @@ class ClassifierWidget(QWidget, Styles):
 			name_map = {self.class_name: self.group_name_user}
 			self.df = self.df.drop(list(set(name_map.values()) & set(self.df.columns)), axis=1).rename(columns=name_map)
 			print(self.df.columns)
-			self.df[self.group_name_user] = self.df[self.group_name_user].replace({0: 1, 1: 0})
+			#self.df[self.group_name_user] = self.df[self.group_name_user].replace({0: 1, 1: 0})
 			self.df.reset_index(inplace=True, drop=True)
 
 
 		for pos,pos_group in self.df.groupby('position'):
 			pos_group.to_csv(pos+os.sep.join(['output', 'tables', f'trajectories_{self.mode}.csv']), index=False)
 
-		# reset
-		#self.init_class()
-		#self.update_props_scatter()
 		self.parent_window.parent_window.update_position_options()
 		self.close()
 
+
+	def help_propagate(self):
+
+		"""
+		Helper for segmentation strategy between threshold-based and Deep learning.
+		"""
+
+		dict_path = os.sep.join([get_software_location(),'celldetective','gui','help','propagate-classification.json'])
+
+		with open(dict_path) as f:
+			d = json.load(f)
+
+		suggestion = help_generic(d)
+		if isinstance(suggestion, str):
+			print(f"{suggestion=}")
+			msgBox = QMessageBox()
+			msgBox.setIcon(QMessageBox.Information)
+			msgBox.setTextFormat(Qt.RichText)
+			msgBox.setText(rf"{suggestion}")
+			msgBox.setWindowTitle("Info")
+			msgBox.setStandardButtons(QMessageBox.Ok)
+			returnValue = msgBox.exec()
+			if returnValue == QMessageBox.Ok:
+				return None
+
 	def switch_to_log(self, i):
 
 		"""
@@ -441,6 +425,7 @@ class ClassifierWidget(QWidget, Styles):
 		elif i==0:
 			try:
 				if self.ax_props.get_yscale()=='linear':
+					ymin,ymax = self.ax_props.get_ylim()
 					self.ax_props.set_yscale('log')
 					self.log_btns[i].setIcon(icon(MDI6.math_log,color="#1565c0"))
 				else:
@@ -452,33 +437,6 @@ class ClassifierWidget(QWidget, Styles):
 		self.ax_props.autoscale()
 		self.propscanvas.canvas.draw_idle()
 
-	def estimate_time(self):
-
-		self.df = self.df.sort_values(by=['position','TRACK_ID'],ignore_index=True)
-		for tid,group in self.df.loc[self.df[self.class_name_user]==2].groupby(['position','TRACK_ID']):
-			indices = group.index
-			status_col = self.class_name_user.replace('class','status')
-			status_signal = group[status_col].values
-			timeline = group['FRAME'].values
-			
-			try:
-				popt, pcov = curve_fit(step_function, timeline.astype(int), status_signal, p0=[self.df['FRAME'].max()//2, 0.8],maxfev=30000)
-				values = [step_function(t, *popt) for t in timeline]
-				r2 = r2_score(status_signal,values)
-			except Exception as e:
-				print(e)
-				self.df.loc[indices, self.class_name_user] = 2.0
-				self.df.loc[indices, self.class_name_user.replace('class','t')] = -1
-				continue
-
-			if r2 > float(self.r2_slider.value()):
-				t0 = popt[0]
-				self.df.loc[indices, self.class_name_user.replace('class','t')] = t0
-				self.df.loc[indices, self.class_name_user] = 0.0
-			else:
-				self.df.loc[indices, self.class_name_user.replace('class','t')] = -1
-				self.df.loc[indices, self.class_name_user] = 2.0
-
 		print('Done.')
 
 
@@ -487,5 +445,3 @@ class ClassifierWidget(QWidget, Styles):
 
 
 
-
-