imgproc: separable box-kernel morphology (dilate_box / erode_box)

Sliding min/max with a monotonic deque, horizontal + vertical passes:
O(n) per pass instead of O(n*k^2) for the generic-kernel path with an
all-ones square kernel. Border semantics identical to dilate/erode with a
ones kernel (out-of-bounds neighbours are skipped) — verified bit-exact
against the generic implementation for k in {1,3,5,7} on random images.

On 1280x720 with the 3x3-open + 5x5-close pair this is the difference
between ~95 ms and single-digit milliseconds in a depth-segmentation
pipeline.

Author: enthropy7

crates/yscv-imgproc/src/core.rs

@@ -124,6 +124,10 @@ pub use ops::detect_orb;
 pub use ops::detect_surf_keypoints;
 /// Morphological dilation with arbitrary structuring element.
 pub use ops::dilate;
+/// Dilation with an all-ones square kernel — separable, O(n) per pass.
+pub use ops::dilate_box;
+/// Erosion with an all-ones square kernel — separable, O(n) per pass.
+pub use ops::erode_box;
 /// Morphological dilation with 3x3 square structuring element.
 /// Input: `[H, W]` grayscale f32.
 pub use ops::dilate_3x3;

crates/yscv-imgproc/src/ops/mod.rs

@@ -107,7 +107,7 @@ pub use intensity::{adjust_gamma, adjust_log, rescale_intensity};
 pub use io::{imread, imread_gray, imwrite};
 pub use morphology::{
     closing_3x3, dilate, dilate_3x3, erode, erode_3x3, morph_blackhat, morph_gradient_3x3,
-    morph_tophat, opening_3x3, remove_small_objects, skeletonize,
+    morph_tophat, opening_3x3, remove_small_objects, skeletonize, dilate_box, erode_box,
 };
 pub use nms::{BBox, TemplateMatchMethod, TemplateMatchResult, nms, template_match};
 pub use normalize::normalize;

crates/yscv-imgproc/src/ops/morphology.rs

@@ -1207,3 +1207,102 @@ pub fn erode(input: &Tensor, kernel: &Tensor) -> Result<Tensor, ImgProcError> {
 
     Tensor::from_vec(vec![h, w, 1], out).map_err(Into::into)
 }
