nbmorph 0.1.0__py3-none-any.whl

nbmorph/__init__.py

@@ -0,0 +1,14 @@
+from .morphology import (
+    dilate_labels_spherical,
+    erode_labels_spherical,
+    open_labels_spherical,
+    close_labels_spherical,
+    smooth_labels_spherical,
+)
+from .mode import onlyzero_mode_box,onlyzero_mode_diamond, fast_mode
+from .minmax import minimum_box, maximum_box, minimum_diamond, maximum_diamond
+from .zero_edges import zero_label_edges_box, zero_label_edges_diamond
+from .utils import cycle
+
+# Define the package version
+__version__ = "0.1.0"

nbmorph/box_kernel.py

@@ -0,0 +1,434 @@
+
+import numba
+import numpy as np
+from .ops import choose_op
+
+
+@numba.njit(inline="always")
+def min18(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, 
+          v10, v11, v12, v13, v14, v15, v16, v17):
+    return  min(
+        min((v0, v1, v2, v3, v4, v5, v6, v7, v8)),
+        min((v9, v10, v11, v12, v13, v14, v15, v16, v17))
+        )
+
+@numba.njit(inline="always")
+def min27(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, 
+          v10, v11, v12, v13, v14, v15, v16, v17,
+          v18, v19, v20, v21, v22, v23, v24, v25, v26):
+    return  min((
+        min((v0, v1, v2, v3, v4, v5, v6, v7, v8)),
+        min((v9, v10, v11, v12, v13, v14, v15, v16, v17)),
+        max((v18, v19, v20, v21, v22, v23, v24, v25, v26))
+        ))
+
+@numba.njit(inline="always")
+def max18(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, 
+          v10, v11, v12, v13, v14, v15, v16, v17):
+    return  max(
+        max((v0, v1, v2, v3, v4, v5, v6, v7, v8)),
+        max((v9, v10, v11, v12, v13, v14, v15, v16, v17))
+        )
+
+@numba.njit(inline="always")
+def max27(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, 
+          v10, v11, v12, v13, v14, v15, v16, v17,
+          v18, v19, v20, v21, v22, v23, v24, v25, v26):
+    return  max((
+        max((v0, v1, v2, v3, v4, v5, v6, v7, v8)),
+        max((v9, v10, v11, v12, v13, v14, v15, v16, v17)),
+        max((v18, v19, v20, v21, v22, v23, v24, v25, v26))
+        ))
+
+@numba.njit(inline="always")
+def choose_op18(opname, 
+                v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, 
+                v10, v11, v12, v13, v14, v15, v16, v17,
+                onlyzero):
+    if onlyzero and v0 >0: return v0
+    match opname:
+        case "min": 
+            return min18(v0, v1, v2, v3, v4, v5, v6, v7, v8,
+                         v9, v10, v11, v12, v13, v14, v15, v16, v17)
+        case "max": 
+            return max18(v0, v1, v2, v3, v4, v5, v6, v7, v8,
+                         v9, v10, v11, v12, v13, v14, v15, v16, v17)
+        case "zeroedges": 
+            return v0 if min18(v0, v1, v2, v3, v4, v5, v6, v7, v8,
+                         v9, v10, v11, v12, v13, v14, v15, v16, v17) == max18(v0, v1, v2, v3, v4, v5, v6, v7, v8,
+                         v9, v10, v11, v12, v13, v14, v15, v16, v17) else 0
+
+@numba.njit(inline="always")
+def choose_op27(opname,
+                v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, 
+                v10, v11, v12, v13, v14, v15, v16, v17,v18,
+                v19, v20, v21, v22, v23, v24, v25, v26,
+                onlyzero=False):
+    if onlyzero and v0 >0: return v0
+    match opname:
+        case "min": 
+            return min27(v0, v1, v2, v3, v4, v5, v6, v7, v8,
+                         v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
+                         v19, v20, v21, v22, v23, v24, v25, v26)
+        case "max": 
+            return max27(v0, v1, v2, v3, v4, v5, v6, v7, v8,
+                         v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
+                         v19, v20, v21, v22, v23, v24, v25, v26)
+        case "zeroedges": 
+            return v0 if min27(v0, v1, v2, v3, v4, v5, v6, v7, v8,
+                         v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
+                         v19, v20, v21, v22, v23, v24, v25, v26) == max27(v0, v1, v2, v3, v4, v5, v6, v7, v8,
+                         v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
+                         v19, v20, v21, v22, v23, v24, v25, v26) else 0
+           
+        
+@numba.njit
+def borders3x3x3(data, opname, out, onlyzero=False):
+    sz, sy, sx = data.shape
+    
+    # --- Front Face (z=0) ---
+    z = 0
+    for y in range(1, sy - 1):
+        for x in range(1, sx - 1):
+            out[z, y, x] = choose_op18(opname, data[z, y, x],
+                # --- Middle Slice (z) ---
+                data[z, y - 1, x - 1], data[z, y - 1, x], data[z, y - 1, x + 1],
+                data[z, y, x - 1], data[z, y, x + 1],
+                data[z, y + 1, x - 1], data[z, y + 1, x], data[z, y + 1, x + 1],
+
+                # --- Bottom Slice (z+1) ---
+                data[z + 1, y - 1, x - 1], data[z + 1, y - 1, x], data[z + 1, y - 1, x + 1],
+                data[z + 1, y, x - 1], data[z + 1, y, x], data[z + 1, y, x + 1],
+                data[z + 1, y + 1, x - 1], data[z + 1, y + 1, x], data[z + 1, y + 1, x + 1],
+            onlyzero=onlyzero)
+
+    # --- Back Face (z=sz-1) ---
+    z = sz - 1
+    for y in range(1, sy - 1):
+        for x in range(1, sx - 1):
+            out[z, y, x] = choose_op18(opname,data[z, y, x],
+                # --- Top Slice (z-1) ---
+                data[z - 1, y - 1, x - 1], data[z - 1, y - 1, x], data[z - 1, y - 1, x + 1],
+                data[z - 1, y, x - 1], data[z - 1, y, x], data[z - 1, y, x + 1],
+                data[z - 1, y + 1, x - 1], data[z - 1, y + 1, x], data[z - 1, y + 1, x + 1],
+
+                # --- Middle Slice (z) ---
+                data[z, y - 1, x - 1], data[z, y - 1, x], data[z, y - 1, x + 1],
+                data[z, y, x - 1], data[z, y, x + 1],
+                data[z, y + 1, x - 1], data[z, y + 1, x], data[z, y + 1, x + 1],
+            onlyzero=onlyzero)
+
+    # --- Top Face (y=0) ---
+    y = 0
+    for z in range(1, sz - 1):
+        for x in range(1, sx - 1):
+            out[z, y, x] = choose_op18(opname, data[z, y, x],
+                # --- Top Slice (z-1) ---
+                data[z - 1, y, x - 1], data[z - 1, y, x], data[z - 1, y, x + 1],
+                data[z - 1, y + 1, x - 1], data[z - 1, y + 1, x], data[z - 1, y + 1, x + 1],
+
+                # --- Middle Slice (z) ---
+                data[z, y, x - 1], data[z, y, x + 1],
+                data[z, y + 1, x - 1], data[z, y + 1, x], data[z, y + 1, x + 1],
+
+                # --- Bottom Slice (z+1) ---
+                data[z + 1, y, x - 1], data[z + 1, y, x], data[z + 1, y, x + 1],
+                data[z + 1, y + 1, x - 1], data[z + 1, y + 1, x], data[z + 1, y + 1, x + 1],
+            onlyzero=onlyzero)
+
+    # --- Bottom Face (y=sy-1) ---
+    y = sy - 1
+    for z in range(1, sz - 1):
+        for x in range(1, sx - 1):
+            out[z, y, x] = choose_op18(opname,data[z, y, x],
+                # --- Top Slice (z-1) ---
+                data[z - 1, y - 1, x - 1], data[z - 1, y - 1, x], data[z - 1, y - 1, x + 1],
+                data[z - 1, y, x - 1], data[z - 1, y, x], data[z - 1, y, x + 1],
+
+                # --- Middle Slice (z) ---
+                data[z, y - 1, x - 1], data[z, y - 1, x], data[z, y - 1, x + 1],
+                data[z, y, x - 1], data[z, y, x + 1],
+
+                # --- Bottom Slice (z+1) ---
+                data[z + 1, y - 1, x - 1], data[z + 1, y - 1, x], data[z + 1, y - 1, x + 1],
+                data[z + 1, y, x - 1], data[z + 1, y, x], data[z + 1, y, x + 1],
+            onlyzero=onlyzero)
+
+    # --- Left Face (x=0) ---
+    x = 0
+    for z in range(1, sz - 1):
+        for y in range(1, sy - 1):
+            out[z, y, x] = choose_op18(opname, data[z, y, x],
+                # --- Top Slice (z-1) ---
+                data[z - 1, y - 1, x], data[z - 1, y - 1, x + 1],
+                data[z - 1, y, x], data[z - 1, y, x + 1],
+                data[z - 1, y + 1, x], data[z - 1, y + 1, x + 1],
+
+                # --- Middle Slice (z) ---
+                data[z, y - 1, x], data[z, y - 1, x + 1],
+                data[z, y, x + 1],
+                data[z, y + 1, x], data[z, y + 1, x + 1],
+
+                # --- Bottom Slice (z+1) ---
+                data[z + 1, y - 1, x], data[z + 1, y - 1, x + 1],
+                data[z + 1, y, x], data[z + 1, y, x + 1],
+                data[z + 1, y + 1, x], data[z + 1, y + 1, x + 1],
+            onlyzero=onlyzero)
+
+    # --- Right Face (x=sx-1) ---
+    x = sx - 1
+    for z in range(1, sz - 1):
+        for y in range(1, sy - 1):
+            out[z, y, x] = choose_op18(opname, data[z, y, x],
+                # --- Top Slice (z-1) ---
+                data[z - 1, y - 1, x - 1], data[z - 1, y - 1, x],
+                data[z - 1, y, x - 1], data[z - 1, y, x],
+                data[z - 1, y + 1, x - 1], data[z - 1, y + 1, x],
+
+                # --- Middle Slice (z) ---
+                data[z, y - 1, x - 1], data[z, y - 1, x],
+                data[z, y, x - 1],
+                data[z, y + 1, x - 1], data[z, y + 1, x],
+
+                # --- Bottom Slice (z+1) ---
+                data[z + 1, y - 1, x - 1], data[z + 1, y - 1, x],
+                data[z + 1, y, x - 1], data[z + 1, y, x],
+                data[z + 1, y + 1, x - 1], data[z + 1, y + 1, x],
+            onlyzero=onlyzero)
+
+    # --- Edges ---
+    # Front-Top Edge (z=0, y=0)
+    z, y = 0, 0
+    for x in range(1, sx - 1):
+        out[z, y, x] = choose_op(opname, (data[z, y, x],
+            data[z, y, x - 1], data[z, y, x + 1],
+            data[z, y + 1, x - 1], data[z, y + 1, x], data[z, y + 1, x + 1],
+            data[z + 1, y, x - 1], data[z + 1, y, x], data[z + 1, y, x + 1],
+            data[z + 1, y + 1, x - 1], data[z + 1, y + 1, x], data[z + 1, y + 1, x + 1],
+        ), onlyzero=onlyzero)
+
+    # Front-Bottom Edge (z=0, y=sy-1)
+    z, y = 0, sy - 1
+    for x in range(1, sx - 1):
+        out[z, y, x] = choose_op(opname, ( data[z, y, x],
+            data[z, y - 1, x - 1], data[z, y - 1, x], data[z, y - 1, x + 1],
+            data[z, y, x - 1], data[z, y, x + 1],
+            data[z + 1, y - 1, x - 1], data[z + 1, y - 1, x], data[z + 1, y - 1, x + 1],
+            data[z + 1, y, x - 1], data[z + 1, y, x], data[z + 1, y, x + 1],
+        ), onlyzero=onlyzero)
+
+    # Back-Top Edge (z=sz-1, y=0)
+    z, y = sz - 1, 0
+    for x in range(1, sx - 1):
+        out[z, y, x] = choose_op(opname, (data[z, y, x],
+            data[z - 1, y, x - 1], data[z - 1, y, x], data[z - 1, y, x + 1],
+            data[z - 1, y + 1, x - 1], data[z - 1, y + 1, x], data[z - 1, y + 1, x + 1],
+            data[z, y, x - 1],  data[z, y, x + 1],
+            data[z, y + 1, x - 1], data[z, y + 1, x], data[z, y + 1, x + 1],
+        ), onlyzero=onlyzero)
+
+    # Back-Bottom Edge (z=sz-1, y=sy-1)
+    z, y = sz - 1, sy - 1
+    for x in range(1, sx - 1):
+        out[z, y, x] = choose_op(opname, (data[z, y, x],
+            data[z - 1, y - 1, x - 1], data[z - 1, y - 1, x], data[z - 1, y - 1, x + 1],
+            data[z - 1, y, x - 1], data[z - 1, y, x], data[z - 1, y, x + 1],
+            data[z, y - 1, x - 1], data[z, y - 1, x], data[z, y - 1, x + 1],
+            data[z, y, x - 1], data[z, y, x + 1],
+        ), onlyzero=onlyzero)
+
+    # Front-Left Edge (z=0, x=0)
+    z, x = 0, 0
+    for y in range(1, sy - 1):
+        out[z, y, x] = choose_op(opname, (data[z, y, x],
+            data[z, y - 1, x], data[z, y - 1, x + 1],
+            data[z, y, x + 1],
+            data[z, y + 1, x], data[z, y + 1, x + 1],
+            data[z + 1, y - 1, x], data[z + 1, y - 1, x + 1],
+            data[z + 1, y, x], data[z + 1, y, x + 1],
+            data[z + 1, y + 1, x], data[z + 1, y + 1, x + 1],
+        ), onlyzero=onlyzero)
+
+    # Front-Right Edge (z=0, x=sx-1)
+    z, x = 0, sx - 1
+    for y in range(1, sy - 1):
+        out[z, y, x] = choose_op(opname, (data[z, y, x],
+            data[z, y - 1, x - 1], data[z, y - 1, x],
+            data[z, y, x - 1], 
+            data[z, y + 1, x - 1], data[z, y + 1, x],
+            data[z + 1, y - 1, x - 1], data[z + 1, y - 1, x],
+            data[z + 1, y, x - 1], data[z + 1, y, x],
+            data[z + 1, y + 1, x - 1], data[z + 1, y + 1, x],
+        ), onlyzero=onlyzero)
+
+    # Back-Left Edge (z=sz-1, x=0)
+    z, x = sz - 1, 0
+    for y in range(1, sy - 1):
+        out[z, y, x] = choose_op(opname, (data[z, y, x],
+            data[z - 1, y - 1, x], data[z - 1, y - 1, x + 1],
+            data[z - 1, y, x], data[z - 1, y, x + 1],
+            data[z - 1, y + 1, x], data[z - 1, y + 1, x + 1],
+            data[z, y - 1, x], data[z, y - 1, x + 1],
+            data[z, y, x + 1],
+            data[z, y + 1, x], data[z, y + 1, x + 1],
+        ), onlyzero=onlyzero)
+
+    # Back-Right Edge (z=sz-1, x=sx-1)
+    z, x = sz - 1, sx - 1
+    for y in range(1, sy - 1):
+        out[z, y, x] = choose_op(opname, (data[z, y, x],
+            data[z - 1, y - 1, x - 1], data[z - 1, y - 1, x],
+            data[z - 1, y, x - 1], data[z - 1, y, x],
+            data[z - 1, y + 1, x - 1], data[z - 1, y + 1, x],
+            data[z, y - 1, x - 1], data[z, y - 1, x],
+            data[z, y, x - 1], 
+            data[z, y + 1, x - 1], data[z, y + 1, x],
+        ), onlyzero=onlyzero)
+
+    # Top-Left Edge (y=0, x=0)
+    y, x = 0, 0
+    for z in range(1, sz - 1):
+        out[z, y, x] = choose_op(opname, (data[z, y, x],
+            data[z - 1, y, x], data[z - 1, y, x + 1],
+            data[z - 1, y + 1, x], data[z - 1, y + 1, x + 1],
+            data[z, y, x + 1],
+            data[z, y + 1, x], data[z, y + 1, x + 1],
+            data[z + 1, y, x], data[z + 1, y, x + 1],
+            data[z + 1, y + 1, x], data[z + 1, y + 1, x + 1],
+        ), onlyzero=onlyzero)
+
+    # Top-Right Edge (y=0, x=sx-1)
+    y, x = 0, sx - 1
+    for z in range(1, sz - 1):
+        out[z, y, x] = choose_op(opname, (data[z, y, x],
+            data[z - 1, y, x - 1], data[z - 1, y, x],
+            data[z - 1, y + 1, x - 1], data[z - 1, y + 1, x],
+            data[z, y, x - 1], 
+            data[z, y + 1, x - 1], data[z, y + 1, x],
+            data[z + 1, y, x - 1], data[z + 1, y, x],
+            data[z + 1, y + 1, x - 1], data[z + 1, y + 1, x],
+        ), onlyzero=onlyzero)
+
+    # Bottom-Left Edge (y=sy-1, x=0)
+    y, x = sy - 1, 0
+    for z in range(1, sz - 1):
+        out[z, y, x] = choose_op(opname, (data[z, y, x],
+            data[z - 1, y - 1, x], data[z - 1, y - 1, x + 1],
+            data[z - 1, y, x], data[z - 1, y, x + 1],
+            data[z, y - 1, x], data[z, y - 1, x + 1],
+            data[z, y, x + 1],
+            data[z + 1, y - 1, x], data[z + 1, y - 1, x + 1],
+            data[z + 1, y, x], data[z + 1, y, x + 1],
+        ), onlyzero=onlyzero)
+
+    # Bottom-Right Edge (y=sy-1, x=sx-1)
+    y, x = sy - 1, sx - 1
+    for z in range(1, sz - 1):
+        out[z, y, x] = choose_op(opname, (data[z, y, x],
+            data[z - 1, y - 1, x - 1], data[z - 1, y - 1, x],
+            data[z - 1, y, x - 1], data[z - 1, y, x],
+            data[z, y - 1, x - 1], data[z, y - 1, x],
+            data[z, y, x - 1], 
+            data[z + 1, y - 1, x - 1], data[z + 1, y - 1, x],
+            data[z + 1, y, x - 1], data[z + 1, y, x],
+        ), onlyzero=onlyzero)
+
+    # --- Corners ---
+    # Front-Top-Left Corner (z=0, y=0, x=0)
+    out[0, 0, 0] = choose_op(opname, (data[0, 0, 0], 
+        data[0, 0, 1],
+        data[0, 1, 0], data[0, 1, 1],
+        data[1, 0, 0], data[1, 0, 1],
+        data[1, 1, 0], data[1, 1, 1],
+        ), onlyzero=onlyzero)
+
+    # Front-Top-Right Corner (z=0, y=0, x=sx-1)
+    out[0, 0, sx - 1] = choose_op(opname, (data[0, 0, sx - 1],
+        data[0, 0, sx - 2], 
+        data[0, 1, sx - 2], data[0, 1, sx - 1],
+        data[1, 0, sx - 2], data[1, 0, sx - 1],
+        data[1, 1, sx - 2], data[1, 1, sx - 1],
+        ), onlyzero=onlyzero)
+
+    # Front-Bottom-Left Corner (z=0, y=sy-1, x=0)
+    out[0, sy - 1, 0] = choose_op(opname, (data[0, sy - 1, 0],
+        data[0, sy - 2, 0], data[0, sy - 2, 1],
+        data[0, sy - 1, 1],
+        data[1, sy - 2, 0], data[1, sy - 2, 1],
+        data[1, sy - 1, 0], data[1, sy - 1, 1],
+        ), onlyzero=onlyzero)
+
+    # Front-Bottom-Right Corner (z=0, y=sy-1, x=sx-1)
+    out[0, sy - 1, sx - 1] = choose_op(opname, (data[0, sy - 1, sx - 1],
+        data[0, sy - 2, sx - 2], data[0, sy - 2, sx - 1],
+        data[0, sy - 1, sx - 2],
+        data[1, sy - 2, sx - 2], data[1, sy - 2, sx - 1],
+        data[1, sy - 1, sx - 2], data[1, sy - 1, sx - 1],
+        ), onlyzero=onlyzero)
+
+    # Back-Top-Left Corner (z=sz-1, y=0, x=0)
+    out[sz - 1, 0, 0] = choose_op(opname, (data[sz - 1, 0, 0],
+        data[sz - 2, 0, 0], data[sz - 2, 0, 1],
+        data[sz - 2, 1, 0], data[sz - 2, 1, 1],
+        data[sz - 1, 0, 1],
+        data[sz - 1, 1, 0], data[sz - 1, 1, 1],
+        ), onlyzero=onlyzero)
+
+    # Back-Top-Right Corner (z=sz-1, y=0, x=sx-1)
+    out[sz - 1, 0, sx - 1] = choose_op(opname, (data[sz - 1, 0, sx - 1],
+        data[sz - 2, 0, sx - 2], data[sz - 2, 0, sx - 1],
+        data[sz - 2, 1, sx - 2], data[sz - 2, 1, sx - 1],
+        data[sz - 1, 0, sx - 2], 
+        data[sz - 1, 1, sx - 2], data[sz - 1, 1, sx - 1],
+        ), onlyzero=onlyzero)
+
+    # Back-Bottom-Left Corner (z=sz-1, y=sy-1, x=0)
+    out[sz - 1, sy - 1, 0] = choose_op(opname, (data[sz - 1, sy - 1, 0], 
+        data[sz - 2, sy - 2, 0], data[sz - 2, sy - 2, 1],
+        data[sz - 2, sy - 1, 0], data[sz - 2, sy - 1, 1],
+        data[sz - 1, sy - 2, 0], data[sz - 1, sy - 2, 1],
+        data[sz - 1, sy - 1, 1],
+        ), onlyzero=onlyzero)
+
+    # Back-Bottom-Right Corner (z=sz-1, y=sy-1, x=sx-1)
+    out[sz - 1, sy - 1, sx - 1] = choose_op(opname, (data[sz - 1, sy - 1, sx - 1],
+        data[sz - 2, sy - 2, sx - 2], data[sz - 2, sy - 2, sx - 1],
+        data[sz - 2, sy - 1, sx - 2], data[sz - 2, sy - 1, sx - 1],
+        data[sz - 1, sy - 2, sx - 2], data[sz - 1, sy - 2, sx - 1],
+        data[sz - 1, sy - 1, sx - 2], 
+        ), onlyzero=onlyzero)
+
+
+@numba.njit(inline="always")
+def op3x3x3(data, z, y, x, opname, onlyzero):
+    return choose_op27(opname,
+        # --- Top Slice (z-1) ---
+        data[z-1, y-1, x-1], data[z-1, y-1, x], data[z-1, y-1, x+1],
+        data[z-1, y,   x-1], data[z-1, y,   x], data[z-1, y,   x+1],
+        data[z-1, y+1, x-1], data[z-1, y+1, x], data[z-1, y+1, x+1],
+        
+        # --- Middle Slice (z) ---
+        data[z,   y-1, x-1], data[z,   y-1, x], data[z,   y-1, x+1],
+        data[z,   y,   x-1], data[z,     y, x] , data[z,   y,   x+1],
+        data[z,   y+1, x-1], data[z,   y+1, x], data[z,   y+1, x+1],
+
+        # --- Bottom Slice (z+1) ---
+        data[z+1, y-1, x-1], data[z+1, y-1, x], data[z+1, y-1, x+1],
+        data[z+1, y,   x-1], data[z+1, y,   x], data[z+1, y,   x+1],
+        data[z+1, y+1, x-1], data[z+1, y+1, x], data[z+1, y+1, x+1],
+        onlyzero=onlyzero
+    )
+
+
+@numba.njit(parallel=True, cache=False)
+def kernel3x3x3(data, opname, out=None, onlyzero=False):
+    sz, sy, sx = data.shape
+    if out is None:
+        out = np.zeros_like(data)
+    assert data.shape == out.shape
+    for z in numba.prange(1, sz-1):
+        for y in range(1, sy-1):
+            for x in range(1, sx-1):
+                out[z,y,x] = op3x3x3(data, z,y,x, opname, onlyzero)
+    borders3x3x3(data, opname, out, onlyzero=onlyzero)
+    return out

