added distance to object to DistanceMeasureWidget feature and saving to csv file. _compute_seg_object_distances needed to be adapted to accept 2D data (prev. only 3D data was accepted)

lufre1 · lufre1 · commit 9980c2ba8cbc · 2024-11-15T15:51:00.000+01:00
diff --git a/synaptic_reconstruction/distance_measurements.py b/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
diff --git a/synaptic_reconstruction/tools/synaptic_plugin/base_widget.py b/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):
@@ -67,7 +68,6 @@ def _get_layer_selector_data(self, selector_name):
             
             if isinstance(image_selector, QComboBox):
                 selected_layer_name = image_selector.currentText()
-                print("selector_name", selector_name,  "selected_layer_name", selected_layer_name)
                 if selected_layer_name in self.viewer.layers:
                     return self.viewer.layers[selected_layer_name].data
         return None  # Return None if layer not found
diff --git a/synaptic_reconstruction/tools/synaptic_plugin/distance_measure_widget.py b/synaptic_reconstruction/tools/synaptic_plugin/distance_measure_widget.py
@@ -44,23 +44,6 @@ 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.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
-    #         # selected_layer_name = self.layer_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_layer_selector_data(self.image_selector_name1)
         segmentation2_data = self._get_layer_selector_data(self.image_selector_name2)
@@ -72,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()
diff --git a/synaptic_reconstruction/tools/synaptic_plugin/segmentation_widget.py b/synaptic_reconstruction/tools/synaptic_plugin/segmentation_widget.py
@@ -98,9 +98,15 @@ def on_predict(self):
             if ts != 0 or h != 0:  # if anything changed from default
                 use_custom_tiling = True
         if use_custom_tiling:
-            segmentation = run_segmentation(image, model_path=model_path, model_key=model_key, tiling=tiling)
+            segmentation = run_segmentation(
+                image, model_path=model_path, model_key=model_key,
+                tiling=tiling, scale=self.scale_param.value()
+                )
         else:
-            segmentation = run_segmentation(image, model_path=model_path, model_key=model_key)
+            segmentation = run_segmentation(
+                image, model_path=model_path, model_key=model_key,
+                scale=self.scale_param.value()
+                )
 
         # Add the segmentation layer
         self.viewer.add_labels(segmentation, name=f"{model_key}-segmentation")
@@ -122,20 +128,25 @@ def _create_settings_widget(self):
         setting_values.layout().addLayout(layout)
 
         # Create UI for the tile shape.
-        self.tile_x, self.tile_y = 0, 0  # defaults
+        self.tile_x, self.tile_y = 512, 512  # defaults
         self.tile_x_param, self.tile_y_param, layout = self._add_shape_param(
             ("tile_x", "tile_y"), (self.tile_x, self.tile_y), min_val=0, max_val=2048, step=16,
             # tooltip=get_tooltip("embedding", "tiling")
         )
         setting_values.layout().addLayout(layout)
 
         # Create UI for the halo.
-        self.halo_x, self.halo_y = 0, 0  # defaults
+        self.halo_x, self.halo_y = 64, 64  # defaults
         self.halo_x_param, self.halo_y_param, layout = self._add_shape_param(
             ("halo_x", "halo_y"), (self.halo_x, self.halo_y), min_val=0, max_val=512,
             # tooltip=get_tooltip("embedding", "halo")
         )
         setting_values.layout().addLayout(layout)
+        
+        self.scale_param, layout = self._add_float_param(
+            "scale", 0.5, min_val=0.0, max_val=8.0,
+        )
+        setting_values.layout().addLayout(layout)
 
         settings = self._make_collapsible(widget=setting_values, title="Advanced Settings")
         return settings
diff --git a/synaptic_reconstruction/tools/util.py b/synaptic_reconstruction/tools/util.py
@@ -9,20 +9,78 @@
 from torch_em.util.prediction import predict_with_halo
 from synaptic_reconstruction.inference.vesicles import segment_vesicles
 from synaptic_reconstruction.inference.mitochondria import segment_mitochondria
+import csv
 
 
-def save_to_csv(file_path, data, delimiter="\t"):
+# def save_to_csv(file_path, data, delimiter="\t"):
+#     if not file_path.endswith(".csv"):
+#         file_path = os.path.join(file_path, "data.csv")
+#     np.savetxt(file_path, data, delimiter=delimiter)
+#     return file_path
+# def save_to_csv(file_path, data, delimiter="\t", header=None):
+#     if not file_path.endswith(".csv"):
+#         file_path = os.path.join(file_path, "data.csv")
+
+#     # Check if the data is a tuple or list of arrays
+#     if isinstance(data, (tuple, list)):
+#         try:
+#             # Combine data into a single 2D array if possible
+#             data = np.column_stack(data)
+#         except ValueError:
+#             raise ValueError("The data elements cannot be combined into a 2D array. Ensure consistent shapes.")
+
+#     # Save the data to the file
+#     np.savetxt(file_path, data, delimiter=delimiter, header=header)
+#     return file_path
+def save_to_csv(file_path, data, delimiter="\t", header=None):
+    """
+    Save structured data to a CSV file.
+
+    Parameters:
+    - file_path (str): Path to save the CSV file.
+    - data (tuple): A tuple of arrays with mixed types (distances, endpoint1, endpoint2, seg_ids).
+    - delimiter (str): Delimiter for the CSV file (default is tab-delimited).
+    - header (list or None): List of column headers for the CSV file.
+    """
     if not file_path.endswith(".csv"):
         file_path = os.path.join(file_path, "data.csv")
-    np.savetxt(file_path, data, delimiter=delimiter)
-    return file_path
 
+    # Ensure the directory exists
+    if not os.path.isdir(os.path.dirname(file_path)):
+        raise FileNotFoundError(f"Directory does not exist: {os.path.dirname(file_path)}")
+
+    # Unpack the data
+    distances, endpoint1, endpoint2, seg_ids = data
+
+    # Check consistency of data lengths
+    n = len(distances)
+    if not all(len(arr) == n for arr in [endpoint1, endpoint2, seg_ids]):
+        raise ValueError("All data components must have the same length.")
+
+    # Open the file and write the data
+    with open(file_path, mode='w', newline='') as csvfile:
+        writer = csv.writer(csvfile, delimiter=delimiter)
+        
+        # Write the header if provided
+        if header:
+            writer.writerow(header)
+        
+        # Write the data rows
+        for i in range(n):
+            writer.writerow([
+                distances[i],
+                f"({endpoint1[i][0]}, {endpoint1[i][1]})",
+                f"({endpoint2[i][0]}, {endpoint2[i][1]})",
+                seg_ids[i]
+            ])
+
+    return file_path
 
-def run_segmentation(image, model_path, model_key, tiling=None):
+def run_segmentation(image, model_path, model_key, tiling=None, scale=1.0):
     if model_key == "vesicles":
-        segmentation = segment_vesicles(image, model_path=model_path, tiling=tiling)
+        segmentation = segment_vesicles(image, model_path=model_path, tiling=tiling, scale=[scale])
     elif model_key == "mitochondria":
-        segmentation = segment_mitochondria(image, model_path=model_path, tiling=tiling)
+        segmentation = segment_mitochondria(image, model_path=model_path, tiling=tiling, scale=[scale])
     return segmentation
 
 
