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

celldetective/_version.py

@@ -1 +1 @@
-__version__ = "1.5.0b2"
+__version__ = "1.5.0b4"

celldetective/gui/InitWindow.py

@@ -325,14 +325,18 @@ class AppInitWindow(CelldetectiveMainWindow):
     def reload_previous_experiments(self):
 
         self.recent_file_acts = []
-        if os.path.exists(os.sep.join([self.soft_path, "celldetective", "recent.txt"])):
-            recent_exps = open(
-                os.sep.join([self.soft_path, "celldetective", "recent.txt"]), "r"
-            )
-            recent_exps = recent_exps.readlines()
-            recent_exps = [r.strip() for r in recent_exps]
+        recent_path = os.sep.join([self.soft_path, "celldetective", "recent.txt"])
+        if os.path.exists(recent_path):
+            with open(recent_path, "r") as f:
+                recent_exps = [r.strip() for r in f.readlines()]
             recent_exps.reverse()
-            recent_exps = list(dict.fromkeys(recent_exps))
+            recent_exps = list(dict.fromkeys(recent_exps))[:10]
+
+            # Auto-clean the file as well
+            with open(recent_path, "w") as f:
+                for r in reversed(recent_exps):
+                    f.write(r + "\n")
+
             self.recent_file_acts = [QAction(r, self) for r in recent_exps]
             for r in self.recent_file_acts:
                 r.triggered.connect(
@@ -525,10 +529,23 @@ class AppInitWindow(CelldetectiveMainWindow):
                 logger.info(f"Number of positions per well:")
                 pretty_table(number_pos)
 
-                with open(
-                    os.sep.join([self.soft_path, "celldetective", "recent.txt"]), "a+"
-                ) as f:
-                    f.write(self.exp_dir + "\n")
+                recent_path = os.sep.join(
+                    [self.soft_path, "celldetective", "recent.txt"]
+                )
+                recent_exps = []
+                if os.path.exists(recent_path):
+                    with open(recent_path, "r") as f:
+                        recent_exps = [r.strip() for r in f.readlines()]
+
+                recent_exps.append(self.exp_dir)
+                # Deduplicate (keep latest)
+                recent_exps = list(dict.fromkeys(reversed(recent_exps)))
+                recent_exps.reverse()  # Back to original order (latest at end)
+                recent_exps = recent_exps[-10:]  # Keep only last 10
+
+                with open(recent_path, "w") as f:
+                    for r in recent_exps:
+                        f.write(r + "\n")
 
             threading.Thread(
                 target=log_position_stats, args=(wells,), daemon=True

celldetective/gui/base/components.py

@@ -120,6 +120,8 @@ class QCheckableComboBox(QComboBox):
         actions = self.toolMenu.actions()
 
         item = self.model().itemFromIndex(index)
+        if item is None:
+            return
         if item.checkState() == Qt.Checked:
             item.setCheckState(Qt.Unchecked)
             actions[idx].setChecked(False)

celldetective/gui/base_annotator.py

@@ -305,7 +305,11 @@ class BaseAnnotator(CelldetectiveMainWindow, Styles):
         ]
         # self.log_btns = [QPushButton() for i in range(self.n_signals)]
 
-        signals = list(self.df_tracks.columns)
+        signals = [
+            c
+            for c in self.df_tracks.columns
+            if pd.api.types.is_numeric_dtype(self.df_tracks[c])
+        ]
 
         to_remove = [
             "FRAME",
@@ -357,7 +361,10 @@ class BaseAnnotator(CelldetectiveMainWindow, Styles):
 
         for i in range(len(self.signal_choice_cb)):
             self.signal_choice_cb[i].addItems(["--"] + signals)
-            self.signal_choice_cb[i].setCurrentIndex(i + 1)
+            if i + 1 < self.signal_choice_cb[i].count():
+                self.signal_choice_cb[i].setCurrentIndex(i + 1)
+            else:
+                self.signal_choice_cb[i].setCurrentIndex(0)
             self.signal_choice_cb[i].currentIndexChanged.connect(self.plot_signals)
 
     def on_scatter_pick(self, event):

celldetective/gui/control_panel.py

@@ -58,14 +58,15 @@ logger = logging.getLogger(__name__)
 
 
 class BackgroundLoader(QThread):
-     def run(self):
-         logger.info("Loading background packages...")
-         try:
-             from celldetective.gui.viewers.base_viewer import StackVisualizer
-             self.StackVisualizer = StackVisualizer
-         except Exception:
-             logger.error("Background packages not loaded...")
-         logger.info("Background packages loaded...")
+    def run(self):
+        logger.info("Loading background packages...")
+        try:
+            from celldetective.gui.viewers.base_viewer import StackVisualizer
+
+            self.StackVisualizer = StackVisualizer
+        except Exception:
+            logger.error("Background packages not loaded...")
+        logger.info("Background packages loaded...")
 
 
 class ControlPanel(CelldetectiveMainWindow):
@@ -179,9 +180,11 @@ class ControlPanel(CelldetectiveMainWindow):
 
         name = self.exp_dir.split(os.sep)[-2]
         experiment_label = QLabel(f"Experiment:")
-        experiment_label.setStyleSheet("""
+        experiment_label.setStyleSheet(
+            """
 			font-weight: bold;
-			""")
+			"""
+        )
 
         self.folder_exp_btn = QPushButton()
         self.folder_exp_btn.setIcon(icon(MDI6.folder, color="black"))
@@ -553,16 +556,18 @@ class ControlPanel(CelldetectiveMainWindow):
             for p in self.ProcessPopulations:
                 p.check_seg_btn.setEnabled(False)
                 p.check_tracking_result_btn.setEnabled(False)
-                p.view_tab_btn.setEnabled(True)
-                p.signal_analysis_action.setEnabled(True)
+                p.view_tab_btn.setEnabled(self.position_list.isAnySelected())
+                p.signal_analysis_action.setEnabled(self.position_list.isAnySelected())
                 p.check_seg_btn.setEnabled(False)
                 p.check_tracking_result_btn.setEnabled(False)
-                p.check_measurements_btn.setEnabled(False)
-                p.check_signals_btn.setEnabled(False)
+                p.check_measurements_btn.setEnabled(self.position_list.isAnySelected())
+                p.check_signals_btn.setEnabled(self.position_list.isAnySelected())
                 p.delete_tracks_btn.hide()
 
-            self.NeighPanel.view_tab_btn.setEnabled(True)
-            self.NeighPanel.check_signals_btn.setEnabled(False)
+            self.NeighPanel.view_tab_btn.setEnabled(self.position_list.isAnySelected())
+            self.NeighPanel.check_signals_btn.setEnabled(
+                self.position_list.isAnySelected()
+            )
             self.view_stack_btn.setEnabled(False)
 
         elif self.well_list.isMultipleSelection():

celldetective/gui/gui_utils.py

@@ -822,10 +822,15 @@ def color_from_state(state, recently_modified=False):
     color_map = {}
     for value in unique_values:
 
-        if np.isnan(value):
-            value = "nan"
-            color_map[value] = "k"
-        elif value == 0:
+        try:
+            if np.isnan(value):
+                value = "nan"
+                color_map[value] = "k"
+                continue
+        except TypeError:
+            pass
+
+        if value == 0:
             color_map[value] = "tab:blue"
         elif value == 1:
             color_map[value] = "tab:red"
@@ -834,7 +839,11 @@ def color_from_state(state, recently_modified=False):
         else:
             import matplotlib.pyplot as plt
 
-            color_map[value] = plt.cm.tab20(value / 20.0)
+            if isinstance(value, (int, float, np.number)):
+                idx = value
+            else:
+                idx = hash(str(value)) % 20
+            color_map[value] = plt.cm.tab20(idx / 20.0)
 
     return color_map
 

celldetective/gui/measure_annotator.py

@@ -101,6 +101,7 @@ class MeasureAnnotator(BaseAnnotator):
 
     def __init__(self, *args, **kwargs):
 
+        self.status_name = "group"
         super().__init__(read_config=False, *args, **kwargs)
 
         self.setWindowTitle("Static annotator")
@@ -115,17 +116,21 @@ class MeasureAnnotator(BaseAnnotator):
 
         self.current_frame = 0
         self.show_fliers = False
-        self.status_name = "group"
 
         if self.proceed:
 
             from celldetective.utils.image_loaders import fix_missing_labels
+            from celldetective.tracking import write_first_detection_class
 
             # Ensure labels match stack length
             if self.len_movie > 0:
                 temp_labels = locate_labels(self.pos, population=self.mode)
                 if temp_labels is None or len(temp_labels) < self.len_movie:
-                    fix_missing_labels(self.pos, population=self.mode)
+                    fix_missing_labels(
+                        self.pos,
+                        population=self.mode,
+                        prefix=self.parent_window.movie_prefix,
+                    )
                     self.labels = locate_labels(self.pos, population=self.mode)
                 elif len(temp_labels) > self.len_movie:
                     self.labels = temp_labels[: self.len_movie]
@@ -174,13 +179,62 @@ class MeasureAnnotator(BaseAnnotator):
             cols = np.array(self.df_tracks.columns)
             self.class_cols = np.array(
                 [
-                    c.startswith("group") or c.startswith("class")
+                    c.startswith("group")
+                    or c.startswith("class")
+                    or c.startswith("status")
                     for c in list(self.df_tracks.columns)
                 ]
             )
             self.class_cols = list(cols[self.class_cols])
 
-            to_remove = ["class_id", "group_color", "class_color"]
+            to_remove = [
+                "class_id",
+                "group_color",
+                "class_color",
+                "group_id",
+                "status_color",
+                "status_id",
+            ]
+            for col in to_remove:
+                try:
+                    self.class_cols.remove(col)
+                except:
+                    pass
+
+            # Generate missing status columns from class columns
+            for c in self.class_cols:
+                if c.startswith("class_"):
+                    status_col = c.replace("class_", "status_")
+                    if status_col not in self.df_tracks.columns:
+                        if (
+                            status_col == "status_firstdetection"
+                            or c == "class_firstdetection"
+                        ):
+                            try:
+                                from celldetective.tracking import (
+                                    write_first_detection_class,
+                                )
+
+                                self.df_tracks = write_first_detection_class(
+                                    self.df_tracks
+                                )
+                            except Exception as e:
+                                logger.error(
+                                    f"Could not generate status_firstdetection: {e}"
+                                )
+                                self.df_tracks[status_col] = self.df_tracks[c]
+                        else:
+                            self.df_tracks[status_col] = self.df_tracks[c]
+
+            # Re-evaluate class_cols after generation
+            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])
             for col in to_remove:
                 try:
                     self.class_cols.remove(col)
