celldetective 1.5.0b1__py3-none-any.whl → 1.5.0b3__py3-none-any.whl

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")

celldetective/gui/process_block.py

@@ -9,6 +9,7 @@ from PyQt5.QtWidgets import (
     QHBoxLayout,
     QCheckBox,
     QMessageBox,
+    QApplication,
 )
 from PyQt5.QtCore import Qt, QSize, QTimer, QThread, pyqtSignal
 from superqt.fonticon import icon
@@ -30,13 +31,14 @@ from celldetective.gui.base.components import (
     CelldetectiveWidget,
     CelldetectiveProgressDialog,
     QHSeperationLine,
+    HoverButton,
 )
 
 import numpy as np
 from glob import glob
 from celldetective import get_logger
 
-logger = get_logger()
+logger = get_logger("celldetective")
 
 
 class NapariLoaderThread(QThread):
@@ -345,11 +347,12 @@ class ProcessPanel(QFrame, Styles):
         self.refresh_signal_models()
         # self.to_disable.append(self.cell_models_list)
 
-        self.train_signal_model_btn = QPushButton("TRAIN")
+        self.train_signal_model_btn = HoverButton(
+            "TRAIN", MDI6.redo_variant, "black", "white"
+        )
         self.train_signal_model_btn.setToolTip(
             "Train or retrain an event detection model\non newly annotated data."
         )
-        self.train_signal_model_btn.setIcon(icon(MDI6.redo_variant, color="black"))
         self.train_signal_model_btn.setIconSize(QSize(20, 20))
         self.train_signal_model_btn.setStyleSheet(self.button_style_sheet_3)
         model_zoo_layout.addWidget(self.train_signal_model_btn, 5)
@@ -557,8 +560,7 @@ class ProcessPanel(QFrame, Styles):
         self.seg_model_list.setGeometry(50, 50, 200, 30)
         self.init_seg_model_list()
 