nbmorph/diamond_kernel.py

@@ -0,0 +1,44 @@
+import numba
+import numpy as np
+from .ops import choose_op
+
+
+@numba.njit(inline="always")
+def clamp(index, size):
+    return max(0,index-1), min(index+1, size-1)
+  
+@numba.njit(parallel=True, cache=True)
+def diamond_loop_padded(data, opname:str, out=None, onlyzero=False):
+    if out is None:
+        out = np.empty_like(data)
+    assert data.shape == out.shape
+    sz, sy, sx = data.shape
+    for z in numba.prange(sz):
+        zl, zr = clamp(z, sz)
+        for y in range(sy):
+            yl, yr = clamp(y, sy)
+            # first x slice:
+            x = 0
+            out[z,y,x] = choose_op(opname, (data[z,y,x], 
+                             data[zl,y,x], data[zr,y,x],
+                             data[z,yl,x], data[z,yr,x],
+                             data[z,y, min(x+1, sx-1)], data[z,y, x]),
+                             onlyzero=onlyzero)
+            # middle slices
+            for x in range(1, sx-1):
+                out[z,y,x] = choose_op(opname, (data[z,y,x], 
+                                data[zl,y,x], data[zr,y,x],
+                                data[z,yl,x], data[z,yr,x],
+                                data[z,y,x-1], data[z,y,x+1]),
+                                onlyzero=onlyzero)
+
+            #last slice, if more than 1 slice
+            if sx > 1:
+                x = sx -1
+                out[z,y,x] = choose_op(opname, (data[z,y,x], 
+                                    data[zl,y,x], data[zr,y,x],
+                                    data[z,yl,x], data[z,yr,x],
+                                    data[z,y, x -1], data[z,y, x]),
+                                    onlyzero=onlyzero)
+
+    return out