@@ -188,7 +242,8 @@ class MeasureAnnotator(BaseAnnotator):
                     pass
 
             if len(self.class_cols) > 0:
-                self.status_name = self.class_cols[0]
+                if self.status_name not in self.class_cols:
+                    self.status_name = self.class_cols[0]
             else:
                 self.status_name = "group"
 
@@ -335,7 +390,13 @@ class MeasureAnnotator(BaseAnnotator):
         cols = np.array(self.df_tracks.columns)
         self.class_cols = np.array(
             [
-                c.startswith("group") or c.startswith("status")
+                c.startswith("group")
+                or c.startswith("status")
+                or (
+                    c.startswith("class")
+                    and not c.endswith("_id")
+                    and not c.endswith("_color")
+                )
                 for c in list(self.df_tracks.columns)
             ]
         )
@@ -347,14 +408,23 @@ class MeasureAnnotator(BaseAnnotator):
             "class_id",
             "class_color",
             "status_color",
+            "status_id",
         ]
         for col in to_remove:
-            try:
+            while col in self.class_cols:
                 self.class_cols.remove(col)
-            except Exception:
-                pass
+
+        # Filter to keep only group_* and status_* as requested by user, but allow 'group' if it exists
+        final_cols = []
+        for c in self.class_cols:
+            if c == "group" or c.startswith("group_") or c.startswith("status_"):
+                final_cols.append(c)
+
+        self.class_cols = final_cols
 
         self.class_choice_cb.addItems(self.class_cols)
