Front end dev

src/client/dcp_client/app.py

@@ -6,6 +6,10 @@
 from dcp_client.utils import utils
 from dcp_client.utils import settings
 
+#changed from here
+from skimage.feature import canny, peak_local_max
+import numpy as np
+import cv2
 
 class Model(ABC):
     @abstractmethod
@@ -138,4 +142,83 @@ def delete_images(self, image_names):
             if os.path.exists(os.path.join(self.cur_selected_path, image_name)):    
                 self.fs_image_storage.delete_image(self.cur_selected_path, image_name)
 
+
+class Compute4Mask:
+
+    @staticmethod
+    def get_unique_objects(active_mask):
+        """
+        Get unique objects from the active mask.
+        """
+
+        return set(np.unique(active_mask)[1:])
+
+    @staticmethod
+    def find_edges(instance_mask, idx=None):
+        '''
+        Find edges in the instance mask.
+
+        Parameters:
+        - instance_mask (numpy.ndarray): The instance mask array.
+        - idx (list, optional): Indices of specific labels to get contours.
+
+        Returns:
+        - numpy.ndarray: Array representing edges in the instance segmentation mask.
+        '''
+        if idx is not None and not isinstance(idx, list):
+            idx = [idx]
+
+        instances = np.unique(instance_mask)[1:]
+        edges = np.zeros_like(instance_mask).astype(int)
+
+        # to merge the discontinuous contours
+        kernel = np.ones((5, 5))
+
+        if len(instances):
+            for i in instances:
+                if idx is None or i in idx:
+
+                    mask_instance = (instance_mask == i).astype(np.uint8)
+
+                    edge_mask = 255 * (canny(255 * (mask_instance)) > 0).astype(np.uint8)
+                    edge_mask = cv2.morphologyEx(
+                        edge_mask, 
+                        cv2.MORPH_CLOSE, 
+                        kernel,
+                    )
+                    edges = edges + edge_mask
+
+            # if masks are intersecting then we want to count it only once
+            edges = edges > 0
+
+            return edges
+
+    @staticmethod    
+    def get_rounded_pos(event_position):
+        """
+        Get rounded position from the event position.
+        """
+
+        c, event_x, event_y = event_position
+        return int(c), int(np.round(event_x)), int(np.round(event_y))
+
+    @staticmethod
+    def argmax (counts):
+
+       return np.argmax(counts)
+
+    @staticmethod
+    def get_unique_counts_around_event(source_mask, c, event_x, event_y):
+        """
+        Get unique counts around the specified event position in the source mask.
+        """
+        return np.unique(source_mask[c, event_x - 1: event_x + 2, event_y - 1: event_y + 2], return_counts=True)
+
+    @staticmethod
+    def get_unique_counts_for_mask(source_mask, c, mask_fill):
+        """
+        Get unique counts for the specified mask in the source mask.
+        """
+        return np.unique(source_mask[abs(c - 1)][mask_fill], return_counts=True) 
+
 

src/client/dcp_client/gui/main_window.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
-from PyQt5.QtWidgets import QWidget, QPushButton, QVBoxLayout, QFileSystemModel, QHBoxLayout, QLabel, QTreeView
-from PyQt5.QtCore import Qt
+from qtpy.QtWidgets import QWidget, QPushButton, QVBoxLayout, QFileSystemModel, QHBoxLayout, QLabel, QTreeView
+from qtpy.QtCore import Qt
 
 from dcp_client.utils import settings
 from dcp_client.utils.utils import IconProvider, create_warning_box
@@ -12,6 +12,7 @@
     from dcp_client.app import Application
 
 
+
 class MainWindow(QWidget):
     '''Main Window Widget object.
     Opens the main window of the app where selected images in both directories are listed. 
@@ -147,7 +148,7 @@ def on_launch_napari_button_clicked(self):
             create_warning_box(message_text, message_title="Warning")
         else:
             self.nap_win = NapariWindow(self.app)
-            self.nap_win.show()
+            self.nap_win.show() 
 
 if __name__ == "__main__":
     import sys

src/client/dcp_client/gui/napari_window.py

@@ -1,14 +1,30 @@
 from __future__ import annotations
 from typing import List, TYPE_CHECKING
 
-from PyQt5.QtWidgets import QWidget, QPushButton, QVBoxLayout, QHBoxLayout
+from qtpy.QtWidgets import QWidget, QPushButton, QComboBox, QLabel, QGridLayout
+from qtpy.QtCore import Qt
 import napari
+from napari.qt import thread_worker
+from dcp_client.app import Compute4Mask
+
 
 if TYPE_CHECKING:
     from dcp_client.app import Application
 
 from dcp_client.utils import utils
 
+widget_list = [
+    'ellipse_button',
+    'line_button',
+    'path_button',
+    'polygon_button',
+    'vertex_remove_button',
+    'vertex_insert_button',
+    'move_back_button',
+    'move_front_button',
+    'label_eraser',
+]
+
 class NapariWindow(QWidget):
     '''Napari Window Widget object.
     Opens the napari image viewer to view and fix the labeles.