nbmorph/minmax.py

@@ -0,0 +1,22 @@
+import numpy as np
+import numba
+from .diamond_kernel import diamond_loop_padded 
+from .box_kernel import kernel3x3x3
+
+@numba.njit(cache=True)
+def minimum_box(a, out=None,onlyzero=False):
+    return kernel3x3x3(a, opname="min", out=out, onlyzero=onlyzero)
+
+@numba.njit(cache=True)
+def maximum_box(a, out=None,onlyzero=False):
+    return kernel3x3x3(a, opname="max", out=out, onlyzero=onlyzero)
+
+@numba.njit(cache=True)
+def minimum_diamond(data, out=None, onlyzero=False):
+    return diamond_loop_padded(data, opname="min", out=out, onlyzero=onlyzero)
+
+@numba.njit(cache=True)
+def maximum_diamond(data, out=None, onlyzero=False):
+    return diamond_loop_padded(data, opname="max", out=out, onlyzero=onlyzero)
+
+

nbmorph/mode.py

@@ -0,0 +1,389 @@
+import numba 
+import numpy as np
+from .minmax import maximum_box, maximum_diamond
+
+@numba.njit
+def fast_mode(a):
+    return fast_modeN(a, len(a))
+
+@numba.njit(inline="always")
+def fast_modeN(a, N):
+    """
+    Find the mode of a 1D array, ignoring zeros. This is an O(n^2) algorithm, 
+    but fast on small data (len(a) < 50), as needed here.
+
+    Args:
+        a (np.ndarray): The input 1D array.
+
+    Returns:
+        The mode of the array.
+    """
+    max_count = 0
+    current_count = 0
+    mode = a[0]
+    for i in range(N):
+        #if a[i] == mode: continue
+        current_count = 0
+        for j in range(N):
+            current_count += (a[i] == a[j])
+
+        if current_count > N/2:
+            return a[i]
+
+        elif current_count > max_count:
+            mode = a[i]
+            max_count = current_count
+
+        elif current_count == max_count and a[i] < mode:
+            mode = a[i]
+    return mode
+
+@numba.njit(inline="always")
+def _cs(a, b):
+    """Performs a compare-swap on two values."""
+    if a > b:
+        return b, a
+    else:
+        return a, b
+
+
+@numba.njit(inline="always")
+def sort26_network(
+    v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
+    v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25
+):
+    """
+    Sorts 26 elements using a pre-defined sorting network.
+    From https://bertdobbelaere.github.io/sorting_networks.html
+    """
+    v0, v1 = _cs(v0, v1); v2, v3 = _cs(v2, v3); v4, v5 = _cs(v4, v5); v6, v7 = _cs(v6, v7); v8, v9 = _cs(v8, v9); v10, v11 = _cs(v10, v11); v12, v13 = _cs(v12, v13); v14, v15 = _cs(v14, v15); v16, v17 = _cs(v16, v17); v18, v19 = _cs(v18, v19); v20, v21 = _cs(v20, v21); v22, v23 = _cs(v22, v23); v24, v25 = _cs(v24, v25)
+    v0, v2 = _cs(v0, v2); v1, v3 = _cs(v1, v3); v4, v6 = _cs(v4, v6); v5, v7 = _cs(v5, v7); v8, v10 = _cs(v8, v10); v9, v11 = _cs(v9, v11); v14, v16 = _cs(v14, v16); v15, v17 = _cs(v15, v17); v18, v20 = _cs(v18, v20); v19, v21 = _cs(v19, v21); v22, v24 = _cs(v22, v24); v23, v25 = _cs(v23, v25)
+    v0, v4 = _cs(v0, v4); v1, v6 = _cs(v1, v6); v2, v5 = _cs(v2, v5); v3, v7 = _cs(v3, v7); v8, v14 = _cs(v8, v14); v9, v16 = _cs(v9, v16); v10, v15 = _cs(v10, v15); v11, v17 = _cs(v11, v17); v18, v22 = _cs(v18, v22); v19, v24 = _cs(v19, v24); v20, v23 = _cs(v20, v23); v21, v25 = _cs(v21, v25)
+    v0, v18 = _cs(v0, v18); v1, v19 = _cs(v1, v19); v2, v20 = _cs(v2, v20); v3, v21 = _cs(v3, v21); v4, v22 = _cs(v4, v22); v5, v23 = _cs(v5, v23); v6, v24 = _cs(v6, v24); v7, v25 = _cs(v7, v25); v9, v12 = _cs(v9, v12); v13, v16 = _cs(v13, v16)
+    v3, v11 = _cs(v3, v11); v8, v9 = _cs(v8, v9); v10, v13 = _cs(v10, v13); v12, v15 = _cs(v12, v15); v14, v22 = _cs(v14, v22); v16, v17 = _cs(v16, v17)
+    v0, v8 = _cs(v0, v8); v1, v9 = _cs(v1, v9); v2, v14 = _cs(v2, v14); v6, v12 = _cs(v6, v12); v7, v15 = _cs(v7, v15); v10, v18 = _cs(v10, v18); v11, v23 = _cs(v11, v23); v13, v19 = _cs(v13, v19); v16, v24 = _cs(v16, v24); v17, v25 = _cs(v17, v25)
+    v1, v2 = _cs(v1, v2); v3, v18 = _cs(v3, v18); v4, v8 = _cs(v4, v8); v7, v22 = _cs(v7, v22); v17, v21 = _cs(v17, v21); v23, v24 = _cs(v23, v24)
+    v3, v14 = _cs(v3, v14); v4, v10 = _cs(v4, v10); v5, v18 = _cs(v5, v18); v7, v20 = _cs(v7, v20); v8, v13 = _cs(v8, v13); v11, v22 = _cs(v11, v22); v12, v17 = _cs(v12, v17); v15, v21 = _cs(v15, v21)
+    v1, v4 = _cs(v1, v4); v5, v6 = _cs(v5, v6); v7, v9 = _cs(v7, v9); v8, v10 = _cs(v8, v10); v15, v17 = _cs(v15, v17); v16, v18 = _cs(v16, v18); v19, v20 = _cs(v19, v20); v21, v24 = _cs(v21, v24)
+    v2, v5 = _cs(v2, v5); v3, v10 = _cs(v3, v10); v6, v14 = _cs(v6, v14); v9, v13 = _cs(v9, v13); v11, v19 = _cs(v11, v19); v12, v16 = _cs(v12, v16); v15, v22 = _cs(v15, v22); v20, v23 = _cs(v20, v23)
+    v2, v8 = _cs(v2, v8); v5, v7 = _cs(v5, v7); v6, v9 = _cs(v6, v9); v11, v12 = _cs(v11, v12); v13, v14 = _cs(v13, v14); v16, v19 = _cs(v16, v19); v17, v23 = _cs(v17, v23); v18, v20 = _cs(v18, v20)
+    v2, v4 = _cs(v2, v4); v3, v5 = _cs(v3, v5); v6, v11 = _cs(v6, v11); v7, v10 = _cs(v7, v10); v9, v16 = _cs(v9, v16); v12, v13 = _cs(v12, v13); v14, v19 = _cs(v14, v19); v15, v18 = _cs(v15, v18); v20, v22 = _cs(v20, v22); v21, v23 = _cs(v21, v23)
+    v3, v4 = _cs(v3, v4); v5, v8 = _cs(v5, v8); v6, v7 = _cs(v6, v7); v9, v11 = _cs(v9, v11); v10, v12 = _cs(v10, v12); v13, v15 = _cs(v13, v15); v14, v16 = _cs(v14, v16); v17, v20 = _cs(v17, v20); v18, v19 = _cs(v18, v19); v21, v22 = _cs(v21, v22)
+    v5, v6 = _cs(v5, v6); v7, v8 = _cs(v7, v8); v9, v10 = _cs(v9, v10); v11, v12 = _cs(v11, v12); v13, v14 = _cs(v13, v14); v15, v16 = _cs(v15, v16); v17, v18 = _cs(v17, v18); v19, v20 = _cs(v19, v20)
+    v4, v5 = _cs(v4, v5); v6, v7 = _cs(v6, v7); v8, v9 = _cs(v8, v9); v10, v11 = _cs(v10, v11); v12, v13 = _cs(v12, v13); v14, v15 = _cs(v14, v15); v16, v17 = _cs(v16, v17); v18, v19 = _cs(v18, v19); v20, v21 = _cs(v20, v21)
+    
+    return v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25
+
+@numba.njit(inline="always")
+def sort6_network(v0, v1, v2, v3, v4, v5):
+    """
+    Sorts 6 elements using a pre-defined sorting network.
+    From https://bertdobbelaere.github.io/sorting_networks.html
+    """
+    v0, v5 = _cs(v0, v5)
+    v1, v3 = _cs(v1, v3)
+    v2, v4 = _cs(v2, v4)
+    
+    v1, v2 = _cs(v1, v2)
+    v3, v4 = _cs(v3, v4)
+    
+    v0, v3 = _cs(v0, v3)
+    v2, v5 = _cs(v2, v5)
+    
+    v0, v1 = _cs(v0, v1)
+    v2, v3 = _cs(v2, v3)
+    v4, v5 = _cs(v4, v5)
+    
+    v1, v2 = _cs(v1, v2)
+    v3, v4 = _cs(v3, v4)
+    
+    return v0, v1, v2, v3, v4, v5
+
+@numba.njit(inline="always")
+def mode_diamond(data, z, y, x):
+    """
+    Calculates the mode of a diamond neighborhood.
+    The neighborhood includes its 6 direct neighbors: 
+    (z, y, x-1), (z, y, x+1), (z, y-1, x),
+    (z, y+1, x), (z-1, y, x), (z+1, y, x).
+    """    
+
+    (v0, v1, v2, v3, v4, v5) = sort6_network(
+        data[z, y, x-1], data[z, y, x+1],
+        data[z, y-1, x], data[z, y+1, x],
+        data[z-1, y, x], data[z+1, y, x]
+    )
+
+    one = np.uint8(1)
+    l0 = one
+    l1 = (l0 + one) if v1 == v0 and v1 > 0 else one 
+    l2 = (l1 + one) if v2 == v1 and v2 > 0 else one 
+    l3 = (l2 + one) if v3 == v2 and v3 > 0 else one 
+    l4 = (l3 + one) if v4 == v3 and v4 > 0 else one 
+    l5 = (l4 + one) if v5 == v4 and v5 > 0 else one 
+
+    def _update_max(len1, val1, len2, val2):
+        if len2 >= len1:
+            return len2, val2
+        return len1, val1
+
+    (l_max, v_mode) = _update_max(l0, v0, l1, v1)
+    (l_max, v_mode) = _update_max(l_max, v_mode, l2, v2)
+    (l_max, v_mode) = _update_max(l_max, v_mode, l3, v3)
+    (l_max, v_mode) = _update_max(l_max, v_mode, l4, v4)
+    (l_max, v_mode) = _update_max(l_max, v_mode, l5, v5)
+    
+    #print(v_mode)
+    return v_mode
+
+
+@numba.njit(inline="always")
+def mode_box(data, z, y, x):
+    """
+    Calculates the mode of a 3x3x3 neighborhood by explicitly
+    accessing all 26 neighbors.
+    """    
+
+    (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
+    v12, v13, v14, v15, v16, v17, v18, v19, v20,
+    v21, v22, v23, v24, v25 ) = sort26_network(
+        # --- Top Slice (z-1) ---
+        data[z-1, y-1, x-1], data[z-1, y-1, x], data[z-1, y-1, x+1],
+        data[z-1, y,   x-1], data[z-1, y,   x], data[z-1, y,   x+1],
+        data[z-1, y+1, x-1], data[z-1, y+1, x], data[z-1, y+1, x+1],
+        
+        # --- Middle Slice (z) ---
+        data[z,   y-1, x-1], data[z,   y-1, x], data[z,   y-1, x+1],
+        data[z,   y,   x-1]                   , data[z,   y,   x+1],
+        data[z,   y+1, x-1], data[z,   y+1, x], data[z,   y+1, x+1],
+
+        # --- Bottom Slice (z+1) ---
+        data[z+1, y-1, x-1], data[z+1, y-1, x], data[z+1, y-1, x+1],
+        data[z+1, y,   x-1], data[z+1, y,   x], data[z+1, y,   x+1],
+        data[z+1, y+1, x-1], data[z+1, y+1, x], data[z+1, y+1, x+1]
+    )
+
+    one = np.uint8(1)
+    l0 = one
+    l1 = (l0 + one) if v1 == v0 and v1>0 else one 
+    l2 = (l1 + one) if v2 == v1 and v2>0 else one 
+    l3 = (l2 + one) if v3 == v2 and v3>0 else one 
+    l4 = (l3 + one) if v4 == v3 and v4>0 else one 
+    l5 = (l4 + one) if v5 == v4 and v5>0 else one 
+    l6 = (l5 + one) if v6 == v5 and v6>0 else one 
+    l7 = (l6 + one) if v7 == v6 and v7>0 else one 
+    l8 = (l7 + one) if v8 == v7 and v8>0 else one 
+    l9 = (l8 + one) if v9 == v8 and v9>0 else one 
+    l10 = (l9 + one) if v10 == v9 and v10>0 else one 
+    l11 = (l10 + one) if v11 == v10 and v11>0 else one 
+    l12 = (l11 + one) if v12 == v11 and v12>0 else one 
+    l13 = (l12 + one) if v13 == v12 and v13>0 else one 
+    l14 = (l13 + one) if v14 == v13 and v14>0 else one 
+    l15 = (l14 + one) if v15 == v14 and v15>0 else one 
+    l16 = (l15 + one) if v16 == v15 and v16>0 else one 
+    l17 = (l16 + one) if v17 == v16 and v17>0 else one 
+    l18 = (l17 + one) if v18 == v17 and v18>0 else one 
+    l19 = (l18 + one) if v19 == v18 and v19>0 else one 
+    l20 = (l19 + one) if v20 == v19 and v20>0 else one 
+    l21 = (l20 + one) if v21 == v20 and v21>0 else one 
+    l22 = (l21 + one) if v22 == v21 and v22>0 else one 
+    l23 = (l22 + one) if v23 == v22 and v23>0 else one 
+    l24 = (l23 + one) if v24 == v23 and v24>0 else one 
+    l25 = (l24 + one) if v25 == v24 and v25>0 else one 
+
+    def _update_max(len1, val1, len2, val2):
+        if len2 >= len1:
+            return len2, val2
+        return len1, val1
+
+       # Layer 1: 13 parallel comparisons
+    l1, v1 = _update_max(l0, v0, l1, v1)
+    l3, v3 = _update_max(l2, v2, l3, v3)
+    l5, v5 = _update_max(l4, v4, l5, v5)
+    l7, v7 = _update_max(l6, v6, l7, v7)
+    l9, v9 = _update_max(l8, v8, l9, v9)
+    l11, v11 = _update_max(l10, v10, l11, v11)
+    l13, v13 = _update_max(l12, v12, l13, v13)
+    l15, v15 = _update_max(l14, v14, l15, v15)
+    l17, v17 = _update_max(l16, v16, l17, v17)
+    l19, v19 = _update_max(l18, v18, l19, v19)
+    l21, v21 = _update_max(l20, v20, l21, v21)
+    l23, v23 = _update_max(l22, v22, l23, v23)
+    l25, v25 = _update_max(l24, v24, l25, v25)
+
+    # Layer 2: Winners from Layer 1 compete (6 parallel comparisons)
+    l3, v3 = _update_max(l1, v1, l3, v3)
+    l7, v7 = _update_max(l5, v5, l7, v7)
+    l11, v11 = _update_max(l9, v9, l11, v11)
+    l15, v15 = _update_max(l13, v13, l15, v15)
+    l19, v19 = _update_max(l17, v17, l19, v19)
+    l23, v23 = _update_max(l21, v21, l23, v23)
+    # l25, v25 are carried over
+
+    # Layer 3: 3 parallel comparisons
+    l7, v7 = _update_max(l3, v3, l7, v7)
+    l15, v15 = _update_max(l11, v11, l15, v15)
+    l23, v23 = _update_max(l19, v19, l23, v23)
+    # l25, v25 are carried over
+
+    # Layer 4: 2 parallel comparisons
+    l15, v15 = _update_max(l7, v7, l15, v15)
+    l25, v25 = _update_max(l23, v23, l25, v25)
+
+    # Layer 5: Final comparison
+    l25, v25 = _update_max(l15, v15, l25, v25)
+    return v25
+
+
+@numba.njit(inline="always")
+def load_box_stencil(data, z, y, x, sz,sy,sx, nbs):
+    z1 = -1 if z > 0 else 0; z2 = 2 if z < sz-1 else 1
+    y1 = -1 if y > 0 else 0; y2 = 2 if y < sy-1 else 1
+    x1 = -1 if x > 0 else 0; x2 = 2 if x < sx-1 else 1
+    nnz = 0
+    for i in range(z1,z2):
+        for j in range(y1,y2):
+            for k in range(x1,x2):
+                val = data[z + i, y + j, x + k]
+                nbs[nnz] = val
+                if val > 0:
+                    nnz += 1
+    return nnz
+
+@numba.njit(inline="always")
+def load_diamond_stencil(data, z, y, x, sz, sy, sx, nbs):
+    """
+    Loads a diamond stencil into a neighbors array, counting only non-zero values.
+    The stencil includes the 6 direct neighbors.
+    Boundary conditions are handled by checking array dimensions.
+    
+    Parameters:
+    - data: The 3D input NumPy array.
+    - z, y, x: The coordinates of the center point.
+    - sz, sy, sx: The dimensions of the data array.
+    - nbs: The NumPy array to load the neighbors into.
+    
+    Returns:
+    - The number of non-zero values loaded.
+    """
+    nnz = 0
+    
+    if z > 0:
+        val = data[z - 1, y, x]
+        nbs[nnz] = val
+        if val > 0:
+            nnz += 1
+    
+    if z < sz - 1:
+        val = data[z + 1, y, x]
+        nbs[nnz] = val
+        if val > 0:
+            nnz += 1
+        
+    if y > 0:
+        val = data[z, y - 1, x]
+        nbs[nnz] = val
+        if val > 0:
+            nnz += 1
+            
+    if y < sy - 1:
+        val = data[z, y + 1, x]
+        nbs[nnz] = val
+        if val > 0:
+            nnz += 1
+
+    if x > 0:
+        val = data[z, y, x - 1]
+        nbs[nnz] = val
+        if val > 0:
+            nnz += 1
+            
+    if x < sx - 1:
+        val = data[z, y, x + 1]
+        nbs[nnz] = val
+        if val > 0:
+            nnz += 1
+    return nnz
+
+@numba.njit
+def _mode_borders(data, out, stencil):
+    sz, sy, sx = data.shape
+    nbs = np.empty(17, dtype=data.dtype)
+
+    def process_point(z, y, x):
+        if data[z, y, x] > 0:
+            out[z, y, x] = data[z, y, x]
+        else:
+            if stencil=="box":
+                nnz = load_box_stencil(data, z, y, x, sz,sy,sx, nbs)
+            else:
+                nnz = load_diamond_stencil(data, z, y, x, sz,sy,sx, nbs)
+            
+            out[z, y, x] = fast_modeN(nbs, nnz) * (nnz > 0)
+
+    # 1. Top and Bottom faces (Z-axis)
+    for z in [0, sz - 1]:
+        for y in range(sy):
+            for x in range(sx):
+                process_point(z, y, x)
+
+    # 2. Front and Back faces (Y-axis), excluding edges already done by Z-faces
+    for y in [0, sy - 1]:
+        for z in range(1, sz - 1): # Note: range starts at 1, ends at sz-2
+            for x in range(sx):
+                process_point(z, y, x)
+
+    # 3. Left and Right faces (X-axis), excluding edges already done by Z and Y faces
+    for x in [0, sx - 1]:
+        for z in range(1, sz - 1): # Note: range starts at 1
+            for y in range(1, sy - 1): # Note: range starts at 1
+                process_point(z, y, x)
+
+    return out
+
+@numba.njit(parallel=True)
+def _onlyzero_mode_box(data, out=None):
+    sz, sy, sx = data.shape
+    if out is None:
+        out = np.empty_like(data)
+    assert data.shape == out.shape
+    for z in numba.prange(1, sz-1):
+        for y in range(1, sy-1):
+            for x in range(1, sx-1):
+                if data[z,y,x]>0:
+                    out[z,y,x] = data[z,y,x]
+                else:
+                    out[z,y,x] = mode_box(data, z,y,x)
+    _mode_borders(data, out, stencil="box")
+    return out
+
+
+@numba.njit(cache=True)
+def onlyzero_mode_box(data, out=None):
+    if isinstance(data.dtype.type(0), bool):
+        return maximum_box(data, out, onlyzero=True)
+    else:
+        return _onlyzero_mode_box(data, out=out)
+
+@numba.njit(parallel=True)
+def _onlyzero_mode_diamond(data, out=None):
+    sz, sy, sx = data.shape
+    if out is None:
+        out = np.empty_like(data)
+    assert data.shape == out.shape
+    for z in numba.prange(1, sz-1):
+        for y in range(1, sy-1):
+            for x in range(1, sx-1):
+                if data[z,y,x]>0:
+                    out[z,y,x] = data[z,y,x]
+                else:
+                    out[z,y,x] = mode_diamond(data, z,y,x)
+    _mode_borders(data, out, stencil="diamond")
+    return out
+
+@numba.njit(cache=True)
+def onlyzero_mode_diamond(data, out=None):
+    if isinstance(data.dtype.type(0), bool):
+        return maximum_diamond(data, out, onlyzero=True)
+    else:
+        return _onlyzero_mode_diamond(data, out=out)

