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

celldetective/gui/base_annotator.py

@@ -0,0 +1,786 @@
+from glob import glob
+import os
+import numpy as np
+import pandas as pd
+from PyQt5.QtGui import QKeySequence
+from PyQt5.QtWidgets import QApplication, QCheckBox, QFileDialog, QLineEdit, QMessageBox, QHBoxLayout, QRadioButton, \
+	QShortcut, \
+	QVBoxLayout, \
+	QPushButton, \
+	QComboBox, \
+	QLabel
+from PyQt5.QtCore import QSize, Qt
+import matplotlib.pyplot as plt
+from matplotlib.ticker import MultipleLocator
+from sklearn.preprocessing import MinMaxScaler
+from superqt import QSearchableComboBox
+
+from superqt.fonticon import icon
+from fonticon_mdi6 import MDI6
+import json
+
+from celldetective.gui import Styles, CelldetectiveWidget, CelldetectiveMainWindow
+from celldetective.utils import get_software_location
+from celldetective.io import auto_load_number_of_frames, extract_experiment_channels, get_experiment_metadata, \
+	get_experiment_labels, load_frames
+from celldetective.gui.gui_utils import FigureCanvas, center_window, color_from_status, color_from_class, ExportPlotBtn
+import gc
+
+class BaseAnnotator(CelldetectiveMainWindow, Styles):
+
+	def __init__(self, parent_window=None, read_config=True):
+
+		super().__init__()
+		self.parent_window = parent_window
+		self.read_config = read_config
+		
+		self.mode = self.parent_window.mode
+		self.pos = self.parent_window.parent_window.pos
+		self.exp_dir = self.parent_window.exp_dir
+		self.PxToUm = self.parent_window.parent_window.PxToUm
+		self.n_signals = 3
+		self.soft_path = get_software_location()
+		self.recently_modified = False
+		self.selection = []
+		self.MinMaxScaler = MinMaxScaler()
+		self.fraction = 1
+		self.log_scale = False
+
+		self.instructions_path = self.exp_dir + os.sep.join(['configs', f'signal_annotator_config_{self.mode}.json'])
+		self.trajectories_path = self.pos + os.sep.join(['output','tables',f'trajectories_{self.mode}.csv'])
+
+		self.screen_height = self.parent_window.parent_window.parent_window.screen_height
+		self.screen_width = self.parent_window.parent_window.parent_window.screen_width
+		self.value_magnitude = 1
+		
+		self.setMinimumWidth(int(0.8 * self.screen_width))
+		self.setMinimumHeight(int(0.8 * self.screen_height))
+		
+		self.proceed = True
+		self.locate_stack()
+		if not self.proceed:
+			self.close()
+		else:
+			if self.read_config:
+				self.load_annotator_config()
+			self.locate_tracks()
+			self._init_base_widgets()
+	
+	def _init_base_widgets(self):
+		self._init_base_widgets_left()
+		self._init_base_widgets_right()
+	
+	def _init_base_widgets_right(self):
+		pass
+	
+	def _init_base_widgets_left(self):
+		
+		self.class_label = QLabel('event: ')
+		self.class_choice_cb = QComboBox()
+
+		cols = np.array(self.df_tracks.columns)
+		self.class_cols = np.array([c.startswith('class') for c in list(self.df_tracks.columns)])
+		
+		self.class_cols = list(cols[self.class_cols])
+		try:
+			self.class_cols.remove('class_id')
+		except Exception:
+			pass
+		try:
+			self.class_cols.remove('class_color')
+		except Exception:
+			pass
+
+		self.class_choice_cb.addItems(self.class_cols)
+		self.class_choice_cb.currentIndexChanged.connect(self.compute_status_and_colors)
+
+		self.add_class_btn = QPushButton('')
+		self.add_class_btn.setStyleSheet(self.button_select_all)
+		self.add_class_btn.setIcon(icon(MDI6.plus, color="black"))
+		self.add_class_btn.setToolTip("Add a new event class")
+		self.add_class_btn.setIconSize(QSize(20, 20))
+		self.add_class_btn.clicked.connect(self.create_new_event_class)
+
+		self.del_class_btn = QPushButton('')
+		self.del_class_btn.setStyleSheet(self.button_select_all)
+		self.del_class_btn.setIcon(icon(MDI6.delete, color="black"))
+		self.del_class_btn.setToolTip("Delete an event class")
+		self.del_class_btn.setIconSize(QSize(20, 20))
+		self.del_class_btn.clicked.connect(self.del_event_class)
+		
+		self.cell_info = QLabel('')
+
+		self.correct_btn = QPushButton('correct')
+		self.correct_btn.setIcon(icon(MDI6.redo_variant, color="white"))
+		self.correct_btn.setIconSize(QSize(20, 20))
+		self.correct_btn.setStyleSheet(self.button_style_sheet)
+		self.correct_btn.clicked.connect(self.show_annotation_buttons)
+		self.correct_btn.setEnabled(False)
+
+		self.cancel_btn = QPushButton('cancel')
+		self.cancel_btn.setStyleSheet(self.button_style_sheet_2)
+		self.cancel_btn.setShortcut(QKeySequence("Esc"))
+		self.cancel_btn.setEnabled(False)
+		self.cancel_btn.clicked.connect(self.cancel_selection)
+		
+		self._init_cell_fig_widgets()
+		
+		self.save_btn = QPushButton('Save')
+		self.save_btn.setStyleSheet(self.button_style_sheet)
+		self.save_btn.clicked.connect(self.save_trajectories)
+
+		self.export_btn = QPushButton('')
+		self.export_btn.setStyleSheet(self.button_select_all)
+		self.export_btn.clicked.connect(self.export_signals)
+		self.export_btn.setIcon(icon(MDI6.export, color="black"))
+		self.export_btn.setIconSize(QSize(25, 25))
+
+	def _init_cell_fig_widgets(self):
+		
+		self.generate_signal_choices()
+		self.create_cell_signal_canvas()
+		self.cell_fcanvas.setMinimumHeight(int(0.2 * self.screen_height))
+		
+		self.outliers_check = QCheckBox('Show outliers')
+		self.outliers_check.toggled.connect(self.show_outliers)
+		
+		self.normalize_features_btn = QPushButton('')
+		self.normalize_features_btn.setStyleSheet(self.button_select_all)
+		self.normalize_features_btn.setIcon(icon(MDI6.arrow_collapse_vertical, color="black"))
+		self.normalize_features_btn.setIconSize(QSize(25, 25))
+		self.normalize_features_btn.setFixedSize(QSize(30, 30))
+		self.normalize_features_btn.clicked.connect(self.normalize_features)
+		self.normalized_signals = False
+		
+		self.log_btn = QPushButton()
+		self.log_btn.setIcon(icon(MDI6.math_log, color="black"))
+		self.log_btn.setStyleSheet(self.button_select_all)
+		self.log_btn.clicked.connect(self.switch_to_log)
+	
+		self.export_plot_btn = ExportPlotBtn(self.cell_fig, export_dir = self.exp_dir)
+
+	def close_without_new_class(self):
+		self.newClassWidget.close()
+
+	def init_class_selection_block(self):
+		
+		self.class_hbox = QHBoxLayout()
+		self.class_hbox.setContentsMargins(0,0,0,0)
+		
+		self.class_hbox.addWidget(self.class_label, 25)
+		self.class_hbox.addWidget(self.class_choice_cb, 70)
+		self.class_hbox.addWidget(self.add_class_btn, 5)
+		self.class_hbox.addWidget(self.del_class_btn, 5)
+	
+	def init_options_block(self):
+		self.options_hbox = QHBoxLayout()
+		self.options_hbox.setContentsMargins(0, 0, 0, 0)
+		
+	def init_correction_block(self):
+		self.action_hbox = QHBoxLayout()
+		self.action_hbox.setContentsMargins(0,0,0,0)
+		
+		self.action_hbox.addWidget(self.correct_btn)
+		self.action_hbox.addWidget(self.cancel_btn)
+	
+	def init_plot_buttons_block(self):
+		self.plot_buttons_hbox = QHBoxLayout()
+		self.plot_buttons_hbox.setContentsMargins(0, 0, 0, 0)
+		self.plot_buttons_hbox.addWidget(QLabel(''), 90)
+		self.plot_buttons_hbox.addWidget(self.outliers_check, 5)
+		self.plot_buttons_hbox.addWidget(self.normalize_features_btn, 5)
+		self.plot_buttons_hbox.addWidget(self.log_btn, 5)
+		self.plot_buttons_hbox.addWidget(self.export_plot_btn, 5)
+	
+	def init_save_btn_block(self):
+		
+		self.btn_hbox = QHBoxLayout()
+		self.btn_hbox.setContentsMargins(0,10,0,0)
+		self.btn_hbox.addWidget(self.save_btn, 90)
+		self.btn_hbox.addWidget(self.export_btn, 10)
+
+	def populate_window(self):
+		
+		"""
+		Create the multibox design.
+
+		"""
+
+		# Main layout
+		self.button_widget = CelldetectiveWidget()
+		self.main_layout = QHBoxLayout()
+		self.button_widget.setLayout(self.main_layout)
+		self.main_layout.setContentsMargins(30, 30, 30, 30)
+		
+		# Left panel
+		self.left_panel = QVBoxLayout()
+		self.left_panel.setContentsMargins(30, 5, 30, 5)
+		self.left_panel.setSpacing(3)
+		
+		self.init_class_selection_block()
+		self.left_panel.addLayout(self.class_hbox, 5)
+		self.left_panel.addWidget(self.cell_info,10)
+		
+		self.init_options_block()
+		self.init_correction_block()
+		self.left_panel.addLayout(self.options_hbox, 5)
+		self.left_panel.addLayout(self.action_hbox, 5)
+		
+		self.left_panel.addWidget(self.cell_fcanvas, 45)
+		
+		self.init_plot_buttons_block()
+		self.left_panel.addLayout(self.plot_buttons_hbox, 5)
+	
+		signal_choice_vbox = QVBoxLayout()
+		signal_choice_vbox.setContentsMargins(30, 0, 30, 0)
+		for i in range(len(self.signal_choice_cb)):
+			hlayout = QHBoxLayout()
+			hlayout.addWidget(self.signal_choice_label[i], 20)
+			hlayout.addWidget(self.signal_choice_cb[i], 75)
+			signal_choice_vbox.addLayout(hlayout)
+
+		self.left_panel.addLayout(signal_choice_vbox, 15)
+		
+		self.init_save_btn_block()
+		self.left_panel.addLayout(self.btn_hbox, 5)
+
+		# Right panel
+		self.right_panel = QVBoxLayout()
+		
+		# add left/right to main layout
+		self.main_layout.addLayout(self.left_panel, 35)
+		self.main_layout.addLayout(self.right_panel, 65)
+		self.button_widget.adjustSize()
+		#self.compute_status_and_colors(0)
+
+		self.setCentralWidget(self.button_widget)
+		# self.show()
+		
+		self.del_shortcut = QShortcut(Qt.Key_Delete, self)  # QKeySequence("s")
+		self.del_shortcut.activated.connect(self.shortcut_suppr)
+		self.del_shortcut.setEnabled(False)
+
+		QApplication.processEvents()
+
+	def generate_signal_choices(self):
+
+		self.signal_choice_cb = [QSearchableComboBox() for i in range(self.n_signals)]
+		self.signal_choice_label = [QLabel(f'signal {i + 1}: ') for i in range(self.n_signals)]
+		# self.log_btns = [QPushButton() for i in range(self.n_signals)]
+
+		signals = list(self.df_tracks.columns)
+
+		to_remove = ['FRAME', 'ID', 'POSITION_X', 'POSITION_Y', 'TRACK_ID', 'antibody', 'cell_type',
+					 'class', 'class_color', 'class_id', 'concentration', 'dummy', 'generation',
+					 'group', 'group_color', 'index', 'parent', 'pharmaceutical_agent', 'pos_name',
+					 'position', 'root', 'state', 'status', 'status_color', 't', 't0', 'well',
+					 'well_index', 'well_name', 'x_anim', 'y_anim',
+					 ]
+
+		meta = get_experiment_metadata(self.exp_dir)
+		if meta is not None:
+			keys = list(meta.keys())
+			to_remove.extend(keys)
+
+		labels = get_experiment_labels(self.exp_dir)
+		if labels is not None:
+			keys = list(labels.keys())
+			to_remove.extend(labels)
+
+		for c in to_remove:
+			if c in signals:
+				signals.remove(c)
+
+		for i in range(len(self.signal_choice_cb)):
+			self.signal_choice_cb[i].addItems(['--'] + signals)
+			self.signal_choice_cb[i].setCurrentIndex(i + 1)
+			self.signal_choice_cb[i].currentIndexChanged.connect(self.plot_signals)
+	
+	def on_scatter_pick(self, event):
+		
+		self.event = event
+		
+		self.correct_btn.disconnect()
+		self.correct_btn.clicked.connect(self.show_annotation_buttons)
+		
+		print(f"{self.selection=}")
+		
+		ind = event.ind
+		
+		if len(ind) > 1:
+			# More than one point in vicinity
+			datax, datay = [self.positions[self.framedata][i, 0] for i in ind], [self.positions[self.framedata][i, 1]
+																				 for i in ind]
+			msx, msy = event.mouseevent.xdata, event.mouseevent.ydata
+			dist = np.sqrt((np.array(datax) - msx) ** 2 + (np.array(datay) - msy) ** 2)
+			ind = [ind[np.argmin(dist)]]
+		
+		if len(ind) > 0 and (len(self.selection) == 0):
+			
+			self.selection.append([ind[0], self.framedata])
+			self.select_single_cell(ind[0], self.framedata)
+		
+		elif len(ind) > 0 and len(self.selection) == 1:
+			self.cancel_btn.click()
+		else:
+			pass
+		
+		# self.draw_frame(self.current_frame)
+		# self.fcanvas.canvas.draw()
+		#
+	def load_annotator_config(self):
+
+		"""
+		Load settings from config or set default values.
+		"""
+
+		if os.path.exists(self.instructions_path):
+			with open(self.instructions_path, 'r') as f:
+
+				instructions = json.load(f)
+
+				if 'rgb_mode' in instructions:
+					self.rgb_mode = instructions['rgb_mode']
+				else:
+					self.rgb_mode = False
+
+				if 'percentile_mode' in instructions:
+					self.percentile_mode = instructions['percentile_mode']
+				else:
+					self.percentile_mode = True
+
+				if 'channels' in instructions:
+					self.target_channels = instructions['channels']
+				else:
+					self.target_channels = [[self.channel_names[0], 0.01, 99.99]]
+
+				if 'fraction' in instructions:
+					self.fraction = float(instructions['fraction'])
+				else:
+					self.fraction = 0.25
+
+				if 'interval' in instructions:
+					self.anim_interval = int(instructions['interval'])
+				else:
+					self.anim_interval = 1
+
+				if 'log' in instructions:
+					self.log_option = instructions['log']
+				else:
+					self.log_option = False
+		else:
+			self.rgb_mode = False
+			self.log_option = False
+			self.percentile_mode = True
+			self.target_channels = [[self.channel_names[0], 0.01, 99.99]]
+			self.fraction = 0.25
+			self.anim_interval = 1
+
+
+	def locate_stack(self):
+
+		"""
+		Locate the target movie.
+
+		"""
+
+		movies = glob(self.pos + os.sep.join(["movie", f"{self.parent_window.parent_window.movie_prefix}*.tif"]))
+
+		if len(movies) == 0:
+			msgBox = QMessageBox()
+			msgBox.setIcon(QMessageBox.Warning)
+			msgBox.setText("No movie is detected in the experiment folder.\nPlease check the stack prefix...")
+			msgBox.setWindowTitle("Warning")
+			msgBox.setStandardButtons(QMessageBox.Ok)
+			returnValue = msgBox.exec()
+			if returnValue == QMessageBox.Ok:
+				self.proceed = False
+				self.close()
+			else:
+				self.close()
+		else:
+			self.stack_path = movies[0]
+			self.len_movie = self.parent_window.parent_window.len_movie
+			len_movie_auto = auto_load_number_of_frames(self.stack_path)
+			if len_movie_auto is not None:
+				self.len_movie = len_movie_auto
+			exp_config = self.exp_dir + "config.ini"
+			self.channel_names, self.channels = extract_experiment_channels(self.exp_dir)
+			self.channel_names = np.array(self.channel_names)
+			self.channels = np.array(self.channels)
+			self.nbr_channels = len(self.channels)
+			self.img = load_frames(0, self.stack_path, normalize_input=False)
+	def create_cell_signal_canvas(self):
+
+		self.cell_fig, self.cell_ax = plt.subplots(tight_layout=True)
+		self.cell_fcanvas = FigureCanvas(self.cell_fig, interactive=True)
+		self.cell_ax.clear()
+
+		spacing = 0.5
+		minorLocator = MultipleLocator(1)
+		self.cell_ax.xaxis.set_minor_locator(minorLocator)
+		self.cell_ax.xaxis.set_major_locator(MultipleLocator(5))
+		self.cell_ax.grid(which='major')
+		self.cell_ax.set_xlabel("time [frame]")
+		self.cell_ax.set_ylabel("signal")
+
+		self.cell_fig.set_facecolor('none')  # or 'None'
+		self.cell_fig.canvas.setStyleSheet("background-color: transparent;")
+
+
+		self.lines = [
+			self.cell_ax.plot([np.linspace(0, self.len_movie - 1, self.len_movie)], [np.zeros((self.len_movie))])[0] for
+			i in range(len(self.signal_choice_cb))]
+		for i in range(len(self.lines)):
+			self.lines[i].set_label(f'signal {i}')
+
+		min_val, max_val = self.cell_ax.get_ylim()
+		self.line_dt, = self.cell_ax.plot([-1, -1], [min_val, max_val], c="k", linestyle="--")
+
+		self.cell_ax.set_xlim(0, self.len_movie)
+		self.cell_ax.legend(fontsize=8)
+		self.cell_fcanvas.canvas.draw()
+	
+	def resizeEvent(self, event):
+		
+		super().resizeEvent(event)
+		try:
+			self.cell_fig.tight_layout()
+		except:
+			pass
+
+	def locate_tracks(self):
+
+		"""
+		Locate the tracks.
+		"""
+
+		if not os.path.exists(self.trajectories_path):
+
+			msgBox = QMessageBox()
+			msgBox.setIcon(QMessageBox.Warning)
+			msgBox.setText("The trajectories cannot be detected.")
+			msgBox.setWindowTitle("Warning")
+			msgBox.setStandardButtons(QMessageBox.Ok)
+			returnValue = msgBox.exec()
+			if returnValue == QMessageBox.Yes:
+				self.close()
+		else:
+
+			# Load and prep tracks
+			self.df_tracks = pd.read_csv(self.trajectories_path)
+			self.df_tracks = self.df_tracks.sort_values(by=['TRACK_ID', 'FRAME'])
+			self.df_tracks.replace([np.inf, -np.inf], np.nan, inplace=True)
+
+			cols = np.array(self.df_tracks.columns)
+			self.class_cols = np.array([c.startswith('class') for c in list(self.df_tracks.columns)])
+			self.class_cols = list(cols[self.class_cols])
+			try:
+				self.class_cols.remove('class_id')
+			except:
+				pass
+			try:
+				self.class_cols.remove('class_color')
+			except:
+				pass
+			if len(self.class_cols) > 0:
+				self.class_name = self.class_cols[0]
+				self.expected_status = 'status'
+				suffix = self.class_name.replace('class', '').replace('_', '')
+				if suffix != '':
+					self.expected_status += '_' + suffix
+					self.expected_time = 't_' + suffix
+				else:
+					self.expected_time = 't0'
+				self.time_name = self.expected_time
+				self.status_name = self.expected_status
+			else:
+				self.class_name = 'class'
+				self.time_name = 't0'
+				self.status_name = 'status'
+
+			if self.time_name in self.df_tracks.columns and self.class_name in self.df_tracks.columns and not self.status_name in self.df_tracks.columns:
+				# only create the status column if it does not exist to not erase static classification results
+				self.make_status_column()
+			elif self.time_name in self.df_tracks.columns and self.class_name in self.df_tracks.columns:
+				# all good, do nothing
+				pass
+			else:
+				if not self.status_name in self.df_tracks.columns:
+					self.df_tracks[self.status_name] = 0
+					self.df_tracks['status_color'] = color_from_status(0)
+					self.df_tracks['class_color'] = color_from_class(1)
+
+			if not self.class_name in self.df_tracks.columns:
+				self.df_tracks[self.class_name] = 1
+			if not self.time_name in self.df_tracks.columns:
+				self.df_tracks[self.time_name] = -1
+
+			self.df_tracks['status_color'] = [color_from_status(i) for i in self.df_tracks[self.status_name].to_numpy()]
+			self.df_tracks['class_color'] = [color_from_class(i) for i in self.df_tracks[self.class_name].to_numpy()]
+
+			self.df_tracks = self.df_tracks.dropna(subset=['POSITION_X', 'POSITION_Y'])
+			self.df_tracks['x_anim'] = self.df_tracks['POSITION_X'] * self.fraction
+			self.df_tracks['y_anim'] = self.df_tracks['POSITION_Y'] * self.fraction
+			self.df_tracks['x_anim'] = self.df_tracks['x_anim'].astype(int)
+			self.df_tracks['y_anim'] = self.df_tracks['y_anim'].astype(int)
+			
+			self.extract_scatter_from_trajectories()
+			self.track_of_interest = self.df_tracks['TRACK_ID'].min()
+
+			self.loc_t = []
+			self.loc_idx = []
+			for t in range(len(self.tracks)):
+				indices = np.where(self.tracks[t] == self.track_of_interest)[0]
+				if len(indices) > 0:
+					self.loc_t.append(t)
+					self.loc_idx.append(indices[0])
+
+			self.MinMaxScaler = MinMaxScaler()
+			self.columns_to_rescale = list(self.df_tracks.columns)
+
+			cols_to_remove = ['group', 'group_color', 'status', 'status_color', 'class_color', 'TRACK_ID', 'FRAME',
+							  'x_anim', 'y_anim', 't','dummy','group_color',
+							  'state', 'generation', 'root', 'parent', 'class_id', 'class', 't0', 'POSITION_X',
+							  'POSITION_Y', 'position', 'well', 'well_index', 'well_name', 'pos_name', 'index',
+							  'concentration', 'cell_type', 'antibody', 'pharmaceutical_agent', 'ID'] + self.class_cols
+
+			meta = get_experiment_metadata(self.exp_dir)
+			if meta is not None:
+				keys = list(meta.keys())
+				cols_to_remove.extend(keys)
+
+			labels = get_experiment_labels(self.exp_dir)
+			if labels is not None:
+				keys = list(labels.keys())
+				cols_to_remove.extend(labels)
+
+			cols = np.array(list(self.df_tracks.columns))
+			time_cols = np.array([c.startswith('t_') for c in cols])
+			time_cols = list(cols[time_cols])
+			cols_to_remove += time_cols
+			
+			status_cols = np.array([c.startswith('status_') for c in cols])
+			status_cols = list(cols[status_cols])
+			cols_to_remove += status_cols
+
+			for tr in cols_to_remove:
+				try:
+					self.columns_to_rescale.remove(tr)
+				except:
+					pass
+
+			x = self.df_tracks[self.columns_to_rescale].values
+			self.MinMaxScaler.fit(x)
+	
+	def del_event_class(self):
+
+		msgBox = QMessageBox()
+		msgBox.setIcon(QMessageBox.Warning)
+		msgBox.setText(
+			f"You are about to delete the class {self.class_choice_cb.currentText()}. The associated time and\nstatus will also be deleted. Do you still want to proceed?")
+		msgBox.setWindowTitle("Warning")
+		msgBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
+		returnValue = msgBox.exec()
+		if returnValue == QMessageBox.No:
+			return None
+		else:
+			class_to_delete = self.class_choice_cb.currentText()
+			time_to_delete = class_to_delete.replace('class', 't')
+			status_to_delete = class_to_delete.replace('class', 'status')
+			cols_to_delete = [class_to_delete, time_to_delete, status_to_delete]
+			for c in cols_to_delete:
+				try:
+					self.df_tracks = self.df_tracks.drop([c], axis=1)
+				except Exception as e:
+					print(e)
+			item_idx = self.class_choice_cb.findText(class_to_delete)
+			self.class_choice_cb.removeItem(item_idx)
+			
+	def normalize_features(self):
+
+		x = self.df_tracks[self.columns_to_rescale].values
+
+		if not self.normalized_signals:
+			x = self.MinMaxScaler.transform(x)
+			self.df_tracks[self.columns_to_rescale] = x
+			self.plot_signals()
+			self.normalized_signals = True
+			self.normalize_features_btn.setIcon(icon(MDI6.arrow_collapse_vertical, color="#1565c0"))
+			self.normalize_features_btn.setIconSize(QSize(25, 25))
+		else:
+			x = self.MinMaxScaler.inverse_transform(x)
+			self.df_tracks[self.columns_to_rescale] = x
+			self.plot_signals()
+			self.normalized_signals = False
+			self.normalize_features_btn.setIcon(icon(MDI6.arrow_collapse_vertical, color="black"))
+			self.normalize_features_btn.setIconSize(QSize(25, 25))
+
+	def switch_to_log(self):
+
+		"""
+		Better would be to create a log(quantity) and plot it...
+		"""
+
+		try:
+			if self.cell_ax.get_yscale()=='linear':
+				ymin,ymax = self.cell_ax.get_ylim()
+				self.cell_ax.set_yscale('log')
+				self.log_btn.setIcon(icon(MDI6.math_log,color="#1565c0"))
+				self.cell_ax.set_ylim(self.value_magnitude, ymax)
+				self.log_scale = True
+			else:
+				self.cell_ax.set_yscale('linear')
+				self.log_btn.setIcon(icon(MDI6.math_log,color="black"))
+				self.log_scale = False
+		except Exception as e:
+			print(e)
+
+		#self.cell_ax.autoscale()
+		self.cell_fcanvas.canvas.draw_idle()
+		
+	def start(self):
+		'''
+		Starts interactive animation. Adds the draw frame command to the GUI
+		handler, calls show to start the event loop.
+		'''
+		self.start_btn.setShortcut(QKeySequence(""))
+
+		self.last_frame_btn.setEnabled(True)
+		self.last_frame_btn.clicked.connect(self.set_last_frame)
+
+		self.first_frame_btn.setEnabled(True)
+		self.first_frame_btn.clicked.connect(self.set_first_frame)
+
+		self.start_btn.hide()
+		self.stop_btn.show()
+
+		self.anim.event_source.start()
+		self.stop_btn.clicked.connect(self.stop)
+		
+	def contrast_slider_action(self):
+
+		"""
+		Recontrast the imshow as the contrast slider is moved.
+		"""
+
+		self.vmin = self.contrast_slider.value()[0]
+		self.vmax = self.contrast_slider.value()[1]
+		self.im.set_clim(vmin=self.vmin, vmax=self.vmax)
+		self.fcanvas.canvas.draw_idle()
+		
+	def show_outliers(self):
+		if self.outliers_check.isChecked():
+			self.show_fliers = True
+			self.plot_signals()
+		else:
+			self.show_fliers = False
+			self.plot_signals()
+
+	def export_signals(self):
+
+		auto_dataset_name = self.pos.split(os.sep)[-4] + '_' + self.pos.split(os.sep)[-2] + '.npy'
+
+		if self.normalized_signals:
+			self.normalize_features_btn.click()
+
+		training_set = []
+		cols = self.df_tracks.columns
+		tracks = np.unique(self.df_tracks["TRACK_ID"].to_numpy())
+
+		for track in tracks:
+			# Add all signals at given track
+			signals = {}
+			for c in cols:
+				signals.update({c: self.df_tracks.loc[self.df_tracks["TRACK_ID"] == track, c].to_numpy()})
+			time_of_interest = self.df_tracks.loc[self.df_tracks["TRACK_ID"] == track, self.time_name].to_numpy()[0]
+			cclass = self.df_tracks.loc[self.df_tracks["TRACK_ID"] == track, self.class_name].to_numpy()[0]
+			signals.update({"time_of_interest": time_of_interest, "class": cclass})
+			# Here auto add all available channels
+			training_set.append(signals)
+
+		pathsave = QFileDialog.getSaveFileName(self, "Select file name", self.exp_dir + auto_dataset_name, ".npy")[0]
+		if pathsave != '':
+			if not pathsave.endswith(".npy"):
+				pathsave += ".npy"
+			try:
+				np.save(pathsave, training_set)
+				print(f'File successfully written in {pathsave}.')
+			except Exception as e:
+				print(f"Error {e}...")
+
+	def create_new_event_class(self):
+
+		# display qwidget to name the event
+		self.newClassWidget = CelldetectiveWidget()
+		self.newClassWidget.setWindowTitle('Create new event class')
+
+		layout = QVBoxLayout()
+		self.newClassWidget.setLayout(layout)
+		name_hbox = QHBoxLayout()
+		name_hbox.addWidget(QLabel('event name: '), 25)
+		self.class_name_le = QLineEdit('event')
+		name_hbox.addWidget(self.class_name_le, 75)
+		layout.addLayout(name_hbox)
+
+		class_labels = ['event', 'no event', 'else']
+		layout.addWidget(QLabel('prefill: '))
+		radio_box = QHBoxLayout()
+		self.class_option_rb = [QRadioButton() for i in range(3)]
+		for i, c in enumerate(self.class_option_rb):
+			if i == 0:
+				c.setChecked(True)
+			c.setText(class_labels[i])
+			radio_box.addWidget(c, 33, alignment=Qt.AlignCenter)
+		layout.addLayout(radio_box)
+
+		btn_hbox = QHBoxLayout()
+		submit_btn = QPushButton('submit')
+		cancel_btn = QPushButton('cancel')
+		btn_hbox.addWidget(cancel_btn, 50)
+		btn_hbox.addWidget(submit_btn, 50)
+		layout.addLayout(btn_hbox)
+
+		submit_btn.clicked.connect(self.write_new_event_class)
+		cancel_btn.clicked.connect(self.close_without_new_class)
+
+		self.newClassWidget.show()
+		center_window(self.newClassWidget)
+
+	def shortcut_suppr(self):
+		self.correct_btn.click()
+		self.suppr_btn.click()
+		self.correct_btn.click()
+
+	def closeEvent(self, event):
+		# result = QMessageBox.question(self,
+		# 			  "Confirm Exit...",
+		# 			  "Are you sure you want to exit ?",
+		# 			  QMessageBox.Yes| QMessageBox.No,
+		# 			  )
+		# del self.img
+		gc.collect()
+	
+	def save_trajectories(self):
+		# specific to signal/static annotator
+		print('Save trajectory function not implemented for BaseAnnotator class...')
+		
+	def cancel_selection(self):
+		print('we are in cancel selection...')
+		self.hide_annotation_buttons()
+		self.correct_btn.setEnabled(False)
+		self.correct_btn.setText('correct')
+		self.cancel_btn.setEnabled(False)
+
+		try:
+			self.selection.pop(0)
+		except Exception as e:
+			pass
+		
+		try:
+			for k, (t, idx) in enumerate(zip(self.loc_t, self.loc_idx)):
+				self.colors[t][idx, 0] = self.previous_color[k][0]
+				#self.colors[t][idx, 1] = self.previous_color[k][1]
+		except Exception as e:
+			pass
+