morphology in dedicated layer

Author: lufre1

synaptic_reconstruction/tools/base_widget.py

@@ -38,7 +38,7 @@ def _create_layer_selector(self, selector_name, layer_type="Image"):
 
         selector_widget = QtWidgets.QWidget()
         image_selector = QtWidgets.QComboBox()
-        layer_label = QtWidgets.QLabel(f"{selector_name} Layer:")
+        layer_label = QtWidgets.QLabel(f"{selector_name}:")
 
         # Populate initial options
         self._update_selector(selector=image_selector, layer_filter=layer_filter)

synaptic_reconstruction/tools/distance_measure_widget.py

@@ -87,10 +87,10 @@ def _add_lines_and_table(self, lines, properties, table_data, name):
             blending="additive",
             properties=properties,
         )
-        if line_layer.metadata is None:
-            line_layer.metadata = table_data
-        else:
-            line_layer.metadata["distances"] = table_data
+        # if line_layer.metadata is None:
+        #     line_layer.metadata = table_data
+        # else:
+        line_layer.properties["distances"] = table_data
 
         if add_table is not None:
             add_table(line_layer, self.viewer)

synaptic_reconstruction/tools/morphology_widget.py

@@ -69,7 +69,7 @@ def _create_shapes_layer(self, table_data, name="Shapes Layer"):
             if 'z' not in table_data.columns
             else table_data[['x', 'y', 'z']].to_numpy()
         )
-        radii = table_data['radii'].to_numpy()
+        radii = table_data['radius'].to_numpy()
 
         if coords.shape[1] == 2:
             # For 2D data, create circular outlines using trigonometric functions
@@ -131,7 +131,7 @@ def _to_table_data(self, coords, radii, props):
         table_data = {
             'label_id': [prop.label for prop in props],
             **{col: coords[:, i] for i, col in enumerate(col_names)},
-            'radii': radii,
+            '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],
@@ -158,11 +158,6 @@ def _add_table(self, coords, radii, props, name="Shapes Layer"):
         # Add the shapes layer
         layer = self._create_shapes_layer(table_data, name)
 
-        # Add properties to segmentation layer
-        segmentation_layer = self._get_layer_selector_layer(self.image_selector_name1)
-
-        segmentation_layer.metadata["morphology"] = table_data
-
         if add_table is not None:
             add_table(layer, self.viewer)
 
@@ -199,7 +194,7 @@ def on_measure_vesicle_morphology(self):
             resolution=resolution,
             props=props,
         )