nbmorph/morphology.py

@@ -0,0 +1,131 @@
+import numpy as np
+import numba
+from .mode import onlyzero_mode_box, onlyzero_mode_diamond
+from .minmax import minimum_box, minimum_diamond
+from .zero_edges import zero_label_edges_box, zero_label_edges_diamond
+from .utils import cycle
+
+@numba.njit(cache=True)
+def dilate_labels_spherical(labels: np.ndarray, radius: int=1, 
+                            struct_sequence:str="DDB") -> np.ndarray:
+    """
+    Performs fast, quasi-spherical multilabel dilation on a CPU.
+    This approximates a spherical structuring element by alternating between a box (3x3x3)
+    and a diamond (6-connected) kernel for each iteration.
+    Args:
+        labels: The input 3D labeled image (must be an integer type).
+        radius: The dilation radius in voxels. Each iteration expands by one voxel.
+
+    Returns:
+        The dilated 3D labeled image.
+    """
+    # Use two buffers that are swapped (ping-pong) to propagate labels iteratively
+    # We start by copying the original labels to both
+
+    # Initial setup: The original data is the first "pong".
+    pong = np.copy(labels)
+    ping = np.empty_like(pong)
+
+    for s in cycle(struct_sequence, radius):
+        # Determine which kernel to use for this iteration
+        if s=="B":
+            onlyzero_mode_box(pong, out=ping)
+        elif s=="D":
+            onlyzero_mode_diamond(pong, out=ping)
+
+        # --- Swap Buffers for the Next Iteration ---
+        # The ping of this step becomes the pong for the next one.
+        pong, ping = ping, pong
+    return pong
+
+@numba.njit(cache=True)
+def erode_labels_spherical(labels: np.ndarray, radius: int=1, 
+                           struct_sequence:str="DDB") -> np.ndarray:
+    """
+    Performs fast, quasi-spherical multilabel erosion on a CPU.
+
+    Args:
+        labels (np.ndarray): The input 3D labeled image.
+        radius (int, optional): The erosion radius. Defaults to 1.
+
+    Returns:
+        np.ndarray: The eroded labeled image.
+    """
+    assert radius > 0
+    pong = np.copy(labels)
+    ping = np.empty_like(pong)
+
+    if struct_sequence[0]=="D":
+        zero_label_edges_diamond(pong, out=ping)
+    elif struct_sequence[0]=="B":
+        zero_label_edges_box(pong, out=ping)
+
+    if radius==1: 
+        return ping
+    
+    for s in cycle(struct_sequence, radius)[1:]:
+        if s=="B":
+            minimum_box(ping, out=pong)
+        elif s=="D":
+            minimum_diamond(ping, out=pong)
+        ping, pong = pong, ping
+    return ping
+
+#@numba.njit
+def open_labels_spherical(labels: np.ndarray, radius: int=1, iterations:int=1) -> np.ndarray:
+    """
+    Performs a morphological opening on a labeled image.
+
+    Args:
+        labels (np.ndarray): The input 3D labeled image.
+        radius (int): The radius of the spherical structuring element.
+        iterations (int, optional): The number of iterations. Defaults to 1.
+
+    Returns:
+        np.ndarray: The opened labeled image.
+    """
+    out = np.copy(labels)
+    for i in range(iterations):
+        out = erode_labels_spherical(out, radius)
+        out = dilate_labels_spherical(out, radius)
+    return out
+
+#@numba.njit
+def close_labels_spherical(labels: np.ndarray, radius: int, iterations:int=1) -> np.ndarray:
+    """
+    Performs a morphological closing on a labeled image.
+
+    Args:
+        labels (np.ndarray): The input 3D labeled image.
+        radius (int): The radius of the spherical structuring element.
+        iterations (int, optional): The number of iterations. Defaults to 1.
+
+    Returns:
+        np.ndarray: The closed labeled image.
+    """
+    out = np.copy(labels)
+    #print("closing...")
+    for i in range(iterations):
+        out1 = dilate_labels_spherical(out, radius)
+        #print(f"after dilate: {out1.sum()}")
+        out = erode_labels_spherical(out1, radius)
+        #print(f"after erode: {out.sum()}")
+    return out
+
+#@numba.njit
+def smooth_labels_spherical(labels: np.ndarray, radius: int, iterations:int=1) -> np.ndarray:
+    """
+    Performs a morphological smoothing on a labeled image.
+
+    Args:
+        labels (np.ndarray): The input 3D labeled image.
+        radius (int): The radius of the spherical structuring element.
+        iterations (int, optional): The number of iterations. Defaults to 1.
+
+    Returns:
+        np.ndarray: The smoothed labeled image.
+    """
+    for i in range(iterations):
+        labels = open_labels_spherical(labels, radius)
+        labels = close_labels_spherical(labels, radius)
+    return labels

