celldetective 1.4.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

celldetective/gui/{signal_annotator.py → event_annotator.py}

@@ -1,213 +1,126 @@
-from PyQt5.QtWidgets import QComboBox, QLabel, QRadioButton, QLineEdit, QFileDialog, QApplication, \
-	QPushButton, QVBoxLayout, QHBoxLayout, QMessageBox, QShortcut, QLineEdit, QSlider, QCheckBox
+from PyQt5.QtWidgets import QComboBox, QLabel, QRadioButton, QFileDialog, QApplication, \
+	QPushButton, QVBoxLayout, QHBoxLayout, QMessageBox, QShortcut, QLineEdit, QSlider
 from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QKeySequence, QIntValidator
 
 from celldetective.gui.gui_utils import center_window, color_from_state
 from superqt import QLabeledDoubleSlider, QLabeledDoubleRangeSlider, QSearchableComboBox
-from celldetective.utils import extract_experiment_channels, get_software_location, _get_img_num_per_channel
-from celldetective.io import auto_load_number_of_frames, load_frames, \
-	load_napari_data, get_experiment_metadata, get_experiment_labels
-from celldetective.gui.gui_utils import FigureCanvas, color_from_status, color_from_class, ExportPlotBtn
-import json
+from celldetective.utils import _get_img_num_per_channel
+from celldetective.io import load_frames, get_experiment_metadata, get_experiment_labels, locate_labels
+from celldetective.gui.gui_utils import FigureCanvas, color_from_status, color_from_class
 import numpy as np
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
 import os
-from glob import glob
 import matplotlib.pyplot as plt
-from matplotlib.ticker import MultipleLocator
 from tqdm import tqdm
 import gc
 from matplotlib.animation import FuncAnimation
 from matplotlib.cm import tab10
 import pandas as pd
 from sklearn.preprocessing import MinMaxScaler
-from celldetective.gui import Styles, CelldetectiveWidget, CelldetectiveMainWindow
+from celldetective.gui import CelldetectiveWidget
 from celldetective.measure import contour_of_instance_segmentation
 from celldetective.utils import pretty_table
+from celldetective.gui.base_annotator import BaseAnnotator
 
-class SignalAnnotator(CelldetectiveMainWindow):
+class EventAnnotator(BaseAnnotator):
 	"""
 	UI to set tracking parameters for bTrack.
 
 	"""
 
-	def __init__(self, parent_window=None):
+	def __init__(self, *args, **kwargs):
 
-		super().__init__()
-		
-		center_window(self)
-		self.proceed = True
-
-		self.parent_window = parent_window
+		super().__init__(*args, **kwargs)
 		self.setWindowTitle("Signal annotator")
-		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.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.setMinimumHeight(int(0.8*self.screen_height))
-		self.value_magnitude = 1
 
 		# default params
 		self.class_name = 'class'
 		self.time_name = 't0'
 		self.status_name = 'status'
 
-		self.locate_stack()
+		# self.locate_stack()
 		if not self.proceed:
 			self.close()
 		else:
-			self.load_annotator_config()
-			self.locate_tracks()
+			#self.load_annotator_config()
+			#self.locate_tracks()
 			self.prepare_stack()
 
-			self.generate_signal_choices()
 			self.frame_lbl = QLabel('frame: ')
 			self.looped_animation()
-			self.create_cell_signal_canvas()
-
-			self.populate_widget()
-
-	def resizeEvent(self, event):
-		
-		super().resizeEvent(event)
-
-		try:
-			self.cell_fig.tight_layout()
-		except:
-			pass
-
-	def populate_widget(self):
-
-		"""
-		Create the multibox design.
-
-		"""
-
-		self.button_widget = CelldetectiveWidget()
-		main_layout = QHBoxLayout()
-		self.button_widget.setLayout(main_layout)
-
-		main_layout.setContentsMargins(30, 30, 30, 30)
-		self.left_panel = QVBoxLayout()
-		self.left_panel.setContentsMargins(30, 5, 30, 5)
-		self.left_panel.setSpacing(3)
-
-		self.right_panel = QVBoxLayout()
-
-		class_hbox = QHBoxLayout()
-		class_hbox.setContentsMargins(0,0,0,0)
-		class_hbox.addWidget(QLabel('event: '), 25)
-		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.init_event_buttons()
+			self.populate_window()
+			
+			self.outliers_check.hide()
+			if hasattr(self, "contrast_slider"):
+				self.im.set_clim(self.contrast_slider.value()[0], self.contrast_slider.value()[1])
 
-		self.class_choice_cb.addItems(self.class_cols)
-		self.class_choice_cb.currentIndexChanged.connect(self.compute_status_and_colors)
-
-		class_hbox.addWidget(self.class_choice_cb, 70)
-
-		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)
-		class_hbox.addWidget(self.add_class_btn, 5)
-
-		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)
-		class_hbox.addWidget(self.del_class_btn, 5)
-
-		self.left_panel.addLayout(class_hbox,5)
-
-		self.cell_info = QLabel('')
-		self.left_panel.addWidget(self.cell_info,10)
-
-		# Annotation buttons
-		options_hbox = QHBoxLayout()
-		options_hbox.setContentsMargins(0, 0, 0, 0)
+	def init_event_buttons(self):
+	
 		self.event_btn = QRadioButton('event')
 		self.event_btn.setStyleSheet(self.button_style_sheet_2)
 		self.event_btn.toggled.connect(self.enable_time_of_interest)
-
+	
 		self.no_event_btn = QRadioButton('no event')
 		self.no_event_btn.setStyleSheet(self.button_style_sheet_2)
 		self.no_event_btn.toggled.connect(self.enable_time_of_interest)
-
+	
 		self.else_btn = QRadioButton('else')
 		self.else_btn.setStyleSheet(self.button_style_sheet_2)
 		self.else_btn.toggled.connect(self.enable_time_of_interest)
-
+	
 		self.suppr_btn = QRadioButton('remove')
 		self.suppr_btn.setToolTip('Mark for deletion. Upon saving, the cell\nwill be removed from the tables.')
 		self.suppr_btn.setStyleSheet(self.button_style_sheet_2)
 		self.suppr_btn.toggled.connect(self.enable_time_of_interest)
+	
+		self.time_of_interest_label = QLabel('time of interest: ')
+		self.time_of_interest_le = QLineEdit()
 
-		options_hbox.addWidget(self.event_btn, 25, alignment=Qt.AlignCenter)
-		options_hbox.addWidget(self.no_event_btn, 25, alignment=Qt.AlignCenter)
-		options_hbox.addWidget(self.else_btn, 25, alignment=Qt.AlignCenter)
-		options_hbox.addWidget(self.suppr_btn, 25, alignment=Qt.AlignCenter)
-		self.left_panel.addLayout(options_hbox,5)
+	
+	def populate_options_layout(self):
+		
+		# clear options hbox
+		for i in reversed(range(self.options_hbox.count())):
+			self.options_hbox.itemAt(i).widget().setParent(None)
+	
+		options_layout = QVBoxLayout()
+		# add new widgets
 
+		btn_hbox = QHBoxLayout()
+		btn_hbox.addWidget(self.event_btn, 25, alignment=Qt.AlignCenter)
+		btn_hbox.addWidget(self.no_event_btn, 25, alignment=Qt.AlignCenter)
+		btn_hbox.addWidget(self.else_btn, 25, alignment=Qt.AlignCenter)
+		btn_hbox.addWidget(self.suppr_btn, 25, alignment=Qt.AlignCenter)
+	
 		time_option_hbox = QHBoxLayout()
 		time_option_hbox.setContentsMargins(0, 5, 100, 10)
-		self.time_of_interest_label = QLabel('time of interest: ')
 		time_option_hbox.addWidget(self.time_of_interest_label, 10)
-		self.time_of_interest_le = QLineEdit()
 		time_option_hbox.addWidget(self.time_of_interest_le, 15)
 		time_option_hbox.addWidget(QLabel(''), 75)
