Merge pull request #50 from computational-cell-analytics/49-plugin-updates

Updates to the plugins

Author: constantinpape

synaptic_reconstruction/distance_measurements.py

@@ -158,16 +158,21 @@ def _compute_seg_object_distances(segmentation, segmented_object, resolution, ve
     n = len(seg_ids)
 
     distances = np.zeros(n)
-    endpoints1 = np.zeros((n, 3), dtype="int")
-    endpoints2 = np.zeros((n, 3), dtype="int")
+    ndim = segmentation.ndim
+    endpoints1 = np.zeros((n, ndim), dtype="int")
+    endpoints2 = np.zeros((n, ndim), dtype="int")
 
     object_ids = []
     # We use this so often, it should be refactored.
     props = regionprops(segmentation)
     for prop in tqdm(props, disable=not verbose):
         bb = prop.bbox
-        offset = np.array(bb[:3])
-        bb = np.s_[bb[0]:bb[3], bb[1]:bb[4], bb[2]:bb[5]]
+        offset = np.array(bb[:ndim])
+        # bb = np.s_[bb[0]:bb[3], bb[1]:bb[4], bb[2]:bb[5]]
+        if len(bb) == 4:  # 2D bounding box
+            bb = np.s_[bb[0]:bb[2], bb[1]:bb[3]]
+        elif len(bb) == 6:  # 3D bounding box
+            bb = np.s_[bb[0]:bb[3], bb[1]:bb[4], bb[2]:bb[5]]
 
         label = prop.label
         mask = segmentation[bb] == label

synaptic_reconstruction/tools/synaptic_plugin/base_widget.py

@@ -3,6 +3,7 @@
 from qtpy.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QPushButton, QFileDialog, QLabel, QSpinBox, QLineEdit, QGroupBox, QFormLayout, QFrame, QComboBox, QCheckBox
 import qtpy.QtWidgets as QtWidgets
 from superqt import QCollapsible
+from magicgui.widgets import create_widget
 
 
 class BaseWidget(QWidget):
@@ -11,6 +12,66 @@ def __init__(self):
         self.viewer = napari.current_viewer()
         self.attribute_dict = {}
 
+    def _create_layer_selector(self, selector_name, layer_type="Image"):
+        """
+        Create a layer selector for an image or labels and store it in a dictionary.
+        
+        Parameters:
+        - selector_name (str): The name of the selector, used as a key in the dictionary.
+        - layer_type (str): The type of layer to filter for ("Image" or "Labels").
+        """
+        if not hasattr(self, "layer_selectors"):
+            self.layer_selectors = {}
+
+        # Determine the annotation type for the widget
+        if layer_type == "Image":
+            layer_filter = napari.layers.Image
+        elif layer_type == "Labels":
+            layer_filter = napari.layers.Labels
+        else:
+            raise ValueError("layer_type must be either 'Image' or 'Labels'.")
+
+        selector_widget = QtWidgets.QWidget()
+        image_selector = QtWidgets.QComboBox()
+        layer_label = QtWidgets.QLabel(f"{selector_name} Layer:")
+        
+        # Populate initial options
+        self._update_selector(selector=image_selector, layer_filter=layer_filter)
+        
+        # Update selector on layer events
+        self.viewer.layers.events.inserted.connect(lambda event: self._update_selector(image_selector, layer_filter))
+        self.viewer.layers.events.removed.connect(lambda event: self._update_selector(image_selector, layer_filter))
+
+        # Store the selector in the dictionary
+        self.layer_selectors[selector_name] = selector_widget
+        
+        # Set up layout
+        layout = QVBoxLayout()
+        layout.addWidget(layer_label)
+        layout.addWidget(image_selector)
+        selector_widget.setLayout(layout)
+        return selector_widget
+    
+    def _update_selector(self, selector, layer_filter):
+        """Update a single selector with the current image layers in the viewer."""
+        selector.clear()
+        image_layers = [layer.name for layer in self.viewer.layers if isinstance(layer, layer_filter)]  # if isinstance(layer, napari.layers.Image)
+        selector.addItems(image_layers)
+
+    def _get_layer_selector_data(self, selector_name):
+        """Return the data for the layer currently selected in a given selector."""
+        if selector_name in self.layer_selectors:
+            selector_widget = self.layer_selectors[selector_name]
+            
+            # Retrieve the QComboBox from the QWidget's layout
+            image_selector = selector_widget.layout().itemAt(1).widget()
+            
+            if isinstance(image_selector, QComboBox):
+                selected_layer_name = image_selector.currentText()
+                if selected_layer_name in self.viewer.layers:
+                    return self.viewer.layers[selected_layer_name].data
+        return None  # Return None if layer not found
+
     def _add_string_param(self, name, value, title=None, placeholder=None, layout=None, tooltip=None):
         if layout is None:
             layout = QtWidgets.QHBoxLayout()

synaptic_reconstruction/tools/synaptic_plugin/distance_measure_widget.py

@@ -17,12 +17,11 @@ def __init__(self):
         self.viewer = napari.current_viewer()
         layout = QVBoxLayout()
 
-        self.selectors = {}
         self.image_selector_name1 = "Segmentation 1"
         self.image_selector_name2 = "Segmentation 2"
         # Create the image selection dropdown
-        self.segmentation1_selector_widget = self.create_image_selector(selector_name=self.image_selector_name1)
-        self.segmentation2_selector_widget = self.create_image_selector(selector_name=self.image_selector_name2)
+        self.segmentation1_selector_widget = self._create_layer_selector(self.image_selector_name1, layer_type="Labels")
+        self.segmentation2_selector_widget = self._create_layer_selector(self.image_selector_name2, layer_type="Labels")
 
         # create save path
         self.settings = self._create_settings_widget()
@@ -45,17 +44,9 @@ def __init__(self):
 
         self.setLayout(layout)
 
-    def get_selected_layer_data(self, selector_name):
-        """Return the data for the layer currently selected in a given selector."""
-        if selector_name in self.selectors:
-            selected_layer_name = self.selectors[selector_name].currentText()
-            if selected_layer_name in self.viewer.layers:
-                return self.viewer.layers[selected_layer_name].data
-        return None  # Return None if layer not found
-
     def on_measure_segmentation_to_object(self):
-        segmentation1_data = self.get_selected_layer_data(self.image_selector_name1)
-        segmentation2_data = self.get_selected_layer_data(self.image_selector_name2)
+        segmentation1_data = self._get_layer_selector_data(self.image_selector_name1)
+        segmentation2_data = self._get_layer_selector_data(self.image_selector_name2)
         if segmentation1_data is None or segmentation2_data is None:
             show_info("Please choose both segmentation layers.")
             return
@@ -64,144 +55,79 @@ def on_measure_segmentation_to_object(self):
         (distances,
          endpoints1,
          endpoints2,
-         seg_ids,
-         object_ids) = distance_measurements.measure_segmentation_to_object_distances(
+         seg_ids) = distance_measurements.measure_segmentation_to_object_distances(
             segmentation=segmentation1_data,
             segmented_object=segmentation2_data,
             distance_type="boundary",
             # save_path=self.save_path
         )
-        if self.save_path is not None:
-            file_path = save_to_csv(self.save_path, data=(distances, endpoints1, endpoints2, seg_ids, object_ids))
+        if self.save_path.text() != "":
+            # save to csv
+            header = "distances endpoints1 endpoints2 seg_ids"
+            header_list = header.split(" ")
+            file_path = save_to_csv(
+                self.save_path.text(),
+                data=(distances, endpoints1, endpoints2, seg_ids),
+                header=header_list
+                )
             show_info(f"Measurements saved to {file_path}")
+        lines, properties = distance_measurements.create_object_distance_lines(
+            distances=distances,
+            endpoints1=endpoints1,
+            endpoints2=endpoints2,
+            seg_ids=seg_ids
+        )
 
-        show_info("Not implemented yet.")
+        # Add the lines layer
+        self.viewer.add_shapes(
+            lines,
+            name="Distance Lines",
+            shape_type="line",  # Specify the shape type as 'line'
+            edge_width=2,
+            edge_color="red",
+            blending="additive",  # Use 'additive' for blending if needed
+        )
+        if self.save_path.text() != "":
+            show_info(f"Added distance lines and saved file to {file_path}.")
+        else:
+            show_info("Added distance lines.")
         return
 
     def on_measure_pairwise(self):
         if self.image is None:
             show_info("Please choose a segmentation.")
             return
-        if self.save_path is None:
+        if self.save_path.value() is None:
             show_info("Please choose a save path.")
             return
-        # get segmentation
-        segmentation = self.image
-        # run measurements
         show_info("Not implemented yet.")
         return
-        distance_measurements.measure_pairwise_object_distances(
-            segmentation=segmentation, distance_type="boundary",
-            save_path=self.save_path
-            )
-        lines, properties = distance_measurements.create_distance_lines(
-            measurement_path=self.save_path
-        )
-
-        # Add the lines layer
-        self.viewer.add_lines(
-            lines, name="Distance Lines", visible=True, edge_width=2, edge_color="red", edge_blend="additive"
-        )
-
-        # layer_kwargs = {"colormap": "inferno", "blending": "additive"}
-        # return segmentation, layer_kwargs
-
-    def create_image_selector(self, selector_name):
-        attribute_dict = {}
-        viewer = self.viewer
-        """Create an image selector widget for a specific layer attribute."""
-        selector_widget = QWidget()
-        image_selector = QComboBox()
-        title_label = QLabel(f"Select Layer for {selector_name}:")
-
-        # Populate initial options
-        self.update_selector(viewer, image_selector)
-
-        # Connect selection change to update image data in attribute_dict
-        image_selector.currentIndexChanged.connect(
-            lambda: self.update_image_data(viewer, image_selector, attribute_dict, selector_name)
-        )
-
-        # Update selector on layer events
-        viewer.layers.events.inserted.connect(lambda event: self.update_selector(viewer, image_selector))
-        viewer.layers.events.removed.connect(lambda event: self.update_selector(viewer, image_selector))
-
-        # Store this combo box in the selectors dictionary
-        self.selectors[selector_name] = image_selector
-
-        # Set up layout
-        layout = QVBoxLayout()
-        layout.addWidget(title_label)
-        layout.addWidget(image_selector)
-        selector_widget.setLayout(layout)
-
-        return selector_widget
-
-    def update_selector(self, viewer, selector):
-        """Update a single selector with the current image layers in the viewer."""
-        selector.clear()
-        image_layers = [layer.name for layer in viewer.layers]  # if isinstance(layer, napari.layers.Image)
-        selector.addItems(image_layers)
-
-    def update_image_data(self, viewer, selector, attribute_dict, attribute_name):
-        """Update the specified attribute in the attribute_dict with selected layer data."""
-        selected_layer_name = selector.currentText()
-        if selected_layer_name in viewer.layers:
-            attribute_dict[attribute_name] = viewer.layers[selected_layer_name].data
-        else:
-            attribute_dict[attribute_name] = None  # Reset if no valid selection
+        # distance_measurements.measure_pairwise_object_distances(
+        #     segmentation=segmentation, distance_type="boundary",
+        #     save_path=self.save_path
+        #     )
+        # lines, properties = distance_measurements.create_distance_lines(
+        #     measurement_path=self.save_path
+        # )
+
+        # # Add the lines layer
+        # self.viewer.add_lines(
+        #     lines, name="Distance Lines", visible=True, edge_width=2, edge_color="red", edge_blend="additive"
+        # )
 
     def _create_settings_widget(self):
         setting_values = QWidget()
         # setting_values.setToolTip(get_tooltip("embedding", "settings"))
         setting_values.setLayout(QVBoxLayout())
 
         self.save_path, layout = self._add_path_param(
-            name="Save Directory", select_type="directory", value=None
+            name="Save Directory", select_type="directory", value=""
         )
         setting_values.layout().addLayout(layout)
 
         settings = self._make_collapsible(widget=setting_values, title="Advanced Settings")
         return settings
 
-    # def create_image_selector(self):
-    #     selector_widget = QWidget()
-    #     self.image_selector = QComboBox()
-
-    #     title_label = QLabel("Select Image Layer:")
-
-    #     # Populate initial options
-    #     self.update_image_selector()
-
-    #     # Connect selection change to update self.image
-    #     self.image_selector.currentIndexChanged.connect(self.update_image_data)
-
-    #     # Connect to Napari layer events to update the list
-    #     self.viewer.layers.events.inserted.connect(self.update_image_selector)
-    #     self.viewer.layers.events.removed.connect(self.update_image_selector)
-
-    #     layout = QVBoxLayout()
-    #     layout.addWidget(title_label)
-    #     layout.addWidget(self.image_selector)
-    #     selector_widget.setLayout(layout)
-    #     return selector_widget
-
-    # def update_image_selector(self, event=None):
-    #     """Update dropdown options with current image layers in the viewer."""
-    #     self.image_selector.clear()
-
-    #     # Add each image layer's name to the dropdown
-    #     image_layers = [layer.name for layer in self.viewer.layers if isinstance(layer, napari.layers.Image)]
-    #     self.image_selector.addItems(image_layers)
-
-    # def update_image_data(self):
-    #     """Update the self.image attribute with data from the selected layer."""
-    #     selected_layer_name = self.image_selector.currentText()
-    #     if selected_layer_name in self.viewer.layers:
-    #         self.image = self.viewer.layers[selected_layer_name].data
-    #     else:
-    #         self.image = None  # Reset if no valid selection
-
 
 def get_distance_measure_widget():
     return DistanceMeasureWidget()