nbmorph/ops.py

@@ -0,0 +1,16 @@
+import numba
+
+@numba.njit(inline="always")
+def zero_if_not_allequal(nbs):
+    if max(nbs) == min(nbs):
+        return nbs[0]
+    else:
+        return 0
+
+@numba.njit(inline="always")
+def choose_op(opname, nbs, onlyzero):
+    if onlyzero and nbs[0]>0: return nbs[0]
+    match opname:
+        case "min": return min(nbs)
+        case "max": return max(nbs)
+        case "zeroedges": return zero_if_not_allequal(nbs)

nbmorph/utils.py

@@ -0,0 +1,6 @@
+import numpy as np
+import numba
+
+@numba.njit
+def cycle(s: str, i:int):
+    return (s*i)[:i]

nbmorph/zero_edges.py

@@ -0,0 +1,25 @@
+import numba
+from .diamond_kernel import diamond_loop_padded
+from .box_kernel import kernel3x3x3
+
+@numba.njit(cache=True)
+def zero_label_edges_box(a, out=None):
+    """
+    Set the edges of labels to zero.
+
+    Args:
+        a (np.ndarray): The input 3D labeled array.
+
+    Returns:
+        np.ndarray: The array with label edges set to zero.
+    """
+    return kernel3x3x3(a, opname="zeroedges", out=out)
+
+
+@numba.njit(cache=True)
+def zero_label_edges_diamond(data, out=None):
+    return diamond_loop_padded(data, out=out, opname="zeroedges")
+
+
+
+