-		self.left_panel.addLayout(time_option_hbox,5)
-
-		main_action_hbox = QHBoxLayout()
-		main_action_hbox.setContentsMargins(0,0,0,0)
-		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)
-		main_action_hbox.addWidget(self.correct_btn)
-
-		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)
-		main_action_hbox.addWidget(self.cancel_btn)
-		self.left_panel.addLayout(main_action_hbox,5)
-
+	
+		options_layout.addLayout(btn_hbox)
+		options_layout.addLayout(time_option_hbox)
+		
+		self.options_hbox.addLayout(options_layout)
+	
 		self.annotation_btns_to_hide = [self.event_btn, self.no_event_btn,
 										self.else_btn, self.time_of_interest_label,
 										self.time_of_interest_le, self.suppr_btn]
 		self.hide_annotation_buttons()
-		#### End of annotation buttons
+	
+	def populate_window(self):
+
+		"""
+		Create the multibox design.
 
+		"""
+		
+		super().populate_window()
+		self.populate_options_layout()
+	
 		self.del_shortcut = QShortcut(Qt.Key_Delete, self)  # QKeySequence("s")
 		self.del_shortcut.activated.connect(self.shortcut_suppr)
 		self.del_shortcut.setEnabled(False)
@@ -216,68 +129,8 @@ class SignalAnnotator(CelldetectiveMainWindow):
 		self.no_event_shortcut.activated.connect(self.shortcut_no_event)
 		self.no_event_shortcut.setEnabled(False)
 
-		# Cell signals
-
-		self.left_panel.addWidget(self.cell_fcanvas, 45)
-
-		plot_buttons_hbox = QHBoxLayout()
-		plot_buttons_hbox.setContentsMargins(0, 0, 0, 0)
-		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.setShortcut(QKeySequence('n'))
-		self.normalize_features_btn.clicked.connect(self.normalize_features)
-
-		plot_buttons_hbox.addWidget(QLabel(''), 90)
-		plot_buttons_hbox.addWidget(self.normalize_features_btn, 5)
-		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)
-		plot_buttons_hbox.addWidget(self.log_btn, 5)
-
-		self.export_plot_btn = ExportPlotBtn(self.cell_fig, export_dir = self.exp_dir)
-		plot_buttons_hbox.addWidget(self.export_plot_btn, 5)		
-
-		self.left_panel.addLayout(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)
-			# hlayout.addWidget(self.log_btns[i], 5)
-			signal_choice_vbox.addLayout(hlayout)
-
-		# self.log_btns[i].setIcon(icon(MDI6.math_log,color="black"))
-		# self.log_btns[i].setStyleSheet(self.parent.parent.parent.button_select_all)
-		# self.log_btns[i].clicked.connect(lambda ch, i=i: self.switch_to_log(i))
-
-		self.left_panel.addLayout(signal_choice_vbox,15)
-
-		btn_hbox = QHBoxLayout()
-		btn_hbox.setContentsMargins(0,10,0,0)
-		self.save_btn = QPushButton('Save')
-		self.save_btn.setStyleSheet(self.button_style_sheet)
-		self.save_btn.clicked.connect(self.save_trajectories)
-		btn_hbox.addWidget(self.save_btn, 90)
-
-		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))
-		btn_hbox.addWidget(self.export_btn, 10)
-		self.left_panel.addLayout(btn_hbox,5)
-
-		# Animation
+		# Right side
 		animation_buttons_box = QHBoxLayout()
-
 		animation_buttons_box.addWidget(self.frame_lbl, 20, alignment=Qt.AlignLeft)
 
 		self.first_frame_btn = QPushButton()
@@ -317,7 +170,6 @@ class SignalAnnotator(CelldetectiveMainWindow):
 		animation_buttons_box.addWidget(self.last_frame_btn, 5, alignment=Qt.AlignRight)
 
 		self.right_panel.addLayout(animation_buttons_box, 5)
-
 		self.right_panel.addWidget(self.fcanvas, 90)
 
 		if not self.rgb_mode:
@@ -335,99 +187,16 @@ class SignalAnnotator(CelldetectiveMainWindow):
 			contrast_hbox.addWidget(QLabel('contrast: '))
 			contrast_hbox.addWidget(self.contrast_slider, 90)
 			self.right_panel.addLayout(contrast_hbox, 5)
-
-		# speed_hbox = QHBoxLayout()
-		# speed_hbox.setContentsMargins(150,5,150,5)
-		# self.interval_slider = QLabeledSlider()
-		# self.interval_slider.setSingleStep(1)
-		# self.interval_slider.setTickInterval(1)
-		# self.interval_slider.setOrientation(Qt.Horizontal)
-		# self.interval_slider.setRange(1, 10000)
-		# self.interval_slider.setValue(self.speed)
-		# self.interval_slider.valueChanged.connect(self.interval_slider_action)
-		# speed_hbox.addWidget(QLabel('interval (ms): '))
-		# speed_hbox.addWidget(self.interval_slider,90)
-		# self.right_panel.addLayout(speed_hbox, 10)
-
-		# self.populate_left_panel()
-		# grid.addLayout(self.left_side, 0, 0, 1, 1)
-
-		main_layout.addLayout(self.left_panel, 35)
-		main_layout.addLayout(self.right_panel, 65)
-		self.button_widget.adjustSize()
-
-		self.compute_status_and_colors(0)
-
-		self.setCentralWidget(self.button_widget)
-		self.show()
+		
+		if self.class_choice_cb.currentText()!="":
+			self.compute_status_and_colors(0)
+		
+		self.no_event_shortcut = QShortcut(QKeySequence("n"), self)  # QKeySequence("s")
+		self.no_event_shortcut.activated.connect(self.shortcut_no_event)
+		self.no_event_shortcut.setEnabled(False)
 
 		QApplication.processEvents()
 
-	def del_event_class(self):
-
-		msgBox = QMessageBox()
-		msgBox.setIcon(QMessageBox.Warning)
-		msgBox.setText(
-			f"You are about to delete event 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 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)
-
-	# Prefill with class value
-	# write in table
-
 	def write_new_event_class(self):
 
 		if self.class_name_le.text() == '':
@@ -472,8 +241,8 @@ class SignalAnnotator(CelldetectiveMainWindow):
 
 		self.newClassWidget.close()
 
-	def close_without_new_class(self):
-		self.newClassWidget.close()
+	# def close_without_new_class(self):
+	# 	self.newClassWidget.close()
 
 	def compute_status_and_colors(self, i):
 
@@ -518,36 +287,14 @@ class SignalAnnotator(CelldetectiveMainWindow):
 
 		self.fcanvas.canvas.draw()
 
-
-	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 cancel_selection(self):
-
-		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:
-			print(f"L 536 {e=}")
-
+		
+		super().cancel_selection()
 		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:
-			print(f'L 543 {e=}')
+			pass
 
 	def hide_annotation_buttons(self):
 
@@ -653,169 +400,6 @@ class SignalAnnotator(CelldetectiveMainWindow):
 
 		self.selection.pop(0)
 
-	# self.fcanvas.canvas.draw()
-
-	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)
-
-	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'])
-
-			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)
-			#self.columns_to_rescale = self.df_tracks.select_dtypes(exclude=['object']).columns
-
-			# is_number = np.vectorize(lambda x: np.issubdtype(x, np.number))
-			# is_number_test = is_number(self.df_tracks.dtypes)
-			# self.columns_to_rescale = [col for t,col in zip(is_number_test,self.df_tracks.columns) if t]
-			# print(self.columns_to_rescale)
-
-			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
-			#cols_to_remove.extend(self.df_tracks.select_dtypes(include=['object']).columns)
-
-			for tr in cols_to_remove:
-				try:
-					self.columns_to_rescale.remove(tr)
-				except:
-					pass
-			# print(f'column {tr} could not be found...')
-
-			x = self.df_tracks[self.columns_to_rescale].values
-			self.MinMaxScaler.fit(x)
-
-	# self.loc_t, self.loc_idx = np.where(self.tracks==self.track_of_interest)
 
 	def make_status_column(self):
 
