celldetective 1.5.0b0__py3-none-any.whl → 1.5.0b2__py3-none-any.whl

celldetective/gui/event_annotator.py

@@ -11,7 +11,10 @@ from PyQt5.QtWidgets import (
     QShortcut,
     QLineEdit,
     QSlider,
+    QAction,
+    QMenu,
 )
+from celldetective.gui.interactive_timeseries_viewer import InteractiveEventViewer
 from PyQt5.QtCore import Qt, QSize, QThread, pyqtSignal, QTimer
 from PyQt5.QtGui import QKeySequence, QIntValidator
 
@@ -266,66 +269,65 @@ class EventAnnotator(BaseAnnotator):
 
         QApplication.processEvents()
 
-    def write_new_event_class(self):
+        # Add Menu for Interactive Plotter
+        menubar = self.menuBar()
+        viewMenu = menubar.addMenu("View")
 
-        if self.class_name_le.text() == "":
-            self.target_class = "class"
-            self.target_time = "t0"
-        else:
-            self.target_class = "class_" + self.class_name_le.text()
-            self.target_time = "t_" + self.class_name_le.text()
-
-        if self.target_class in list(self.df_tracks.columns):
+        openPlotterAct = QAction("Interactive Plotter", self)
+        openPlotterAct.setShortcut("Ctrl+P")
+        openPlotterAct.setStatusTip("Open interactive signal plotter for corrections")
+        openPlotterAct.triggered.connect(self.launch_interactive_viewer)
+        viewMenu.addAction(openPlotterAct)
 
-            msgBox = QMessageBox()
-            msgBox.setIcon(QMessageBox.Warning)
-            msgBox.setText(
-                "This event name already exists. If you proceed,\nall annotated data will be rewritten. Do you wish to continue?"
+    def launch_interactive_viewer(self):
+        if (
+            not hasattr(self, "plotter")
+            or self.plotter is None
+            or not self.plotter.isVisible()
+        ):
+            label = None
+            if hasattr(self, "class_name") and self.class_name.startswith("class_"):
+                label = self.class_name.replace("class_", "")
+
+            # Create with shared DF and callback
+            self.plotter = InteractiveEventViewer(
+                self.trajectories_path,
+                df=self.df_tracks,
+                event_label=label,
+                callback=self.on_viewer_update,
+                parent=self,
             )
-            msgBox.setWindowTitle("Warning")
-            msgBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
-            returnValue = msgBox.exec()
-            if returnValue == QMessageBox.No:
-                return None
-            else:
-                pass
-
-        fill_option = np.where([c.isChecked() for c in self.class_option_rb])[0][0]
-        self.df_tracks.loc[:, self.target_class] = fill_option
-        if fill_option == 0:
-            self.df_tracks.loc[:, self.target_time] = 0.1
-        else:
-            self.df_tracks.loc[:, self.target_time] = -1
+        self.plotter.show()
+        self.plotter.activateWindow()
 
-        self.class_choice_cb.clear()
-        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])
-        if "class_id" in self.class_cols:
-            self.class_cols.remove("class_id")
-        if "class_color" in self.class_cols:
-            self.class_cols.remove("class_color")
-        self.class_choice_cb.addItems(self.class_cols)
-        idx = self.class_choice_cb.findText(self.target_class)
-        self.class_choice_cb.setCurrentIndex(idx)
-
-        self.newClassWidget.close()
+    def on_viewer_update(self):
+        """Callback from interactive viewer to refresh annotator."""
+        self.compute_status_and_colors(0)
+        self.update_scatters_only()
+        self.fcanvas.canvas.draw_idle()
 
-    # def close_without_new_class(self):
-    # 	self.newClassWidget.close()
+    def update_scatters_only(self):
+        """Update only the scatters without reloading the image."""
+        self.status_scatter.set_offsets(self.positions[self.framedata])
+        self.status_scatter.set_color(self.colors[self.framedata][:, 1])
+        self.class_scatter.set_offsets(self.positions[self.framedata])
+        self.class_scatter.set_edgecolor(self.colors[self.framedata][:, 0])
 
     def compute_status_and_colors(self, i):
 
         self.class_name = self.class_choice_cb.currentText()
-        self.expected_status = "status"
+        if self.class_name == "":
+            self.class_name = "class"
+
         suffix = self.class_name.replace("class", "").replace("_", "", 1)
         if suffix != "":