nbmorph-0.1.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: nbmorph
+Version: 0.1.0
+Summary: A small package with Numba-accelerated morphological operations.
+Author-email: Marius Causemann <mariusca@simula.no>
+License: MIT License
+        
+        Copyright (c) [2025] [Marius Causemann]
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: numba
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: fastmorph; extra == "test"
+Dynamic: license-file
+
+# nbmorph
+
+A small, Numba-accelerated Python package for morphological operations on 3D labeled images.
+
+`nbmorph` provides a set of common morphological operations optimized for performance using Numba. It is designed to work with 3D NumPy arrays representing labeled image data, where different integer labels correspond to different objects.
+
+## Features
+
+* **Numba-accelerated:** Operations are just-in-time compiled with Numba for high performance on CPUs.
+
+* **3D Label Image Support:** All operations are designed for 3D labeled images (integer NumPy arrays).
+
+* **Quasi-Spherical Structuring Elements:** Approximates spherical structuring elements by alternating between box and diamond kernels for dilation and erosion.
+
+* **Core Morphological Operations:**
+
+  * `dilate_labels_spherical`: Expands the boundaries of labeled regions by assigning the mode of the neighborhood to background voxels.
+
+  * `erode_labels_spherical`: Shrinks the boundaries of labeled regions.
+
+  * `open_labels_spherical`: Removes small noise and thin protrusions (erosion followed by dilation).
+
+  * `close_labels_spherical`: Fills small holes within objects (dilation followed by erosion).
+
+  * `smooth_labels_spherical`: Smoothes object boundaries by performing an opening followed by a closing.
+
+![Effect of Morphological Smoothing](img/smoothing_effect.png)
+*Demonstration of the smoothing effect with varying radii and iterations on a sample image.*
+
+
+## Installation
+
+You can install `nbmorph` directly from the source directory using pip:
+
+```
+pip install .
+
+```
+
+
+## Usage
+
+Here is a basic example of how to use `nbmorph` to apply morphological smoothing to a 3D labeled image.
+
+```
+import numpy as np
+import nbmorph
+
+# Create a sample 3D labeled image
+# For example, a 5x5x5 cube of label 1 in a 10x10x10 volume
+labels = np.zeros((10, 10, 10), dtype=np.uint16)
+labels[2:7, 2:7, 2:7] = 1
+
+# Apply morphological smoothing with a radius of 1
+smoothed_labels = nbmorph.smooth_labels_spherical(labels, radius=1)
+
+print("Smoothing complete. The smoothed labels are in the 'smoothed_labels' array.")
+
+```
+
+## Operations
+
+The core functions of the library are:
+
+* `nbmorph.dilate_labels_spherical(labels, radius=1)`
+
+* `nbmorph.erode_labels_spherical(labels, radius=1)`
+
+* `nbmorph.open_labels_spherical(labels, radius=1, iterations=1)`
+
+* `nbmorph.close_labels_spherical(labels, radius=1, iterations=1)`
+
+* `nbmorph.smooth_labels_spherical(labels, radius=1, iterations=1)`
+
+## Testing
+
+Tests are written using `pytest`. To run the tests, first install the test dependencies and then run `pytest`:
+
+```
+pip install .[test]
+pytest
+```
+
+## Benchmarking
+
+A benchmark script is included in the `scripts` directory:
+
+```
+python scripts/benchmark.py
+```
+
+## License
+
+This project is licensed under the MIT License - see the `LICENSE` file for details.

