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

celldetective/gui/viewers/spot_detection_viewer.py

@@ -0,0 +1,341 @@
+import os
+from glob import glob
+from pathlib import Path
+
+import numpy as np
+from PyQt5.QtCore import QSize
+from PyQt5.QtGui import QDoubleValidator
+from PyQt5.QtWidgets import QMessageBox, QHBoxLayout, QLabel, QComboBox, QLineEdit, QPushButton
+from fonticon_mdi6 import MDI6
+from natsort import natsorted
+from superqt.fonticon import icon
+
+from celldetective.gui.gui_utils import PreprocessingLayout2
+from celldetective.gui.viewers.base_viewer import StackVisualizer
+from celldetective.utils.image_loaders import load_frames
+from celldetective import get_logger
+
+logger = get_logger(__name__)
+
+class SpotDetectionVisualizer(StackVisualizer):
+
+    def __init__(
+        self,
+        parent_channel_cb=None,
+        parent_diameter_le=None,
+        parent_threshold_le=None,
+        parent_preprocessing_list=None,
+        cell_type="targets",
+        labels=None,
+        *args,
+        **kwargs,
+    ):
+
+        super().__init__(*args, **kwargs)
+
+        self.cell_type = cell_type
+        self.labels = labels
+        self.detection_channel = self.target_channel
+        self.switch_from_channel = False
+
+        self.parent_channel_cb = parent_channel_cb
+        self.parent_diameter_le = parent_diameter_le
+        self.parent_threshold_le = parent_threshold_le
+        self.parent_preprocessing_list = parent_preprocessing_list
+
+        self.spot_sizes = []
+        self.floatValidator = QDoubleValidator()
+        self.init_scatter()
+
+        self.generate_detection_channel()
+        self.detection_channel = self.detection_channel_cb.currentIndex()
+
+        self.generate_spot_detection_params()
+        self.generate_add_measurement_btn()
+        self.load_labels()
+        self.change_frame(self.mid_time)
+
+        self.ax.callbacks.connect("xlim_changed", self.update_marker_sizes)
+        self.ax.callbacks.connect("ylim_changed", self.update_marker_sizes)
+
+        self.apply_diam_btn.clicked.connect(self.detect_and_display_spots)
+        self.apply_thresh_btn.clicked.connect(self.detect_and_display_spots)
+
+        self.channel_cb.setCurrentIndex(self.target_channel)
+        self.detection_channel_cb.setCurrentIndex(self.target_channel)
+
+    def update_marker_sizes(self, event=None):
+
+        # Get axis bounds
+        xlim = self.ax.get_xlim()
+        ylim = self.ax.get_ylim()
+
+        # Data-to-pixel scale
+        ax_width_in_pixels = self.ax.bbox.width
+        ax_height_in_pixels = self.ax.bbox.height
+
+        x_scale = (float(xlim[1]) - float(xlim[0])) / ax_width_in_pixels
+        y_scale = (float(ylim[1]) - float(ylim[0])) / ax_height_in_pixels
+
+        # Choose the smaller scale for square pixels
+        scale = min(x_scale, y_scale)
+
+        # Convert radius_px to data units
+        if len(self.spot_sizes) > 0:
+
+            radius_data_units = self.spot_sizes / float(scale)
+
+            # Convert to scatter `s` size (points squared)
+            radius_pts = radius_data_units * (72.0 / self.fig.dpi)
+            size = np.pi * (radius_pts**2)
+
+            # Update scatter sizes
+            self.spot_scat.set_sizes(size)
+            self.fig.canvas.draw_idle()
+
+    def init_scatter(self):
+        self.spot_scat = self.ax.scatter(
+            [], [], s=50, facecolors="none", edgecolors="tab:red", zorder=100
+        )
+        self.canvas.canvas.draw()
+
+    def change_frame(self, value):
+
+        super().change_frame(value)
+        if not self.switch_from_channel:
+            self.reset_detection()
+
+        if self.mode == "virtual":
+            from tifffile import imread
+
+            self.init_label = imread(self.mask_paths[value])
+            self.target_img = load_frames(
+                self.img_num_per_channel[self.detection_channel, value],
+                self.stack_path,
+                normalize_input=False,
+            )[:, :, 0]
+        elif self.mode == "direct":
+            self.init_label = self.labels[value, :, :]
+            self.target_img = self.stack[value, :, :, self.detection_channel].copy()
+
+    def detect_and_display_spots(self):
+
+        self.reset_detection()
+        self.control_valid_parameters()  # set current diam and threshold
+        # self.change_frame(self.frame_slider.value())
+        # self.set_detection_channel_index(self.detection_channel_cb.currentIndex())
+
+        image_preprocessing = self.preprocessing.list.items
+        if image_preprocessing == []:
+            image_preprocessing = None
+
+        from celldetective.measure import extract_blobs_in_image
+
+        blobs_filtered = extract_blobs_in_image(
+            self.target_img,
+            self.init_label,
+            threshold=self.thresh,
+            diameter=self.diameter,
+            image_preprocessing=image_preprocessing,
+        )
+        if blobs_filtered is not None:
+            self.spot_positions = np.array([[x, y] for y, x, _ in blobs_filtered])
+            if len(self.spot_positions) > 0:
+                self.spot_sizes = np.sqrt(2) * np.array(
+                    [sig for _, _, sig in blobs_filtered]
+                )
+            # radius_pts = self.spot_sizes * (self.fig.dpi / 72.0)
+            # sizes = np.pi*(radius_pts**2)
+            if len(self.spot_positions) > 0:
+                self.spot_scat.set_offsets(self.spot_positions)
+            else:
+                empty_offset = np.ma.masked_array([0, 0], mask=True)
+                self.spot_scat.set_offsets(empty_offset)
+            # self.spot_scat.set_sizes(sizes)
+            if len(self.spot_positions) > 0:
+                self.update_marker_sizes()
+            self.canvas.canvas.draw()
+
+    def reset_detection(self):
+
+        self.ax.scatter([], []).get_offsets()
+        empty_offset = np.ma.masked_array([0, 0], mask=True)
+        self.spot_scat.set_offsets(empty_offset)
+        self.canvas.canvas.draw()
+
+    def load_labels(self):
+
+        # Load the cell labels
+        if self.labels is not None:
+
+            if isinstance(self.labels, list):
+                self.labels = np.array(self.labels)
+
+            assert (
+                self.labels.ndim == 3
+            ), "Wrong dimensions for the provided labels, expect TXY"
+            assert len(self.labels) == self.stack_length
+
+            self.mode = "direct"
+            self.init_label = self.labels[self.mid_time, :, :]
+        else:
+            self.mode = "virtual"
+            assert isinstance(self.stack_path, str)
+            assert self.stack_path.endswith(".tif")
+            self.locate_labels_virtual()
+
+    def locate_labels_virtual(self):
+        # Locate virtual labels
+
+        labels_path = (
+            str(Path(self.stack_path).parent.parent)
+            + os.sep
+            + f"labels_{self.cell_type}"
+            + os.sep
+        )
+        self.mask_paths = natsorted(glob(labels_path + "*.tif"))
+
+        if len(self.mask_paths) == 0:
+
+            msgBox = QMessageBox()
+            msgBox.setIcon(QMessageBox.Critical)
+            msgBox.setText("No labels were found for the selected cells. Abort.")
+            msgBox.setWindowTitle("Critical")
+            msgBox.setStandardButtons(QMessageBox.Ok)
+            returnValue = msgBox.exec()
+            self.close()
+
+        from tifffile import imread
+
+        self.init_label = imread(self.mask_paths[self.frame_slider.value()])
+
+    def generate_detection_channel(self):
+
+        assert self.channel_names is not None
+        assert len(self.channel_names) == self.n_channels
+
+        channel_layout = QHBoxLayout()
+        channel_layout.setContentsMargins(15, 0, 15, 0)
+        channel_layout.addWidget(QLabel("Detection\nchannel: "), 25)
+
+        self.detection_channel_cb = QComboBox()
+        self.detection_channel_cb.addItems(self.channel_names)
+        self.detection_channel_cb.currentIndexChanged.connect(
+            self.set_detection_channel_index
+        )
+        channel_layout.addWidget(self.detection_channel_cb, 75)
+
+        # self.invert_check = QCheckBox('invert')
+        # if self.invert:
+        # 	self.invert_check.setChecked(True)
+        # self.invert_check.toggled.connect(self.set_invert)
+        # channel_layout.addWidget(self.invert_check, 10)
+
+        self.canvas.layout.addLayout(channel_layout)
+
+        self.preprocessing = PreprocessingLayout2(fraction=25, parent_window=self)
+        self.preprocessing.setContentsMargins(15, 0, 15, 0)
+        self.canvas.layout.addLayout(self.preprocessing)
+
+    # def set_invert(self):
+    # 	if self.invert_check.isChecked():
+    # 		self.invert = True
+    # 	else:
+    # 		self.invert = False
+
+    def set_detection_channel_index(self, value):
+
+        self.detection_channel = value
+        if self.mode == "direct":
+            self.target_img = self.stack[-1, :, :, self.detection_channel]
+        elif self.mode == "virtual":
+            self.target_img = load_frames(
+                self.img_num_per_channel[
+                    self.detection_channel, self.frame_slider.value()
+                ],
+                self.stack_path,
+                normalize_input=False,
+            ).astype(float)[:, :, 0]
+
+    def generate_spot_detection_params(self):
+
+        self.spot_diam_le = QLineEdit("1")
+        self.spot_diam_le.setValidator(self.floatValidator)
+        self.apply_diam_btn = QPushButton("Set")
+        self.apply_diam_btn.setStyleSheet(self.button_style_sheet_2)
+
+        self.spot_thresh_le = QLineEdit("0")
+        self.spot_thresh_le.setValidator(self.floatValidator)
+        self.apply_thresh_btn = QPushButton("Set")
+        self.apply_thresh_btn.setStyleSheet(self.button_style_sheet_2)
+
+        self.spot_diam_le.textChanged.connect(self.control_valid_parameters)
+        self.spot_thresh_le.textChanged.connect(self.control_valid_parameters)
+
+        spot_diam_layout = QHBoxLayout()
+        spot_diam_layout.setContentsMargins(15, 0, 15, 0)
+        spot_diam_layout.addWidget(QLabel("Spot diameter: "), 25)
+        spot_diam_layout.addWidget(self.spot_diam_le, 65)
+        spot_diam_layout.addWidget(self.apply_diam_btn, 10)
+        self.canvas.layout.addLayout(spot_diam_layout)
+
+        spot_thresh_layout = QHBoxLayout()
+        spot_thresh_layout.setContentsMargins(15, 0, 15, 0)
+        spot_thresh_layout.addWidget(QLabel("Detection\nthreshold: "), 25)
+        spot_thresh_layout.addWidget(self.spot_thresh_le, 65)
+        spot_thresh_layout.addWidget(self.apply_thresh_btn, 10)
+        self.canvas.layout.addLayout(spot_thresh_layout)
+
+    def generate_add_measurement_btn(self):
+
+        add_hbox = QHBoxLayout()
+        self.add_measurement_btn = QPushButton("Add measurement")
+        self.add_measurement_btn.clicked.connect(self.set_measurement_in_parent_list)
+        self.add_measurement_btn.setIcon(icon(MDI6.plus, color="white"))
+        self.add_measurement_btn.setIconSize(QSize(20, 20))
+        self.add_measurement_btn.setStyleSheet(self.button_style_sheet)
+        add_hbox.addWidget(QLabel(""), 33)
+        add_hbox.addWidget(self.add_measurement_btn, 33)
+        add_hbox.addWidget(QLabel(""), 33)
+        self.canvas.layout.addLayout(add_hbox)
+
+    def control_valid_parameters(self):
+
+        valid_diam = False
+        try:
+            self.diameter = float(self.spot_diam_le.text().replace(",", "."))
+            valid_diam = True
+        except:
+            valid_diam = False
+
+        valid_thresh = False
+        try:
+            self.thresh = float(self.spot_thresh_le.text().replace(",", "."))
+            valid_thresh = True
+        except:
+            valid_thresh = False
+
+        if valid_diam and valid_thresh:
+            self.apply_diam_btn.setEnabled(True)
+            self.apply_thresh_btn.setEnabled(True)
+            self.add_measurement_btn.setEnabled(True)
+        else:
+            self.apply_diam_btn.setEnabled(False)
+            self.apply_thresh_btn.setEnabled(False)
+            self.add_measurement_btn.setEnabled(False)
+
+    def set_measurement_in_parent_list(self):
+
+        if self.parent_channel_cb is not None:
+            self.parent_channel_cb.setCurrentIndex(self.detection_channel)
+        if self.parent_diameter_le is not None:
+            self.parent_diameter_le.setText(self.spot_diam_le.text())
+        if self.parent_threshold_le is not None:
+            self.parent_threshold_le.setText(self.spot_thresh_le.text())
+        if self.parent_preprocessing_list is not None:
+            self.parent_preprocessing_list.clear()
+            items = self.preprocessing.list.getItems()
+            for item in items:
+                self.parent_preprocessing_list.addItemToList(item)
+            self.parent_preprocessing_list.items = self.preprocessing.list.items
+        self.close()