+
+// ── Box-kernel morphology: separable sliding min/max, O(n) per pass ──────
+
+/// 1D sliding-window extremum over a clamped window (monotonic deque).
+/// `cmp(new, back)` returns true when `back` must be evicted (e.g. `new >= back` for max).
+fn sliding_extremum_1d(
+    src: &[f32],
+    dst: &mut [f32],
+    radius: usize,
+    keep_new: fn(f32, f32) -> bool,
+) {
+    let n = src.len();
+    // deque of indices; values monotone (front = current extremum)
+    let mut deque: std::collections::VecDeque<usize> = std::collections::VecDeque::new();
+    for x in 0..n + radius {
+        if x < n {
+            while let Some(&back) = deque.back() {
+                if keep_new(src[x], src[back]) {
+                    deque.pop_back();
+                } else {
+                    break;
+                }
+            }
+            deque.push_back(x);
+        }
+        // окно для выхода out = x - radius: [out - radius, out + radius] ∩ [0, n)
+        if x >= radius {
+            let out = x - radius;
+            while let Some(&front) = deque.front() {
+                if front + radius < out {
+                    deque.pop_front();
+                } else {
+                    break;
+                }
+            }
+            if let Some(&front) = deque.front() {
+                dst[out] = src[front];
+            }
+        }
+    }
+}
+
+fn box_filter_2d(
+    input: &Tensor,
+    ksize: usize,
+    keep_new: fn(f32, f32) -> bool,
+) -> Result<Tensor, ImgProcError> {
+    let (h, w, c) = hwc_shape(input)?;
+    if c != 1 {
+        return Err(ImgProcError::InvalidChannelCount {
+            expected: 1,
+            got: c,
+        });
+    }
+    if ksize == 0 || ksize % 2 == 0 {
+        return Err(ImgProcError::InvalidBlockSize { block_size: ksize });
+    }
+    let radius = ksize / 2;
+    let data = input.data();
+    let mut tmp = vec![0.0f32; h * w];
+    // горизонтальный проход
+    for y in 0..h {
+        sliding_extremum_1d(
+            &data[y * w..(y + 1) * w],
+            &mut tmp[y * w..(y + 1) * w],
+            radius,
+            keep_new,
+        );
+    }
+    // вертикальный проход (колонка -> scratch -> 1D -> обратно)
+    let mut out = vec![0.0f32; h * w];
+    let mut col_src = vec![0.0f32; h];
+    let mut col_dst = vec![0.0f32; h];
+    for x in 0..w {
+        for y in 0..h {
+            col_src[y] = tmp[y * w + x];
+        }
+        sliding_extremum_1d(&col_src, &mut col_dst, radius, keep_new);
+        for y in 0..h {
+            out[y * w + x] = col_dst[y];
+        }
+    }
+    Tensor::from_vec(vec![h, w, 1], out).map_err(Into::into)
+}
+
+/// Dilation with an all-ones square kernel of odd size `ksize`.
+///
+/// Identical результату [`dilate`] с ones-ядром (границы клампятся), но
+/// сепарабельно и за O(n) на проход вместо O(n·k²) — на 720p и ядре 5×5
+/// это порядок с лишним разницы.
+pub fn dilate_box(input: &Tensor, ksize: usize) -> Result<Tensor, ImgProcError> {
+    box_filter_2d(input, ksize, |new, back| new >= back)
+}
+
+/// Erosion with an all-ones square kernel of odd size `ksize`.
+/// See [`dilate_box`] for semantics and complexity.
+pub fn erode_box(input: &Tensor, ksize: usize) -> Result<Tensor, ImgProcError> {
+    box_filter_2d(input, ksize, |new, back| new <= back)
+}

crates/yscv-imgproc/src/tests/morphology.rs

@@ -378,3 +378,34 @@ fn dilate_3x3_rgb_large() {
     // Pixel far away should be 0
     assert!((od[0]).abs() < 1e-6);
 }
+
+#[test]
+fn box_morphology_matches_generic_ones_kernel() {
+    use super::super::{dilate, dilate_box, erode, erode_box};
+    // псевдослучайное изображение 17x13 — сверяем с generic-ядром единиц
+    let (h, w) = (17usize, 13usize);
+    let mut state = 0x1234_5678_u64;
+    let mut data = Vec::with_capacity(h * w);
+    for _ in 0..h * w {
+        state = state.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+        data.push(((state >> 33) % 1000) as f32 / 100.0);
+    }
+    let img = Tensor::from_vec(vec![h, w, 1], data).unwrap();
+    for ksize in [1usize, 3, 5, 7] {
+        let kernel = Tensor::from_vec(vec![ksize, ksize, 1], vec![1.0f32; ksize * ksize]).unwrap();
+        let d_ref = dilate(&img, &kernel).unwrap();
+        let d_box = dilate_box(&img, ksize).unwrap();
+        assert_eq!(d_ref.data(), d_box.data(), "dilate ksize={ksize}");
+        let e_ref = erode(&img, &kernel).unwrap();
+        let e_box = erode_box(&img, ksize).unwrap();
+        assert_eq!(e_ref.data(), e_box.data(), "erode ksize={ksize}");
+    }
+}
+
+#[test]
+fn box_morphology_rejects_even_kernel() {
+    use super::super::dilate_box;
+    let img = Tensor::from_vec(vec![4, 4, 1], vec![0.0f32; 16]).unwrap();
+    assert!(dilate_box(&img, 4).is_err());
+    assert!(dilate_box(&img, 0).is_err());
+}