from dev repo; merge into Main

Author: MMathisLab

napari_cellseg3d/_tests/res/test.tif

@@ -1,4 +1,5 @@
 from typing import Union
+from typing import Optional
 
 from qtpy.QtCore import Qt
 from qtpy.QtCore import QUrl
@@ -312,6 +313,32 @@ def make_button(
     return btn
 
 
+class DropdownMenu(QComboBox):
+    """Creates a dropdown menu with a title and adds specified entries to it"""
+
+    def __init__(
+        self,
+        entries: Optional[list] = None,
+        parent: Optional[QWidget] = None,
+        label: Optional[str] = None,
+        fixed: Optional[bool] = True,
+    ):
+        """Args:
+        entries (array(str)): Entries to add to the dropdown menu. Defaults to None, no entries if None
+        parent (QWidget): parent QWidget to add dropdown menu to. Defaults to None, no parent is set if None
+        label (str) : if not None, creates a QLabel with the contents of 'label', and returns the label as well
+        fixed (bool): if True, will set the size policy of the dropdown menu to Fixed in h and w. Defaults to True.
+        """
+        super().__init__(parent)
+        self.label = None
+        if entries is not None:
+            self.addItems(entries)
+        if label is not None:
+            self.label = QLabel(label)
+        if fixed:
+            self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+
 def make_combobox(
     entries=None,
     parent: QWidget = None,
@@ -329,22 +356,13 @@ def make_combobox(
     Returns:
         QComboBox : created dropdown menu
     """
-    if parent is None:
-        menu = QComboBox()
-    else:
-        menu = QComboBox(parent)
-
-    if entries is not None:
-        menu.addItems(entries)
-
-    if fixed:
-        menu.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
-
     if label is not None:
-        label = QLabel(label)
+        menu = DropdownMenu(entries, parent, label, fixed)
+        label = menu.label
         return menu, label
-
-    return menu
+    else:
+        menu = DropdownMenu(entries, parent, fixed=fixed)
+        return menu
 
 
 def add_widgets(layout, widgets, alignment=LEFT_AL):
@@ -363,6 +381,30 @@ def add_widgets(layout, widgets, alignment=LEFT_AL):
             layout.addWidget(w, alignment=alignment)
 
 
+class CheckBox(QCheckBox):
+    """Shortcut for creating QCheckBox with a title and a function"""
+
+    def __init__(
+        self,
+        title: Optional[str] = None,
+        func: Optional[callable] = None,
+        parent: Optional[QWidget] = None,
+        fixed: Optional[bool] = True,
+    ):
+        """
+        Args:
+            title (str-like): title of the checkbox. Defaults to None, if None no title is set
+            func (callable): function to execute when checkbox is toggled. Defaults to None, no binding is made if None
+            parent (QWidget): parent QWidget to add checkbox to. Defaults to None, no parent is set if None
+            fixed (bool): if True, will set the size policy of the checkbox to Fixed in h and w. Defaults to True.
+        """
+        super().__init__(title, parent)
+        if fixed:
+            self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+        if func is not None:
+            self.toggled.connect(func)
+
+
 def make_checkbox(
     title: str = None,
     func: callable = None,
@@ -378,26 +420,10 @@ def make_checkbox(
         fixed (bool): if True, will set the size policy of the checkbox to Fixed in h and w. Defaults to True.
 
     Returns:
-        QCheckBox : created button
+        QCheckBox : created widget
     """
-    if parent is not None:
-        if title is not None:
-            box = QCheckBox(title, parent)
-        else:
-            box = QCheckBox(parent)
-    else:
-        if title is not None:
-            box = QCheckBox(title, parent)
-        else:
-            box = QCheckBox(parent)
 
-    if fixed:
-        box.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
-
-    if func is not None:
-        box.toggled.connect(func)
-
-    return box
+    return CheckBox(title, func, parent, fixed)
 
 
 def combine_blocks(
@@ -456,6 +482,76 @@ def combine_blocks(
     return temp_widget
 
 
+def toggle_visibility(checkbox, widget):
+    """Toggles the visibility of a widget based on the status of a checkbox.
+
+    Args:
+        checkbox: The QCheckbox that determines whether to show or not
+        widget: The widget to hide or show
+    """
+    widget.setVisible(checkbox.isChecked())
+
+
+class AnisotropyWidgets(QWidget):
+    def __init__(self, parent, default_x=1, default_y=1, default_z=1):
+        super().__init__(parent)
+
+        self._layout = QVBoxLayout()
+        self._layout.setSpacing(0)
+        self._layout.setContentsMargins(0, 0, 0, 0)
+
+        self.container, self._boxes_layout = make_container(T=7, parent=parent)
+        self.checkbox = make_checkbox(
+            "Anisotropic data", self.toggle_display_aniso, parent
+        )
+
+        self.box_widgets = make_n_spinboxes(
+            n=3, min=1.0, max=1000, default=1, step=0.5, double=True
+        )
+        self.box_widgets[0].setValue(default_x)  # TODO change default
+        self.box_widgets[1].setValue(default_y)  # TODO change default
+        self.box_widgets[2].setValue(default_z)  # TODO change default
+
+        for w in self.box_widgets:
+            w.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+
+        self.box_widgets_lbl = [
+            make_label("Resolution in " + axis + " (microns) :", parent=parent)
+            for axis in "xyz"
+        ]
+
+        ##################
+        # tooltips
+        self.checkbox.setToolTip(
+            "If you have anisotropic data, you can scale data using your resolution in microns"
+        )
+        [w.setToolTip("Resolution in microns") for w in self.box_widgets]
+        ##################
+
+        self.build()
+
+    def toggle_display_aniso(self):
+        """Shows the choices for correcting anisotropy when viewing results depending on whether :py:attr:`self.checkbox` is checked"""
+        toggle_visibility(self.checkbox, self.container)
+
+    def build(self):
+        [
+            self._boxes_layout.addWidget(widget, alignment=LEFT_AL)
+            for widgets in zip(self.box_widgets_lbl, self.box_widgets)
+            for widget in widgets
+        ]
+        # anisotropy
+        self.container.setLayout(self._boxes_layout)
+        self.container.setVisible(False)
+
+        add_widgets(self._layout, [self.checkbox, self.container])
+        self.setLayout(self._layout)
+
+    def get_anisotropy_factors(self):
+        """Returns : the resolution in microns for each of the three dimensions"""
+        return [w.value() for w in self.box_widgets]
+
+
 def open_url(url):
     """Opens the url given as a string in OS default browser using :py:func:`QDesktopServices.openUrl`.
 

napari_cellseg3d/interface.py

@@ -9,6 +9,7 @@
 from matplotlib.figure import Figure
 from qtpy.QtWidgets import QSizePolicy
 from scipy import ndimage
+from monai.transforms import Zoom
 from tifffile import imwrite
 
 from napari_cellseg3d import utils
@@ -25,6 +26,7 @@ def launch_review(
     checkbox,
     filetype,
     as_folder,
+    zoom_factor,
 ):
     """Launch the review process, loading the original image, the labels & the raw labels (from prediction)
     in the viewer.
@@ -64,12 +66,13 @@ def launch_review(
 
         as_folder (bool): Whether to load as folder or single file
 
+        zoom_factor (array(int)): zoom factors for each axis
+
 
     """
     images_original = original
     base_label = base
 
-
     view1 = viewer
 
     view1.scale_bar.visible = True
@@ -79,14 +82,17 @@ def launch_review(
         name="volume",
         colormap="inferno",
         contrast_limits=[200, 1000],
+        scale=zoom_factor,
     )  # anything bigger than 255 will get mapped to 255... they did it like this because it must have rgb images
-    view1.add_labels(base_label, name="labels", seed=0.6)
+    view1.add_labels(base_label, name="labels", seed=0.6, scale=zoom_factor)
+
     if raw is not None:  # raw labels is from the prediction
         view1.add_image(
             ndimage.gaussian_filter(raw, sigma=3),
             colormap="magenta",
             name="low_confident",
             blending="additive",
+            scale=zoom_factor,
         )
     else:
         pass
@@ -199,17 +205,17 @@ def quicksave():
 
         xy_axes = canvas.figure.add_subplot(3, 1, 1)
         canvas.figure.suptitle("Shift-click on image for plot \n", fontsize=8)
-        xy_axes.imshow(np.zeros((100, 100), np.uint8))
+        xy_axes.imshow(np.zeros((100, 100), np.int16))
         xy_axes.scatter(50, 50, s=10, c="red", alpha=0.25)
         xy_axes.set_xlabel("x axis")
         xy_axes.set_ylabel("y axis")
         yz_axes = canvas.figure.add_subplot(3, 1, 2)
-        yz_axes.imshow(np.zeros((100, 100), np.uint8))
+        yz_axes.imshow(np.zeros((100, 100), np.int16))
         yz_axes.scatter(50, 50, s=10, c="red", alpha=0.25)
         yz_axes.set_xlabel("y axis")
         yz_axes.set_ylabel("z axis")
         zx_axes = canvas.figure.add_subplot(3, 1, 3)
-        zx_axes.imshow(np.zeros((100, 100), np.uint8))
+        zx_axes.imshow(np.zeros((100, 100), np.int16))
         zx_axes.scatter(50, 50, s=10, c="red", alpha=0.25)
         zx_axes.set_xlabel("x axis")
         zx_axes.set_ylabel("z axis")
@@ -232,12 +238,13 @@ def update_canvas_canvas(viewer, event):
                 print(m_point)
 
                 crop_big = crop_img(
-                    [m_point[0], m_point[1], m_point[2]], viewer.layers[0]
+                    [m_point[0], m_point[1], m_point[2]],
+                    viewer.layers["volume"],
                 )
 
-                xy_axes.imshow(crop_big[50], "gray")
-                yz_axes.imshow(crop_big.transpose(1, 0, 2)[50], "gray")
-                zx_axes.imshow(crop_big.transpose(2, 0, 1)[50], "gray")
+                xy_axes.imshow(crop_big[50], cmap="inferno", vmin=200, vmax=2000)
+                yz_axes.imshow(crop_big.transpose(1, 0, 2)[50], cmap="inferno", vmin=200, vmax=2000)
+                zx_axes.imshow(crop_big.transpose(2, 0, 1)[50], cmap="inferno", vmin=200, vmax=2000)
                 canvas.draw_idle()
             except Exception as e:
                 print(e)
@@ -256,21 +263,36 @@ def update_button(axis_event):
     view1.dims.events.current_step.connect(update_button)
 
     def crop_img(points, layer):
+
+        if zoom_factor != [1,1,1]:
+            im = np.array(layer.data, dtype=np.int16)
+            image = Zoom(
+                zoom_factor,
+                keep_size=False,
+                padding_mode="empty",
+            )(np.expand_dims(im, axis=0))
+            image = image[0]
+        # image = ndimage.zoom(layer.data, zoom_factor, mode="nearest") # cleaner but much slower...
+        else :
+            image = layer.data
+
         min_vals = [x - 50 for x in points]
         max_vals = [x + 50 for x in points]
         yohaku_minus = [n if n < 0 else 0 for n in min_vals]
         yohaku_plus = [
-            x - layer.data.shape[i] if layer.data.shape[i] < x else 0
+            x - image.shape[i] if image.shape[i] < x else 0
             for i, x in enumerate(max_vals)
         ]
         crop_slice = tuple(
             slice(np.maximum(0, n), x) for n, x in zip(min_vals, max_vals)
         )
+
         if as_folder:
-            crop_temp = layer.data[crop_slice].persist().compute()
+            crop_temp = image[crop_slice].persist().compute()
         else:
+
             crop_temp = layer.data[crop_slice]
-        cropped_img = np.zeros((100, 100, 100), np.uint8)
+        cropped_img = np.zeros((100, 100, 100), np.int16)
         cropped_img[
             -yohaku_minus[0] : 100 - yohaku_plus[0],
             -yohaku_minus[1] : 100 - yohaku_plus[1],

napari_cellseg3d/launch_review.py

@@ -130,15 +130,6 @@ def __init__(self, viewer: "napari.viewer.Viewer"):
         self.btn_save_log.setVisible(False)
         #####################################################
 
-    def toggle_visibility(self, checkbox, widget):
-        """Toggles the visibility of a widget based on the status of a checkbox.
-
-        Args:
-            checkbox: The QCheckbox that determines whether to show or not
-            widget: The widget to hide or show
-        """
-        widget.setVisible(checkbox.isChecked())
-
     def send_log(self, text):
         """Emit a signal to print in a Log"""
         self.log.print_and_log(text)
@@ -231,7 +222,7 @@ def display_status_report(self):
 
     def toggle_weights_path(self):
         """Toggle visibility of weight path"""
-        self.toggle_visibility(
+        ui.toggle_visibility(
             self.custom_weights_choice, self.weights_path_container
         )
 

napari_cellseg3d/model_framework.py

@@ -218,6 +218,11 @@ def volume_stats(volume_image):
     def fill(lst, n=len(properties) - 1):
         return fill_list_in_between(lst, n, "")
 
+    if len(volume_image.flatten()) != 0:
+        ratio = fill([np.sum(volume) / len(volume_image.flatten())])
+    else:
+        ratio = 0
+
     return {
         "Volume": volume,
         "Centroid x": [region.centroid[0] for region in properties],
@@ -228,6 +233,6 @@ def fill(lst, n=len(properties) - 1):
         "Image size": fill([volume_image.shape]),
         "Total image volume": fill([len(volume_image.flatten())]),
         "Total object volume (pixels)": fill([np.sum(volume)]),
-        "Filling ratio": fill([np.sum(volume) / len(volume_image.flatten())]),
+        "Filling ratio": ratio,
         "Number objects": fill([len(properties)]),
     }