@@ -947,53 +531,53 @@ class SignalAnnotator(CelldetectiveMainWindow):
 				self.df_tracks.loc[self.df_tracks['FRAME'] == t, ['class_color', 'status_color']].to_numpy())
 			self.tracks.append(self.df_tracks.loc[self.df_tracks['FRAME'] == t, 'TRACK_ID'].to_numpy())
 
-	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 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 prepare_stack(self):
 
@@ -1079,76 +663,17 @@ class SignalAnnotator(CelldetectiveMainWindow):
 		self.fig.canvas.mpl_connect('pick_event', self.on_scatter_pick)
 		self.fcanvas.canvas.draw()
 
-	def create_cell_signal_canvas(self):
+	def select_single_cell(self, index, timepoint):
 
-		self.cell_fig, self.cell_ax = plt.subplots(tight_layout=True)
-		self.cell_fcanvas = FigureCanvas(self.cell_fig, interactive=True)
-		self.cell_ax.clear()
+		self.correct_btn.setEnabled(True)
+		self.cancel_btn.setEnabled(True)
+		self.del_shortcut.setEnabled(True)
+		self.no_event_shortcut.setEnabled(True)
 
-		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()
-
-		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)
-
-		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
-
-	def select_single_cell(self, index, timepoint):
-
-		self.correct_btn.setEnabled(True)
-		self.cancel_btn.setEnabled(True)
-		self.del_shortcut.setEnabled(True)
-		self.no_event_shortcut.setEnabled(True)
-
-		self.track_of_interest = self.tracks[timepoint][index]
-		print(f'You selected cell #{self.track_of_interest}...')
-		self.give_cell_information()
-		self.plot_signals()
+		self.track_of_interest = self.tracks[timepoint][index]
+		print(f'You selected cell #{self.track_of_interest}...')
+		self.give_cell_information()
+		self.plot_signals()
 
 		self.loc_t = []
 		self.loc_idx = []
@@ -1164,11 +689,6 @@ class SignalAnnotator(CelldetectiveMainWindow):
 			self.colors[t][idx] = 'lime'
 
 
-	def shortcut_suppr(self):
-		self.correct_btn.click()
-		self.suppr_btn.click()
-		self.correct_btn.click()
-
 	def shortcut_no_event(self):
 		self.correct_btn.click()
 		self.no_event_btn.click()
@@ -1237,25 +757,6 @@ class SignalAnnotator(CelldetectiveMainWindow):
 		self.anim.pause()
 		self.stop_btn.clicked.connect(self.start)
 
-	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 give_cell_information(self):
 
 		cell_selected = f"cell: {self.track_of_interest}\n"
@@ -1273,17 +774,10 @@ class SignalAnnotator(CelldetectiveMainWindow):
 		self.df_tracks = self.df_tracks.drop(self.df_tracks[self.df_tracks[self.class_name] > 2].index)
 		self.df_tracks.to_csv(self.trajectories_path, index=False)
 		print('Table successfully exported...')
-		self.compute_status_and_colors(0)
+		if self.class_choice_cb.currentText()!="":
+			self.compute_status_and_colors(0)
 		self.extract_scatter_from_trajectories()
 
-	# self.give_cell_information()
-
-	# def interval_slider_action(self):
-
-	# 	print(dir(self.anim.event_source))
-
-	# 	self.anim.event_source.interval = self.interval_slider.value()
-	# 	self.anim.event_source._timer_set_interval()
 
 	def set_last_frame(self):
 
@@ -1315,6 +809,11 @@ class SignalAnnotator(CelldetectiveMainWindow):
 
 		self.first_key = 0
 		self.anim._drawn_artists = self.draw_frame(0)
+		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.anim._drawn_artists = sorted(self.anim._drawn_artists, key=lambda x: x.get_zorder())
 		for a in self.anim._drawn_artists:
 			a.set_visible(True)
@@ -1328,92 +827,15 @@ class SignalAnnotator(CelldetectiveMainWindow):
 		self.stop_btn.clicked.connect(self.start)
 		self.start_btn.setShortcut(QKeySequence("f"))
 
-	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)
+class MeasureAnnotator(BaseAnnotator):
 
-		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 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)
-			else:
-				self.cell_ax.set_yscale('linear')
-				self.log_btn.setIcon(icon(MDI6.math_log,color="black"))
-		except Exception as e:
-			print(e)
-
-		#self.cell_ax.autoscale()
-		self.cell_fcanvas.canvas.draw_idle()
-
-class MeasureAnnotator(SignalAnnotator):
+	def __init__(self, *args, **kwargs):
+		
+		super().__init__(read_config=False, *args, **kwargs)
 
-	def __init__(self, parent_window=None):
+		self.setWindowTitle("Static annotator")
 
-		SignalAnnotator.__init__(self)
-		self.parent_window = parent_window
-		self.setWindowTitle("Signal annotator")
-		self.mode = self.parent_window.mode
-		self.pos = self.parent_window.parent_window.pos
-		self.exp_dir = self.parent_window.exp_dir
-		self.n_signals = 3
-		self.soft_path = get_software_location()
-		self.recently_modified = False
-		self.selection = []
 		self.int_validator = QIntValidator()
 		self.current_alpha=0.5
 		self.value_magnitude = 1
@@ -1421,255 +843,93 @@ class MeasureAnnotator(SignalAnnotator):
 		epsilon = 0.01
 		self.observed_min_intensity = 0
 		self.observed_max_intensity = 0 + epsilon
-
-
-		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.current_frame = 0
 		self.show_fliers = False
 		self.status_name = 'group'
 
-		center_window(self)
-
-		self.locate_stack()
-
-		data, properties, graph, labels, _ = load_napari_data(self.pos, prefix=None, population=self.mode,return_stack=False)
-		# if data is not None:
-		# 	self.labels = relabel_segmentation(labels,data,properties)
-		# else:
-		self.labels = labels
-
-		self.current_channel = 0
-
-		self.locate_tracks()
-
-		self.generate_signal_choices()
-		self.frame_lbl = QLabel('position: ')
-		self.static_image()
-		self.create_cell_signal_canvas()
-
-		self.populate_widget()
-		self.changed_class()
-
-		self.setMinimumWidth(int(0.8 * self.screen_width))
-		# self.setMaximumHeight(int(0.8*self.screen_height))
-		self.setMinimumHeight(int(0.8 * self.screen_height))
-		# self.setMaximumHeight(int(0.8*self.screen_height))
-
-		self.setAttribute(Qt.WA_DeleteOnClose)
-		self.previous_index = None
-
+		if self.proceed:
+			
+			self.labels = locate_labels(self.pos, population=self.mode)
+	
+			self.current_channel = 0
+			self.frame_lbl = QLabel('position: ')
+			self.static_image()
+	
+			self.populate_window()
+			self.changed_class()
+	
+			self.previous_index = None
+			if hasattr(self, "contrast_slider"):
+				self.im.set_clim(self.contrast_slider.value()[0], self.contrast_slider.value()[1])
 
-	def static_image(self):
+		else:
+			self.close()
+	
+	def locate_tracks(self):
 
 		"""
-		Load an image.
-
+		Locate the tracks.
 		"""
 