@@ -27,28 +43,182 @@ def __init__(self, app: Application):
 
         # Set the viewer
         self.viewer = napari.Viewer(show=False)
+
         self.viewer.add_image(img, name=utils.get_path_stem(self.app.cur_selected_img))
+
         for seg_file in self.app.seg_filepaths:
             self.viewer.add_labels(self.app.load_image(seg_file), name=utils.get_path_stem(seg_file))
 
+        self.layer = self.viewer.layers[utils.get_path_stem(self.app.seg_filepaths[0])]
+        self.qctrl = self.viewer.window.qt_viewer.controls.widgets[self.layer]
+
+        self.changed = False
+        self.event_coords = None
+        self.active_mask_instance = None
+
         main_window = self.viewer.window._qt_window
-        layout = QVBoxLayout()
-        layout.addWidget(main_window)
+
+        layout = QGridLayout()
+        layout.addWidget(main_window, 0, 0, 1, 4)
+
+        # set first mask as active by default
+        self.active_mask_index = 0
+
+        # unique labels
+        self.instances = Compute4Mask.get_unique_objects(self.layer.data[self.active_mask_index])
+
+        # for copying contours
+        self.instances_updated = set()
+
+        # For each instance find the contours and set the color of it to 0 to be invisible
+        edges = Compute4Mask.find_edges(instance_mask=self.layer.data[0])
+        self.layer.data = self.layer.data * (~edges).astype(int)
+
+        self.switch_to_active_mask()
+
+        if self.layer.data.shape[0] >= 2:
+            # User hint
+            message_label = QLabel('Choose an active mask')
+            message_label.setAlignment(Qt.AlignRight)
+            layout.addWidget(message_label, 1, 0)
+
+        # Drop list to choose which is an active mask
+
+            self.mask_choice_dropdown = QComboBox()
+            self.mask_choice_dropdown.setEnabled(False)
+            self.mask_choice_dropdown.addItem('Instance Segmentation Mask', userData=0)
+            self.mask_choice_dropdown.addItem('Labels Mask', userData=1)
+            layout.addWidget(self.mask_choice_dropdown, 1, 1)
+
+            # when user has chosens the mask, we don't want to change it anymore to avoid errors
+            lock_button = QPushButton("Confirm Final Choice")
+            lock_button.setEnabled(False)
+            lock_button.clicked.connect(self.set_active_mask)
+
+            layout.addWidget(lock_button, 1, 2)
+            self.layer.mouse_drag_callbacks.append(self.copy_mask_callback)
+            self.layer.events.set_data.connect(lambda event: self.copy_mask_callback(self.layer, event))
 
-        buttons_layout = QHBoxLayout()
 
         add_to_inprogress_button = QPushButton('Move to \'Curatation in progress\' folder')
-        buttons_layout.addWidget(add_to_inprogress_button)
+        layout.addWidget(add_to_inprogress_button, 2, 0, 1, 2)
         add_to_inprogress_button.clicked.connect(self.on_add_to_inprogress_button_clicked)
 
         add_to_curated_button = QPushButton('Move to \'Curated dataset\' folder')
-        buttons_layout.addWidget(add_to_curated_button)
+        layout.addWidget(add_to_curated_button, 2, 2, 1, 2)
         add_to_curated_button.clicked.connect(self.on_add_to_curated_button_clicked)
 
-        layout.addLayout(buttons_layout)
-
         self.setLayout(layout)
