celldetective 1.3.1__tar.gz → 1.3.2__tar.gz

{celldetective-1.3.1 → celldetective-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: celldetective
-Version: 1.3.1
+Version: 1.3.2
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro

celldetective-1.3.2/celldetective/_version.py

@@ -0,0 +1 @@
+__version__ = "1.3.2"

{celldetective-1.3.1 → celldetective-1.3.2}/celldetective/events.py

@@ -104,6 +104,8 @@ def switch_to_events(classes, event_times, max_times, origin_times=None, left_ce
 							pass
 				elif c==1:
 					delta_t = mt - ot
+					if cut_observation_time is not None:
+						delta_t = cut_observation_time - ot
 					if delta_t>0:
 						events.append(0)
 						survival_times.append(delta_t)

{celldetective-1.3.1 → celldetective-1.3.2}/celldetective/gui/classifier_widget.py

@@ -253,6 +253,24 @@ class ClassifierWidget(QWidget, Styles):
 
 	def update_props_scatter(self, feature_changed=True):
 
+		try:
+			if np.any(self.df[self.features_cb[0].currentText()].to_numpy() <= 0.):
+				if self.ax_props.get_yscale()=='log':
+					self.log_btns[0].click()
+				self.log_btns[0].setEnabled(False)
+			else:
+				self.log_btns[0].setEnabled(True)
+
+			if np.any(self.df[self.features_cb[1].currentText()].to_numpy() <= 0.):
+				if self.ax_props.get_xscale()=='log':
+					self.log_btns[1].click()
+				self.log_btns[1].setEnabled(False)
+			else:
+				self.log_btns[1].setEnabled(True)
+		except Exception as e:
+			#print(e)
+			pass
+
 		class_name = self.class_name
 
 		try:
@@ -279,11 +297,24 @@ class ClassifierWidget(QWidget, Styles):
 				max_x = self.df.dropna(subset=feat_x)[feat_x].max()
 				min_y = self.df.dropna(subset=feat_y)[feat_y].min()
 				max_y = self.df.dropna(subset=feat_y)[feat_y].max()
+				
+				x_padding = (max_x - min_x) * 0.05
+				y_padding = (max_y - min_y) * 0.05
+				if x_padding==0:
+					x_padding = 0.05
+				if y_padding==0:
+					y_padding = 0.05
 
 				if min_x==min_x and max_x==max_x:
-					self.ax_props.set_xlim(min_x, max_x)
+					if self.ax_props.get_xscale()=='linear':
+						self.ax_props.set_xlim(min_x - x_padding, max_x + x_padding)
+					else:
+						self.ax_props.set_xlim(min_x, max_x)
 				if min_y==min_y and max_y==max_y:
-					self.ax_props.set_ylim(min_y, max_y)
+					if self.ax_props.get_yscale()=='linear':
+						self.ax_props.set_ylim(min_y - y_padding, max_y + y_padding)
+					else:
+						self.ax_props.set_ylim(min_y, max_y)						
 			
 				self.propscanvas.canvas.toolbar.update()
 
@@ -452,22 +483,39 @@ class ClassifierWidget(QWidget, Styles):
 
 		if i==1:
 			try:
+				feat_x = self.features_cb[1].currentText()
+				min_x = self.df.dropna(subset=feat_x)[feat_x].min()
+				max_x = self.df.dropna(subset=feat_x)[feat_x].max()
+				x_padding = (max_x - min_x) * 0.05
+				if x_padding==0:
+					x_padding = 0.05
+
 				if self.ax_props.get_xscale()=='linear':
+					self.ax_props.set_xlim(min_x, max_x)
 					self.ax_props.set_xscale('log')
 					self.log_btns[i].setIcon(icon(MDI6.math_log,color="#1565c0"))
 				else:
 					self.ax_props.set_xscale('linear')
+					self.ax_props.set_xlim(min_x - x_padding, max_x + x_padding)
 					self.log_btns[i].setIcon(icon(MDI6.math_log,color="black"))
 			except Exception as e:
 				print(e)
 		elif i==0:
 			try:
+				feat_y = self.features_cb[0].currentText()
+				min_y = self.df.dropna(subset=feat_y)[feat_y].min()
+				max_y = self.df.dropna(subset=feat_y)[feat_y].max()
+				y_padding = (max_y - min_y) * 0.05
+				if y_padding==0:
+					y_padding = 0.05
+
 				if self.ax_props.get_yscale()=='linear':
-					ymin,ymax = self.ax_props.get_ylim()
+					self.ax_props.set_ylim(min_y, max_y)
 					self.ax_props.set_yscale('log')
 					self.log_btns[i].setIcon(icon(MDI6.math_log,color="#1565c0"))
 				else:
 					self.ax_props.set_yscale('linear')
+					self.ax_props.set_ylim(min_y - y_padding, max_y + y_padding)
 					self.log_btns[i].setIcon(icon(MDI6.math_log,color="black"))
 			except Exception as e:
 				print(e)

{celldetective-1.3.1 → celldetective-1.3.2}/celldetective/gui/control_panel.py

@@ -181,7 +181,13 @@ class ControlPanel(QMainWindow, Styles):
 		exp_hbox = QHBoxLayout()
 		exp_hbox.addWidget(experiment_label, 25, alignment=Qt.AlignRight)
 		exp_subhbox = QHBoxLayout()
-		exp_subhbox.addWidget(QLabel(name), 90, alignment=Qt.AlignLeft)
+		if len(name)>thresh:
+			name_cut = name[:thresh - 3]+'...'
+		else:
+			name_cut = name
+		exp_name_lbl = QLabel(name_cut)
+		exp_name_lbl.setToolTip(name)
+		exp_subhbox.addWidget(exp_name_lbl, 90, alignment=Qt.AlignLeft)
 		exp_subhbox.addWidget(self.folder_exp_btn, 5, alignment=Qt.AlignRight)
 		exp_subhbox.addWidget(self.edit_config_button, 5, alignment=Qt.AlignRight)
 		exp_hbox.addLayout(exp_subhbox, 75)

{celldetective-1.3.1 → celldetective-1.3.2}/celldetective/gui/generic_signal_plot.py

@@ -5,7 +5,11 @@ from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QDoubleValidator
 
 from celldetective.gui.gui_utils import center_window, FigureCanvas, ExportPlotBtn
+from celldetective.gui.tableUI import TableUI
+from celldetective.io import collect_experiment_metadata
+
 from superqt.fonticon import icon
+from superqt import QLabeledSlider
 from fonticon_mdi6 import MDI6
 import numpy as np
 import json
@@ -16,7 +20,9 @@ from glob import glob
 from matplotlib.cm import tab10
 from celldetective.gui import Styles
 import matplotlib.cm as mcm
+import pandas as pd
 
+from lifelines.utils import qth_survival_times
 
 class GenericSignalPlotWidget(QWidget, Styles):
 
@@ -136,6 +142,14 @@ class GenericSignalPlotWidget(QWidget, Styles):
 		plot_buttons_hbox.addWidget(self.export_btn, 5, alignment=Qt.AlignRight)
 		self.layout.addLayout(plot_buttons_hbox)
 
+		self.export_tabular_btn = QPushButton('')
+		self.export_tabular_btn.setIcon(icon(MDI6.table,color="black"))
+		self.export_tabular_btn.setStyleSheet(self.button_select_all)
+		self.export_tabular_btn.setToolTip('Tabulate survival values.')
+		self.export_tabular_btn.setIconSize(QSize(20, 20))
+		plot_buttons_hbox.addWidget(self.export_tabular_btn, 5, alignment=Qt.AlignRight)
+		self.export_tabular_btn.hide()
+
 		self.ax.set_prop_cycle('color',[self.cmap(i) for i in np.linspace(0, 1, len(self.parent_window.well_indices))])
 
 		self.fig.set_facecolor('none')  # or 'None'
@@ -671,7 +685,9 @@ class SurvivalPlotWidget(GenericSignalPlotWidget):
 		self.class_selection_widget.hide()
 		self.rescale_widget.hide()
 		self.cell_lines_alpha_wdg.hide()
-		
+		self.export_tabular_btn.show()
+		self.export_tabular_btn.clicked.connect(self.set_table_options)
+
 	def switch_to_log(self):
 
 		"""
@@ -790,4 +806,147 @@ class SurvivalPlotWidget(GenericSignalPlotWidget):
 		
 		# Plot a signal
 		if line==line:
-			line.plot_survival_function(ci_show=ci_option, ax=self.ax, legend=legend, color=color, label=label, xlabel='timeline [min]')
+			line.plot_survival_function(ci_show=ci_option, ax=self.ax, legend=legend, color=color, label=label, xlabel='timeline [min]')
+
+	def set_table_options(self):
+
+		self.config_table_wg = QWidget()
+		self.config_table_wg.setMinimumWidth(480)
+		self.config_table_wg.setWindowTitle('Survival data')
+		
+		layout = QVBoxLayout()
+		self.config_table_wg.setLayout(layout)
+
+		self.all_values_rb = QRadioButton('tabulate all values')
+		self.single_timepoint_rb = QRadioButton('survival at single timepoint [min]: ')
+		self.ec_rb = QRadioButton(r'EC N% survival: ')
+		self.all_values_rb.toggled.connect(self.activate_sliders)
+		self.single_timepoint_rb.toggled.connect(self.activate_sliders)
+
+		self.single_timepoint_slider = QLabeledSlider()
+		self.single_timepoint_slider.setRange(0, int(self.df['FRAME'].max()*self.parent_window.FrameToMin))
+		self.single_timepoint_slider.setValue(int(self.df['FRAME'].max()*self.parent_window.FrameToMin))
+
+		self.ec_slider = QLabeledSlider()
+		self.ec_slider.setRange(0, 100)
+		self.ec_slider.setValue(50)
+
+		self.ec_rb.toggled.connect(self.activate_sliders)
+		self.all_values_rb.click()
+
+		self.set_btn = QPushButton('Set')
+		self.set_btn.setStyleSheet(self.button_style_sheet)
+		self.set_btn.clicked.connect(self.assemble_survival_data)
+
+		layout.addWidget(self.all_values_rb)
+
+		single_tp_layout = QHBoxLayout()
+		single_tp_layout.addWidget(self.single_timepoint_rb, 33)
+		single_tp_layout.addWidget(self.single_timepoint_slider, 66)
+		layout.addLayout(single_tp_layout)
+
+		ec_layout = QHBoxLayout()
+		ec_layout.addWidget(self.ec_rb, 33)
+		ec_layout.addWidget(self.ec_slider, 66)
+		layout.addLayout(ec_layout)
+
+		layout.addWidget(self.set_btn)
+		center_window(self.config_table_wg)
+		self.config_table_wg.show()
+
+	def activate_sliders(self):
+		if self.all_values_rb.isChecked():
+			self.single_timepoint_slider.setEnabled(False)
+			self.ec_slider.setEnabled(False)
+		elif self.single_timepoint_rb.isChecked():
+			self.single_timepoint_slider.setEnabled(True)
+			self.ec_slider.setEnabled(False)
+		elif self.ec_rb.isChecked():
+			self.ec_slider.setEnabled(True)
+			self.single_timepoint_slider.setEnabled(False)
+
+	def assemble_survival_data(self):
+
+		if self.plot_options[0].isChecked():
+			data = self.df_well_info
+			groupby = ['well_path']
+		if self.plot_options[1].isChecked():
+			data = self.df_pos_info
+			groupby = ['pos_path']
+		if self.plot_options[2].isChecked():
+			print('Not implemented yet... Please select "well" or "position" as grouping...')
+			return None	
+
+		if self.all_values_rb.isChecked():
+
+			survival_table = []
+			tid=0
+			for name,group in data.groupby(groupby):
+				print(name)
+				if groupby[0]=="pos_path":
+					metadata = collect_experiment_metadata(pos_path=name[0])
+				elif groupby[0]=="well_path":
+					metadata = collect_experiment_metadata(well_path=name[0])					
+				ks_estimator = group['survival_fit'].values[0]
+				if ks_estimator!=ks_estimator:
+					continue
+				timeline = list(ks_estimator.survival_function_.index)
+				survival = ks_estimator.survival_function_['KM_estimate'].values
+				lower_error = ks_estimator.confidence_interval_['KM_estimate_lower_0.95'].values
+				upper_error = ks_estimator.confidence_interval_['KM_estimate_upper_0.95'].values
+				for k in range(len(timeline)):
+					dico = metadata.copy()
+					dico.update({'TRACK_ID': tid,'FRAME': int(timeline[k] / self.parent_window.FrameToMin),'timeline': timeline[k], 'survival': survival[k], "event_fraction": 1-survival[k], 'KM_estimate_lower_0.95': lower_error[k], 'KM_estimate_upper_0.95': upper_error[k]})
+					survival_table.append(dico)
+				tid+=1
+			
+			survival_table = pd.DataFrame(survival_table)
+			self.table = TableUI(survival_table, f"Survival data", plot_mode="plot_track_signals")
+			self.table.show()		
+
+		elif self.single_timepoint_rb.isChecked():
+
+			survival_table = []
+			tid=0
+			for name,group in data.groupby(groupby):
+				print(name)
+				if groupby[0]=="pos_path":
+					metadata = collect_experiment_metadata(pos_path=name[0])
+				elif groupby[0]=="well_path":
+					metadata = collect_experiment_metadata(well_path=name[0])					
+				ks_estimator = group['survival_fit'].values[0]
+				if ks_estimator!=ks_estimator:
+					continue
+				survival = ks_estimator.survival_function_at_times(self.single_timepoint_slider.value()).values[0]
+				dico = metadata.copy()
+				dico.update({'timepoint': self.single_timepoint_slider.value(), 'survival': survival, 'event_fraction': 1 - survival})
+				survival_table.append(dico)
+				tid+=1
+		
+			survival_table = pd.DataFrame(survival_table)
+			self.table = TableUI(survival_table, f"Survival data", plot_mode="static")
+			self.table.show()
+
+		elif self.ec_rb.isChecked():
+			
+			survival_table = []
+			tid=0
+			for name,group in data.groupby(groupby):
+				print(name)
+				if groupby[0]=="pos_path":
+					metadata = collect_experiment_metadata(pos_path=name[0])
+				elif groupby[0]=="well_path":
+					metadata = collect_experiment_metadata(well_path=name[0])					
+				ks_estimator = group['survival_fit'].values[0]
+				if ks_estimator!=ks_estimator:
+					continue
+				survival = ks_estimator.survival_function_
+				ecN = qth_survival_times(float(self.ec_slider.value())/100.0, survival)
+				dico = metadata.copy()
+				dico.update({"qth": int(self.ec_slider.value()), f'EC{int(self.ec_slider.value())}% [min]': ecN})
+				survival_table.append(dico)
+				tid+=1
+		
+			survival_table = pd.DataFrame(survival_table)
+			self.table = TableUI(survival_table, f"Survival data", plot_mode="static")
+			self.table.show()

{celldetective-1.3.1 → celldetective-1.3.2}/celldetective/gui/gui_utils.py

@@ -1,7 +1,7 @@
 import numpy as np
 from PyQt5.QtWidgets import QApplication, QMessageBox, QFrame, QSizePolicy, QWidget, QLineEdit, QListWidget, QVBoxLayout, QComboBox, \
 	QPushButton, QLabel, QHBoxLayout, QCheckBox, QFileDialog
-from PyQt5.QtCore import Qt, QSize
+from PyQt5.QtCore import Qt, QSize, QAbstractTableModel
 from PyQt5.QtGui import QDoubleValidator, QIntValidator
 
 from celldetective.gui import Styles
@@ -16,6 +16,95 @@ from inspect import getmembers, isfunction
 from celldetective.filters import *
 from os import sep
 
+class PandasModel(QAbstractTableModel):
+
+	"""
+	from https://stackoverflow.com/questions/31475965/fastest-way-to-populate-qtableview-from-pandas-data-frame
+	"""
+
+	def __init__(self, data):
+		QAbstractTableModel.__init__(self)
+		self._data = data
+		self.colors = dict()
+
+	def rowCount(self, parent=None):
+		return self._data.shape[0]
+
+	def columnCount(self, parent=None):
+		return self._data.shape[1]
+
+	def data(self, index, role=Qt.DisplayRole):
+		if index.isValid():
+			if role == Qt.DisplayRole:
+				return str(self._data.iloc[index.row(), index.column()])
+			if role == Qt.BackgroundRole:
+				color = self.colors.get((index.row(), index.column()))
+				if color is not None:
+					return color
+		return None
+
+	def headerData(self, rowcol, orientation, role):
+		if orientation == Qt.Horizontal and role == Qt.DisplayRole:
+			return self._data.columns[rowcol]
+		if orientation == Qt.Vertical and role == Qt.DisplayRole:
+			return self._data.index[rowcol]
+		return None
+
+	def change_color(self, row, column, color):
+		ix = self.index(row, column)
+		self.colors[(row, column)] = color
+		self.dataChanged.emit(ix, ix, (Qt.BackgroundRole,))
+
+
+class GenericOpColWidget(QWidget, Styles):
+
+	def __init__(self, parent_window, column=None, title=''):
+
+		super().__init__()
+		
+		self.parent_window = parent_window
+		self.column = column
+		self.title = title
+
+		self.setWindowTitle(self.title)
+		# Create the QComboBox and add some items
+		
+		self.layout = QVBoxLayout(self)
+		self.layout.setContentsMargins(30,30,30,30)
+
+		self.sublayout = QVBoxLayout()
+
+		self.measurements_cb = QComboBox()
+		self.measurements_cb.addItems(list(self.parent_window.data.columns))
+		if self.column is not None:
+			idx = self.measurements_cb.findText(self.column)
+			self.measurements_cb.setCurrentIndex(idx)
+
+		measurement_layout = QHBoxLayout()
+		measurement_layout.addWidget(QLabel('measurements: '), 25)
+		measurement_layout.addWidget(self.measurements_cb, 75)
+		self.sublayout.addLayout(measurement_layout)
+
+		self.layout.addLayout(self.sublayout)
+		
+		self.submit_btn = QPushButton('Compute')
+		self.submit_btn.setStyleSheet(self.button_style_sheet)
+		self.submit_btn.clicked.connect(self.launch_operation)
+		self.layout.addWidget(self.submit_btn, 30)
+
+		self.setAttribute(Qt.WA_DeleteOnClose)		
+		center_window(self)
+
+	def launch_operation(self):
+
+		self.compute()
+		self.parent_window.model = PandasModel(self.parent_window.data)
+		self.parent_window.table_view.setModel(self.parent_window.model)
+		self.close()	
+
+	def compute(self):
+		pass
+
 
 class QuickSliderLayout(QHBoxLayout):
 	

{celldetective-1.3.1 → celldetective-1.3.2}/celldetective/gui/plot_signals_ui.py

@@ -96,7 +96,7 @@ class ConfigSignalPlot(QWidget, Styles):
 		main_layout.addWidget(panel_title, alignment=Qt.AlignCenter)
 
 		labels = [QLabel('population: '), QLabel('class: '), QLabel('time of\ninterest: '), QLabel('cmap: ')]
-		self.cb_options = [['targets','effectors'],['class'], ['t0'], []]
+		self.cb_options = [['targets','effectors'],[], [], []]
 		self.cbs = [QComboBox() for i in range(len(labels))]
 		self.cbs[-1] = QColormapComboBox()
 		
@@ -183,6 +183,11 @@ class ConfigSignalPlot(QWidget, Styles):
 			self.auto_close = True
 			return None
 		
+		if 'class' in self.all_columns:
+			class_columns.append("class")
+		if 't0' in self.all_columns:
+			time_columns.append('t0')
+		
 		self.cbs[2].clear()
 		self.cbs[2].addItems(np.unique(self.cb_options[2]+time_columns))
 
@@ -339,7 +344,7 @@ class ConfigSignalPlot(QWidget, Styles):
 
 		for block,movie_group in self.df.groupby(['well','position']):
 
-			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=[0,1], return_matrix=True, forced_max_duration=max_time)
+			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=None, return_matrix=True, forced_max_duration=max_time)
 			well_signal_event, well_std_event, timeline_event, matrix_event = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=[0], return_matrix=True, forced_max_duration=max_time)		
 			well_signal_no_event, well_std_no_event, timeline_no_event, matrix_no_event = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=[1], return_matrix=True, forced_max_duration=max_time)
 			self.mean_plots_timeline = timeline_all
@@ -354,7 +359,7 @@ class ConfigSignalPlot(QWidget, Styles):
 		# Per well
 		for well,well_group in self.df.groupby('well'):
 
-			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=[0,1], return_matrix=True, forced_max_duration=max_time)
+			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=None, return_matrix=True, forced_max_duration=max_time)
 			well_signal_event, well_std_event, timeline_event, matrix_event = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=[0], return_matrix=True, forced_max_duration=max_time)			
 			well_signal_no_event, well_std_no_event, timeline_no_event, matrix_no_event = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=[1], return_matrix=True, forced_max_duration=max_time)
 			

{celldetective-1.3.1 → celldetective-1.3.2}/celldetective/gui/process_block.py

@@ -920,7 +920,7 @@ class ProcessPanel(QFrame, Styles):
 			plot_mode = 'plot_track_signals'
 			if 'TRACK_ID' not in list(self.df.columns):
 				plot_mode = 'static'
-			self.tab_ui = TableUI(self.df, f"Well {self.parent_window.well_list.currentText()}; Position {self.parent_window.position_list.currentText()}", population=self.mode, plot_mode=plot_mode)
+			self.tab_ui = TableUI(self.df, f"Well {self.parent_window.well_list.currentText()}; Position {self.parent_window.position_list.currentText()}", population=self.mode, plot_mode=plot_mode, save_inplace_option=True)
 			self.tab_ui.show()
 		else:
 			print('Table could not be loaded...')
@@ -1207,28 +1207,19 @@ class NeighPanel(QFrame, Styles):
 		self.measure_pairs_action.setToolTip("Measure the relative quantities defined for the cell pairs, for all neighborhoods.")
 		rel_layout.addWidget(self.measure_pairs_action, 90)
 
-		# self.visu_btn = QPushButton()
-		# self.visu_btn.setIcon(icon(MDI6.eye_check_outline,color="black"))
-		# self.visu_btn.setIconSize(QSize(20, 20))
-		# self.visu_btn.clicked.connect(self.check_measurements2)
-		# self.visu_btn.setToolTip("Open measurement annotator for two populations.")
-		# self.visu_btn.setStyleSheet(self.button_select_all)
-		# self.grid_contents.addWidget(self.visu_btn, 1,1,1,1,alignment=Qt.AlignRight)
-		# rel_layout.addWidget(self.visu_btn, 6)
-
-		# self.config_rel_annotator_btn = QPushButton()
-		# self.config_rel_annotator_btn.setIcon(icon(MDI6.cog_outline, color="black"))
-		# self.config_rel_annotator_btn.setIconSize(QSize(20, 20))
-		# self.config_rel_annotator_btn.setToolTip("Configure the animation of the annotation tool.")
-		# self.config_rel_annotator_btn.setStyleSheet(self.button_select_all)
-		# self.config_rel_annotator_btn.clicked.connect(self.open_signal_annotator_configuration_ui)
-		# # self.grid_contents.addWidget(self.config_rel_annotator_btn, 1,2,1,1, alignment=Qt.AlignRight)
-		# rel_layout.addWidget(self.config_rel_annotator_btn, 6)
+		self.classify_pairs_btn = QPushButton()
+		self.classify_pairs_btn.setIcon(icon(MDI6.scatter_plot, color="black"))
+		self.classify_pairs_btn.setIconSize(QSize(20, 20))
+		self.classify_pairs_btn.setToolTip("Classify data.")
+		self.classify_pairs_btn.setStyleSheet(self.button_select_all)
+		self.classify_pairs_btn.clicked.connect(self.open_classifier_ui_pairs)
+		rel_layout.addWidget(self.classify_pairs_btn, 5) #4,2,1,1, alignment=Qt.AlignRight
+
 		self.grid_contents.addLayout(rel_layout, 6, 0, 1, 4)
 
 		signal_layout = QVBoxLayout()
 		signal_hlayout = QHBoxLayout()
-		self.signal_analysis_action = QCheckBox("PAIR SIGNAL ANALYSIS")
+		self.signal_analysis_action = QCheckBox("DETECT PAIR EVENTS")
 		self.signal_analysis_action.setStyleSheet("""
 		font-size: 10px;
 		padding-left: 10px;
@@ -1304,6 +1295,26 @@ class NeighPanel(QFrame, Styles):
 		self.neigh_action.setChecked(True)
 		self.neigh_action.setChecked(False)
 
+	def open_classifier_ui_pairs(self):
+		
+		self.mode = "pairs"
+		self.load_available_tables()
+		if self.df is None:
+
+			msgBox = QMessageBox()
+			msgBox.setIcon(QMessageBox.Warning)
+			msgBox.setText("No table was found...")
+			msgBox.setWindowTitle("Warning")
+			msgBox.setStandardButtons(QMessageBox.Ok)
+			returnValue = msgBox.exec()
+			if returnValue == QMessageBox.Ok:
+				return None
+			else:
+				return None
+		else:
+			self.ClassifierWidget = ClassifierWidget(self)
+			self.ClassifierWidget.show()
+
 
 	def help_neighborhood(self):
 
@@ -1360,7 +1371,7 @@ class NeighPanel(QFrame, Styles):
 
 		if self.df is not None:
 			plot_mode = 'static'
-			self.tab_ui = TableUI(self.df, f"Well {self.parent_window.well_list.currentText()}; Position {self.parent_window.position_list.currentText()}", population='pairs', plot_mode=plot_mode)
+			self.tab_ui = TableUI(self.df, f"Well {self.parent_window.well_list.currentText()}; Position {self.parent_window.position_list.currentText()}", population='pairs', plot_mode=plot_mode, save_inplace_option=True)
 			self.tab_ui.show()
 		else:
 			print('Table could not be loaded...')