-		self.framedata = 0
-		self.current_label=self.labels[self.current_frame]
-		self.fig, self.ax = plt.subplots(tight_layout=True)
-		self.fcanvas = FigureCanvas(self.fig, interactive=True)
-		self.ax.clear()
-		# print(self.current_stack.shape)
-		self.im = self.ax.imshow(self.img, cmap='gray')
-		self.status_scatter = self.ax.scatter(self.positions[0][:, 0], self.positions[0][:, 1], marker="o",
-											  facecolors='none', edgecolors=self.colors[0][:, 0], s=200, picker=True)
-		self.im_mask = self.ax.imshow(np.ma.masked_where(self.current_label == 0, self.current_label),
-											  cmap='viridis', interpolation='none',alpha=self.current_alpha,vmin=0,vmax=np.nanmax(self.labels.flatten()))
-		self.ax.set_xticks([])
-		self.ax.set_yticks([])
-		self.ax.set_aspect('equal')
-
-		self.fig.set_facecolor('none')  # or 'None'
-		self.fig.canvas.setStyleSheet("background-color: black;")
-
-		self.fig.canvas.mpl_connect('pick_event', self.on_scatter_pick)
-		self.fcanvas.canvas.draw()
-
-	def create_cell_signal_canvas(self):
-
-		self.cell_fig, self.cell_ax = plt.subplots()
-		self.cell_fcanvas = FigureCanvas(self.cell_fig, interactive=False)
-		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_fcanvas.canvas.draw()
-
-		self.plot_signals()
-
-	def plot_signals(self):
-		
-		#try:
-		current_frame = self.current_frame  # Assuming you have a variable for the current frame
-		
-		yvalues = []
-		all_yvalues = []
-		current_yvalues = []
-		all_median_values = []
-		labels = []
-		range_values = []
-
-		for i in range(len(self.signal_choice_cb)):
-
-			signal_choice = self.signal_choice_cb[i].currentText()
-
-			if signal_choice != "--":
-				if 'TRACK_ID' in self.df_tracks.columns:
-					ydata = self.df_tracks.loc[
-						(self.df_tracks['TRACK_ID'] == self.track_of_interest) &
-						(self.df_tracks['FRAME'] == current_frame), signal_choice].to_numpy()
-				else:
-					ydata = self.df_tracks.loc[
-						(self.df_tracks['ID'] == self.track_of_interest), signal_choice].to_numpy()
-				all_ydata = self.df_tracks.loc[:, signal_choice].to_numpy()
-				ydataNaN = ydata
-				ydata = ydata[ydata == ydata]  # remove nan
-
-				current_ydata = self.df_tracks.loc[
-					(self.df_tracks['FRAME'] == current_frame), signal_choice].to_numpy()
-				current_ydata = current_ydata[current_ydata == current_ydata]
-				all_ydata = all_ydata[all_ydata == all_ydata]
-				yvalues.extend(ydataNaN)
-				current_yvalues.append(current_ydata)
-				all_yvalues.append(all_ydata)
-				range_values.extend(all_ydata)
-				labels.append(signal_choice)
-
-		self.cell_ax.clear()
-
-		if len(yvalues) > 0:
-			try:
-				self.cell_ax.boxplot(all_yvalues, showfliers=self.show_fliers)
-			except Exception as e:
-				print(f"{e=}")
-			ylim = self.cell_ax.get_ylim()
-			self.cell_ax.set_ylim(ylim)
-			x_pos = np.arange(len(all_yvalues)) + 1
-
-			for index, feature in enumerate(current_yvalues):
-				x_values_strip = (index + 1) + np.random.normal(0, 0.04, size=len(
-					feature))
-				self.cell_ax.plot(x_values_strip, feature, marker='o', linestyle='None', color=tab10.colors[0],
-								  alpha=0.1)
-			
-			self.cell_ax.plot(x_pos, yvalues, marker='H', linestyle='None', color=tab10.colors[3], alpha=1)
-
-			range_values = np.array(range_values)
-			if len(range_values[range_values==range_values])>0:
-
-				if len(range_values[range_values>0])>0:
-					self.value_magnitude = np.nanmin(range_values[range_values>0]) - 0.03*(np.nanmax(range_values[range_values>0]) - np.nanmin(range_values[range_values>0]))
-				else:
-					self.value_magnitude = 1
-
-				self.non_log_ymin = np.nanmin(range_values) - 0.03*(np.nanmax(range_values) - np.nanmin(range_values))
-				self.non_log_ymax = np.nanmax(range_values) + 0.03*(np.nanmax(range_values) - np.nanmin(range_values))
-				if self.cell_ax.get_yscale()=='linear':
-					self.cell_ax.set_ylim(self.non_log_ymin, self.non_log_ymax)
-				else:
-					self.cell_ax.set_ylim(self.value_magnitude, self.non_log_ymax)
+		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:
-			self.cell_ax.text(0.5, 0.5, "No data available", horizontalalignment='center',
-							  verticalalignment='center', transform=self.cell_ax.transAxes)
 
-		self.cell_fcanvas.canvas.draw()
+			# Load and prep tracks
+			self.df_tracks = pd.read_csv(self.trajectories_path)
+			if 'TRACK_ID' in self.df_tracks.columns:
+				self.df_tracks = self.df_tracks.sort_values(by=['TRACK_ID', 'FRAME'])
+			else:
+				self.df_tracks = self.df_tracks.sort_values(by=['ID', 'FRAME'])
 
-		# except Exception as e:
-		# 	print("plot_signals: ",f"{e=}")
+			cols = np.array(self.df_tracks.columns)
+			self.class_cols = np.array([c.startswith('group') or c.startswith('class') for c in list(self.df_tracks.columns)])
+			self.class_cols = list(cols[self.class_cols])
 
-	def configure_ylims(self):
+			to_remove = ['class_id','group_color','class_color']
+			for col in to_remove:
+				try:
+					self.class_cols.remove(col)
+				except:
+					pass
+			
+			if len(self.class_cols) > 0:
+				self.status_name = self.class_cols[0]
+			else:
+				self.status_name = 'group'
 
-		try:
-			min_values = []
-			max_values = []
-			for i in range(len(self.signal_choice_cb)):
-				signal = self.signal_choice_cb[i].currentText()
-				if signal == '--':
-					continue
-				else:
-					maxx = np.max(self.df_tracks.loc[:, signal].to_numpy().flatten())
-					minn = np.min(self.df_tracks.loc[:, signal].to_numpy().flatten())
-					min_values.append(minn)
-					max_values.append(maxx)
+			if self.status_name not 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()
+			else:
+				# all good, do nothing
+				pass
 
-			if len(min_values) > 0:
-				self.cell_ax.set_ylim(np.amin(min_values), np.amax(max_values))
-		except Exception as e:
-			print(e)
+			all_states = self.df_tracks.loc[:, self.status_name].tolist()
+			all_states = np.array(all_states)
+			self.state_color_map = color_from_state(all_states, recently_modified=False)
+			self.df_tracks['group_color'] = self.df_tracks[self.status_name].apply(self.assign_color_state)
 
-	def plot_red_points(self, ax):
-		yvalues = []
-		current_frame = self.current_frame
-		for i in range(len(self.signal_choice_cb)):
-			signal_choice = self.signal_choice_cb[i].currentText()
-			if signal_choice != "--":
-				#print(f'plot signal {signal_choice} for cell {self.track_of_interest} at frame {current_frame}')
-				if 'TRACK_ID' in self.df_tracks.columns:
-					ydata = self.df_tracks.loc[
-						(self.df_tracks['TRACK_ID'] == self.track_of_interest) &
-						(self.df_tracks['FRAME'] == current_frame), signal_choice].to_numpy()
-				else:
-					ydata = self.df_tracks.loc[
-						(self.df_tracks['ID'] == self.track_of_interest) &
-						(self.df_tracks['FRAME'] == current_frame), signal_choice].to_numpy()
-				ydata = ydata[ydata == ydata]  # remove nan
-				yvalues.extend(ydata)
-		x_pos = np.arange(len(yvalues)) + 1
-		ax.plot(x_pos, yvalues, marker='H', linestyle='None', color=tab10.colors[3],
-				alpha=1)  # Plot red points representing cells
-		self.cell_fcanvas.canvas.draw()
+			self.df_tracks = self.df_tracks.dropna(subset=['POSITION_X', 'POSITION_Y'])
+			self.df_tracks['x_anim'] = self.df_tracks['POSITION_X']
+			self.df_tracks['y_anim'] = self.df_tracks['POSITION_Y']
+			self.df_tracks['x_anim'] = self.df_tracks['x_anim'].astype(int)
+			self.df_tracks['y_anim'] = self.df_tracks['y_anim'].astype(int)
 