-        self.show()
+
+    def switch_controls(self, target_widget, status: bool):
+        """
+        Enable or disable a specific widget.
+
+        Parameters:
+        - target_widget (str): The name of the widget to be controlled within the QCtrl object.
+        - status (bool): If True, the widget will be enabled; if False, it will be disabled.
+
+        """
+        getattr(self.qctrl, target_widget).setEnabled(status)
+
+    def switch_to_active_mask(self):
+        """
+        Switch the application to the active mask mode by enabling 'paint_button', 'erase_button' 
+        and 'fill_button'.
+        """
+
+        self.switch_controls("paint_button", True)
+        self.switch_controls("erase_button", True)
+        self.switch_controls("fill_button", True)
+
+        self.active_mask = True
+
+    def switch_to_non_active_mask(self):
+        """
+        Switch the application to non-active mask mode by enabling 'fill_button' and disabling 'paint_button' and 'erase_button'.
+        """
+
+        self.instances = Compute4Mask.get_unique_objects(self.layer.data[self.active_mask_index])
+
+
+        self.switch_controls("paint_button", False)
+        self.switch_controls("erase_button", False)
+        self.switch_controls("fill_button", True) 
+
+        self.active_mask = False
+
+    def set_active_mask(self):
+        """
+        Sets the active mask index based on the drop down list, by default 
+        instance segmentation mask is an active mask with index 0.
+        If the active mask index is 1, it switches to non-active mask mode.
+        """
+        if self.active_mask_index == 1:
+            self.switch_to_non_active_mask()
+
+
+    def copy_mask_callback(self, layer, event):
+        """
+        Handles mouse press and set data events to copy masks based on the active mask index.
+        Parameters:
+            - layer: The layer object associated with the mask.
+            - event: The event triggering the callback.
+        """
+
+        source_mask = layer.data
+
+        if event.type == "mouse_press":
+
+            c, event_x, event_y = Compute4Mask.get_rounded_pos(event.position)
+            self.event_coords = (c, event_x, event_y)
+
+
+        elif event.type == "set_data":
+
+            if self.viewer.dims.current_step[0] == self.active_mask_index:
+                self.switch_to_active_mask()
+            else:
+                self.switch_to_non_active_mask()
+
+            if self.event_coords is not None:
+
+                c, event_x, event_y = self.event_coords
+
+                if c == self.active_mask_index:
+
+                    # When clicking, the mouse provides a continuous position.
+                    # To identify the color placement, we examine nearby positions within one pixel [idx_x - 1, idx_x + 1] and [idx_y - 1, idx_y + 1].
+
+                    labels, counts = Compute4Mask.get_unique_counts_around_event(source_mask, c, event_x, event_y)
+
+                    if labels.size > 0:
+
+                        # index of the most common color in the area around the click excluding 0 
+                        idx = Compute4Mask.argmax(counts)
+                        # the most common color in the area around the click 
+                        label = labels[idx]
+                        # get the mask of the instance
+                        mask_fill = source_mask[c] == label
+
+                        # Find the color of the label mask at the given point
+                        # Determine the most common color in the label mask
+                        labels_seg, counts_seg = Compute4Mask.get_unique_counts_for_mask(source_mask, c, mask_fill)
+                        idx_seg = Compute4Mask.argmax(counts_seg)
+                        label_seg = labels_seg[idx_seg]
+
+                        # If a new color is used, then it is copied to a label mask
+                        # Otherwise, we copy the existing color from the label mask 
+
+                        if not label in self.instances:
+                            source_mask[abs(c - 1)][mask_fill] = label
+                        else:
+                            source_mask[abs(c - 1)][mask_fill] = label_seg
+
+                else:
+                    # the only action to be applied to the instance mask is erasing.
+                    mask_fill = source_mask[abs(c - 1)] == 0
+                    source_mask[c][mask_fill] = 0
+
 
     def on_add_to_curated_button_clicked(self):
         '''
@@ -66,6 +236,7 @@ def on_add_to_curated_button_clicked(self):
             message_text = "Please select the segmenation you wish to save from the layer list"
             utils.create_warning_box(message_text, message_title="Warning")
             return
+
         seg = self.viewer.layers[cur_seg_selected].data
 
         # Move original image
@@ -78,6 +249,7 @@ def on_add_to_curated_button_clicked(self):
         self.app.delete_images(self.app.seg_filepaths)
         # TODO Create the Archive folder for the rest? Or move them as well? 
 
+        self.viewer.close()
         self.close()
 
     def on_add_to_inprogress_button_clicked(self):
@@ -105,4 +277,5 @@ def on_add_to_inprogress_button_clicked(self):
         seg = self.viewer.layers[cur_seg_selected].data
         self.app.save_image(self.app.inprogr_data_path, cur_seg_selected+'.tiff', seg)
 
+        self.viewer.close()
         self.close()

src/client/dcp_client/gui/welcome_window.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
-from PyQt5.QtWidgets import QWidget, QPushButton, QVBoxLayout, QHBoxLayout, QLabel, QFileDialog, QLineEdit
-from PyQt5.QtCore import Qt
+from qtpy.QtWidgets import QWidget, QPushButton, QVBoxLayout, QHBoxLayout, QLabel, QFileDialog, QLineEdit
+from qtpy.QtCore import Qt
 
 from dcp_client.gui.main_window import MainWindow
 from dcp_client.utils.utils import create_warning_box