Address claude code review

Author: constantinpape

examples/skeleton/teasar.py

@@ -11,7 +11,7 @@
 def main():
     path = Path(__file__).with_name("00004_gt_mask.mrc")
 
-    full_crop = False
+    full_crop = True
     if full_crop:
         bb = np.s_[:]
     else:

include/bioimage_cpp/skeleton/detail/compact_grid_dijkstra.hxx

@@ -52,6 +52,28 @@ struct CompactGridDomain {
     [[nodiscard]] bool has_full_lookup() const noexcept {
         return !full_to_compact.empty();
     }
+
+    // CSR domains release the dense reverse map after building adjacency.
+    // Keep full-index conversion independent of that storage decision.
+    [[nodiscard]] std::uint32_t compact_node_from_full(
+        const std::size_t full
+    ) const noexcept {
+        if (has_full_lookup()) {
+            return full < full_to_compact.size()
+                ? full_to_compact[full] : kNoCompactNode;
+        }
+        if (full > static_cast<std::size_t>(kNoCompactNode)) {
+            return kNoCompactNode;
+        }
+        const auto full32 = static_cast<std::uint32_t>(full);
+        const auto it = std::lower_bound(
+            compact_to_full.begin(), compact_to_full.end(), full32
+        );
+        if (it == compact_to_full.end() || *it != full32) {
+            return kNoCompactNode;
+        }
+        return static_cast<std::uint32_t>(it - compact_to_full.begin());
+    }
 };
 
 inline void build_compact_neighbors(

include/bioimage_cpp/skeleton/distributed/border_targets.hxx

@@ -277,12 +277,12 @@ std::vector<LabeledVoxelTarget<LabelT>> border_targets_impl(
                     }();
                     const auto edge_distance = std::min({
                         static_cast<long double>(spacing[face_axes[0]]) *
-                            (static_cast<long double>(run.y) - 0.5L),
+                            (static_cast<long double>(run.y) + 0.5L),
                         static_cast<long double>(spacing[face_axes[0]]) *
                             (static_cast<long double>(height) - 0.5L -
                              static_cast<long double>(run.y)),
                         static_cast<long double>(spacing[face_axes[1]]) *
-                            (static_cast<long double>(x) - 0.5L),
+                            (static_cast<long double>(x) + 0.5L),
                         static_cast<long double>(spacing[face_axes[1]]) *
                             (static_cast<long double>(width) - 0.5L -
                              static_cast<long double>(x)),

include/bioimage_cpp/skeleton/teasar.hxx

@@ -625,26 +625,12 @@ inline LatticeSkeletonGraph teasar_compact_impl(
     {
         BIOIMAGE_PROFILE_SCOPE(profile, "root_dijkstra")
         if (required_root != std::numeric_limits<std::size_t>::max()) {
-            if (required_root > std::numeric_limits<std::uint32_t>::max()) {
-                throw std::runtime_error(
-                    "prepared required root exceeds compact index range"
-                );
-            }
-            const auto it = std::lower_bound(
-                domain.compact_to_full.begin(), domain.compact_to_full.end(),
-                static_cast<std::uint32_t>(required_root)
-            );
-            if (
-                it == domain.compact_to_full.end() ||
-                *it != static_cast<std::uint32_t>(required_root)
-            ) {
+            root = domain.compact_node_from_full(required_root);
+            if (root == detail::kNoCompactNode) {
                 throw std::runtime_error(
                     "prepared required root is not foreground"
                 );
             }
-            root = static_cast<std::uint32_t>(
-                std::distance(domain.compact_to_full.begin(), it)
-            );
         } else {
             std::vector<Distance> first_field;
             detail::compact_physical_distance_field<Adjacency>(
@@ -808,19 +794,11 @@ inline LatticeSkeletonGraph teasar_compact_impl(
         if (full_target >= n) {
             throw std::runtime_error("prepared required target is out of bounds");
         }
-        const auto it = std::lower_bound(
-            domain.compact_to_full.begin(), domain.compact_to_full.end(),
-            static_cast<std::uint32_t>(full_target)
-        );
-        if (
-            it == domain.compact_to_full.end() ||
-            *it != static_cast<std::uint32_t>(full_target)
-        ) {
+        const auto target = domain.compact_node_from_full(full_target);
+        if (target == detail::kNoCompactNode) {
             throw std::runtime_error("prepared required target is not foreground");
         }
-        compact_required_targets.push_back(static_cast<std::uint32_t>(
-            std::distance(domain.compact_to_full.begin(), it)
-        ));
+        compact_required_targets.push_back(target);
     }
     std::sort(
         compact_required_targets.begin(), compact_required_targets.end(),

tests/skeleton/test_distributed.py

@@ -60,6 +60,25 @@ def test_border_targets_binary_and_label_semantics_and_corner_deduplication():
     assert sum(len(values) for values in labeled.values()) == 2
 
 
+def test_border_target_edge_tiebreak_uses_physical_low_edge_distance():
+    face = np.array(
+        [
+            [0, 0, 1, 0, 0, 0, 1, 0, 1, 0],
+            [0, 1, 0, 0, 0, 1, 1, 1, 1, 0],
+            [1, 0, 0, 1, 1, 1, 0, 0, 1, 0],
+        ],
+        dtype=np.uint8,
+    )
+    block = np.zeros((3, 10, 2), dtype=np.uint8)
+    block[:, :, -1] = face
+
+    targets = dist.block_border_targets(
+        block, [(2, "high")], spacing=(2.0, 1.0, 1.0)
+    )
+
+    np.testing.assert_array_equal(targets, [[1, 1, 1], [2, 4, 1]])
+
+
 def test_block_teasar_required_target_and_existing_teasar_equivalence():
     mask = np.zeros((9, 9, 13), dtype=np.uint8)
     mask[2:7, 2:7, 1:12] = 1