-	def on_scatter_pick(self, event):
-		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):
-			ind = ind[0]
-			self.selection.append(ind)
-			self.correct_btn.setEnabled(True)
-			self.cancel_btn.setEnabled(True)
-			self.del_shortcut.setEnabled(True)
-			self.no_event_shortcut.setEnabled(True)
-			self.track_of_interest = self.tracks[self.framedata][ind]
-			print(f'You selected cell #{self.track_of_interest}...')
-			self.give_cell_information()
-			if len(self.cell_ax.lines) > 0:
-				self.cell_ax.lines[-1].remove()  # Remove the last line (red points) from the plot
-				self.plot_red_points(self.cell_ax)
+			self.extract_scatter_from_trajectories()
+			if 'TRACK_ID' in self.df_tracks.columns:
+				self.track_of_interest = self.df_tracks.dropna(subset='TRACK_ID')['TRACK_ID'].min()
 			else:
-				self.plot_signals()
+				self.track_of_interest = self.df_tracks.dropna(subset='ID')['ID'].min()
 
 			self.loc_t = []
 			self.loc_idx = []
@@ -1679,49 +939,80 @@ class MeasureAnnotator(SignalAnnotator):
 					self.loc_t.append(t)
 					self.loc_idx.append(indices[0])
 
-			self.previous_color = []
-			for t, idx in zip(self.loc_t, self.loc_idx):
-				self.previous_color.append(self.colors[t][idx].copy())
-				self.colors[t][idx] = 'lime'
-
-		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 populate_widget(self):
-
-		"""
-		Create the multibox design.
-
-		"""
+			self.MinMaxScaler = MinMaxScaler()
+			self.columns_to_rescale = list(self.df_tracks.columns)
 
-		self.button_widget = CelldetectiveWidget()
-		main_layout = QHBoxLayout()
-		self.button_widget.setLayout(main_layout)
+			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
 
-		main_layout.setContentsMargins(30, 30, 30, 30)
+			meta = get_experiment_metadata(self.exp_dir)
+			if meta is not None:
+				keys = list(meta.keys())
+				cols_to_remove.extend(keys)
 
-		self.left_panel = QVBoxLayout()
-		self.left_panel.setContentsMargins(30, 5, 30, 5)
-		#self.left_panel.setSpacing(3)
+			labels = get_experiment_labels(self.exp_dir)
+			if labels is not None:
+				keys = list(labels.keys())
+				cols_to_remove.extend(labels)
 
-		self.right_panel = QVBoxLayout()
+			for tr in cols_to_remove:
+				try:
+					self.columns_to_rescale.remove(tr)
+				except:
+					pass
 
-		class_hbox = QHBoxLayout()
-		class_hbox.setContentsMargins(0,0,0,0)
-		class_hbox.setSpacing(0)
+			x = self.df_tracks[self.columns_to_rescale].values
+			self.MinMaxScaler.fit(x)
 
-		class_hbox.addWidget(QLabel('characteristic \n group: '), 25)
-		self.class_choice_cb = QComboBox()
+	
+	def populate_options_layout(self):
+		# clear options hbox
+		for i in reversed(range(self.options_hbox.count())):
+			self.options_hbox.itemAt(i).widget().setParent(None)
+		
+		time_option_hbox = QHBoxLayout()
+		time_option_hbox.setContentsMargins(100, 0, 100, 0)
+		time_option_hbox.setSpacing(0)
 
+		self.time_of_interest_label = QLabel('phenotype: ')
+		time_option_hbox.addWidget(self.time_of_interest_label, 30)
+		
+		self.time_of_interest_le = QLineEdit()
+		self.time_of_interest_le.setValidator(self.int_validator)
+		time_option_hbox.addWidget(self.time_of_interest_le)
+		
+		self.suppr_btn = QPushButton('')
+		self.suppr_btn.setStyleSheet(self.button_select_all)
+		self.suppr_btn.setIcon(icon(MDI6.delete, color="black"))
+		self.suppr_btn.setToolTip("Delete cell")
+		self.suppr_btn.setIconSize(QSize(20, 20))
+		self.suppr_btn.clicked.connect(self.del_cell)
+		time_option_hbox.addWidget(self.suppr_btn)
+		
+		self.options_hbox.addLayout(time_option_hbox)
+		
+	def update_widgets(self):
+		
+		self.class_label.setText('characteristic \n group: ')
+		self.update_class_cb()
+		self.add_class_btn.setToolTip("Add a new characteristic group")
+		self.del_class_btn.setToolTip("Delete a characteristic group")
+		
+		self.export_btn.disconnect()
+		self.export_btn.clicked.connect(self.export_measurements)
+		
+	def update_class_cb(self):
+		
+		self.class_choice_cb.disconnect()
+		self.class_choice_cb.clear()
 		cols = np.array(self.df_tracks.columns)
 		self.class_cols = np.array([c.startswith('group') or c.startswith('status') for c in list(self.df_tracks.columns)])
 		self.class_cols = list(cols[self.class_cols])
 
-		to_remove = ['group_id','group_color','class_id','class_color']
+		to_remove = ['group_id', 'group_color', 'class_id', 'class_color', 'status_color']
 		for col in to_remove:
 			try:
 				self.class_cols.remove(col)
@@ -1730,143 +1021,21 @@ class MeasureAnnotator(SignalAnnotator):
 
 		self.class_choice_cb.addItems(self.class_cols)
 		self.class_choice_cb.currentIndexChanged.connect(self.changed_class)
-		class_hbox.addWidget(self.class_choice_cb, 70)
-
-		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 characteristic group")
-		self.add_class_btn.setIconSize(QSize(20, 20))
-		self.add_class_btn.clicked.connect(self.create_new_event_class)
-		class_hbox.addWidget(self.add_class_btn, 5)
-
-		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 a characteristic group")
-		self.del_class_btn.setIconSize(QSize(20, 20))
-		self.del_class_btn.clicked.connect(self.del_event_class)
-		class_hbox.addWidget(self.del_class_btn, 5)
-
-		self.left_panel.addLayout(class_hbox,5)
-
-		self.cell_info = QLabel('')
-		self.left_panel.addWidget(self.cell_info,5)
-
-		time_option_hbox = QHBoxLayout()
-		time_option_hbox.setContentsMargins(100, 0, 100, 0)
-		time_option_hbox.setSpacing(0)
-
-		self.time_of_interest_label = QLabel('phenotype: ')
-		time_option_hbox.addWidget(self.time_of_interest_label, 30)
-		self.time_of_interest_le = QLineEdit()
-		self.time_of_interest_le.setValidator(self.int_validator)
-		time_option_hbox.addWidget(self.time_of_interest_le)
-		self.del_cell_btn = QPushButton('')
-		self.del_cell_btn.setStyleSheet(self.button_select_all)
-		self.del_cell_btn.setIcon(icon(MDI6.delete, color="black"))
-		self.del_cell_btn.setToolTip("Delete cell")
-		self.del_cell_btn.setIconSize(QSize(20, 20))
-		self.del_cell_btn.clicked.connect(self.del_cell)
-		time_option_hbox.addWidget(self.del_cell_btn)
-		self.left_panel.addLayout(time_option_hbox,5)
-
-		main_action_hbox = QHBoxLayout()
-		main_action_hbox.setContentsMargins(0,0,0,0)
-		main_action_hbox.setSpacing(0)
-
-		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)
-		main_action_hbox.addWidget(self.correct_btn)
-
-		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)
-		main_action_hbox.addWidget(self.cancel_btn)
-		self.left_panel.addLayout(main_action_hbox,5)
 
+	def populate_window(self):
+		
+		super().populate_window()
+		# Left panel updates
+		self.populate_options_layout()
+		self.update_widgets()
+		
 		self.annotation_btns_to_hide = [self.time_of_interest_label,
 										self.time_of_interest_le,
-										self.del_cell_btn]
+										self.suppr_btn]
 		self.hide_annotation_buttons()