-            self.expected_status += "_" + suffix
+            self.expected_status = "status_" + suffix
             self.expected_time = "t_" + suffix
         else:
+            self.expected_status = "status"
             self.expected_time = "t0"
+        self.expected_class = self.class_name
+
         self.time_name = self.expected_time
         self.status_name = self.expected_status
 
@@ -371,6 +373,9 @@ class EventAnnotator(BaseAnnotator):
 
         self.fcanvas.canvas.draw()
 
+    # def close_without_new_class(self):
+    # 	self.newClassWidget.close()
+
     def cancel_selection(self):
 
         super().cancel_selection()
@@ -1030,1017 +1035,3 @@ class EventAnnotator(BaseAnnotator):
         self.start_btn.setShortcut(QKeySequence("f"))
 
 
-class MeasureAnnotator(BaseAnnotator):
-
-    def __init__(self, *args, **kwargs):
-
-        super().__init__(read_config=False, *args, **kwargs)
-
-        self.setWindowTitle("Static annotator")
-
-        self.int_validator = QIntValidator()
-        self.current_alpha = 0.5
-        self.value_magnitude = 1
-
-        epsilon = 0.01
-        self.observed_min_intensity = 0
-        self.observed_max_intensity = 0 + epsilon
-
-        self.current_frame = 0
-        self.show_fliers = False
-        self.status_name = "group"
-
-        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]
-                )
-
-        else:
-            self.close()
-
-    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
-
-            if len(self.class_cols) > 0:
-                self.status_name = 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
-
-            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 = 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)
-
-            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
-
-            x = self.df_tracks[self.columns_to_rescale].values
-            self.MinMaxScaler.fit(x)
-
-    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",
-            "status_color",
-        ]
-        for col in to_remove:
-            try:
-                self.class_cols.remove(col)
-            except Exception:
-                pass
-
-        self.class_choice_cb.addItems(self.class_cols)
-        self.class_choice_cb.currentIndexChanged.connect(self.changed_class)
-
-    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.suppr_btn,
-        ]
-        self.hide_annotation_buttons()
-
-        # Right panel
-        animation_buttons_box = QHBoxLayout()
-        animation_buttons_box.addWidget(self.frame_lbl, 20, alignment=Qt.AlignLeft)
-
-        self.first_frame_btn = QPushButton()
-        self.first_frame_btn.clicked.connect(self.set_previous_frame)
-        self.first_frame_btn.setShortcut(QKeySequence("f"))
-        self.first_frame_btn.setIcon(icon(MDI6.page_first, color="black"))
-        self.first_frame_btn.setStyleSheet(self.button_select_all)
-        self.first_frame_btn.setFixedSize(QSize(60, 60))
-        self.first_frame_btn.setIconSize(QSize(30, 30))
-
-        self.last_frame_btn = QPushButton()
-        self.last_frame_btn.clicked.connect(self.set_next_frame)
-        self.last_frame_btn.setShortcut(QKeySequence("l"))
-        self.last_frame_btn.setIcon(icon(MDI6.page_last, color="black"))
-        self.last_frame_btn.setStyleSheet(self.button_select_all)
-        self.last_frame_btn.setFixedSize(QSize(60, 60))
-        self.last_frame_btn.setIconSize(QSize(30, 30))
-
-        self.frame_slider = QSlider(Qt.Horizontal)
-        self.frame_slider.setFixedSize(200, 30)
-        self.frame_slider.setRange(0, self.len_movie - 1)
-        self.frame_slider.setValue(0)
-        self.frame_slider.valueChanged.connect(self.update_frame)
-
-        self.start_btn = QPushButton()
-        self.start_btn.clicked.connect(self.start)
-        self.start_btn.setIcon(icon(MDI6.play, color="black"))
-        self.start_btn.setFixedSize(QSize(60, 60))
-        self.start_btn.setStyleSheet(self.button_select_all)
-        self.start_btn.setIconSize(QSize(30, 30))
-        self.start_btn.hide()
-
-        animation_buttons_box.addWidget(
-            self.first_frame_btn, 5, alignment=Qt.AlignRight
-        )
-        animation_buttons_box.addWidget(self.frame_slider, 5, alignment=Qt.AlignCenter)
-        animation_buttons_box.addWidget(self.last_frame_btn, 5, alignment=Qt.AlignLeft)
-
-        self.right_panel.addLayout(animation_buttons_box, 5)
-
-        self.right_panel.addWidget(self.fcanvas, 90)
-
-        contrast_hbox = QHBoxLayout()
-        contrast_hbox.setContentsMargins(150, 5, 150, 5)
-        self.contrast_slider = QLabeledDoubleRangeSlider()
-
-        self.contrast_slider.setSingleStep(0.001)
-        self.contrast_slider.setTickInterval(0.001)
-        self.contrast_slider.setOrientation(Qt.Horizontal)
-        self.contrast_slider.setRange(
-            *[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)]
-        )
-        self.contrast_slider.valueChanged.connect(self.contrast_slider_action)
-        contrast_hbox.addWidget(QLabel("contrast: "))
-        contrast_hbox.addWidget(self.contrast_slider, 90)
-        self.right_panel.addLayout(contrast_hbox, 5)
-        self.alpha_slider = QLabeledDoubleSlider()
-        self.alpha_slider.setSingleStep(0.001)
-        self.alpha_slider.setOrientation(Qt.Horizontal)
-        self.alpha_slider.setRange(0, 1)
-        self.alpha_slider.setValue(self.current_alpha)
-        self.alpha_slider.setDecimals(3)
-        self.alpha_slider.valueChanged.connect(self.set_transparency)
-
-        slider_alpha_hbox = QHBoxLayout()
-        slider_alpha_hbox.setContentsMargins(150, 5, 150, 5)
-        slider_alpha_hbox.addWidget(QLabel("transparency: "), 10)
-        slider_alpha_hbox.addWidget(self.alpha_slider, 90)
-        self.right_panel.addLayout(slider_alpha_hbox)
-
-        channel_hbox = QHBoxLayout()
-        self.choose_channel = QComboBox()
-        self.choose_channel.addItems(self.channel_names)
-        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):
-        """
-        Load an image.
-
-        """
-
-        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 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):
-
-        auto_dataset_name = (
-            self.pos.split(os.sep)[-4]
-            + "_"
-            + self.pos.split(os.sep)[-2]
-            + f"_{str(self.current_frame).zfill(3)}"
-            + f"_{self.status_name}.npy"
-        )
-
-        if self.normalized_signals:
-            self.normalize_features_btn.click()
-
-        subdf = self.df_tracks.loc[self.df_tracks["FRAME"] == self.current_frame, :]
-        subdf["class"] = subdf[self.status_name]
-        dico = subdf.to_dict("records")
-
-        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, dico)
-                print(f"File successfully written in {pathsave}.")
-            except Exception as e:
-                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
-        self.frame_slider.setValue(self.current_frame)
-        self.update_frame()
-        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
-        self.frame_slider.setValue(self.current_frame)
-        self.update_frame()
-
-        self.start_btn.setShortcut(QKeySequence("l"))
-
-    def write_new_event_class(self):
-
-        if self.class_name_le.text() == "":
-            self.target_class = "group"
-        else:
-            self.target_class = "group_" + self.class_name_le.text()
-
-        if self.target_class in list(self.df_tracks.columns):
-            msgBox = QMessageBox()
-            msgBox.setIcon(QMessageBox.Warning)
-            msgBox.setText(
-                "This characteristic group name already exists. If you proceed,\nall annotated data will be rewritten. Do you wish to continue?"
-            )
-            msgBox.setWindowTitle("Warning")
-            msgBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
-            returnValue = msgBox.exec()
-            if returnValue == QMessageBox.No:
-                return None
-            else:
-                pass
-
-        self.df_tracks.loc[:, self.target_class] = 0
-
-        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)
-        self.newClassWidget.close()
-
-    def hide_annotation_buttons(self):
-
-        for a in self.annotation_btns_to_hide:
-            a.hide()
-        self.time_of_interest_label.setEnabled(False)
-        self.time_of_interest_le.setText("")
-        self.time_of_interest_le.setEnabled(False)
-
-    def set_transparency(self):
-        self.current_alpha = self.alpha_slider.value()
-        self.im_mask.set_alpha(self.current_alpha)
-        self.fcanvas.canvas.draw()
-
-    def show_annotation_buttons(self):
-
-        for a in self.annotation_btns_to_hide:
-            a.show()
-
-        self.time_of_interest_label.setEnabled(True)
-        self.time_of_interest_le.setEnabled(True)
-        self.correct_btn.setText("submit")
-
-        self.correct_btn.disconnect()
-        self.correct_btn.clicked.connect(self.apply_modification)
-
-    def give_cell_information(self):
-
-        try:
-            cell_selected = f"cell: {self.track_of_interest}\n"
-            if "TRACK_ID" in self.df_tracks.columns:
-                cell_status = f"phenotype: {self.df_tracks.loc[(self.df_tracks['FRAME']==self.current_frame)&(self.df_tracks['TRACK_ID'] == self.track_of_interest), self.status_name].to_numpy()[0]}\n"
-            else:
-                cell_status = f"phenotype: {self.df_tracks.loc[self.df_tracks['ID'] == self.track_of_interest, self.status_name].to_numpy()[0]}\n"
-            self.cell_info.setText(cell_selected + cell_status)
-        except Exception as e:
-            print(e)
-
-    def create_new_event_class(self):
-
-        # display qwidget to name the event
-        self.newClassWidget = CelldetectiveWidget()
-        self.newClassWidget.setWindowTitle("Create new characteristic group")
-
-        layout = QVBoxLayout()
-        self.newClassWidget.setLayout(layout)
-        name_hbox = QHBoxLayout()
-        name_hbox.addWidget(QLabel("group name: "), 25)
-        self.class_name_le = QLineEdit("group")
-        name_hbox.addWidget(self.class_name_le, 75)
-        layout.addLayout(name_hbox)
-
-        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 apply_modification(self):
-        if self.time_of_interest_le.text() != "":
-            status = int(self.time_of_interest_le.text())
-        else:
-            status = 0
-        if "TRACK_ID" in self.df_tracks.columns:
-            self.df_tracks.loc[
-                (self.df_tracks["TRACK_ID"] == self.track_of_interest)
-                & (self.df_tracks["FRAME"] == self.current_frame),
-                self.status_name,
-            ] = status
-
-            indices = self.df_tracks.index[
-                (self.df_tracks["TRACK_ID"] == self.track_of_interest)
-                & (self.df_tracks["FRAME"] == self.current_frame)
-            ]
-        else:
-            self.df_tracks.loc[
-                (self.df_tracks["ID"] == self.track_of_interest)
-                & (self.df_tracks["FRAME"] == self.current_frame),
-                self.status_name,
-            ] = status
-
-            indices = self.df_tracks.index[
-                (self.df_tracks["ID"] == self.track_of_interest)
-                & (self.df_tracks["FRAME"] == self.current_frame)
-            ]
-
-        self.df_tracks.loc[indices, self.status_name] = status
-        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.extract_scatter_from_trajectories()
-        self.give_cell_information()
-
-        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)
-
-        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"
-        return self.state_color_map[state]
-
-    def draw_frame(self, framedata):
-        """
-        Update plot elements at each timestep of the loop.
-        """
-        self.framedata = framedata
-        self.frame_lbl.setText(f"position: {self.framedata}")
-        self.im.set_array(self.img)
-        self.status_scatter.set_offsets(self.positions[self.framedata])
-        # try:
-        self.status_scatter.set_edgecolors(self.colors[self.framedata][:, 0])
-        # except Exception as e:
-        # 	pass
-
-        self.current_label = self.labels[self.current_frame]
-        self.current_label = contour_of_instance_segmentation(self.current_label, 5)
-
-        self.im_mask.remove()
-        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()),
-        )
-
-        return (
-            self.im,
-            self.status_scatter,
-            self.im_mask,
-        )
-
-    def compute_status_and_colors(self):
-
-        self.cancel_selection()
-
-        if self.class_choice_cb.currentText() == "":
-            pass
-        else:
-            self.status_name = self.class_choice_cb.currentText()
-
-        if self.status_name not in self.df_tracks.columns:
-            print("Creating a new status for visualization...")
-            self.make_status_column()
-        else:
-            print(f'Generating per-state colors for the status "{self.status_name}"...')
-            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)
-            print(f'Color mapping for "{self.status_name}":')
-            pretty_table(self.state_color_map)
-            self.df_tracks["group_color"] = self.df_tracks[self.status_name].apply(
-                self.assign_color_state
-            )
-
-    def make_status_column(self):
-        if self.status_name == "state_firstdetection":
-            pass
-        else:
-            self.df_tracks.loc[:, self.status_name] = 0
-            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 extract_scatter_from_trajectories(self):
-
-        self.positions = []
-        self.colors = []
-        self.tracks = []
-
-        for t in np.arange(self.len_movie):
-            self.positions.append(
-                self.df_tracks.loc[
-                    self.df_tracks["FRAME"] == t, ["POSITION_X", "POSITION_Y"]
-                ].to_numpy()
-            )
-            self.colors.append(
-                self.df_tracks.loc[
-                    self.df_tracks["FRAME"] == t, ["group_color"]
-                ].to_numpy()
-            )
-            if "TRACK_ID" in self.df_tracks.columns:
-                self.tracks.append(
-                    self.df_tracks.loc[
-                        self.df_tracks["FRAME"] == t, "TRACK_ID"
-                    ].to_numpy()
-                )
-            else:
-                self.tracks.append(
-                    self.df_tracks.loc[self.df_tracks["FRAME"] == t, "ID"].to_numpy()
-                )
-
-    def changed_class(self):
-        self.status_name = self.class_choice_cb.currentText()
-        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):
-        """
-        Update the displayed frame.
-        """
-        self.current_frame = self.frame_slider.value()
-        self.reload_frame()
-        if "TRACK_ID" in list(self.df_tracks.columns):
-            pass
-        elif "ID" in list(self.df_tracks.columns):
-            print("ID in cols... change class of interest... ")
-            self.track_of_interest = self.df_tracks[
-                self.df_tracks["FRAME"] == self.current_frame
-            ]["ID"].min()
-            self.modify()
-
-        self.draw_frame(self.current_frame)
-        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 changed_channel(self):
-
-        self.reload_frame()
-        self.contrast_slider.setRange(
-            *[np.nanpercentile(self.img, 0.001), np.nanpercentile(self.img, 99.999)]
-        )
-        self.contrast_slider.setValue(
-            [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:
-            self.cancel_selection()
-        self.df_tracks = self.df_tracks.drop(
-            self.df_tracks[self.df_tracks[self.status_name] == 99].index
-        )
-        # color_column = str(self.status_name) + "_color"
-        try:
-            self.df_tracks.drop(columns="", inplace=True)
-        except:
-            pass
-        try:
-            self.df_tracks.drop(columns="group_color", inplace=True)
-        except:
-            pass
-        try:
-            self.df_tracks.drop(columns="x_anim", inplace=True)
-        except:
-            pass
-        try:
-            self.df_tracks.drop(columns="y_anim", inplace=True)
-        except:
-            pass
-
-        self.df_tracks.to_csv(self.trajectories_path, index=False)
-        print("Table successfully exported...")
-
-        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)
-
-        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()
-
-        self.correct_btn.disconnect()
-        self.correct_btn.clicked.connect(self.show_annotation_buttons)
-
-    def reload_frame(self):
-        """
-        Load the frame from the current channel and time choice. Show imshow, update histogram.
-        """
-
-        # self.clear_post_threshold_options()
-        self.previous_channel = self.current_channel
-        self.current_channel = self.choose_channel.currentIndex()
-
-        t = int(self.frame_slider.value())
-        idx = t * self.nbr_channels + self.current_channel
-        self.img = load_frames(idx, self.stack_path, normalize_input=False)
-
-        if self.previous_channel != self.current_channel:
-            # reinitialize intensity bounds
-            epsilon = 0.01
-            self.observed_min_intensity = 0
-            self.observed_max_intensity = 0 + epsilon
-
-        if self.img is not None:
-            max_img = np.nanmax(self.img)
-            min_img = np.nanmin(self.img)
-            if max_img > self.observed_max_intensity:
-                self.observed_max_intensity = max_img
-            if min_img < self.observed_min_intensity:
-                self.observed_min_intensity = min_img
-            self.refresh_imshow()
-        # self.redo_histogram()
-        else:
-            print("Frame could not be loaded...")
-
-    def refresh_imshow(self):
-        """
-
-        Update the imshow based on the current frame selection.
-
-        """
-
-        if self.previous_channel != self.current_channel:
-
-            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))
-            self.contrast_slider.setValue([self.vmin, self.vmax])
-            self.contrast_slider.valueChanged.connect(self.contrast_slider_action)
-        else:
-            # self.contrast_slider.disconnect()
-            self.contrast_slider.setRange(
-                self.observed_min_intensity, self.observed_max_intensity
-            )
-            # self.contrast_slider.valueChanged.connect(self.contrast_slider_action)
-
-        self.im.set_data(self.img)
-
-    def del_cell(self):
-        self.time_of_interest_le.setEnabled(False)
-        self.time_of_interest_le.setText("99")
-        self.apply_modification()