celldetective 1.3.1__py3-none-any.whl → 1.3.3.post1__py3-none-any.whl

celldetective/_version.py

@@ -1 +1 @@
-__version__ = "1.3.1"
+__version__ = "1.3.3.post1"

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/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/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)
@@ -444,8 +450,8 @@ class ControlPanel(QMainWindow, Styles):
 			self.view_stack_btn.setEnabled(False)
 			self.ProcessEffectors.signal_analysis_action.setEnabled(True)
 			self.ProcessTargets.signal_analysis_action.setEnabled(True)
-
-			self.delete_tracks_btn.hide()
+			if hasattr(self,'delete_tracks_btn'):
+				self.delete_tracks_btn.hide()
 			self.ProcessTargets.delete_tracks_btn.hide()
 			self.ProcessEffectors.delete_tracks_btn.hide()
 		else:

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/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/gui/measurement_options.py

@@ -10,7 +10,7 @@ from superqt import QLabeledDoubleSlider
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
 
-from celldetective.gui.thresholds_gui import ThresholdSpot
+#from celldetective.gui.thresholds_gui import ThresholdSpot
 from celldetective.utils import extract_experiment_channels, get_software_location
 from celldetective.io import load_frames, auto_load_number_of_frames
 from celldetective.measure import compute_haralick_features
@@ -26,7 +26,7 @@ from tifffile import imread
 from pathlib import Path
 import gc
 
-from celldetective.gui.viewers import CellEdgeVisualizer
+from celldetective.gui.viewers import CellEdgeVisualizer, SpotDetectionVisualizer
 from celldetective.gui.layouts import ProtocolDesignerLayout, BackgroundFitCorrectionLayout, LocalCorrectionLayout
 from celldetective.gui.gui_utils import ThresholdLineEdit
 from celldetective.gui import Styles
@@ -951,51 +951,54 @@ class ConfigMeasurements(QMainWindow, Styles):
 
 		layout.addWidget(self.threshold_lbl, 4, 0)
 		layout.addWidget(self.threshold_value, 4, 1)
-		self.preview_spot = QPushButton('Preview')
-		self.preview_spot.clicked.connect(self.spot_preview)
-		self.preview_spot.setStyleSheet(self.button_style_sheet_2)
-		layout.addWidget(self.preview_spot, 5, 0, 1, 2)
-		self.spot_channel.setEnabled(False)
-		self.spot_channel_lbl.setEnabled(False)
-		self.diameter_value.setEnabled(False)
-		self.diameter_lbl.setEnabled(False)
-		self.threshold_value.setEnabled(False)
-		self.threshold_lbl.setEnabled(False)
-		self.preview_spot.setEnabled(False)
 
+		self.spot_viewer_btn = QPushButton()
+		self.spot_viewer_btn.clicked.connect(self.spot_preview)
+		self.spot_viewer_btn.setIcon(icon(MDI6.image_check, color="k"))
+		self.spot_viewer_btn.setStyleSheet(self.button_select_all)
+		self.spot_viewer_btn.setToolTip('Set detection parameters visually.')
+		layout.addWidget(self.spot_viewer_btn, 1, 1, 1, 1, alignment=Qt.AlignRight)
+
+		self.spot_detection_widgets = [self.spot_channel, self.spot_channel_lbl, self.diameter_value, self.diameter_lbl, self.threshold_value, self.threshold_lbl, self.spot_viewer_btn]
+		for wg in self.spot_detection_widgets:
+			wg.setEnabled(False)
 
 	def enable_spot_preview(self):
 
 		diam = self.diameter_value.text().replace(',','').replace('.','')
 		thresh = self.threshold_value.text().replace(',','').replace('.','')
 		if diam.isnumeric() and thresh.isnumeric():
-			self.preview_spot.setEnabled(True)
+			self.spot_viewer_btn.setEnabled(True)
 		else:
-			self.preview_spot.setEnabled(False)
+			self.spot_viewer_btn.setEnabled(False)
 
 	def spot_preview(self):
 		self.locate_image()
 		if self.test_frame is not None:
 			self.locate_mask()
 			if self.test_mask is not None:
-				self.spot_visual = ThresholdSpot(current_channel=self.spot_channel.currentIndex(), img=self.test_frame,
-												 mask=self.test_mask, parent_window=self)
+				self.spot_visual = SpotDetectionVisualizer(frame_slider=True,
+														   contrast_slider=True,
+														   cell_type=self.mode,
+														   channel_cb=True,
+														   channel_names = self.channel_names,
+														   stack_path=self.current_stack,
+														   n_channels=len(self.channel_names),
+														   target_channel=self.spot_channel.currentIndex(),
+														   window_title='Detect spots',
+														   parent_channel_cb=self.spot_channel,
+														   parent_diameter_le=self.diameter_value,
+														   parent_threshold_le=self.threshold_value,
+														   PxToUm = 1,)
+				self.spot_visual.show()
+				#self.spot_visual = ThresholdSpot(current_channel=self.spot_channel.currentIndex(), img=self.test_frame,
+				#								 mask=self.test_mask, parent_window=self)
 
 	def enable_spot_detection(self):
-		if self.spot_check.isChecked():
-			self.spot_channel.setEnabled(True)
-			self.spot_channel_lbl.setEnabled(True)
-			self.diameter_value.setEnabled(True)
-			self.diameter_lbl.setEnabled(True)
-			self.threshold_value.setEnabled(True)
-			self.threshold_lbl.setEnabled(True)
-			self.preview_spot.setEnabled(True)
 
+		if self.spot_check.isChecked():
+			for wg in self.spot_detection_widgets:
+				wg.setEnabled(True)
 		else:
-			self.spot_channel.setEnabled(False)
-			self.spot_channel_lbl.setEnabled(False)
-			self.diameter_value.setEnabled(False)
-			self.diameter_lbl.setEnabled(False)
-			self.threshold_value.setEnabled(False)
-			self.threshold_lbl.setEnabled(False)
-			self.preview_spot.setEnabled(False)
+			for wg in self.spot_detection_widgets:
+				wg.setEnabled(False)

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)