-		#### End of annotation buttons
-
-		self.del_shortcut = QShortcut(Qt.Key_Delete, self)  # QKeySequence("s")
-		self.del_shortcut.activated.connect(self.shortcut_suppr)
-		self.del_shortcut.setEnabled(False)
-
-		self.no_event_shortcut = QShortcut(QKeySequence("n"), self)  # QKeySequence("s")
-		self.no_event_shortcut.activated.connect(self.shortcut_no_event)
-		self.no_event_shortcut.setEnabled(False)
-
-		# Cell signals
-		self.cell_fcanvas.setMinimumHeight(int(0.2*self.screen_height))
-		self.left_panel.addWidget(self.cell_fcanvas,90)
-
-		plot_buttons_hbox = QHBoxLayout()
-		plot_buttons_hbox.setContentsMargins(0, 0, 0, 0)
-		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.setShortcut(QKeySequence('n'))
-		self.normalize_features_btn.clicked.connect(self.normalize_features)
-
-		plot_buttons_hbox.addWidget(QLabel(''), 90)
-		plot_buttons_hbox.addWidget(self.outliers_check)
-		plot_buttons_hbox.addWidget(self.normalize_features_btn, 5)
-		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)
-		plot_buttons_hbox.addWidget(self.log_btn, 5)
-
-		self.left_panel.addLayout(plot_buttons_hbox,5)
-
-		signal_choice_vbox = QVBoxLayout()
-		signal_choice_vbox.setContentsMargins(30, 0, 30, 50)
-		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)
-			# hlayout.addWidget(self.log_btns[i], 5)
-			signal_choice_vbox.addLayout(hlayout)
-
-		# self.log_btns[i].setIcon(icon(MDI6.math_log,color="black"))
-		# self.log_btns[i].setStyleSheet(self.parent.parent.parent.button_select_all)
-		# self.log_btns[i].clicked.connect(lambda ch, i=i: self.switch_to_log(i))
-
-		self.left_panel.addLayout(signal_choice_vbox,10)
-
-		btn_hbox = QHBoxLayout()
-		self.save_btn = QPushButton('Save')
-		self.save_btn.setStyleSheet(self.button_style_sheet)
-		self.save_btn.clicked.connect(self.save_trajectories)
-		btn_hbox.addWidget(self.save_btn, 90)
-
-		self.export_btn = QPushButton('')
-		self.export_btn.setStyleSheet(self.button_select_all)
-		self.export_btn.clicked.connect(self.export_measurements)
-		self.export_btn.setIcon(icon(MDI6.export, color="black"))
-		self.export_btn.setIconSize(QSize(25, 25))
-		btn_hbox.addWidget(self.export_btn, 10)
-		self.left_panel.addLayout(btn_hbox,5)
-
-		# Animation
+		
+		# Right panel
 		animation_buttons_box = QHBoxLayout()
-
 		animation_buttons_box.addWidget(self.frame_lbl, 20, alignment=Qt.AlignLeft)
 
 		self.first_frame_btn = QPushButton()
@@ -1942,25 +1111,180 @@ class MeasureAnnotator(SignalAnnotator):
 		self.choose_channel.currentIndexChanged.connect(self.changed_channel)
 		channel_hbox.addWidget(self.choose_channel)
 		self.right_panel.addLayout(channel_hbox, 5)
+	
+		self.draw_frame(0)
+		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()
+		self.plot_signals()
+	
+	def static_image(self):
 
-		main_layout.addLayout(self.left_panel, 35)
-		main_layout.addLayout(self.right_panel, 65)
-		self.button_widget.adjustSize()
+		"""
+		Load an image.
 
-		self.setCentralWidget(self.button_widget)
-		self.show()
+		"""
 
-		QApplication.processEvents()
+		self.framedata = 0
+		self.current_label=self.labels[self.current_frame]
+		self.fig, self.ax = plt.subplots(tight_layout=True)
+		self.fcanvas = FigureCanvas(self.fig, interactive=True)
+		self.ax.clear()
+		# print(self.current_stack.shape)
+		self.im = self.ax.imshow(self.img, cmap='gray')
+		self.status_scatter = self.ax.scatter(self.positions[0][:, 0], self.positions[0][:, 1], marker="o",
+											  facecolors='none', edgecolors=self.colors[0][:, 0], s=200, picker=True)
+		self.im_mask = self.ax.imshow(np.ma.masked_where(self.current_label == 0, self.current_label),
+											  cmap='viridis', interpolation='none',alpha=self.current_alpha,vmin=0,vmax=np.nanmax(self.labels.flatten()))
+		self.ax.set_xticks([])
+		self.ax.set_yticks([])
+		self.ax.set_aspect('equal')
+
+		self.fig.set_facecolor('none')  # or 'None'
+		self.fig.canvas.setStyleSheet("background-color: black;")
+
+		self.fig.canvas.mpl_connect('pick_event', self.on_scatter_pick)
+		self.fcanvas.canvas.draw()
+
+		
+	def plot_signals(self):
+
+		#try:
+		current_frame = self.current_frame  # Assuming you have a variable for the current frame
+
+		yvalues = []
+		all_yvalues = []
+		current_yvalues = []
+		labels = []
+		range_values = []
+
+		for i in range(len(self.signal_choice_cb)):
+
+			signal_choice = self.signal_choice_cb[i].currentText()
+
+			if signal_choice != "--":
+				if 'TRACK_ID' in self.df_tracks.columns:
+					ydata = self.df_tracks.loc[
+						(self.df_tracks['TRACK_ID'] == self.track_of_interest) &
+						(self.df_tracks['FRAME'] == current_frame), signal_choice].to_numpy()
+				else:
+					ydata = self.df_tracks.loc[
+						(self.df_tracks['ID'] == self.track_of_interest), signal_choice].to_numpy()
+				all_ydata = self.df_tracks.loc[:, signal_choice].to_numpy()
+				ydataNaN = ydata
+				ydata = ydata[ydata == ydata]  # remove nan
+
+				current_ydata = self.df_tracks.loc[
+					(self.df_tracks['FRAME'] == current_frame), signal_choice].to_numpy()
+				current_ydata = current_ydata[current_ydata == current_ydata]
+				all_ydata = all_ydata[all_ydata == all_ydata]
+				yvalues.extend(ydataNaN)
+				current_yvalues.append(current_ydata)
+				all_yvalues.append(all_ydata)
+				range_values.extend(all_ydata)
+				labels.append(signal_choice)
+
+		self.cell_ax.clear()
+		if self.log_scale:
+			self.cell_ax.set_yscale('log')
+		else:
+			self.cell_ax.set_yscale('linear')
+
+		if len(yvalues) > 0:
+			try:
+				self.cell_ax.boxplot(all_yvalues, showfliers=self.show_fliers)
+			except Exception as e:
+				print(f"{e=}")
+			
+			x_pos = np.arange(len(all_yvalues)) + 1
+			for index, feature in enumerate(current_yvalues):
+				x_values_strip = (index + 1) + np.random.normal(0, 0.04, size=len(
+					feature))
+				self.cell_ax.plot(x_values_strip, feature, marker='o', linestyle='None', color=tab10.colors[0],
+								  alpha=0.1)
+			self.cell_ax.plot(x_pos, yvalues, marker='H', linestyle='None', color=tab10.colors[3], alpha=1)
+			range_values = np.array(range_values)
+			range_values = range_values[range_values==range_values]
+			
+			if len(range_values[range_values > 0]) > 0:
+				self.value_magnitude = np.nanmin(range_values[range_values > 0]) - 0.03 * (
+							np.nanmax(range_values[range_values > 0]) - np.nanmin(range_values[range_values > 0]))
+			else:
+				self.value_magnitude = 1
+			
+			self.non_log_ymin = np.nanmin(range_values) - 0.03 * (np.nanmax(range_values) - np.nanmin(range_values))
+			self.non_log_ymax = np.nanmax(range_values) + 0.03 * (np.nanmax(range_values) - np.nanmin(range_values))
+			if self.cell_ax.get_yscale() == 'linear':
+				self.cell_ax.set_ylim(self.non_log_ymin, self.non_log_ymax)
+			else:
+				self.cell_ax.set_ylim(self.value_magnitude, self.non_log_ymax)
+		else:
+			self.cell_ax.text(0.5, 0.5, "No data available", horizontalalignment='center',
+							  verticalalignment='center', transform=self.cell_ax.transAxes)
+
+		self.cell_fcanvas.canvas.draw()
+
+	def plot_red_points(self, ax):
+		yvalues = []
+		current_frame = self.current_frame
+		for i in range(len(self.signal_choice_cb)):
+			signal_choice = self.signal_choice_cb[i].currentText()
+			if signal_choice != "--":
+				#print(f'plot signal {signal_choice} for cell {self.track_of_interest} at frame {current_frame}')
+				if 'TRACK_ID' in self.df_tracks.columns:
+					ydata = self.df_tracks.loc[
+						(self.df_tracks['TRACK_ID'] == self.track_of_interest) &
+						(self.df_tracks['FRAME'] == current_frame), signal_choice].to_numpy()
+				else:
+					ydata = self.df_tracks.loc[
+						(self.df_tracks['ID'] == self.track_of_interest) &
+						(self.df_tracks['FRAME'] == current_frame), signal_choice].to_numpy()
+				ydata = ydata[ydata == ydata]  # remove nan
+				yvalues.extend(ydata)
+		x_pos = np.arange(len(yvalues)) + 1
+		ax.plot(x_pos, yvalues, marker='H', linestyle='None', color=tab10.colors[3],
+				alpha=1)  # Plot red points representing cells
+		self.cell_fcanvas.canvas.draw()
 
