celldetective 1.4.2__py3-none-any.whl → 1.5.0b0__py3-none-any.whl

celldetective/gui/base/components.py

@@ -0,0 +1,249 @@
+import numpy as np
+from PyQt5.QtGui import QStandardItemModel, QPalette, QFontMetrics
+from PyQt5.QtWidgets import (
+    QMainWindow,
+    QWidget,
+    QDialog,
+    QMessageBox,
+    QComboBox,
+    QToolButton,
+    QMenu,
+    QStylePainter,
+    QStyleOptionComboBox,
+    QStyle,
+    QFrame,
+    QSizePolicy,
+    QProgressDialog,
+)
+from PyQt5.QtCore import Qt, pyqtSignal, QEvent
+from celldetective.gui.base.styles import Styles
+
+
+class CelldetectiveWidget(QWidget, Styles):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.setWindowIcon(self.celldetective_icon)
+        self.setAttribute(Qt.WA_DeleteOnClose)
+
+
+class CelldetectiveMainWindow(QMainWindow, Styles):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.setWindowIcon(self.celldetective_icon)
+        self.setAttribute(Qt.WA_DeleteOnClose)
+
+
+class CelldetectiveDialog(QDialog, Styles):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.setWindowIcon(self.celldetective_icon)
+
+
+class CelldetectiveProgressDialog(QProgressDialog, Styles):
+    def __init__(
+        self,
+        label_text,
+        cancel_button_text="Cancel",
+        minimum=0,
+        maximum=100,
+        parent=None,
+        window_title="Please wait",
+    ):
+        super().__init__(label_text, cancel_button_text, minimum, maximum, parent)
+        self.setWindowIcon(self.celldetective_icon)
+        self.setWindowTitle(window_title)
+        self.setWindowModality(Qt.WindowModal)
+        self.setWindowFlags(
+            self.windowFlags()
+            & ~Qt.WindowContextHelpButtonHint
+            & ~Qt.WindowCloseButtonHint
+        )
+        self.setMinimumDuration(0)
+        self.setValue(0)
+
+        fm = QFontMetrics(self.font())
+        width = max(350, fm.horizontalAdvance(window_title) + 120)
+        self.setMinimumWidth(width)
+
+
+def generic_message(message, msg_type="warning"):
+
+    print(message)
+    message_box = QMessageBox()
+    if msg_type == "warning":
+        message_box.setIcon(QMessageBox.Warning)
+    elif msg_type == "info":
+        message_box.setIcon(QMessageBox.Information)
+    elif msg_type == "critical":
+        message_box.setIcon(QMessageBox.Critical)
+    message_box.setText(message)
+    message_box.setWindowTitle(msg_type)
+    message_box.setStandardButtons(QMessageBox.Ok)
+    _ = message_box.exec()
+
+
+class QCheckableComboBox(QComboBox):
+    """
+    adapted from https://stackoverflow.com/questions/22775095/pyqt-how-to-set-combobox-items-be-checkable
+    """
+
+    activated = pyqtSignal(str)
+
+    def __init__(self, obj="", parent_window=None, *args, **kwargs):
+
+        super().__init__(parent_window, *args, **kwargs)
+
+        self.setTitle("")
+        self.setModel(QStandardItemModel(self))
+        self.obj = obj
+        self.toolButton = QToolButton(parent_window)
+        self.toolButton.setText("")
+        self.toolMenu = QMenu(parent_window)
+        self.toolButton.setMenu(self.toolMenu)
+        self.toolButton.setPopupMode(QToolButton.InstantPopup)
+        self.anySelected = False
+
+        self.view().viewport().installEventFilter(self)
+        self.view().pressed.connect(self.handleItemPressed)
+
+    def clear(self):
+
+        self.unselectAll()
+        self.toolMenu.clear()
+        super().clear()
+
+    def handleItemPressed(self, index):
+
+        idx = index.row()
+        actions = self.toolMenu.actions()
+
+        item = self.model().itemFromIndex(index)
+        if item.checkState() == Qt.Checked:
+            item.setCheckState(Qt.Unchecked)
+            actions[idx].setChecked(False)
+        else:
+            item.setCheckState(Qt.Checked)
+            actions[idx].setChecked(True)
+            self.anySelected = True
+
+        options_checked = np.array([a.isChecked() for a in actions])
+        if len(options_checked[options_checked]) > 1:
+            self.setTitle(f'Multiple {self.obj+"s"} selected...')
+        elif len(options_checked[options_checked]) == 1:
+            idx_selected = np.where(options_checked)[0][0]
+            if idx_selected != idx:
+                item = self.model().item(idx_selected)
+            self.setTitle(item.text())
+        elif len(options_checked[options_checked]) == 0:
+            self.setTitle(f"No {self.obj} selected...")
+            self.anySelected = False
+
+        self.activated.emit(self.title())
+
+    def setCurrentIndex(self, index):
+
+        super().setCurrentIndex(index)
+
+        item = self.model().item(index)
+        modelIndex = self.model().indexFromItem(item)
+
+        self.handleItemPressed(modelIndex)
+
+    def selectAll(self):
+
+        actions = self.toolMenu.actions()
+        for i, a in enumerate(actions):
+            if not a.isChecked():
+                self.setCurrentIndex(i)
+        self.anySelected = True
+
+    def unselectAll(self):
+
+        actions = self.toolMenu.actions()
+        for i, a in enumerate(actions):
+            if a.isChecked():
+                self.setCurrentIndex(i)
+        self.anySelected = False
+
+    def title(self):
+        return self._title
+
+    def setTitle(self, title):
+        self._title = title
+        self.update()
+        self.repaint()
+
+    def paintEvent(self, event):
+
+        painter = QStylePainter(self)
+        painter.setPen(self.palette().color(QPalette.Text))
+        opt = QStyleOptionComboBox()
+        self.initStyleOption(opt)
+        opt.currentText = self._title
+        painter.drawComplexControl(QStyle.CC_ComboBox, opt)
+        painter.drawControl(QStyle.CE_ComboBoxLabel, opt)
+
+    def addItem(self, item, tooltip=None):
+
+        super().addItem(item)
+        idx = self.findText(item)
+        if tooltip is not None:
+            self.setItemData(idx, tooltip, Qt.ToolTipRole)
+        item2 = self.model().item(idx, 0)
+        item2.setCheckState(Qt.Unchecked)
+        action = self.toolMenu.addAction(item)
+        action.setCheckable(True)
+
+    def addItems(self, items):
+
+        super().addItems(items)
+
+        for item in items:
+
+            idx = self.findText(item)
+            item2 = self.model().item(idx, 0)
+            item2.setCheckState(Qt.Unchecked)
+            action = self.toolMenu.addAction(item)
+            action.setCheckable(True)
+
+    def getSelectedIndices(self):
+
+        actions = self.toolMenu.actions()
+        options_checked = np.array([a.isChecked() for a in actions])
+        idx_selected = np.where(options_checked)[0]
+
+        return list(idx_selected)
+
+    def currentText(self):
+        return self.title()
+
+    def isMultipleSelection(self):
+        return self.currentText().startswith("Multiple")
+
+    def isSingleSelection(self):
+        return not self.currentText().startswith(
+            "Multiple"
+        ) and not self.title().startswith("No")
+
+    def isAnySelected(self):
+        return not self.title().startswith("No")
+
+    def eventFilter(self, source, event):
+        if source is self.view().viewport():
+            if event.type() == QEvent.MouseButtonRelease:
+                return True  # Prevent the popup from closing
+        return super().eventFilter(source, event)
+
+
+class QHSeperationLine(QFrame):
+    """
+    a horizontal seperation line\n
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.setMinimumWidth(1)
+        self.setFixedHeight(20)
+        self.setFrameShape(QFrame.HLine)
+        self.setFrameShadow(QFrame.Sunken)
+        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)

celldetective/gui/base/feature_choice.py

@@ -0,0 +1,92 @@
+import ast
+import os
+from celldetective import get_software_location
+from PyQt5.QtWidgets import QComboBox, QPushButton, QVBoxLayout
+
+from celldetective.gui.base.components import CelldetectiveWidget
+from celldetective.gui.base.utils import center_window
+
+CACHED_EXTRA_PROPERTIES = None
+
+
+def get_extra_properties_functions():
+    """
+    Parses celldetective/extra_properties.py using AST to find function definitions
+    without importing the module (which would trigger heavy dependencies).
+    """
+    try:
+        software_path = get_software_location()
+        extra_props_path = os.path.join(
+            software_path, "celldetective", "extra_properties.py"
+        )
+
+        if not os.path.exists(extra_props_path):
+            return []
+
+        with open(extra_props_path, "r", encoding="utf-8") as f:
+            tree = ast.parse(f.read())
+
+        functions = []
+        for node in tree.body:
+            if isinstance(node, ast.FunctionDef):
+                functions.append(node.name)
+
+        return functions
+    except Exception as e:
+        print(f"Failed to parse extra_properties.py: {e}")
+        return []
+
+
+class FeatureChoice(CelldetectiveWidget):
+
+    def __init__(self, parent_window):
+        super().__init__()
+        self.parent_window = parent_window
+        self.setWindowTitle("Add feature")
+        # Create the QComboBox and add some items
+        self.combo_box = QComboBox(self)
+
+        standard_measurements = [
+            "area",
+            "area_bbox",
+            "area_convex",
+            "area_filled",
+            "major_axis_length",
+            "minor_axis_length",
+            "eccentricity",
+            "equivalent_diameter_area",
+            "euler_number",
+            "extent",
+            "feret_diameter_max",
+            "orientation",
+            "perimeter",
+            "perimeter_crofton",
+            "solidity",
+            "intensity_mean",
+            "intensity_max",
+            "intensity_min",
+        ]
+
+        global CACHED_EXTRA_PROPERTIES
+        if CACHED_EXTRA_PROPERTIES is None:
+            CACHED_EXTRA_PROPERTIES = get_extra_properties_functions()
+
+        if CACHED_EXTRA_PROPERTIES:
+            standard_measurements.extend(CACHED_EXTRA_PROPERTIES)
+
+        self.combo_box.addItems(standard_measurements)
+
+        self.add_btn = QPushButton("Add")
+        self.add_btn.setStyleSheet(self.button_style_sheet)
+        self.add_btn.clicked.connect(self.add_current_feature)
+
+        # Create the layout
+        layout = QVBoxLayout(self)
+        layout.addWidget(self.combo_box)
+        layout.addWidget(self.add_btn)
+        center_window(self)
+
+    def add_current_feature(self):
+        filtername = self.combo_box.currentText()
+        self.parent_window.list_widget.addItems([filtername])
+        self.close()

celldetective/gui/base/figure_canvas.py

@@ -0,0 +1,52 @@
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import QVBoxLayout
+
+from celldetective.gui.base.components import CelldetectiveWidget
+from celldetective.gui.base.utils import center_window
+
+
+class FigureCanvas(CelldetectiveWidget):
+    """
+    Generic figure canvas.
+    """
+
+    def __init__(self, fig, title="", interactive=True):
+        super().__init__()
+        self.fig = fig
+        self.setWindowTitle(title)
+        from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg
+
+        self.canvas = FigureCanvasQTAgg(self.fig)
+        self.canvas.setStyleSheet("background-color: transparent;")
+        if interactive:
+            from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT
+
+            self.toolbar = NavigationToolbar2QT(self.canvas)
+        self.layout = QVBoxLayout(self)
+        self.layout.addWidget(self.canvas, 90)
+        if interactive:
+            self.layout.addWidget(self.toolbar)
+
+        #center_window(self)
+        self.setAttribute(Qt.WA_DeleteOnClose)
+
+    def resizeEvent(self, event):
+
+        super().resizeEvent(event)
+        try:
+            self.fig.tight_layout()
+        except:
+            pass
+
+    def draw(self):
+        self.canvas.draw()
+
+    def closeEvent(self, event):
+        """Delete figure on closing window."""
+        # self.canvas.ax.cla() # ****
+        # self.canvas.ax.cla() # ****
+        self.fig.clf()  # ****
+        import matplotlib.pyplot as plt
+
+        plt.close(self.fig)
+        super(FigureCanvas, self).closeEvent(event)

celldetective/gui/base/list_widget.py

@@ -0,0 +1,133 @@
+from PyQt5.QtCore import QTimer
+from PyQt5.QtWidgets import QListWidget, QVBoxLayout
+
+from celldetective.gui.base.components import CelldetectiveWidget
+from celldetective.gui.base.utils import center_window
+
+
+class ListWidget(CelldetectiveWidget):
+    """
+    A customizable widget for displaying and managing a list of items, with the
+    ability to add and remove items interactively.
+
+    This widget is built around a `QListWidget` and allows for initialization with
+    a set of features. It also provides options to retrieve the items, add new items
+    using a custom widget, and remove selected items. The items can be parsed and
+    returned as a list, with support for various data types and formatted input (e.g.,
+    ranges specified with a dash).
+
+    Parameters
+    ----------
+    choiceWidget : QWidget
+            A custom widget that is used to add new items to the list.
+    initial_features : list
+            A list of initial items to populate the list widget.
+    dtype : type, optional
+            The data type to cast the list items to. Default is `str`.
+
+    Attributes
+    ----------
+    initial_features : list
+            The initial set of features or items displayed in the list.
+    choiceWidget : QWidget
+            The widget used to prompt the user to add new items.
+    dtype : type
+            The data type to convert items into when retrieved from the list.
+    items : list
+            A list to store the current items in the list widget.
+    list_widget : QListWidget
+            The core Qt widget that displays the list of items.
+
+    Methods
+    -------
+    addItem()
+            Opens a new window to add an item to the list using the custom `choiceWidget`.
+    getItems()
+            Retrieves the items from the list widget, parsing ranges (e.g., 'min-max')
+            into two values, and converts them to the specified `dtype`.
+    removeSel()
+            Removes the currently selected item(s) from the list widget and updates the
+            internal `items` list accordingly.
+    """
+
+    def __init__(self, choiceWidget, initial_features, dtype=str, *args, **kwargs):
+
+        super().__init__()
+        self.initial_features = initial_features
+        self.choiceWidget = choiceWidget
+        self.dtype = dtype
+        self.items = []
+
+        self.setFixedHeight(80)
+
+        # Initialize list widget
+        self.list_widget = QListWidget()
+        self.list_widget.addItems(initial_features)
+
+        # Set up layout
+        main_layout = QVBoxLayout()
+        main_layout.addWidget(self.list_widget)
+        self.setLayout(main_layout)
+        center_window(self)
+
+    def addItem(self):
+        """
+        Opens the custom choiceWidget to add a new item to the list.
+        """
+
+        self.addItemWindow = self.choiceWidget(self)
+        self.addItemWindow.show()
+        try:
+            QTimer.singleShot(10, lambda: center_window(self.addItemWindow))
+        except Exception as e:
+            pass
+
+    def addItemToList(self, item):
+        self.list_widget.addItems([item])
+
+    def getItems(self):
+        """
+        Retrieves and returns the items from the list widget.
+
+        This method parses any items that contain a range (formatted as 'min-max')
+        into a list of two values, and casts all items to the specified `dtype`.
+
+        Returns
+        -------
+        list
+                A list of the items in the list widget, with ranges split into two values.
+        """
+
+        items = []
+        for x in range(self.list_widget.count()):
+            if len(self.list_widget.item(x).text().split("-")) == 2:
+                if self.list_widget.item(x).text()[0] == "-":
+                    items.append(self.dtype(self.list_widget.item(x).text()))
+                else:
+                    minn, maxx = self.list_widget.item(x).text().split("-")
+                    to_add = [self.dtype(minn), self.dtype(maxx)]
+                    items.append(to_add)
+            else:
+                items.append(self.dtype(self.list_widget.item(x).text()))
+        return items
+
+    def clear(self):
+        self.items = []
+        self.list_widget.clear()
+
+    def removeSel(self):
+        """
+        Removes the selected item(s) from the list widget.
+
+        If there are any selected items, they are removed both from the visual list
+        and the internal `items` list that tracks the current state of the widget.
+        """
+
+        listItems = self.list_widget.selectedItems()
+        if not listItems:
+            return
+        for item in listItems:
+            idx = self.list_widget.row(item)
+            self.list_widget.takeItem(idx)
+            if self.items:
+                del self.items[idx]