-        self.upload_model_btn = QPushButton("UPLOAD")
-        self.upload_model_btn.setIcon(icon(MDI6.upload, color="black"))
+        self.upload_model_btn = HoverButton("UPLOAD", MDI6.upload, "black", "white")
         self.upload_model_btn.setIconSize(QSize(20, 20))
         self.upload_model_btn.setStyleSheet(self.button_style_sheet_3)
         self.upload_model_btn.setToolTip(
@@ -568,11 +570,10 @@ class ProcessPanel(QFrame, Styles):
         self.upload_model_btn.clicked.connect(self.upload_segmentation_model)
         # self.to_disable.append(self.upload_tc_model)
 
-        self.train_btn = QPushButton("TRAIN")
+        self.train_btn = HoverButton("TRAIN", MDI6.redo_variant, "black", "white")
         self.train_btn.setToolTip(
             "Train or retrain a segmentation model\non newly annotated data."
         )
-        self.train_btn.setIcon(icon(MDI6.redo_variant, color="black"))
         self.train_btn.setIconSize(QSize(20, 20))
         self.train_btn.setStyleSheet(self.button_style_sheet_3)
         self.train_btn.clicked.connect(self.open_segmentation_model_config_ui)
@@ -819,58 +820,117 @@ class ProcessPanel(QFrame, Styles):
 
     def check_signals(self):
         from celldetective.gui.event_annotator import EventAnnotator, StackLoaderThread
+        from celldetective.utils.experiment import interpret_wells_and_positions
 
-        test = self.parent_window.locate_selected_position()
-        if test:
-            self.event_annotator = EventAnnotator(self, lazy_load=True)
+        self.well_option = self.parent_window.well_list.getSelectedIndices()
+        self.position_option = self.parent_window.position_list.getSelectedIndices()
 
-            if not getattr(self.event_annotator, "proceed", True):
-                return
+        # Count selected positions
+        well_indices, position_indices = interpret_wells_and_positions(
+            self.exp_dir, self.well_option, self.position_option
+        )
+        total_positions = 0
+        from celldetective.utils.experiment import (
+            get_positions_in_well,
+            get_experiment_wells,
+        )
 
-            self.signal_loader = StackLoaderThread(self.event_annotator)
+        wells = get_experiment_wells(self.exp_dir)
+        for widx in well_indices:
+            positions = get_positions_in_well(wells[widx])
+            if position_indices is not None:
+                total_positions += len(position_indices)
+            else:
+                total_positions += len(positions)
 
-            self.signal_progress = CelldetectiveProgressDialog(
-                "Loading data...", "Cancel", 0, 100, self, window_title="Please wait"
-            )
+        if total_positions == 1:
+            test = self.parent_window.locate_selected_position()
+            if test:
+                self.event_annotator = EventAnnotator(self, lazy_load=True)
 
-            self.signal_progress.setValue(0)
+                if not getattr(self.event_annotator, "proceed", True):
+                    return
 
-            self.signal_loader.progress.connect(self.signal_progress.setValue)
-            self.signal_loader.status_update.connect(self.signal_progress.setLabelText)
-            self.signal_progress.canceled.connect(self.signal_loader.stop)
+                self.signal_loader = StackLoaderThread(self.event_annotator)
 
-            def on_finished():
-                self.signal_progress.blockSignals(True)
-                self.signal_progress.close()
-                if not self.signal_loader._is_cancelled:
-                    try:
-                        self.event_annotator.finalize_init()
-                        self.event_annotator.show()
+                self.signal_progress = CelldetectiveProgressDialog(
+                    "Loading data...",
+                    "Cancel",
+                    0,
+                    100,
+                    self,
+                    window_title="Please wait",
+                )
+
+                self.signal_progress.setValue(0)
+
+                self.signal_loader.progress.connect(self.signal_progress.setValue)
+                self.signal_loader.status_update.connect(
+                    self.signal_progress.setLabelText
+                )
+                self.signal_progress.canceled.connect(self.signal_loader.stop)
+
+                def on_finished():
+                    self.signal_progress.blockSignals(True)
+                    self.signal_progress.close()
+                    if not self.signal_loader._is_cancelled:
                         try:
-                            QTimer.singleShot(
-                                100,
-                                lambda: self.event_annotator.resize(
-                                    self.event_annotator.width() + 1,
-                                    self.event_annotator.height() + 1,
-                                ),
-                            )
-                        except:
-                            pass
-                    except Exception as e:
-                        print(f"Error finalizing annotator: {e}")
-                else:
-                    self.event_annotator.close()
+                            self.event_annotator.finalize_init()
+                            self.event_annotator.show()
+                            try:
+                                QTimer.singleShot(
+                                    100,
+                                    lambda: self.event_annotator.resize(
+                                        self.event_annotator.width() + 1,
+                                        self.event_annotator.height() + 1,
+                                    ),
+                                )
+                            except:
+                                pass
+                        except Exception as e:
+                            print(f"Error finalizing annotator: {e}")
+                    else:
+                        self.event_annotator.close()
 
-            self.signal_loader.finished.connect(on_finished)
-            self.signal_loader.start()
+                self.signal_loader.finished.connect(on_finished)
+                self.signal_loader.start()
+        else:
+            # Multi position explorer: redirect to TableUI with progress bar
+            self.view_table_ui()
 
     def check_measurements(self):
-        from celldetective.gui.event_annotator import MeasureAnnotator
+        from celldetective.gui.measure_annotator import MeasureAnnotator
+        from celldetective.utils.experiment import interpret_wells_and_positions
 
-        test = self.parent_window.locate_selected_position()
-        if test:
-            self.measure_annotator = MeasureAnnotator(self)
-            self.measure_annotator.show()
+        self.well_option = self.parent_window.well_list.getSelectedIndices()
+        self.position_option = self.parent_window.position_list.getSelectedIndices()
+
+        # Count selected positions
+        well_indices, position_indices = interpret_wells_and_positions(
+            self.exp_dir, self.well_option, self.position_option
+        )
+        total_positions = 0
+        from celldetective.utils.experiment import (
+            get_positions_in_well,
+            get_experiment_wells,
+        )
+
+        wells = get_experiment_wells(self.exp_dir)
+        for widx in well_indices:
+            positions = get_positions_in_well(wells[widx])
+            if position_indices is not None:
+                total_positions += len(position_indices)
+            else:
+                total_positions += len(positions)
+
+        if total_positions == 1:
+            test = self.parent_window.locate_selected_position()
+            if test:
+                self.measure_annotator = MeasureAnnotator(self)
+                self.measure_annotator.show()
+        else:
+            # Multi position explorer: redirect to TableUI with progress bar
+            self.view_table_ui()
 
     def enable_segmentation_model_list(self):
         if self.segment_action.isChecked():
@@ -1493,6 +1553,9 @@ class ProcessPanel(QFrame, Styles):
             window_title="Preparing the napari viewer...",
         )
 
+        self.napari_progress.setAutoClose(False)
+        self.napari_progress.setAutoReset(False)
+
         self.napari_progress.setValue(0)
         self.napari_loader.progress.connect(self.napari_progress.setValue)
         self.napari_loader.status.connect(self.napari_progress.setLabelText)