-	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 select_single_cell(self, index, timepoint):
+		
+		self.correct_btn.setEnabled(True)
+		self.cancel_btn.setEnabled(True)
+		self.del_shortcut.setEnabled(True)
+	
+		self.track_of_interest = self.tracks[timepoint][index]
+		print(f'You selected cell #{self.track_of_interest}...')
+		self.give_cell_information()
+	
+		if len(self.cell_ax.lines) > 0:
+			self.cell_ax.lines[-1].remove()  # Remove the last line (red points) from the plot
+			self.plot_red_points(self.cell_ax)
+		else:
+			self.plot_signals()
+		
+		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.previous_color = []
+		for t, idx in zip(self.loc_t, self.loc_idx):
+			self.previous_color.append(self.colors[t][idx].copy())
+			self.colors[t][idx] = 'lime'
+	
+		self.draw_frame(self.current_frame)
+		self.fcanvas.canvas.draw()
 
+	def cancel_selection(self):
+		super().cancel_selection()
+		self.event = None
+		self.draw_frame(self.current_frame)
+		self.fcanvas.canvas.draw()
 
 	def export_measurements(self):
 
@@ -1984,7 +1308,7 @@ class MeasureAnnotator(SignalAnnotator):
 				print(f"Error {e}...")
 
 	def set_next_frame(self):
-		
+
 		self.current_frame = self.current_frame + 1
 		if self.current_frame > self.len_movie - 1:
 			self.current_frame == self.len_movie - 1
@@ -1993,7 +1317,7 @@ class MeasureAnnotator(SignalAnnotator):
 		self.start_btn.setShortcut(QKeySequence("f"))
 
 	def set_previous_frame(self):
-		
+
 		self.current_frame = self.current_frame - 1
 		if self.current_frame < 0:
 			self.current_frame == 0
@@ -2021,15 +1345,11 @@ class MeasureAnnotator(SignalAnnotator):
 				return None
 			else:
 				pass
+
 		self.df_tracks.loc[:, self.target_class] = 0
-		self.class_choice_cb.clear()
-		cols = np.array(self.df_tracks.columns)
-		self.class_cols = np.array([c.startswith('group') for c in list(self.df_tracks.columns)])
-		
-		self.class_cols = list(cols[self.class_cols])
-		self.class_cols.remove('group_color')
 
-		self.class_choice_cb.addItems(self.class_cols)
+		self.update_class_cb()
+
 		idx = self.class_choice_cb.findText(self.target_class)
 		self.status_name = self.target_class
 		self.class_choice_cb.setCurrentIndex(idx)
@@ -2123,7 +1443,6 @@ class MeasureAnnotator(SignalAnnotator):
 		self.state_color_map = color_from_state(all_states, recently_modified=False)
 
 		self.df_tracks['group_color'] = self.df_tracks[self.status_name].apply(self.assign_color_state)
-
 		self.extract_scatter_from_trajectories()
 		self.give_cell_information()
 
@@ -2135,16 +1454,17 @@ class MeasureAnnotator(SignalAnnotator):
 		self.correct_btn.setText('correct')
 		self.cancel_btn.setEnabled(False)
 		self.del_shortcut.setEnabled(False)
-		self.no_event_shortcut.setEnabled(False)
+
 		if len(self.selection) > 0:
 			self.selection.pop(0)
+		
 		self.draw_frame(self.current_frame)
 		self.fcanvas.canvas.draw()
 
 	def assign_color_state(self, state):
 
 		if np.isnan(state):
-		 	state = "nan"
+			state = "nan"
 		return self.state_color_map[state]
 
 	def draw_frame(self, framedata):
@@ -2171,9 +1491,11 @@ class MeasureAnnotator(SignalAnnotator):
 		return (self.im, self.status_scatter,self.im_mask,)
 
 	def compute_status_and_colors(self):
+
+		self.cancel_selection()
 		
 		if self.class_choice_cb.currentText() == '':
-			self.status_name=self.target_class
+			pass
 		else:
 			self.status_name = self.class_choice_cb.currentText()
 
@@ -2189,27 +1511,6 @@ class MeasureAnnotator(SignalAnnotator):
 			pretty_table(self.state_color_map)
 			self.df_tracks['group_color'] = self.df_tracks[self.status_name].apply(self.assign_color_state)
 