celldetective/gui/viewers/threshold_viewer.py

@@ -0,0 +1,309 @@
+from collections import OrderedDict
+
+import numpy as np
+from PyQt5.QtWidgets import QLineEdit, QHBoxLayout, QPushButton, QLabel
+from superqt import QLabeledDoubleSlider
+
+from celldetective.gui.gui_utils import QuickSliderLayout
+from celldetective.gui.viewers.base_viewer import StackVisualizer
+from celldetective import get_logger
+
+logger = get_logger(__name__)
+
+
+class ThresholdedStackVisualizer(StackVisualizer):
+    """
+    A widget for visualizing thresholded image stacks with interactive sliders and channel selection.
+
+    Parameters:
+    - preprocessing (list or None): A list of preprocessing filters to apply to the image before thresholding.
+    - parent_le: The parent QLineEdit instance to set the threshold value.
+    - initial_threshold (float): Initial threshold value.
+    - initial_mask_alpha (float): Initial mask opacity value.
+    - args, kwargs: Additional arguments to pass to the parent class constructor.
+
+    Methods:
+    - generate_apply_btn(): Generate the apply button to set the threshold in the parent QLineEdit.
+    - set_threshold_in_parent_le(): Set the threshold value in the parent QLineEdit.
+    - generate_mask_imshow(): Generate the mask imshow.
+    - generate_threshold_slider(): Generate the threshold slider.
+    - generate_opacity_slider(): Generate the opacity slider for the mask.
+    - change_mask_opacity(value): Change the opacity of the mask.
+    - change_threshold(value): Change the threshold value.
+    - change_frame(value): Change the displayed frame and update the threshold.
+    - compute_mask(threshold_value): Compute the mask based on the threshold value.
+    - preprocess_image(): Preprocess the image before thresholding.
+
+    Notes:
+    - This class extends the functionality of StackVisualizer to visualize thresholded image stacks
+      with interactive sliders for threshold and mask opacity adjustment.
+    """
+
+    def __init__(
+        self,
+        preprocessing=None,
+        parent_le=None,
+        initial_threshold=5,
+        initial_mask_alpha=0.5,
+        show_opacity_slider=True,
+        show_threshold_slider=True,
+        fill_holes=True,
+        *args,
+        **kwargs,
+    ):
+        # Initialize the widget and its attributes
+        super().__init__(*args, **kwargs)
+        self.preprocessing = preprocessing
+        self.thresh = initial_threshold
+        self.mask_alpha = initial_mask_alpha
+        self.fill_holes = fill_holes
+        self.parent_le = parent_le
+        self.show_opacity_slider = show_opacity_slider
+        self.show_threshold_slider = show_threshold_slider
+        self.thresholded = False
+        self.mask = np.zeros_like(self.init_frame)
+        self.thresh_min = 0.0
+        self.thresh_max = 30.0
+
+        self.thresh_max = 30.0
+
+        # Cache for processed images
+        self.processed_cache = OrderedDict()
+        self.processed_image = None
+        self.max_processed_cache_size = 128
+
+        self.generate_threshold_slider()
+
+        if self.thresh is not None:
+            self.compute_mask(self.thresh)
+
+        self.generate_mask_imshow()
+        self.generate_scatter()
+        self.generate_opacity_slider()
+        if isinstance(self.parent_le, QLineEdit):
+            self.generate_apply_btn()
+
+    def generate_apply_btn(self):
+        # Generate the apply button to set the threshold in the parent QLineEdit
+        apply_hbox = QHBoxLayout()
+        self.apply_threshold_btn = QPushButton("Apply")
+        self.apply_threshold_btn.clicked.connect(self.set_threshold_in_parent_le)
+        self.apply_threshold_btn.setStyleSheet(self.button_style_sheet)
+        apply_hbox.addWidget(QLabel(""), 33)
+        apply_hbox.addWidget(self.apply_threshold_btn, 33)
+        apply_hbox.addWidget(QLabel(""), 33)
+        self.canvas.layout.addLayout(apply_hbox)
+
+    def closeEvent(self, event):
+        if hasattr(self, "processed_cache") and isinstance(
+            self.processed_cache, OrderedDict
+        ):
+            self.processed_cache.clear()
+        super().closeEvent(event)
+
+    def set_threshold_in_parent_le(self):
+        # Set the threshold value in the parent QLineEdit
+        self.parent_le.set_threshold(self.threshold_slider.value())
+        self.close()
+
+    def generate_mask_imshow(self):
+        # Generate the mask imshow
+
+        self.im_mask = self.ax.imshow(
+            np.ma.masked_where(self.mask == 0, self.mask),
+            alpha=self.mask_alpha,
+            interpolation="none",
+            vmin=0,
+            vmax=1,
+            cmap="Purples",
+        )
+        self.canvas.canvas.draw()
+
+    def generate_scatter(self):
+        self.scat_markers = self.ax.scatter([], [], color="tab:red")
+
+    def generate_threshold_slider(self):
+        # Generate the threshold slider
+        self.threshold_slider = QLabeledDoubleSlider()
+        if self.thresh is None:
+            init_value = 1.0e5
+        elif isinstance(self.thresh, (list, tuple, np.ndarray)):
+            init_value = self.thresh[0]
+        else:
+            init_value = self.thresh
+        thresh_layout = QuickSliderLayout(
+            label="Threshold: ",
+            slider=self.threshold_slider,
+            slider_initial_value=init_value,
+            slider_range=(self.thresh_min, np.amax([self.thresh_max, init_value])),
+            decimal_option=True,
+            precision=4,
+        )
+        thresh_layout.setContentsMargins(15, 0, 15, 0)
+        self.threshold_slider.valueChanged.connect(self.change_threshold)
+        if self.show_threshold_slider:
+            self.canvas.layout.addLayout(thresh_layout)
+
+    def generate_opacity_slider(self):
+        # Generate the opacity slider for the mask
+        self.opacity_slider = QLabeledDoubleSlider()
+        opacity_layout = QuickSliderLayout(
+            label="Opacity: ",
+            slider=self.opacity_slider,
+            slider_initial_value=0.5,
+            slider_range=(0, 1),
+            decimal_option=True,
+            precision=3,
+        )
+        opacity_layout.setContentsMargins(15, 0, 15, 0)
+        self.opacity_slider.valueChanged.connect(self.change_mask_opacity)
+        if self.show_opacity_slider:
+            self.canvas.layout.addLayout(opacity_layout)
+
+    def change_mask_opacity(self, value):
+        # Change the opacity of the mask
+        self.mask_alpha = value
+        self.im_mask.set_alpha(self.mask_alpha)
+        self.canvas.canvas.draw_idle()
+
+    def change_threshold(self, value):
+        # Change the threshold value
+        self.thresh = value
+
+        # Sync slider if value came from external source (like Wizard)
+        # to prevent slider from being "stale" and overwriting with old value later
+        if hasattr(self, "threshold_slider"):
+            display_val = value
+            if isinstance(value, (list, tuple, np.ndarray)):
+                display_val = value[0]
+
+            try:
+                current_val = self.threshold_slider.value()
+                # Update slider if significant difference
+                if abs(current_val - float(display_val)) > 1e-5:
+                    self.threshold_slider.blockSignals(True)
+                    self.threshold_slider.setValue(float(display_val))
+                    self.threshold_slider.blockSignals(False)
+            except Exception:
+                pass
+
+        if self.thresh is not None:
+            self.compute_mask(self.thresh)
+            mask = np.ma.masked_where(self.mask == 0, self.mask)
+            self.im_mask.set_data(mask)
+            self.canvas.canvas.draw_idle()
+
+    def change_frame(self, value):
+        # Change the displayed frame and update the threshold
+        if self.thresholded:
+            self.init_contrast = True
+        super().change_frame(value)
+        self.processed_image = None
+
+        if self.thresh is not None:
+            self.change_threshold(self.thresh)
+        else:
+            self.change_threshold(self.threshold_slider.value())
+
+        if self.thresholded:
+            self.thresholded = False
+            self.init_contrast = False
+
+    def compute_mask(self, threshold_value):
+        # Compute the mask based on the threshold value
+        if self.processed_image is None:
+            self.preprocess_image()
+
+        from celldetective.utils.image_transforms import (
+            estimate_unreliable_edge,
+            threshold_image,
+        )
+
+        edge = estimate_unreliable_edge(self.preprocessing)
+
+        if isinstance(threshold_value, (list, np.ndarray, tuple)):
+            self.mask = threshold_image(
+                self.processed_image,
+                threshold_value[0],
+                threshold_value[1],
+                foreground_value=1,
+                fill_holes=self.fill_holes,
+                edge_exclusion=edge,
+            ).astype(int)
+        else:
+            self.mask = threshold_image(
+                self.processed_image,
+                threshold_value,
+                np.inf,
+                foreground_value=1,
+                fill_holes=self.fill_holes,
+                edge_exclusion=edge,
+            ).astype(int)
+
+    def preprocess_image(self):
+        # Preprocess the image before thresholding
+
+        # Determine cache key
+        target = self.target_channel
+        time_idx = getattr(self, "current_time_index", 0)
+        cache_key = (target, time_idx, str(self.preprocessing))
+
+        # Check cache
+        if self.preprocessing is not None:
+            if cache_key in self.processed_cache:
+                self.processed_image = self.processed_cache[cache_key]
+                self.processed_cache.move_to_end(cache_key)
+                # Ensure slider range is updated even on cache hit?
+                # Probably redundant if image matches, but safe to skip or do lightweight check.
+                return
+
+        # Compute
+        if self.preprocessing is not None:
+            assert isinstance(self.preprocessing, list)
+            from celldetective.filters import filter_image
+
+            self.processed_image = filter_image(
+                self.init_frame.copy().astype(float), filters=self.preprocessing
+            )
+
+            # Subsampled min/max for slider range
+            if self.processed_image.size > 1000000:
+                view = self.processed_image[::30, ::30]
+            else:
+                view = self.processed_image
+
+            min_ = np.nanmin(view)
+            max_ = np.nanmax(view)
+
+            if min_ < self.thresh_min:
+                self.thresh_min = min_
+            if max_ > self.thresh_max:
+                self.thresh_max = max_
+
+            self.threshold_slider.setRange(self.thresh_min, self.thresh_max)
+
+            # Store in cache
+            self.processed_cache[cache_key] = self.processed_image
+            if len(self.processed_cache) > self.max_processed_cache_size:
+                self.processed_cache.popitem(last=False)
+
+        else:
+            # If no preprocessing, just use init_frame (casted)
+            # We don't cache this as it's just a reference or light copy of init_frame
+            self.processed_image = self.init_frame.astype(float)
+
+    def set_preprocessing(self, activation_protocol):
+
+        self.preprocessing = activation_protocol
+        self.preprocess_image()
+
+        self.im.set_data(self.processed_image)
+        vmin = np.nanpercentile(self.processed_image, 1.0)
+        vmax = np.nanpercentile(self.processed_image, 99.99)
+        self.contrast_slider.setRange(
+            np.nanmin(self.processed_image), np.nanmax(self.processed_image)
+        )
+        self.contrast_slider.setValue((vmin, vmax))
+        self.im.set_clim(vmin, vmax)
+        self.canvas.canvas.draw()
+        self.thresholded = True