-        self._add_table(coords, radii, props, name="Vesicles")
+        self._add_table(coords, radii, props, name="Vesicles Morphology")
 
     def on_measure_structure_morphology(self):
         """add the structure measurements to the segmentation layer (via properties) 
@@ -222,36 +217,22 @@ def on_measure_structure_morphology(self):
         self._add_table_structure(morphology)
 
     def _add_table_structure(self, morphology):
-        segmentation_layer = self._get_layer_selector_layer(self.image_selector_name1)
-        table_data = self._to_table_data_structure(morphology)
-
-        segmentation_layer.metadata["morphology"] = table_data
-        segmentation_layer.properties = table_data
-        print("segmentation layer metadata:\n", segmentation_layer.metadata)
+        segmentation = self._get_layer_selector_data(self.image_selector_name1)
+        layer = self.viewer.add_labels(np.zeros(segmentation.shape, dtype=np.uint16), name="Structure Morphology")
+        # Add properties to layer for add_table function
+        layer.properties = morphology
 
         # Add a table layer to the Napari viewer
         if add_table is not None:
-            add_table(segmentation_layer, self.viewer)
+            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(), table_data)
+            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.")
 
-    def _to_table_data_structure(self, morphology):
-        # Create table data
-        return morphology
-        # for k, v in morphology.items():
-        #     table_data = {k: v}
-        # table_data = {
-        #     "Name": morphology["perimeter [pixel]"],
-        #     "area [pixel^2]": morphology["area [pixel^2]"],
-        #     "perimeter [pixel]": morphology["perimeter [pixel]"],
-        # }
-        return pd.DataFrame(table_data)
-
     def _create_settings_widget(self):
         setting_values = QWidget()
         setting_values.setLayout(QVBoxLayout())

synaptic_reconstruction/tools/vesicle_pool_widget.py

@@ -26,11 +26,13 @@ def __init__(self):
         self.viewer = napari.current_viewer()
         layout = QVBoxLayout()
 
-        self.image_selector_name = "Distances"
-        self.image_selector_name1 = "Segmentation"
+        self.image_selector_name = "Distances to Structure"
+        self.image_selector_name1 = "Vesicles Segmentation"
+        self.image_selector_name2 = "Vesicles Morphology"
         # # Create the image selection dropdown.
         self.image_selector_widget = self._create_layer_selector(self.image_selector_name, layer_type="Shapes")
         self.segmentation1_selector_widget = self._create_layer_selector(self.image_selector_name1, layer_type="Labels")
+        self.image_selector_widget2 = self._create_layer_selector(self.image_selector_name2, layer_type="Shapes")
 
         # Create new layer name
         self.new_layer_name_param, new_layer_name_layout = self._add_string_param(
@@ -54,12 +56,13 @@ def __init__(self):
         self.settings = self._create_settings_widget()
 
         # Create and connect buttons.
-        self.measure_button1 = QPushButton("Measure Vesicle Morphology")
+        self.measure_button1 = QPushButton("Create Vesicle Pool")
         self.measure_button1.clicked.connect(self.on_pool_vesicles)
 
 
         # Add the widgets to the layout.
         layout.addWidget(self.image_selector_widget)
+        layout.addWidget(self.image_selector_widget2)
         layout.addWidget(self.segmentation1_selector_widget)
         layout.addLayout(query_layout)
         layout.addLayout(new_layer_name_layout)
@@ -70,14 +73,14 @@ def __init__(self):
 
         self.setLayout(layout)
 
-    def _create_shapes_layer(self, name, pooling):
-        print(name, pooling)
-        return 
-
     def on_pool_vesicles(self):
-        distances = self._get_layer_selector_data(self.image_selector_name, return_metadata=True)
+        distances_layer = self._get_layer_selector_layer(self.image_selector_name)
+        distances = distances_layer.properties
         segmentation = self._get_layer_selector_data(self.image_selector_name1)
-        morphology = self._get_layer_selector_data(self.image_selector_name1, return_metadata=True)
+        morphology_layer = self._get_layer_selector_layer(self.image_selector_name2)
+        morphology = morphology_layer.properties
+        print("distances", distances)
+        print("morphology", morphology)
 
         if segmentation is None:
             show_info("INFO: Please choose a segmentation.")
@@ -116,11 +119,122 @@ def on_pool_vesicles(self):
         #     resolution = segmentation.ndim * [self.voxel_size_param.value()]
 
     def _compute_vesicle_pool(self, segmentation, distances, morphology, new_layer_name, pooled_group_name, query):
-        print(segmentation, distances, morphology, new_layer_name, pooled_group_name, query)
-        vesicle_pool = {
-            "segmentation": segmentation,
-        }
-        return vesicle_pool 
+        """
+        Compute a vesicle pool based on the provided query parameters.
+
+        Args:
+            segmentation (array): Segmentation data (e.g., labeled regions).
+            distances (dict): Properties from the distances layer.
+            morphology (dict): Properties from the morphology layer.
+            new_layer_name (str): Name for the new layer to be created.
+            pooled_group_name (str): Name for the pooled group to be assigned.
+            query (dict): Query parameters with keys "min_radius" and "max_distance".
+
+        Returns:
+            dict: Updated properties for the new vesicle pool.
+        """
+
+        distances_ids = distances.get("id", [])
+        morphology_ids = morphology.get("label_id", [])
+
+        # Check if IDs are identical
+        if set(distances_ids) != set(morphology_ids):
+            show_info("ERROR: The IDs in distances and morphology are not identical.")
+            return
+
+        distances = pd.DataFrame(distances)
+        morphology = pd.DataFrame(morphology)
+
+        # Merge dataframes on the 'id' column
+        merged_df = morphology.merge(distances, left_on="label_id", right_on="id", suffixes=("_morph", "_dist"))
+        # Filter rows based on query parameters
+        # Apply the query string to filter the data
+        filtered_df = self._parse_query(query, merged_df)
+
+        # Extract valid vesicle IDs
+        valid_vesicle_ids = filtered_df["label_id"].tolist()
+
+        # Debugging output
+        for _, row in filtered_df.iterrows():
+            print(f"Vesicle {row['label_id']}: Passed (Radius: {row['radius']}, Distance: {row['distance']})")
+
+        # Update segmentation layer with valid vesicles
+        new_layer_data = np.zeros(segmentation.shape, dtype=np.uint8)
+        for vesicle_id in valid_vesicle_ids:
+            new_layer_data[segmentation == vesicle_id] = 1  # Highlight pooled vesicles
+
+        # Create a new layer in the viewer
+        self.viewer.add_labels(
+            new_layer_data,
+            name=new_layer_name,
+            properties={
+                "id": valid_vesicle_ids,
+                "radius": filtered_df["radius"].tolist(),
+                "distance": filtered_df["distance"].tolist(),
+            },
+        )
+        show_info(f"Vesicle pool created with {len(valid_vesicle_ids)} vesicles.")
+        return {
+                "id": valid_vesicle_ids,
+                "radius": filtered_df["radius"].tolist(),
+                "distance": filtered_df["distance"].tolist(),
+            }
+
+        # # Filter vesicles based on the query
+        # valid_vesicles = []
+        # for i in distances_ids:
+        #     distance = distances.get("distance", [])[i]
+        #     radius = morphology.get("radius", [])[i]
+        #     if radius >= min_radius and distance <= max_distance:
+        #         print(f"Vesicle {i}: Passed (Radius: {radius}, Distance: {distance})")
+        #         valid_vesicles.append(i)
+        #     else:
+        #         print(f"Vesicle {i}: Failed (Radius: {radius}, Distance: {distance})")
+        
+        # Create pooled properties
+        # pooled_properties = {
+        #     "id": [i for i in valid_vesicles],
+        #     "radius": [morphology["radius"][i] for i in valid_vesicles],
+        #     "distance": [distances["distance"][i] for i in valid_vesicles],
+        # }
+        # print("pooled_properties", pooled_properties)
+        # print("np.unique(segmenation)", np.unique(segmentation))
+
+        # # Create a new layer in the viewer
+        # new_layer_data = np.zeros(segmentation.shape, dtype=np.uint8)
+        # for vesicle_id in valid_vesicles:
+        #     new_layer_data[segmentation == vesicle_id] = 1
+
+        # self.viewer.add_labels(
+        #     new_layer_data,
+        #     name=new_layer_name,
+        #     properties=pooled_properties,
+        # )
+
+        # show_info(f"INFO: Created pooled vesicle layer '{new_layer_name}' with {len(valid_vesicles)} vesicles.")
+        # return pooled_properties
+
+    def _parse_query(self, query, data):
+        """
+        Parse and apply a query string to filter data.
+
+        Args:
+            query (str): Comma-separated query string (e.g., "radius > 15, distance > 250").
+            data (pd.DataFrame): DataFrame containing the data to filter.
+
+        Returns:
+            pd.DataFrame: Filtered DataFrame.
+        """
+        filters = query.split(",")  # Split the query into individual conditions
+        filters = [f.strip() for f in filters]  # Remove extra spaces
+        for condition in filters:
+            try:
+                # Apply each condition to filter the DataFrame
+                data = data.query(condition)
+            except Exception as e:
+                print(f"Failed to apply condition '{condition}': {e}")
+                continue
+        return data
 
     def _create_settings_widget(self):
         setting_values = QWidget()