Refactor plugin functionality, update pool widget

constantinpape · constantinpape · commit 223baee2be21 · 2024-12-05T23:36:04.000+01:00
diff --git a/synaptic_reconstruction/napari.yaml b/synaptic_reconstruction/napari.yaml
@@ -1,5 +1,5 @@
 name: synaptic_reconstruction
-display_name: Synaptic Reconstruction
+display_name: SynapseNet
 # see https://napari.org/stable/plugins/manifest.html for valid categories
 categories: ["Image Processing", "Annotation"]
 contributions:
diff --git a/synaptic_reconstruction/tools/base_widget.py b/synaptic_reconstruction/tools/base_widget.py
@@ -1,13 +1,20 @@
+import os
 from pathlib import Path
 
 import napari
 import qtpy.QtWidgets as QtWidgets
 
+from napari.utils.notifications import show_info
 from qtpy.QtWidgets import (
     QWidget, QVBoxLayout, QHBoxLayout, QLabel, QSpinBox, QComboBox, QCheckBox
 )
 from superqt import QCollapsible
 
+try:
+    from napari_skimage_regionprops import add_table
+except ImportError:
+    add_table = None
+
 
 class BaseWidget(QWidget):
     def __init__(self):
@@ -60,7 +67,7 @@ def _create_layer_selector(self, selector_name, layer_type="Image"):
     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)
+        image_layers = [layer.name for layer in self.viewer.layers if isinstance(layer, layer_filter)]
         selector.addItems(image_layers)
 
     def _get_layer_selector_layer(self, selector_name):
@@ -188,7 +195,7 @@ def _add_shape_param(self, names, values, min_val, max_val, step=1, title=None,
             title=title[1] if title is not None else title, tooltip=tooltip
         )
         layout.addLayout(y_layout)