@@ -1502,13 +1565,15 @@ class ProcessPanel(QFrame, Styles):
             from celldetective.napari.utils import launch_napari_viewer
 
             self.napari_progress.blockSignals(True)
-            self.napari_progress.close()
+            # self.napari_progress.close()
             if self.napari_loader._is_cancelled:
                 logger.info("Task was cancelled...")
+                self.napari_progress.close()
                 return
 
             if isinstance(result, Exception):
                 logger.error(f"napari loading error: {result}")
+                self.napari_progress.close()
                 msgBox = QMessageBox()
                 msgBox.setIcon(QMessageBox.Warning)
                 msgBox.setText(str(result))
@@ -1519,13 +1584,33 @@ class ProcessPanel(QFrame, Styles):
 
             if result:
                 logger.info("Launching the napari viewer with tracks...")
+                self.napari_progress.setLabelText("Initializing Napari viewer...")
+                self.napari_progress.setRange(0, 0)
+                QApplication.processEvents()
+
+                def progress_cb(msg):
+                    if isinstance(msg, str):
+                        self.napari_progress.setLabelText(msg)
+                    QApplication.processEvents()
+
+                if "flush_memory" in result:
+                    result.pop("flush_memory")
+
                 try:
-                    launch_napari_viewer(**result)
+                    launch_napari_viewer(
+                        **result,
+                        block=False,
+                        flush_memory=False,
+                        progress_callback=progress_cb,
+                    )
                     logger.info("napari viewer was closed...")
                 except Exception as e:
                     logger.error(f"Failed to launch Napari: {e}")
                     QMessageBox.warning(self, "Error", f"Failed to launch Napari: {e}")
+                finally:
+                    self.napari_progress.close()
             else:
+                self.napari_progress.close()
                 logger.warning(
                     "napari loading returned None (likely no trajectories found)."
                 )
@@ -1540,33 +1625,95 @@ class ProcessPanel(QFrame, Styles):
 
     def view_table_ui(self):
         from celldetective.gui.tableUI import TableUI
+        from celldetective.gui.workers import ProgressWindow
+        from celldetective.processes.load_table import TableLoaderProcess
+        from celldetective.utils.experiment import interpret_wells_and_positions
 
         logger.info("Load table...")
-        self.load_available_tables()
 