+        if self.status_name in self.class_cols:
+            self.class_choice_cb.setCurrentText(self.status_name)
         self.class_choice_cb.currentIndexChanged.connect(self.changed_class)
 
     def populate_window(self):
@@ -678,13 +748,30 @@ class MeasureAnnotator(BaseAnnotator):
 
         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"
+            if self.status_name in self.df_tracks.columns:
+                if "TRACK_ID" in self.df_tracks.columns:
+                    val = 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()
+                    if len(val) > 0:
+                        cell_status = f"phenotype: {val[0]}\n"
+                    else:
+                        cell_status = "phenotype: N/A\n"
+                else:
+                    val = self.df_tracks.loc[
+                        self.df_tracks["ID"] == self.track_of_interest, self.status_name
+                    ].to_numpy()
+                    if len(val) > 0:
+                        cell_status = f"phenotype: {val[0]}\n"
+                    else:
+                        cell_status = "phenotype: N/A\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"
+                cell_status = f"phenotype: N/A (col '{self.status_name}' missing)\n"
             self.cell_info.setText(cell_selected + cell_status)
         except Exception as e:
-            logger.error(e)
+            logger.error(f"Error in give_cell_information: {e}")
 
     def create_new_event_class(self):
 
@@ -772,8 +859,11 @@ class MeasureAnnotator(BaseAnnotator):
 
     def assign_color_state(self, state):
 
