celldetective 1.3.0.post1__py3-none-any.whl → 1.3.2__py3-none-any.whl

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/layouts.py

@@ -8,7 +8,7 @@ from superqt import QLabeledRangeSlider, QLabeledDoubleSlider, QLabeledSlider, Q
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
 from celldetective.utils import _extract_channel_indices_from_config
-from celldetective.gui.viewers import ThresholdedStackVisualizer, CellEdgeVisualizer, StackVisualizer, CellSizeViewer
+from celldetective.gui.viewers import ThresholdedStackVisualizer, CellEdgeVisualizer, StackVisualizer, CellSizeViewer, ChannelOffsetViewer
 from celldetective.gui import Styles
 from celldetective.preprocessing import correct_background_model, correct_background_model_free, estimate_background_per_condition
 from functools import partial
@@ -535,7 +535,6 @@ class BackgroundFitCorrectionLayout(QGridLayout, Styles):
 		self.threshold_viewer_btn.clicked.connect(self.set_threshold_graphically)
 		self.threshold_viewer_btn.setToolTip('Set the threshold graphically.')
 
-
 		self.model_lbl = QLabel('Model: ')
 		self.model_lbl.setToolTip('2D model to fit the background with.')
 		self.models_cb = QComboBox()
@@ -560,6 +559,8 @@ class BackgroundFitCorrectionLayout(QGridLayout, Styles):
 																			   self.corrected_stack_viewer,
 																			   self.add_correction_btn
 																			   ])
+
+
 	def add_to_layout(self):
 		
 		channel_layout = QHBoxLayout()
@@ -572,6 +573,7 @@ class BackgroundFitCorrectionLayout(QGridLayout, Styles):
 		subthreshold_layout = QHBoxLayout()
 		subthreshold_layout.addWidget(self.threshold_le, 95)
 		subthreshold_layout.addWidget(self.threshold_viewer_btn, 5)
+
 		threshold_layout.addLayout(subthreshold_layout, 75)
 		self.addLayout(threshold_layout, 1, 0, 1, 3)
 
@@ -878,18 +880,26 @@ class ProtocolDesignerLayout(QVBoxLayout, Styles):
 
 	def generate_layout(self):
 
+		self.correction_layout = QVBoxLayout()
+
+		self.background_correction_layout = QVBoxLayout()
+		self.background_correction_layout.setContentsMargins(0,0,0,0)
 		self.title_layout = QHBoxLayout()
 		self.title_layout.addWidget(self.title_lbl, 100, alignment=Qt.AlignCenter)
+		self.background_correction_layout.addLayout(self.title_layout)
+		self.background_correction_layout.addWidget(self.tabs)
+		self.correction_layout.addLayout(self.background_correction_layout)
+		
+		self.addLayout(self.correction_layout)
 
-		self.addLayout(self.title_layout)
-		self.addWidget(self.tabs)
-
+		self.list_layout = QVBoxLayout()
 		list_header_layout = QHBoxLayout()
 		list_header_layout.addWidget(self.protocol_list_lbl)
 		list_header_layout.addWidget(self.delete_protocol_btn, alignment=Qt.AlignRight)
-		self.addLayout(list_header_layout)
+		self.list_layout.addLayout(list_header_layout)
+		self.list_layout.addWidget(self.protocol_list)
 
-		self.addWidget(self.protocol_list)
+		self.addLayout(self.list_layout)
 
 
 	def remove_protocol_from_list(self):
@@ -899,6 +909,117 @@ class ProtocolDesignerLayout(QVBoxLayout, Styles):
 			del self.protocols[current_item]
 			self.protocol_list.takeItem(current_item)
 