-	def del_event_class(self):
-
-		msgBox = QMessageBox()
-		msgBox.setIcon(QMessageBox.Warning)
-		msgBox.setText(
-			f"You are about to delete characteristic group {self.class_choice_cb.currentText()}. 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()
-			cols_to_delete = [class_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 make_status_column(self):
 		if self.status_name == "state_firstdetection":
@@ -2221,133 +1522,6 @@ class MeasureAnnotator(SignalAnnotator):
 			self.state_color_map = color_from_state(all_states, recently_modified=False)
 			self.df_tracks['group_color'] = self.df_tracks[self.status_name].apply(self.assign_color_state)
 
-	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)
-			if 'TRACK_ID' in self.df_tracks.columns:
-				self.df_tracks = self.df_tracks.sort_values(by=['TRACK_ID', 'FRAME'])
-			else:
-				self.df_tracks = self.df_tracks.sort_values(by=['ID', 'FRAME'])
-
-			cols = np.array(self.df_tracks.columns)
-			self.class_cols = np.array([c.startswith('group') or c.startswith('class') for c in list(self.df_tracks.columns)])
-			self.class_cols = list(cols[self.class_cols])
-
-			to_remove = ['class_id','group_color','class_color']
-			for col in to_remove:
-				try:
-					self.class_cols.remove(col)
-				except:
-					pass
-			# try:
-			# 	self.class_cols.remove('class_id')
-			# except:
-			# 	pass
-			# try:
-			# 	self.class_cols.remove('group_color')
-			# except:
-			# 	pass
-			if len(self.class_cols) > 0:
-				self.status = self.class_cols[0]
-
-			else:
-
-				self.status_name = 'group'
-
-			if self.status_name not 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()
-			else:
-				# 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['state_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
-			all_states = self.df_tracks.loc[:, self.status_name].tolist()
-			all_states = np.array(all_states)
-			self.state_color_map = color_from_state(all_states, recently_modified=False)
-			self.df_tracks['group_color'] = self.df_tracks[self.status_name].apply(self.assign_color_state)
-			# 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.df_tracks['y_anim'] = self.df_tracks['POSITION_Y']
-			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()
-			if 'TRACK_ID' in self.df_tracks.columns:
-				self.track_of_interest = self.df_tracks.dropna(subset='TRACK_ID')['TRACK_ID'].min()
-			else:
-				self.track_of_interest = self.df_tracks.dropna(subset='ID')['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)
-
-			# is_number = np.vectorize(lambda x: np.issubdtype(x, np.number))
-			# is_number_test = is_number(self.df_tracks.dtypes)
-			# self.columns_to_rescale = [col for t,col in zip(is_number_test,self.df_tracks.columns) if t]
-			# print(self.columns_to_rescale)
-
-			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)
-
-			for tr in cols_to_remove:
-				try:
-					self.columns_to_rescale.remove(tr)
-				except:
-					pass
-
-			# print(f'column {tr} could not be found...')
-
-			x = self.df_tracks[self.columns_to_rescale].values
-			self.MinMaxScaler.fit(x)
 
 	def extract_scatter_from_trajectories(self):
 
@@ -2366,10 +1540,11 @@ class MeasureAnnotator(SignalAnnotator):
 
 	def changed_class(self):
 		self.status_name = self.class_choice_cb.currentText()
-		self.compute_status_and_colors()
-		self.modify()
-		self.draw_frame(self.current_frame)
-		self.fcanvas.canvas.draw()
+		if self.status_name!="":
+			self.compute_status_and_colors()
+			self.modify()
+			self.draw_frame(self.current_frame)
+			self.fcanvas.canvas.draw()
 
 	def update_frame(self):
 		"""
@@ -2388,54 +1563,11 @@ class MeasureAnnotator(SignalAnnotator):
 		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.give_cell_information()
 
 		self.fcanvas.canvas.draw()
 		self.plot_signals()
 
-	# def load_annotator_config(self):
-	#         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.5955056179775281
-	#         #self.anim_interval = 1
-
-	def prepare_stack(self):
-
-		self.img_num_channels = _get_img_num_per_channel(self.channels, self.len_movie, self.nbr_channels)
-		self.current_stack = []
-		for ch in tqdm(self.target_channels, desc="channel"):
-			target_ch_name = ch[0]
-			if self.percentile_mode:
-				normalize_kwargs = {"percentiles": (ch[1], ch[2]), "values": None}
-			else:
-				normalize_kwargs = {"values": (ch[1], ch[2]), "percentiles": None}
-
-			if self.rgb_mode:
-				normalize_kwargs.update({'amplification': 255., 'clip': True})
-
-			chan = []
-			indices = self.img_num_channels[self.channels[np.where(self.channel_names == target_ch_name)][0]]
-			for t in tqdm(range(len(indices)), desc='frame'):
-				if self.rgb_mode:
-					f = load_frames(indices[t], self.stack_path, scale=self.fraction, normalize_input=True,
-									normalize_kwargs=normalize_kwargs)
-					f = f.astype(np.uint8)
-				else:
-					f = load_frames(indices[t], self.stack_path, scale=self.fraction, normalize_input=False)
-				chan.append(f[:, :, 0])
-
-			self.current_stack.append(chan)
-
-		self.current_stack = np.array(self.current_stack)
-		if self.rgb_mode:
-			self.current_stack = np.moveaxis(self.current_stack, 0, -1)
-		else:
-			self.current_stack = self.current_stack[0]
-			if self.log_option:
-				self.current_stack[np.where((self.current_stack > 0.)&(self.current_stack==self.current_stack))] = np.log(
-					self.current_stack[np.where((self.current_stack > 0.)&(self.current_stack==self.current_stack))])
-
 	def changed_channel(self):
 
 		self.reload_frame()
@@ -2443,12 +1575,12 @@ class MeasureAnnotator(SignalAnnotator):
 			*[np.nanpercentile(self.img, 0.001),
 			  np.nanpercentile(self.img, 99.999)])
 		self.contrast_slider.setValue(
-			[np.nanpercentile(self.img, 1), np.nanpercentile(self.img, 99.99)])
+			[np.nanpercentile(self.img, 0.1), np.nanpercentile(self.img, 99.99)])
 		self.draw_frame(self.current_frame)
 		self.fcanvas.canvas.draw()
 
 	def save_trajectories(self):
-
+		print(f"Saving trajectories !!")
 		if self.normalized_signals:
 			self.normalize_features_btn.click()
 		if self.selection:
@@ -2474,13 +1606,11 @@ class MeasureAnnotator(SignalAnnotator):
 
 		self.df_tracks.to_csv(self.trajectories_path, index=False)
 		print('Table successfully exported...')
-		self.update_frame()
-
-
-	# self.extract_scatter_from_trajectories()
+		
+		self.locate_tracks()
+		self.changed_class()
 
 	def modify(self):
-
 		all_states = self.df_tracks.loc[:, self.status_name].tolist()
 		all_states = np.array(all_states)
 		self.state_color_map = color_from_state(all_states, recently_modified=False)
@@ -2493,84 +1623,6 @@ class MeasureAnnotator(SignalAnnotator):
 		self.correct_btn.disconnect()
 		self.correct_btn.clicked.connect(self.show_annotation_buttons)
 
-		# self.hide_annotation_buttons()
-		# self.correct_btn.setEnabled(False)
-		# self.correct_btn.setText('correct')
-		# self.cancel_btn.setEnabled(False)
-		# self.del_shortcut.setEnabled(False)
-		# self.no_event_shortcut.setEnabled(False)
-
-	def enable_time_of_interest(self):
-		if self.suppr_btn.isChecked():
-			self.time_of_interest_le.setEnabled(False)
-
-	def cancel_selection(self):
-
-		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:
-			print('Cancel selection: ',e)
-
-		try:
-			for k, (t, idx) in enumerate(zip(self.loc_t, self.loc_idx)):
-				# print(self.colors[t][idx, 1])
-				self.colors[t][idx, 0] = self.previous_color[k][0]
-			# self.colors[t][idx, 1] = self.previous_color[k][1]
-		except Exception as e:
-			print("cancel_selection: ",f'{e=}')
-
-		self.event = None
-
-	def locate_stack(self):
-
-		"""
-		Locate the target movie.
-
-		"""
-
-		if isinstance(self.pos, str):
-			movies = glob(self.pos + os.sep.join(['movie',f"{self.parent_window.parent_window.movie_prefix}*.tif"]))
-
-		else:
-			msgBox = QMessageBox()
-			msgBox.setIcon(QMessageBox.Warning)
-			msgBox.setText("Please select a unique position before launching the wizard...")
-			msgBox.setWindowTitle("Warning")
-			msgBox.setStandardButtons(QMessageBox.Ok)
-			returnValue = msgBox.exec()
-			if returnValue == QMessageBox.Ok:
-				self.img = None
-				self.close()
-				return None
-
-		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.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.current_channel = 0
-			self.img = load_frames(0, self.stack_path, normalize_input=False)
-
 	def reload_frame(self):
 
 		"""
@@ -2613,8 +1665,8 @@ class MeasureAnnotator(SignalAnnotator):
 
 		if self.previous_channel != self.current_channel:
 
-			self.vmin = np.nanpercentile(self.img.flatten(), 1)
-			self.vmax = np.nanpercentile(self.img.flatten(), 99.)
+			self.vmin = np.nanpercentile(self.img.flatten(), 0.1)
+			self.vmax = np.nanpercentile(self.img.flatten(), 99.99)
 
 			self.contrast_slider.disconnect()
 			self.contrast_slider.setRange(np.nanmin(self.img), np.nanmax(self.img))
@@ -2627,23 +1679,7 @@ class MeasureAnnotator(SignalAnnotator):
 
 		self.im.set_data(self.img)
 
-	# 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 del_cell(self):
 		self.time_of_interest_le.setEnabled(False)
 		self.time_of_interest_le.setText("99")
 		self.apply_modification()
-
-	def shortcut_suppr(self):
-		self.correct_btn.click()
-		self.del_cell_btn.click()
-		self.correct_btn.click()