Feat report summary (#158)

* doc: skeleton metrics and swc_loading

* feat: fix label misalignments

---------

Co-authored-by: anna-grim <[email protected]>

Author: anna-grim

src/segmentation_skeleton_metrics/data_handling/graph_loading.py

@@ -9,6 +9,7 @@
 
 """
 
+from collections import deque
 from concurrent.futures import (
     as_completed, ProcessPoolExecutor, ThreadPoolExecutor
 )
@@ -346,6 +347,8 @@ def _label_graph(self, graph):
                 for i, label in node_to_label.items():
                     graph.node_labels[i] = label
 
+        GraphLoader.fix_label_misalignments(graph)
+
     def get_patch_labels(self, graph, nodes):
         """
         Gets the segment labels for a given set of nodes within a specified
@@ -395,8 +398,68 @@ def to_local_voxels(self, graph, i, offset):
         offset = np.array(offset)
         return tuple(voxel - offset)
 
-    def fix_label_misalignments(self, graph):
-        pass
+    @staticmethod
+    def fix_label_misalignments(graph):
+        """
+        Adjusts misalignments between the labeled graph and segmentation.
+
+        Parameters
+        ----------
+        graph : LabeledGraph
+            Graph to be searched.
+        """
+        visited_edges = set()
+        for i, j in deque(nx.dfs_edges(graph)):
+            # Check whether to visit edge
+            if frozenset({i, j}) in visited_edges:
+                continue
+
+            # Visit edge
+            if int(graph.node_labels[j]) == 0:
+                GraphLoader.check_misalignment(graph, visited_edges, i, j)
+            visited_edges.add(frozenset({i, j}))
+
+    @staticmethod
+    def check_misalignment(graph, visited_edges, nb, root):
+        """
+        Determines whether zero-valued label corresponds to a misalignment
+        between the graph and segmentation mask.
+
+        Parameters
+        ----------
+        graph : networkx.Graph
+            Graph that represents a ground truth neuron.
+        visited_edges : List[tuple]
+            List of edges in "graph" that have been visited.
+        nb : int
+            Neighbor of "root".
+        root : int
+            Node where possible split starts (i.e. zero-valued label).
+        """
+        # Search graph
+        label_collisions = set()
+        queue = deque([root])
+        visited = set()
+        while len(queue) > 0:
+            # Visit node
+            j = queue.popleft()
+            label_j = int(graph.node_labels[j])
+            if label_j != 0:
+                label_collisions.add(label_j)
+            visited.add(j)
+
+            # Update queue
+            if label_j == 0:
+                for k in graph.neighbors(j):
+                    if k not in visited:
+                        if frozenset({j, k}) not in visited_edges or k == nb:
+                            queue.append(k)
+                            visited_edges.add(frozenset({j, k}))
+
+        # Upd zero nodes
+        if len(label_collisions) == 1:
+            label = label_collisions.pop()
+            graph.update_node_labels(visited, label)
 
 
 class LabelHandler:

src/segmentation_skeleton_metrics/data_handling/skeleton_graph.py

@@ -332,7 +332,7 @@ def run_length_from(self, root):
                     visited.add(k)
         return run_length
 
-    def upd_node_labels(self, nodes, label):
+    def update_node_labels(self, nodes, label):
         """
         Updates the label of the given nodes with a specified label.
 

src/segmentation_skeleton_metrics/evaluate.py

@@ -47,7 +47,8 @@ def evaluate(
     verbose=True
 ):
     """
-    ...
+    Loads data, calls an evaluator object that compute skeleton-based
+    segmentation, and saves the results.
 
     Parameters
     ----------
@@ -164,19 +165,19 @@ def report_summary(self, results):
         # Averaged results
         filename = f"{self.results_filename}-overview.txt"
         path = os.path.join(self.output_dir, filename)
-        util.update_txt(path, "Average Results...")
+        util.update_txt(path, "Average Results...", self.verbose)
         for column in results.columns:
             if column != "SWC Run Length" and column != "SWC Name":
                 avg = util.compute_weighted_avg(results, column)
-                util.update_txt(path, f"  {column}: {avg:.4f}")
+                util.update_txt(path, f"  {column}: {avg:.4f}", self.verbose)
 
         # Total results
         n_splits = results["# Splits"].sum()
-        util.update_txt(path, "\nTotal Results...")
-        util.update_txt(path, f"  # Splits: {n_splits}")
+        util.update_txt(path, "\nTotal Results...", self.verbose)
+        util.update_txt(path, f"  # Splits: {n_splits}", self.verbose)
         if "# Merges" in results.columns:
             n_merges = results["# Merges"].sum()
-            util.update_txt(path, f"  # Merges: {n_merges}")
+            util.update_txt(path, f"  # Merges: {n_merges}", self.verbose)
 
     # --- Writers ---
     def save_fragments(self):

src/segmentation_skeleton_metrics/utils/util.py

@@ -168,7 +168,7 @@ def read_txt(path):
         return f.read().splitlines()
 
 
-def update_txt(path, text):
+def update_txt(path, text, verbose=True):
     """
     Appends the given text to a specified text file and prints the text.
 
@@ -178,8 +178,14 @@ def update_txt(path, text):
         Path to txt file where the text will be appended.
     text : str
         Text to be written to the file.
+    verbose : bool, optional
+        Indication of whether to printout text. Default is True.
     """
-    print(text)
+    # Printout text (if applicable)
+    if verbose:
+        print(text)
+
+    # Update txt file
     with open(path, "a") as file:
         file.write(text + "\n")