-        
+
         if len(names) == 3:
             z_layout = QVBoxLayout()
             z_param, _ = self._add_int_param(
@@ -278,3 +285,43 @@ def _get_file_path(self, name, textbox, tooltip=None):
         else:
             # Handle the case where the selected path is not a file
             print("Invalid file selected. Please try again.")
+
+    def _handle_resolution(self, metadata, voxel_size_param, ndim):
+        # Get the resolution / voxel size from the layer metadata if available.
+        resolution = metadata.get("voxel_size", None)
+        if resolution is not None:
+            resolution = [resolution[ax] for ax in ("zyx" if ndim == 3 else "yx")]
+
+        # If user input was given then override resolution from metadata.
+        if voxel_size_param.value() != 0.0:  # Changed from default.
+            resolution = ndim * [voxel_size_param.value()]
+
+        assert len(resolution) == ndim
+        return resolution
+
+    def _save_table(self, save_path, data):
+        ext = os.path.splitext(save_path)[1]
+        if ext == "":  # No file extension given, By default we save to CSV.
+            file_path = f"{save_path}.csv"
+            data.to_csv(file_path, index=False)
+        elif ext == ".csv":  # Extension was specified as csv
+            file_path = save_path
+            data.to_csv(file_path, index=False)
+        elif ext == ".xlsx":  # We also support excel.
+            file_path = save_path
+            data.to_excel(file_path, index=False)
+        else:
+            raise ValueError("Invalid extension for table: {ext}. We support .csv or .xlsx.")
+        return file_path
+
+    def _add_properties_and_table(self, layer, table_data, save_path=""):
+        if layer.properties:
+            layer.properties = layer.properties.update(table_data)
+        else:
+            layer.properties = table_data
+        if add_table is not None:
+            add_table(layer, self.viewer)
+        # Save table to file if save path is provided.
+        if save_path != "":
+            file_path = self._save_table(self.save_path.text(), table_data)
+            show_info(f"INFO: Added table and saved file to {file_path}.")
diff --git a/synaptic_reconstruction/tools/distance_measure_widget.py b/synaptic_reconstruction/tools/distance_measure_widget.py
@@ -1,5 +1,3 @@
-import os
-
 import napari
 import napari.layers
 import numpy as np
@@ -11,27 +9,6 @@
 from .base_widget import BaseWidget
 from .. import distance_measurements
 
-try:
-    from napari_skimage_regionprops import add_table
-except ImportError:
-    add_table = None
-
-
-def _save_distance_table(save_path, data):
-    ext = os.path.splitext(save_path)[1]
-    if ext == "":  # No file extension given, By default we save to CSV.
-        file_path = f"{save_path}.csv"
-        data.to_csv(file_path, index=False)
-    elif ext == ".csv":  # Extension was specified as csv
-        file_path = save_path
-        data.to_csv(file_path, index=False)
-    elif ext == ".xlsx":  # We also support excel.
-        file_path = save_path
-        data.to_excel(file_path, index=False)
-    else:
-        raise ValueError("Invalid extension for table: {ext}. We support .csv or .xlsx.")
-    return file_path
-
 
 class DistanceMeasureWidget(BaseWidget):
     def __init__(self):
@@ -68,50 +45,33 @@ def __init__(self):
     def _to_table_data(self, distances, seg_ids, endpoints1=None, endpoints2=None):
         assert len(distances) == len(seg_ids), f"{distances.shape}, {seg_ids.shape}"
         if seg_ids.ndim == 2:
-            table_data = {"label1": seg_ids[:, 0], "label2": seg_ids[:, 1], "distance": distances}
+            table_data = {"label_id1": seg_ids[:, 0], "label_id2": seg_ids[:, 1], "distance": distances}
         else:
-            table_data = {"label": seg_ids, "distance": distances}
+            table_data = {"label_id": seg_ids, "distance": distances}
         if endpoints1 is not None:
             axis_names = "zyx" if endpoints1.shape[1] == 3 else "yx"
             table_data.update({f"begin-{ax}": endpoints1[:, i] for i, ax in enumerate(axis_names)})
             table_data.update({f"end-{ax}": endpoints2[:, i] for i, ax in enumerate(axis_names)})
         return pd.DataFrame(table_data)
 
-    def _add_lines_and_table(self, lines, properties, table_data, name):
+    def _add_lines_and_table(self, lines, table_data, name):
         line_layer = self.viewer.add_shapes(
             lines,
             name=name,
             shape_type="line",
             edge_width=2,
             edge_color="red",
             blending="additive",
-            properties=properties,
         )
-
-        line_layer.properties["distances"] = table_data
-
-        if add_table is not None:
-            add_table(line_layer, self.viewer)
-
-        if self.save_path.text() != "":
-            file_path = _save_distance_table(self.save_path.text(), table_data)
-
-        if self.save_path.text() != "":
-            show_info(f"Added distance lines and saved file to {file_path}.")
-        else:
-            show_info("Added distance lines.")
+        self._add_properties_and_table(line_layer, table_data, self.save_path.text())
 
     def on_measure_seg_to_object(self):
         segmentation = self._get_layer_selector_data(self.image_selector_name1)
         object_data = self._get_layer_selector_data(self.image_selector_name2)
-        # get metadata from layer if available
+
+        # Get the resolution / voxel size.
         metadata = self._get_layer_selector_data(self.image_selector_name1, return_metadata=True)
-        resolution = metadata.get("voxel_size", None)
-        if resolution is not None:
-            resolution = [v for v in resolution.values()]
-        # if user input is present override metadata
-        if self.voxel_size_param.value() != 0.0:  # changed from default
-            resolution = segmentation.ndim * [self.voxel_size_param.value()]
+        resolution = self._handle_resolution(metadata, self.voxel_size_param, segmentation.ndim)
 
         (distances,
          endpoints1,
@@ -120,28 +80,23 @@ def on_measure_seg_to_object(self):
             segmentation=segmentation, segmented_object=object_data, distance_type="boundary",
             resolution=resolution
         )
-        lines, properties = distance_measurements.create_object_distance_lines(
+        lines, _ = distance_measurements.create_object_distance_lines(
             distances=distances,
             endpoints1=endpoints1,
             endpoints2=endpoints2,
             seg_ids=seg_ids,
         )
         table_data = self._to_table_data(distances, seg_ids, endpoints1, endpoints2)
-        self._add_lines_and_table(lines, properties, table_data, name="distances")
+        self._add_lines_and_table(lines, table_data, name="distances")
 
     def on_measure_pairwise(self):
         segmentation = self._get_layer_selector_data(self.image_selector_name1)
         if segmentation is None:
             show_info("Please choose a segmentation.")
             return
-        # get metadata from layer if available
+
         metadata = self._get_layer_selector_data(self.image_selector_name1, return_metadata=True)
-        resolution = metadata.get("voxel_size", None)
-        if resolution is not None:
-            resolution = [v for v in resolution.values()]
-        # if user input is present, override metadata
-        if self.voxel_size_param.value() != 0.0:  # changed from default
-            resolution = segmentation.ndim * [self.voxel_size_param.value()]
+        resolution = self._handle_resolution(metadata, self.voxel_size_param, segmentation.ndim)
 
         (distances,
          endpoints1,
@@ -156,7 +111,7 @@ def on_measure_pairwise(self):
             distances=properties["distance"],
             seg_ids=np.concatenate([properties["id_a"][:, None], properties["id_b"][:, None]], axis=1)
         )
-        self._add_lines_and_table(lines, properties, table_data, name="pairwise-distances")
+        self._add_lines_and_table(lines, table_data, name="pairwise-distances")
 
     def _create_settings_widget(self):
         setting_values = QWidget()
diff --git a/synaptic_reconstruction/tools/morphology_widget.py b/synaptic_reconstruction/tools/morphology_widget.py
@@ -11,12 +11,6 @@
 from .base_widget import BaseWidget
 from synaptic_reconstruction.imod.to_imod import convert_segmentation_to_spheres
 from synaptic_reconstruction.morphology import compute_object_morphology
-from synaptic_reconstruction.tools.util import _save_table
-
-try:
-    from napari_skimage_regionprops import add_table
-except ImportError:
-    add_table = None
 
 
 class MorphologyWidget(BaseWidget):
@@ -125,51 +119,19 @@ def _to_table_data(self, coords, radii, props):
         assert len(coords) == len(radii), f"Shape mismatch: {coords.shape}, {radii.shape}"
 
         # Define columns based on dimension (2D or 3D)
-        col_names = ['x', 'y'] if coords.shape[1] == 2 else ['x', 'y', 'z']
+        col_names = ["x", "y"] if coords.shape[1] == 2 else ["x", "y", "z"]
         table_data = {
-            'label_id': [prop.label for prop in props],
+            "label_id": [prop.label for prop in props],
             **{col: coords[:, i] for i, col in enumerate(col_names)},
-            'radius': radii,
-            'intensity_max': [prop.intensity_max for prop in props],
-            'intensity_mean': [prop.intensity_mean for prop in props],
-            'intensity_min': [prop.intensity_min for prop in props],
-            'intensity_std': [prop.intensity_std for prop in props],
+            "radius": radii,
+            "intensity_max": [prop.intensity_max for prop in props],
+            "intensity_mean": [prop.intensity_mean for prop in props],
+            "intensity_min": [prop.intensity_min for prop in props],
+            "intensity_std": [prop.intensity_std for prop in props],
         }
 
         return pd.DataFrame(table_data)
 
-    def _add_table(self, coords, radii, props, name="Shapes Layer"):
-        """
-        Add a Shapes layer and table data to the Napari viewer.
-
-        Args:
-            viewer (napari.Viewer): The Napari viewer instance.
-            coords (np.ndarray): Array of 2D or 3D coordinates.
-            radii (np.ndarray): Array of radii corresponding to the coordinates.
-            props (list): List of properties containing intensity statistics.
-            name (str): Name of the Shapes layer.
-            save_path (str): Path to save the table data, if provided.
-        """
-        # Create table data
-        table_data = self._to_table_data(coords, radii, props)
-
-        # Add the shapes layer
-        layer = self._get_layer_selector_layer(self.image_selector_name1)
-        if layer.properties:
-            layer.properties = layer.properties.update(table_data)
-        else:
-            layer.properties = table_data
-
-        if add_table is not None:
-            add_table(layer, self.viewer)
-
-        # Save the table to a file if a save path is provided
-        if self.save_path.text():
-            table_data.to_csv(self.save_path, index=False)
-            print(f"INFO: Added table and saved file to {self.save_path}.")
-        else:
-            print("INFO: Table added to viewer.")
-
     def on_measure_vesicle_morphology(self):
         segmentation = self._get_layer_selector_data(self.image_selector_name1)
         image = self._get_layer_selector_data(self.image_selector_name)
@@ -180,23 +142,22 @@ def on_measure_vesicle_morphology(self):
             show_info("INFO: Please choose an image.")
             return
 
-        # get metadata from layer if available
+        # Get the resolution / voxel size.
         metadata = self._get_layer_selector_data(self.image_selector_name, return_metadata=True)
-        resolution = metadata.get("voxel_size", None)
-        if resolution is not None:
-            resolution = [v for v in resolution.values()]
-        # if user input is present override metadata
-        if self.voxel_size_param.value() != 0.0:  # changed from default
-            resolution = segmentation.ndim * [self.voxel_size_param.value()]
+        resolution = self._handle_resolution(metadata, self.voxel_size_param, segmentation.ndim)
 
+        # Compute the mophology parameter.
         props = regionprops(label_image=segmentation, intensity_image=image)
-
         coords, radii = convert_segmentation_to_spheres(
             segmentation=segmentation,
             resolution=resolution,
             props=props,
         )
-        self._add_table(coords, radii, props, name="Vesicle Morphology")
+
+        # Create table data and add the properties and table to the layer.
+        table_data = self._to_table_data(coords, radii, props)
+        layer = self._get_layer_selector_layer(self.image_selector_name1)
+        self._add_properties_and_table(layer, table_data, self.save_path.text())
 
     def on_measure_structure_morphology(self):
         """
@@ -213,30 +174,12 @@ def on_measure_structure_morphology(self):
         if resolution is not None:
             resolution = [v for v in resolution.values()]
         morphology = compute_object_morphology(
-            object_=segmentation, structure_name=self.image_selector_name1,
-            resolution=resolution
-            )
-
-        self._add_table_structure(morphology)
+            object_=segmentation, structure_name=self.image_selector_name1, resolution=resolution
+        )
 
-    def _add_table_structure(self, morphology):
+        # Add the properties to the layer and add/save the table.
         layer = self._get_layer_selector_layer(self.image_selector_name1)
-        # Add properties to layer for add_table function
-        if layer.properties:
-            layer.properties = layer.properties.update(morphology)
-        else:
-            layer.properties = morphology
-
-        # Add a table layer to the Napari viewer
-        if add_table is not None:
-            add_table(layer, self.viewer)
-
-        # Save table to file if save path is provided
-        if self.save_path.text() != "":
-            file_path = _save_table(self.save_path.text(), morphology)
-            show_info(f"INFO: Added table and saved file to {file_path}.")
-        else:
-            print("INFO: Table added to viewer.")
+        self._add_properties_and_table(layer, morphology, self.save_path.text())
 
     def _create_settings_widget(self):
         setting_values = QWidget()
diff --git a/synaptic_reconstruction/tools/util.py b/synaptic_reconstruction/tools/util.py
@@ -12,22 +12,6 @@
 from ..inference.vesicles import segment_vesicles
 
 
-def _save_table(save_path, data):
-    ext = os.path.splitext(save_path)[1]
-    if ext == "":  # No file extension given, By default we save to CSV.
-        file_path = f"{save_path}.csv"
-        data.to_csv(file_path, index=False)
-    elif ext == ".csv":  # Extension was specified as csv
-        file_path = save_path
-        data.to_csv(file_path, index=False)
-    elif ext == ".xlsx":  # We also support excel.
-        file_path = save_path
-        data.to_excel(file_path, index=False)
-    else:
-        raise ValueError("Invalid extension for table: {ext}. We support .csv or .xlsx.")
-    return file_path
-
-
 def load_custom_model(model_path: str, device: Optional[Union[str, torch.device]] = None) -> torch.nn.Module:
     model_path = _clean_filepath(model_path)
     if device is None:
diff --git a/synaptic_reconstruction/tools/vesicle_pool_widget.py b/synaptic_reconstruction/tools/vesicle_pool_widget.py
diff --git a/synaptic_reconstruction/tools/volume_reader.py b/synaptic_reconstruction/tools/volume_reader.py