-        if np.isnan(state):
-            state = "nan"
+        try:
+            if np.isnan(state):
+                state = "nan"
+        except TypeError:
+            pass
         return self.state_color_map[state]
 
     def on_scatter_pick(self, event):
@@ -860,9 +950,9 @@ class MeasureAnnotator(BaseAnnotator):
                 ].to_numpy()
             )
             self.colors.append(
-                self.df_tracks.loc[
-                    self.df_tracks["FRAME"] == t, ["group_color"]
-                ].to_numpy()
+                self.df_tracks.loc[self.df_tracks["FRAME"] == t, ["group_color"]]
+                .to_numpy()
+                .copy()
             )
             if "TRACK_ID" in self.df_tracks.columns:
                 self.tracks.append(
@@ -945,6 +1035,12 @@ class MeasureAnnotator(BaseAnnotator):
         self.changed_class()
 
     def modify(self):
+        if self.status_name not in self.df_tracks.columns:
+            logger.warning(
+                f"Column '{self.status_name}' not found in df_tracks. Skipping modify."
+            )
+            return
+
         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)

celldetective/gui/plot_measurements.py

@@ -263,8 +263,7 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
     def ask_for_feature(self):
 
         cols = np.array(list(self.df.columns))
-        is_number = np.vectorize(lambda x: np.issubdtype(x, np.number))
-        feats = cols[is_number(self.df.dtypes)]
+        feats = [c for c in cols if pd.api.types.is_numeric_dtype(self.df[c])]
 
         self.feature_choice_widget = CelldetectiveWidget()
         self.feature_choice_widget.setWindowTitle("Select numeric feature")
@@ -286,8 +285,7 @@ class ConfigMeasurementsPlot(CelldetectiveWidget):
     def ask_for_features(self):
 
         cols = np.array(list(self.df.columns))
-        is_number = np.vectorize(lambda x: np.issubdtype(x, np.number))
-        feats = cols[is_number(self.df.dtypes)]
+        feats = [c for c in cols if pd.api.types.is_numeric_dtype(self.df[c])]
 
         self.feature_choice_widget = CelldetectiveWidget()
         self.feature_choice_widget.setWindowTitle("Select numeric feature")

celldetective/gui/plot_signals_ui.py

@@ -21,6 +21,7 @@ from celldetective.utils.data_cleaning import extract_cols_from_table_list
 from celldetective.utils.parsing import _extract_labels_from_config
 from celldetective.utils.data_loaders import load_experiment_tables
 from celldetective.signals import mean_signal
+import pandas as pd
 import numpy as np
 import os
 import matplotlib.pyplot as plt
@@ -377,8 +378,7 @@ class ConfigSignalPlot(CelldetectiveWidget):
     def ask_for_feature(self):
 
         cols = np.array(list(self.df.columns))
-        is_number = np.vectorize(lambda x: np.issubdtype(x, np.number))
-        feats = cols[is_number(self.df.dtypes)]
+        feats = [c for c in cols if pd.api.types.is_numeric_dtype(self.df[c])]
 
         self.feature_choice_widget = CelldetectiveWidget()
         self.feature_choice_widget.setWindowTitle("Select numeric feature")
@@ -400,8 +400,7 @@ class ConfigSignalPlot(CelldetectiveWidget):
     def ask_for_features(self):
 
         cols = np.array(list(self.df.columns))
-        is_number = np.vectorize(lambda x: np.issubdtype(x, np.number))
-        feats = cols[is_number(self.df.dtypes)]
+        feats = [c for c in cols if pd.api.types.is_numeric_dtype(self.df[c])]
 
         self.feature_choice_widget = CelldetectiveWidget()
         self.feature_choice_widget.setWindowTitle("Select numeric feature")