-        if self.df is not None:
-            plot_mode = "plot_track_signals"
-            if "TRACK_ID" not in list(self.df.columns):
-                plot_mode = "static"
-            self.tab_ui = TableUI(
-                self.df,
-                f"{self.parent_window.well_list.currentText()}; Position {self.parent_window.position_list.currentText()}",
+        # Prepare args for the process
+        self.well_option = self.parent_window.well_list.getSelectedIndices()
+        self.position_option = self.parent_window.position_list.getSelectedIndices()
+
+        # Count selected positions
+        well_indices, position_indices = interpret_wells_and_positions(
+            self.exp_dir, self.well_option, self.position_option
+        )
+        total_positions = 0
+        from celldetective.utils.experiment import (
+            get_positions_in_well,
+            get_experiment_wells,
+        )
+
+        wells = get_experiment_wells(self.exp_dir)
+        for widx in well_indices:
+            positions = get_positions_in_well(wells[widx])
+            if position_indices is not None:
+                total_positions += len(position_indices)
+            else:
+                total_positions += len(positions)
+
+        def show_table(df):
+            if df is not None:
+                plot_mode = "plot_track_signals"
+                if "TRACK_ID" not in list(df.columns):
+                    plot_mode = "static"
+                self.tab_ui = TableUI(
+                    df,
+                    f"{self.parent_window.well_list.currentText()}; Position {self.parent_window.position_list.currentText()}",
+                    population=self.mode,
+                    plot_mode=plot_mode,
+                    save_inplace_option=True,
+                )
+                self.tab_ui.show()
+                center_window(self.tab_ui)
+            else:
+                logger.info("Table could not be loaded...")
+                msgBox = QMessageBox()
+                msgBox.setIcon(QMessageBox.Warning)
+                msgBox.setText("No table could be loaded...")
+                msgBox.setWindowTitle("Info")
+                msgBox.setStandardButtons(QMessageBox.Ok)
+                msgBox.exec()
+
+        if total_positions == 1:
+            # Synchronous load for single position
+            from celldetective.utils.data_loaders import load_experiment_tables
+
+            df = load_experiment_tables(
+                self.exp_dir,
                 population=self.mode,
-                plot_mode=plot_mode,
-                save_inplace_option=True,
+                well_option=self.well_option,
+                position_option=self.position_option,
             )
-            self.tab_ui.show()
-            center_window(self.tab_ui)
+            show_table(df)
         else:
-            logger.info("Table could not be loaded...")
-            msgBox = QMessageBox()
-            msgBox.setIcon(QMessageBox.Warning)
-            msgBox.setText("No table could be loaded...")
-            msgBox.setWindowTitle("Info")
-            msgBox.setStandardButtons(QMessageBox.Ok)
-            returnValue = msgBox.exec()
-            if returnValue == QMessageBox.Ok:
-                return None
+            # Asynchronous load for multiple positions
+            process_args = {
+                "experiment": self.exp_dir,
+                "population": self.mode,
+                "well_option": self.well_option,
+                "position_option": self.position_option,
+                "show_frame_progress": False,
+            }
+
+            self.df = None
+
+            def on_table_loaded(df):
+                self.df = df
+                show_table(self.df)
+
+            self.job = ProgressWindow(
+                TableLoaderProcess,
+                parent_window=self,
+                title="Loading tables...",
+                process_args=process_args,
+                position_info=False,
+                well_label="Wells loaded:",
+                pos_label="Positions loaded:",
+            )
+            self.job._ProgressWindow__runner.signals.result.connect(on_table_loaded)
+            self.job.exec_()
 
     def load_available_tables(self):
         """
@@ -1587,8 +1734,87 @@ class ProcessPanel(QFrame, Styles):
         self.signals = []
         if self.df is not None:
             self.signals = list(self.df.columns)
-        if self.df is None:
-            logger.info("No table could be found for the selected position(s)...")
+        else:
+            logger.info(
+                "No table could be found for the selected position(s)... Anticipating measurements..."
+            )
+
+            from celldetective.utils.experiment import extract_experiment_channels
+
+            channel_names, _ = extract_experiment_channels(self.exp_dir)
+
+            # Standard measurements
+            self.signals = ["area"]
+            for ch in channel_names:
+                self.signals.append(f"{ch}_mean")
+
+            # Anticipate from instructions
+            instr_path = os.path.join(
+                self.exp_dir, "configs", f"measurement_instructions_{self.mode}.json"
+            )
+            if os.path.exists(instr_path):
+                try:
+                    with open(instr_path, "r") as f:
+                        instr = json.load(f)
+
+                    # 1. Features
+                    features = instr.get("features", [])
+                    if features:
+                        for f_name in features:
+                            if f_name == "intensity_mean":
+                                continue  # handled by standard
+                            if f_name == "area":
+                                continue
+
+                            # For other features, skimage/celldetective might suffix them.
+                            # If it's a generic feature, skimage usually keeps the name.
+                            # If it's multichannel, it might need channel names.
+                            # For now, let's keep it simple as requested for intensity_mean and area.
+                            pass
+
+                    # 2. Isotropic measurements
+                    radii = instr.get("intensity_measurement_radii", [])
+                    ops = instr.get("isotropic_operations", [])
+                    if radii and ops:
+                        for r in radii if isinstance(radii, list) else [radii]:
+                            for op in ops:
+                                for ch in channel_names:
+                                    if isinstance(r, list):
+                                        self.signals.append(
+                                            f"{ch}_ring_{int(min(r))}_{int(max(r))}_{op}"
+                                        )
+                                    else:
+                                        self.signals.append(
+                                            f"{ch}_circle_{int(r)}_{op}"
+                                        )
+
+                    # 3. Border distances
+                    borders = instr.get("border_distances", [])
+                    if borders:
+                        for b in borders if isinstance(borders, list) else [borders]:
+                            # Logic from measure.py for suffix
+                            b_str = (
+                                str(b)
+                                .replace("(", "")
+                                .replace(")", "")
+                                .replace(", ", "_")
+                                .replace(",", "_")
+                            )
+                            suffix = (
+                                f"_slice_{b_str.replace('-', 'm')}px"
+                                if ("-" in str(b) or "," in str(b))
+                                else f"_edge_{b_str}px"
+                            )
+                            for ch in channel_names:
+                                # In measure_features, it's {ch}_mean{suffix}
+                                self.signals.append(f"{ch}_mean{suffix}")
+
+                except Exception as e:
+                    logger.warning(f"Could not parse measurement instructions: {e}")
+
+            # Remove duplicates and keep order
+            seen = set()
+            self.signals = [x for x in self.signals if not (x in seen or seen.add(x))]
 
     def set_cellpose_scale(self):