nbmorph-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+nbmorph/__init__.py,sha256=4xhgDT4cPSR8fLzdWGT2hZLvt_kACtKLVCnv2laXJc0,465
+nbmorph/box_kernel.py,sha256=Sk9-2YJUBwCCP_ZnXvkS-_ILOUtSpOAqUMMbO1McLtE,18343
+nbmorph/diamond_kernel.py,sha256=Pt6sEnX4MrZw3nB7UAOrcgbwG4ALGsJVqPGkyrhvJm0,1637
+nbmorph/minmax.py,sha256=E_h7ZJRb-t2SFCYxZW3WwRdWkoQCAsOc65H1tfIlhWA,709
+nbmorph/mode.py,sha256=rakgIWVdbX18Gv-gxZuaOwsDu6RfPdiGNnK9bvYRNtc,15271
+nbmorph/morphology.py,sha256=krm3f4iBEcDy3XtumIvFpAlSOI8n2jo9Kgeij76Gp4E,4448
+nbmorph/ops.py,sha256=ZEKwkLoxD821ou-wBlirfCefFWf7nUAnv4ktmkZ2BnA,412
+nbmorph/utils.py,sha256=887MKCuXN1v1GjGeFBPCEqpvT6JWSaI_75mv9zeT0iY,91
+nbmorph/zero_edges.py,sha256=zGSmFJcMEN-dywgpOyGYb_PtogRbvw572WDAg15aoTA,548
+nbmorph-0.1.0.dist-info/licenses/LICENSE,sha256=sN9aXC3FxdLEbFQ-8mu0XUWeeFeKfPZ3NjuktXFj1EU,1076
+nbmorph-0.1.0.dist-info/METADATA,sha256=NvvqPZAdH-6dcaDqMRvte0-a4VymJ_PeEvzecBipQbI,4812
+nbmorph-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nbmorph-0.1.0.dist-info/top_level.txt,sha256=gOvPcD_UiplCjFLWlaADUo8tRVaBXTqVZE6tjYyWRs4,8
+nbmorph-0.1.0.dist-info/RECORD,,

nbmorph-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nbmorph-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2025] [Marius Causemann]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nbmorph-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nbmorph