ramify 2.0.0__tar.gz → 2.1.0__tar.gz

{ramify-2.0.0 → ramify-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ramify
-Version: 2.0.0
+Version: 2.1.0
 Summary: Segment and measure branching shapes: centerlines, hierarchical space partitioning, and width
 License-File: LICENSE
 Keywords: centerline,geomorphology,medial-axis,morphometry,raster,river,segmentation,skeleton,valley,width

{ramify-2.0.0 → ramify-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ramify"
-version = "2.0.0"
+version = "2.1.0"
 description = "Segment and measure branching shapes: centerlines, hierarchical space partitioning, and width"
 keywords = [
     "centerline",

{ramify-2.0.0 → ramify-2.1.0}/ramify/_skeleton.py

@@ -5,6 +5,7 @@ partition network construction.
 import heapq
 
 import numpy as np
+from skimage.draw import line as draw_line
 from skimage.morphology import skeletonize
 from skimage.graph import MCP_Geometric
 
@@ -183,3 +184,38 @@ def prune_short_leaves(nodes, threshold_fn):
         if not removed_any:
             break
     return kept
+
+
+def disk_cut(path_nodes, half_width, mask_bool, fill=False):
+    """Replace the start of `path_nodes` with one straight chord.
+
+    Near an end, the skeleton forks toward the shape's corners (or runs past a
+    point placed on the side of a pointed end), so a path snapped to it swerves
+    before reaching the trunk. Every path node whose inscribed disk (radius =
+    local half-width, pixel units) reaches the anchor `path_nodes[0]` lies in
+    the same end blob; cut to the farthest such node and join it to the anchor
+    directly. The chord stays inside that disk, hence inside the shape -- up to
+    the slack, so each candidate chord is also rasterized and checked against
+    the mask, falling back to nearer nodes and finally the uncut path.
+
+    `fill=False` joins anchor and node as two consecutive vertices (enough for
+    a LineString); `fill=True` puts the chord's rasterized pixels in between,
+    keeping the path 8-connected for callers that work on pixel lists.
+    """
+    anchor = np.array(path_nodes[0], dtype=float)
+    pts = np.array(path_nodes, dtype=float)
+    d = np.hypot(*(pts - anchor).T)
+    r = half_width[pts[:, 0].astype(int), pts[:, 1].astype(int)]
+    slack = np.maximum(1.0, 0.1 * r)
+    passing = np.nonzero(d <= r + slack)[0]
+
+    for i in passing[::-1]:
+        if i <= 1:
+            break  # already adjacent to the anchor: nothing to cut
+        rr, cc = draw_line(*path_nodes[0], *path_nodes[i])
+        if mask_bool[rr, cc].all():
+            if fill:
+                chord = list(zip(rr.tolist(), cc.tolist()))
+                return chord[:-1] + list(path_nodes[i:])
+            return [path_nodes[0]] + list(path_nodes[i:])
+    return list(path_nodes)

{ramify-2.0.0 → ramify-2.1.0}/ramify/centerline.py

@@ -13,6 +13,7 @@ from ._skeleton import (
     endpoints,
     tree_path,
     prune_short_leaves,
+    disk_cut,
 )
 
 
@@ -25,7 +26,10 @@ def centerline(mask, root=None, tip=None, pixel_size=None) -> LineString:
     - `tip` without `root`: raises `ValueError`.
 
     `root` / `tip` are `(row, col)` pixel indices. Orientation: starts at
-    `root` when given; otherwise deterministic but unspecified.
+    `root` when given; otherwise deterministic but unspecified. Near a given
+    `root` / `tip`, the line leaves the skeleton and runs straight to the
+    point from the farthest skeleton pixel whose inscribed disk reaches it,
+    so it doesn't swerve into the forks a skeleton makes at a shape's end.
 
     This is the *longest* path through the shape, deliberately not the
     heaviest (widest) one that `partition_priority`/`partition_nearest` would
@@ -109,6 +113,11 @@ def centerline(mask, root=None, tip=None, pixel_size=None) -> LineString:
 
         path_nodes = list(reversed(tree_path(parent1, b, stop=a)))
 
+    if root is not None:
+        path_nodes = disk_cut(path_nodes, half_width, mask_bool)
+        if tip is not None:
+            path_nodes = disk_cut(path_nodes[::-1], half_width, mask_bool)[::-1]
+
     rows = np.array([n[0] for n in path_nodes])
     cols = np.array([n[1] for n in path_nodes])
     xs, ys = grid.to_xy(rows, cols)

{ramify-2.0.0 → ramify-2.1.0}/ramify/partition.py

@@ -28,6 +28,7 @@ from ._skeleton import (
     prune_short_leaves,
     path_length,
     path_weight,
+    disk_cut,
 )
 from .centerline import centerline
 
@@ -153,10 +154,30 @@ def _build_network(mask_bool, root, tips, min_length, path_by, open_boundary, pi
             n = parent[n]
 
     segments = break_into_segments(kept, parent, tip_nodes, root)
+    segments = _cut_end_segments(
+        segments, root, set(tip_points), half_width_pixels(mask_bool, None), mask_bool
+    )
     edt = local_half_width(mask_bool, open_boundary, pixel_size)
     return _annotate(segments, edt, pixel_size, path_by, root)
 
 
+def _cut_end_segments(segments, root, anchors, half_width, mask_bool):
+    # Straighten the network where it meets the root and each given tip (see
+    # `disk_cut`). Each cut is confined to the one segment touching that
+    # point: a segment's other end is a junction, so the tree's topology and
+    # shared junction pixels are untouched. Auto-detected tips are skeleton
+    # endpoints already and have nothing to cut toward. Segments run
+    # upstream -> downstream, so the root is at seg[-1] and a tip at seg[0].
+    out = []
+    for seg in segments:
+        if seg[-1] == root:
+            seg = disk_cut(seg[::-1], half_width, mask_bool, fill=True)[::-1]
+        if seg[0] in anchors:
+            seg = disk_cut(seg, half_width, mask_bool, fill=True)
+        out.append(seg)
+    return out
+
+
 def _annotate(segments, edt, pixel_size, path_by, root):
     n = len(segments)
     start_of = {seg[0]: i for i, seg in enumerate(segments)}

{ramify-2.0.0 → ramify-2.1.0}/scripts/gen_images.py

@@ -265,13 +265,13 @@ save("quickstart.png", fig, tight=False)
 
 with warnings.catch_warnings():
     warnings.simplefilter("ignore")
-    _, net_ml, _ = ramify.partition_priority(mask, root, min_length=15.0)
+    _, net_ml, _ = ramify.partition_priority(mask, root, min_length=100.0)
     _, net_all, _ = ramify.partition_priority(mask, root)
 
 fig, axes = plt.subplots(1, 3, figsize=(16, 6))
 for ax, net_i, title in [
     (axes[0], net, f"tips=tips ({len(tips)} tips)"),
-    (axes[1], net_ml, f"min_length=15 ({net_ml['path_id'].nunique()} paths)"),
+    (axes[1], net_ml, f"min_length=100 ({net_ml['path_id'].nunique()} paths)"),
     (axes[2], net_all, f"neither ({net_all['path_id'].nunique()} paths)"),
 ]:
     ax.imshow(mask_arr, cmap="gray_r", alpha=0.25)

ramify-2.1.0/tests/conftest.py

@@ -0,0 +1,73 @@
+import numpy as np
+import pytest
+
+
+@pytest.fixture
+def straight_bar():
+    """A 1-pixel-wide horizontal bar, root at one end, tip at the other."""
+    mask = np.zeros((5, 20), dtype=np.uint8)
+    mask[2, 1:19] = 1
+    return mask, (2, 1), (2, 18)
+
+
+@pytest.fixture
+def stubbed_bar():
+    """A long horizontal bar with a short stub off the middle -- the stub
+    should be trimmed away when choosing endpoints without an explicit tip."""
+    mask = np.zeros((10, 20), dtype=np.uint8)
+    mask[5, 1:19] = 1
+    mask[3:5, 10] = 1
+    return mask
+
+
+@pytest.fixture
+def toy_dataset():
+    from ramify.data import load
+
+    return load()
+
+
+@pytest.fixture
+def flared_bar():
+    """A thick horizontal bar whose left end flares into a fishtail, so the
+    skeleton forks into a Y there. Root sits on the flared end's edge."""
+    from skimage.draw import polygon
+
+    mask = np.zeros((40, 70), dtype=np.uint8)
+    rr, cc = polygon([4, 12, 12, 28, 28, 36], [4, 24, 66, 66, 24, 4])
+    mask[rr, cc] = 1
+    return mask, (20, 4), (20, 65)
+
+
+@pytest.fixture
+def end_deviation():
+    """How far the first `length` of a line strays from the straight chord
+    over that stretch: ~0 for a clean end, several pixels for a swerve into a
+    skeleton fork arm or a sideways snap."""
+    from shapely.geometry import LineString, Point
+
+    def fn(line, length=15.0):
+        chord = LineString([line.coords[0], line.interpolate(length).coords[0]])
+        return max(
+            chord.distance(Point(p))
+            for p in line.coords
+            if line.project(Point(p)) <= length
+        )
+
+    return fn
+
+
+@pytest.fixture
+def inside_mask():
+    """Whether every pixel a (pixel_size=1, numpy-grid) line crosses is in `mask`."""
+    from skimage.draw import line as draw_line
+
+    def fn(line, mask):
+        pix = [(int(y - 0.5), int(x - 0.5)) for x, y in line.coords]
+        for (r0, c0), (r1, c1) in zip(pix[:-1], pix[1:]):
+            rr, cc = draw_line(r0, c0, r1, c1)
+            if not mask[rr, cc].all():
+                return False
+        return True
+
+    return fn

{ramify-2.0.0 → ramify-2.1.0}/tests/test_centerline.py

@@ -106,3 +106,61 @@ def test_output_is_plain_ndarray_free(toy_dataset):
     mask_np = (np.asarray(mask.values) == 1).astype(np.uint8)
     assert isinstance(ramify.centerline(mask, root=root), LineString)
     assert isinstance(ramify.centerline(mask_np, root=root), LineString)
+
+
+def test_root_end_skips_skeleton_fork(flared_bar, end_deviation, inside_mask):
+    mask, root, _ = flared_bar
+    line = ramify.centerline(mask, root=root)
+    assert line.coords[0] == (root[1] + 0.5, root[0] + 0.5)
+    assert end_deviation(line) < 1.0  # uncut path swerves ~5 px into a fork arm
+    assert inside_mask(line, mask)
+
+
+def test_tip_end_skips_skeleton_fork(flared_bar, end_deviation, inside_mask):
+    mask, tip, root = flared_bar  # flared end as the tip this time
+    line = ramify.centerline(mask, root=root, tip=tip)
+    assert line.coords[-1] == (tip[1] + 0.5, tip[0] + 0.5)
+    assert end_deviation(LineString(line.coords[::-1])) < 1.0
+    assert inside_mask(line, mask)
+
+
+def test_root_end_has_no_sideways_snap(toy_dataset, end_deviation, inside_mask):
+    # the bundled root sits on the side of a pointed end; the skeleton runs
+    # past it toward the point, so the uncut path makes a right-angle turn
+    mask, root, _ = toy_dataset
+    mask_np = (np.asarray(mask.values) == 1).astype(np.uint8)
+    line = ramify.centerline(mask_np, root=root)
+    assert end_deviation(line) < 1.0  # ~4.8 px before the cut
+    assert inside_mask(line, mask_np)
+
+
+def test_disk_cut_rejects_chord_leaving_mask():
+    from ramify._skeleton import disk_cut
+
+    # a path that detours around a background pixel; every node's disk is
+    # large enough to reach the anchor, but the straight chord to the far
+    # nodes crosses the hole, so the cut must fall back to a nearer node
+    mask = np.ones((5, 7), dtype=bool)
+    mask[2, 3] = False
+    half_width = np.full(mask.shape, 10.0)
+    path = [(2, 1), (2, 2), (1, 3), (2, 4), (2, 5)]
+    assert disk_cut(path, half_width, mask) == [(2, 1), (1, 3), (2, 4), (2, 5)]
+
+
+def test_disk_cut_leaves_path_when_no_disk_reaches_anchor():
+    from ramify._skeleton import disk_cut
+
+    mask = np.ones((5, 7), dtype=bool)
+    half_width = np.zeros(mask.shape)
+    path = [(2, 0), (2, 1), (2, 2), (1, 3), (2, 4)]
+    assert disk_cut(path, half_width, mask) == path
+
+
+def test_disk_cut_fill_keeps_path_pixel_connected():
+    from ramify._skeleton import disk_cut
+
+    mask = np.ones((7, 9), dtype=bool)
+    half_width = np.full(mask.shape, 10.0)
+    path = [(3, 0), (4, 1), (4, 2), (3, 3), (3, 4), (3, 5)]
+    assert disk_cut(path, half_width, mask) == [(3, 0), (3, 5)]
+    assert disk_cut(path, half_width, mask, fill=True) == [(3, c) for c in range(6)]

{ramify-2.0.0 → ramify-2.1.0}/tests/test_partition.py

@@ -158,3 +158,65 @@ def test_length_path_by_uses_max_not_sum():
     assert by_head[(0, 5)]["path_id"] == trunk_path
     assert by_head[(0, 15)]["path_id"] == trunk_path  # longest single route wins
     assert by_head[(3, 5)]["path_id"] != trunk_path
+
+
+def test_net_root_end_has_no_sideways_snap(toy_dataset, end_deviation):
+    # same straightening as centerline(): the bundled root sits beside the
+    # skeleton, which the uncut network meets at a right angle
+    mask, root, tips = toy_dataset
+    mask_np = (np.asarray(mask.values) == 1).astype(np.uint8)
+    _, net, _ = ramify.partition_priority(mask_np, root, tips=tips)
+    outlet = net[net["downstream_segment_id"].isna()].geometry.iloc[0]
+    assert outlet.coords[0] == (root[1] + 0.5, root[0] + 0.5)
+    assert end_deviation(outlet) < 1.0  # ~4.8 px before the cut
+
+
+def test_net_tip_end_skips_skeleton_fork(flared_bar, end_deviation):
+    from shapely.geometry import LineString
+
+    mask, tip, root = flared_bar  # flared end as the (given) tip
+    _, net, _ = ramify.partition_priority(mask, root, tips=[tip])
+    (line,) = net.geometry  # no junctions: one segment, cut at both ends
+    assert line.coords[-1] == (tip[1] + 0.5, tip[0] + 0.5)
+    assert end_deviation(LineString(line.coords[::-1])) < 1.0
+
+
+def _network_is_intact(df, mask_bool):
+    by_id = dict(zip(df["segment_id"], df["pixels"]))
+    for seg_id, down, pixels in zip(df["segment_id"], df["downstream_segment_id"], df["pixels"]):
+        steps = zip(pixels[:-1], pixels[1:])
+        if not all(max(abs(a[0] - b[0]), abs(a[1] - b[1])) == 1 for a, b in steps):
+            return False
+        if not all(mask_bool[r, c] for r, c in pixels):
+            return False
+        # segments run upstream -> downstream, sharing the junction pixel
+        if not pd.isna(down) and pixels[-1] != by_id[int(down)][0]:
+            return False
+    return True
+
+
+def test_end_cut_stops_at_junction_near_root():
+    from skimage.draw import polygon
+    from ramify.partition import _build_network
+
+    # flared end with a thin tributary joining inside the root's end disk:
+    # the root cut must stay on the short root segment, not swallow the
+    # junction
+    mask = np.zeros((50, 70), dtype=np.uint8)
+    rr, cc = polygon([14, 22, 22, 38, 38, 46], [4, 24, 66, 66, 24, 4])
+    mask[rr, cc] = 1
+    mask[1:20, 14:16] = 1
+    root, tips = (30, 4), [(30, 65), (1, 14)]
+    df = _build_network(mask > 0, root, tips, None, "area", None, 1.0)
+    assert len(df) == 3
+    assert (df["downstream_segment_id"].isna()).sum() == 1
+    assert _network_is_intact(df, mask > 0)
+
+
+def test_end_cuts_keep_toy_network_intact(toy_dataset):
+    from ramify.partition import _build_network
+
+    mask, root, tips = toy_dataset
+    mask_bool = np.asarray(mask.values) == 1
+    df = _build_network(mask_bool, root, tips, None, "area", None, 1.0)
+    assert _network_is_intact(df, mask_bool)

{ramify-2.0.0 → ramify-2.1.0}/uv.lock

@@ -735,7 +735,7 @@ wheels = [
 
 [[package]]
 name = "ramify"
-version = "2.0.0"
+version = "2.1.0"
 source = { editable = "." }
 dependencies = [
     { name = "affine" },

ramify-2.0.0/tests/conftest.py

@@ -1,27 +0,0 @@
-import numpy as np
-import pytest
-
-
-@pytest.fixture
-def straight_bar():
-    """A 1-pixel-wide horizontal bar, root at one end, tip at the other."""
-    mask = np.zeros((5, 20), dtype=np.uint8)
-    mask[2, 1:19] = 1
-    return mask, (2, 1), (2, 18)
-
-
-@pytest.fixture
-def stubbed_bar():
-    """A long horizontal bar with a short stub off the middle -- the stub
-    should be trimmed away when choosing endpoints without an explicit tip."""
-    mask = np.zeros((10, 20), dtype=np.uint8)
-    mask[5, 1:19] = 1
-    mask[3:5, 10] = 1
-    return mask
-
-
-@pytest.fixture
-def toy_dataset():
-    from ramify.data import load
-
-    return load()