+class ChannelOffsetOptionsLayout(QVBoxLayout, Styles):
+	
+	def __init__(self, parent_window=None, *args, **kwargs):
+		
+		super().__init__(*args, **kwargs)
+
+		self.parent_window = parent_window
+		if hasattr(self.parent_window.parent_window, 'exp_config'):
+			self.attr_parent = self.parent_window.parent_window
+		else:
+			self.attr_parent = self.parent_window.parent_window.parent_window
+
+		self.channel_names = self.attr_parent.exp_channels
+
+		self.setContentsMargins(15,15,15,15)
+		self.generate_widgets()
+		self.add_to_layout()
+
+	def generate_widgets(self):
+		
+		self.channel_lbl = QLabel('Channel: ')
+		self.channels_cb = QComboBox()
+		self.channels_cb.addItems(self.channel_names)
+
+		self.shift_lbl = QLabel('Shift: ')
+		self.shift_h_lbl = QLabel('(h): ')
+		self.shift_v_lbl = QLabel('(v): ')
+
+		self.set_shift_btn = QPushButton()
+		self.set_shift_btn.setIcon(icon(MDI6.image_check, color="k"))
+		self.set_shift_btn.setStyleSheet(self.button_select_all)
+		self.set_shift_btn.setToolTip('Set the channel shift.')
+		self.set_shift_btn.clicked.connect(self.open_offset_viewer)
+		
+		self.add_correction_btn = QPushButton('Add correction')
+		self.add_correction_btn.setStyleSheet(self.button_style_sheet_2)
+		self.add_correction_btn.setIcon(icon(MDI6.plus, color="#1565c0"))
+		self.add_correction_btn.setToolTip('Add correction.')
+		self.add_correction_btn.setIconSize(QSize(25, 25))
+		self.add_correction_btn.clicked.connect(self.add_instructions_to_parent_list)
+
+		self.vertical_shift_le = ThresholdLineEdit(init_value=0, connected_buttons=[self.add_correction_btn],placeholder='vertical shift [pixels]', value_type='float')
+		self.horizontal_shift_le = ThresholdLineEdit(init_value=0, connected_buttons=[self.add_correction_btn],placeholder='vertical shift [pixels]', value_type='float')
+	
+	def add_to_layout(self):
+
+		channel_ch_hbox = QHBoxLayout()
+		channel_ch_hbox.addWidget(self.channel_lbl, 25)
+		channel_ch_hbox.addWidget(self.channels_cb, 75)
+		self.addLayout(channel_ch_hbox)
+
+		shift_hbox = QHBoxLayout()
+		shift_hbox.addWidget(self.shift_lbl, 25)
+		
+		shift_subhbox = QHBoxLayout()
+		shift_subhbox.addWidget(self.shift_h_lbl, 10)
+		shift_subhbox.addWidget(self.horizontal_shift_le, 75//2)
+		shift_subhbox.addWidget(self.shift_v_lbl, 10)
+		shift_subhbox.addWidget(self.vertical_shift_le, 75//2)	
+		shift_subhbox.addWidget(self.set_shift_btn, 5)
+
+		shift_hbox.addLayout(shift_subhbox, 75)
+		self.addLayout(shift_hbox)
+
+		btn_hbox = QHBoxLayout()
+		btn_hbox.addWidget(self.add_correction_btn, 95)
+		self.addLayout(btn_hbox)		
+
+	def add_instructions_to_parent_list(self):
+
+		self.generate_instructions()
+		self.parent_window.protocol_layout.protocols.append(self.instructions)
+		correction_description = ""
+		for index, (key, value) in enumerate(self.instructions.items()):
+			if index > 0:
+				correction_description += ", "
+			correction_description += str(key) + " : " + str(value)
+		self.parent_window.protocol_layout.protocol_list.addItem(correction_description)
+
+	def generate_instructions(self):
+
+		self.instructions = {
+					  "correction_type": "offset",
+					  "target_channel": self.channels_cb.currentText(),
+					  "correction_horizontal": self.horizontal_shift_le.get_threshold(),
+					  "correction_vertical": self.vertical_shift_le.get_threshold(),
+					 }
+
+
+	def set_target_channel(self):
+
+		channel_indices = _extract_channel_indices_from_config(self.attr_parent.exp_config, [self.channels_cb.currentText()])
+		self.target_channel = channel_indices[0]
+
+	def open_offset_viewer(self):
+		
+		self.attr_parent.locate_image()
+		self.set_target_channel()
+
+		if self.attr_parent.current_stack is not None:
+			self.viewer = ChannelOffsetViewer(
+											 parent_window = self,
+											 stack_path=self.attr_parent.current_stack,
+											 channel_names=self.attr_parent.exp_channels,
+											 n_channels=len(self.channel_names),
+											 channel_cb=True,
+											 target_channel=self.target_channel,
+											 window_title='offset viewer',
+											)
+			self.viewer.show()
+
 
 class BackgroundModelFreeCorrectionLayout(QGridLayout, Styles):
 	

celldetective/gui/measurement_options.py

@@ -154,7 +154,7 @@ class ConfigMeasurements(QMainWindow, Styles):
 
 		grid = QGridLayout(self.iso_frame)
 
-		self.iso_lbl = QLabel("ISOTROPIC MEASUREMENTS")
+		self.iso_lbl = QLabel("Position-based measurements".upper())
 		self.iso_lbl.setStyleSheet("""
 			font-weight: bold;
 			padding: 0px;
@@ -171,7 +171,7 @@ class ConfigMeasurements(QMainWindow, Styles):
 
 		grid = QGridLayout(self.features_frame)
 
-		self.feature_lbl = QLabel("FEATURES")
+		self.feature_lbl = QLabel("Mask-based measurements".upper())
 		self.feature_lbl.setStyleSheet("""
 			font-weight: bold;
 			padding: 0px;
@@ -262,7 +262,7 @@ class ConfigMeasurements(QMainWindow, Styles):
 		self.add_feature_btn.setToolTip("Add feature")
 		self.add_feature_btn.setIconSize(QSize(20, 20))
 
-		self.features_list = ListWidget(FeatureChoice, initial_features=['area', 'intensity_mean', ])
+		self.features_list = ListWidget(FeatureChoice, initial_features=['area', 'intensity_nanmean', ])
 
 		self.del_feature_btn.clicked.connect(self.features_list.removeSel)
 		self.add_feature_btn.clicked.connect(self.features_list.addItem)

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)