Grelee/skimage filters rank

.pre-commit-config.yaml

@@ -149,6 +149,11 @@ repos:
             ^python/cucim/src/cucim/skimage/filters/_window[.]py$|
             ^python/cucim/src/cucim/skimage/filters/cuda/histogram_median[.]cu$|
             ^python/cucim/src/cucim/skimage/filters/lpi_filter[.]py$|
+            ^python/cucim/src/cucim/skimage/filters/rank/__init__[.]py$|
+            ^python/cucim/src/cucim/skimage/filters/rank/_generic[.]py$|
+            ^python/cucim/src/cucim/skimage/filters/rank/_percentile[.]py$|
+            ^python/cucim/src/cucim/skimage/filters/rank/_rank_filter[.]py$|
+            ^python/cucim/src/cucim/skimage/filters/rank/tests/test_rank[.]py$|
             ^python/cucim/src/cucim/skimage/filters/ridges[.]py$|
             ^python/cucim/src/cucim/skimage/filters/tests/test_correlate[.]py$|
             ^python/cucim/src/cucim/skimage/filters/tests/test_edges[.]py$|
@@ -434,6 +439,11 @@ repos:
             python/cucim/src/cucim/skimage/filters/_window[.]py$|
             python/cucim/src/cucim/skimage/filters/lpi_filter[.]py$|
             python/cucim/src/cucim/skimage/filters/ridges[.]py$|
+            python/cucim/src/cucim/skimage/filters/rank/__init__[.]py$|
+            python/cucim/src/cucim/skimage/filters/rank/_generic[.]py$|
+            python/cucim/src/cucim/skimage/filters/rank/_percentile[.]py$|
+            python/cucim/src/cucim/skimage/filters/rank/_rank_filter[.]py$|
+            python/cucim/src/cucim/skimage/filters/rank/tests/test_rank[.]py$|
             python/cucim/src/cucim/skimage/filters/tests/test_correlate[.]py$|
             python/cucim/src/cucim/skimage/filters/tests/test_edges[.]py$|
             python/cucim/src/cucim/skimage/filters/tests/test_fft_based[.]py$|

benchmarks/skimage/_image_bench.py

@@ -40,11 +40,17 @@ def __init__(
         module_gpu=cupyx.scipy.ndimage,
         function_is_generator=False,
         run_cpu=True,
+        fixed_kwargs_cpu=None,
+        fixed_kwargs_gpu=None,
     ):
         self.shape = shape
         self.function_name = function_name
-        self.fixed_kwargs_cpu = self._update_kwargs_arrays(fixed_kwargs, "cpu")
-        self.fixed_kwargs_gpu = self._update_kwargs_arrays(fixed_kwargs, "gpu")
+        if fixed_kwargs_cpu is None:
+            fixed_kwargs_cpu = fixed_kwargs
+        if fixed_kwargs_gpu is None:
+            fixed_kwargs_gpu = fixed_kwargs
+        self.fixed_kwargs_cpu = self._update_kwargs_arrays(fixed_kwargs_cpu, "cpu")
+        self.fixed_kwargs_gpu = self._update_kwargs_arrays(fixed_kwargs_gpu, "gpu")
         self.var_kwargs = var_kwargs
         self.index_str = index_str
         # self.set_args_kwargs = set_args_kwargs

benchmarks/skimage/cucim_filters_rank_bench.py

@@ -0,0 +1,213 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import argparse
+import os
+
+import numpy as np
+import pandas as pd
+import skimage.filters.rank
+from _image_bench import ImageBench
+from skimage.morphology import disk
+
+import cucim.skimage.filters.rank
+
+RANK_FILTERS = [
+    # generic.py
+    ("autolevel", dict(), dict()),
+    ("enhance_contrast", dict(), dict()),
+    ("entropy", dict(), dict()),
+    ("equalize", dict(), dict()),
+    ("geometric_mean", dict(), dict()),
+    ("gradient", dict(), dict()),
+    ("majority", dict(), dict()),
+    ("maximum", dict(), dict()),
+    ("mean", dict(), dict()),
+    ("median", dict(), dict()),
+    ("minimum", dict(), dict()),
+    ("modal", dict(), dict()),
+    ("noise_filter", dict(), dict()),
+    ("pop", dict(), dict()),
+    ("subtract_mean", dict(), dict()),
+    ("sum", dict(), dict()),
+    ("threshold", dict(), dict()),
+    # percentile.py
+    ("autolevel_percentile", dict(p0=0.1, p1=0.9), dict()),
+    ("enhance_contrast_percentile", dict(p0=0.1, p1=0.9), dict()),
+    ("gradient_percentile", dict(p0=0.1, p1=0.9), dict()),
+    ("mean_percentile", dict(p0=0.1, p1=0.9), dict()),
+    ("percentile", dict(p0=0.5), dict()),
+    ("pop_percentile", dict(p0=0.1, p1=0.9), dict()),
+    ("subtract_mean_percentile", dict(p0=0.1, p1=0.9), dict()),
+    ("sum_percentile", dict(p0=0.1, p1=0.9), dict()),
+    ("threshold_percentile", dict(p0=0.5), dict()),
+    # bilateral.py
+    ("mean_bilateral", dict(s0=10, s1=10), dict()),
+    ("pop_bilateral", dict(s0=10, s1=10), dict()),
+    ("sum_bilateral", dict(s0=10, s1=10), dict()),
+]
+
+
+def _parse_shape(img_size):
+    return tuple(list(map(int, img_size.split(","))))
+
+
+def _parse_radii(radii):
+    return [int(r) for r in radii.split(",")]
+
+
+def _parse_footprint_sizes(footprint_sizes):
+    return [int(size) for size in footprint_sizes.split(",")]
+
+
+def _make_footprints(args):
+    if args.footprint_shape == "disk":
+        return [disk(radius).astype(bool) for radius in _parse_radii(args.radii)]
+
+    footprint_sizes = _parse_footprint_sizes(args.footprint_sizes)
+    if any(size <= 1 or size % 2 == 0 for size in footprint_sizes):
+        raise ValueError("rank filter benchmark footprint sizes must be odd and > 1")
+
+    return [np.ones((size, size), dtype=bool) for size in footprint_sizes]
+
+
+def main(args):
+    cfile = "cucim_filters_rank_results.csv"
+    if getattr(args, "no_resume", False) or not os.path.exists(cfile):
+        all_results = pd.DataFrame()
+    else:
+        all_results = pd.read_csv(cfile, index_col=0)
+    dtypes = [np.dtype(args.dtype)]
+
+    shape = _parse_shape(args.img_size)
+    if len(shape) != 2:
+        raise ValueError("rank filter benchmarks use 2D images")
+
+    footprints = _make_footprints(args)
+
+    for function_name, fixed_kwargs, var_kwargs in RANK_FILTERS:
+        if function_name != args.func_name:
+            continue
+
+        var_kwargs = dict(var_kwargs)
+        var_kwargs["footprint"] = footprints
+        fixed_kwargs_gpu = dict(fixed_kwargs)
+        fixed_kwargs_gpu["backend"] = args.backend
+
+        B = ImageBench(
+            function_name=function_name,
+            shape=shape,
+            dtypes=dtypes,
+            fixed_kwargs=fixed_kwargs,
+            fixed_kwargs_gpu=fixed_kwargs_gpu,
+            var_kwargs=var_kwargs,
+            module_cpu=skimage.filters.rank,
+            module_gpu=cucim.skimage.filters.rank,
+            run_cpu=not args.no_cpu,
+        )
+        results = B.run_benchmark(duration=args.duration)
+        all_results = pd.concat([all_results, results["full"]])
+
+    fbase = os.path.splitext(cfile)[0]
+    all_results.to_csv(cfile, index=True)
+    with open(fbase + ".md", "w") as f:
+        f.write(all_results.to_markdown())
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Benchmarking cuCIM rank filters")
+    func_name_choices = [filter_spec[0] for filter_spec in RANK_FILTERS]
+    dtype_choices = [
+        "float16",
+        "float32",
+        "float64",
+        "int8",
+        "int16",
+        "int32",
+        "int64",
+        "uint8",
+        "uint16",
+        "uint32",
+        "uint64",
+    ]
+    parser.add_argument(
+        "-i", "--img_size", type=str, help="Size of input image", required=True
+    )
+    parser.add_argument(
+        "-d",
+        "--dtype",
+        type=str,
+        help="Dtype of input image",
+        choices=dtype_choices,
+        required=True,
+    )
+    parser.add_argument(
+        "-f",
+        "--func_name",
+        type=str,
+        help="function to benchmark",
+        choices=func_name_choices,
+        required=True,
+    )
+    parser.add_argument(
+        "-t",
+        "--duration",
+        type=int,
+        help="time to run benchmark",
+        required=True,
+    )
+    parser.add_argument(
+        "--footprint_sizes",
+        type=str,
+        help=(
+            "Comma-separated odd square footprint side lengths to benchmark. "
+            "The all-ones rectangular footprints exercise the histogram fast "
+            "path for supported uint8 2D rank filters."
+        ),
+        default="3,7,15,31",
+    )
+    parser.add_argument(
+        "--radii",
+        type=str,
+        help=(
+            "Comma-separated disk footprint radii to benchmark when "
+            "--footprint_shape=disk."
+        ),
+        default="1,3,7,15",
+    )
+    parser.add_argument(
+        "--footprint_shape",
+        type=str,
+        choices=["rectangle", "disk"],
+        help=(
+            "Footprint family to benchmark. rectangle uses all-ones square "
+            "footprints and is the default."
+        ),
+        default="rectangle",
+    )
+    parser.add_argument(
+        "--backend",
+        type=str,
+        choices=["auto", "histogram", "elementwise"],
+        help=(
+            "cuCIM rank backend to benchmark. auto uses automatic dispatch, "
+            "histogram requires the uint8 2D rectangular histogram backend, "
+            "and elementwise forces the generic per-output-pixel backend."
+        ),
+        default="auto",
+    )
+    parser.add_argument(
+        "--no_cpu",
+        action="store_true",
+        help="disable cpu measurements",
+        default=False,
+    )
+    parser.add_argument(
+        "--no_resume",
+        action="store_true",
+        help="do not load existing results CSV; save only this run's results (overwrite)",
+        default=False,
+    )
+
+    args = parser.parse_args()
+    main(args)

benchmarks/skimage/run-nv-bench-filters-rank.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+# Use env var if set/non-empty, otherwise default to 3
+MAX_DURATION="${CUCIM_BENCHMARK_MAX_DURATION:-3}"
+
+# Use env var if set/non-empty, otherwise default to "3,7,15,31"
+FOOTPRINT_SIZES="${CUCIM_BENCHMARK_RANK_FOOTPRINT_SIZES:-3,7,15,31}"
+
+# Use env var if set/non-empty, otherwise default to automatic dispatch
+BACKEND="${CUCIM_BENCHMARK_RANK_BACKEND:-auto}"
+
+param_shape=("512,512" "1920,1080")
+param_filt=(autolevel enhance_contrast entropy equalize geometric_mean gradient majority maximum mean median minimum modal noise_filter pop subtract_mean sum threshold autolevel_percentile enhance_contrast_percentile gradient_percentile mean_percentile percentile pop_percentile subtract_mean_percentile sum_percentile threshold_percentile mean_bilateral pop_bilateral sum_bilateral)
+param_dt=(uint8)
+for shape in "${param_shape[@]}"; do
+    for filt in "${param_filt[@]}"; do
+        for dt in "${param_dt[@]}"; do
+            python cucim_filters_rank_bench.py -f "$filt" -i "$shape" -d "$dt" -t "$MAX_DURATION" --footprint_sizes "$FOOTPRINT_SIZES" --backend "$BACKEND"
+        done
+    done
+done

python/cucim/src/cucim/skimage/_vendored/_ndimage_filters_core.py

@@ -169,6 +169,7 @@ def _call_kernel(
     weights,
     output,
     structure=None,
+    mask=None,
     weights_dtype=numpy.float64,
     structure_dtype=numpy.float64,
 ):
@@ -200,6 +201,9 @@ def _call_kernel(
     if structure is not None:
         structure = cupy.ascontiguousarray(structure, structure_dtype)
         args.append(structure)
+    if mask is not None:
+        mask = cupy.ascontiguousarray(mask, bool)
+        args.append(mask)
     output = _util._get_output(output, input, None, complex_output)  # noqa
     needs_temp = cupy.shares_memory(output, input, "MAY_SHARE_BOUNDS")
     if needs_temp:

python/cucim/src/cucim/skimage/filters/__init__.pyi

@@ -1,5 +1,5 @@
 # SPDX-FileCopyrightText: 2009-2022 the scikit-image team
-# SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
 __all__ = [
@@ -24,6 +24,7 @@ __all__ = [
     "prewitt",
     "prewitt_h",
     "prewitt_v",
+    "rank",
     "rank_order",
     "roberts",
     "roberts_neg_diag",
@@ -52,6 +53,7 @@ __all__ = [
     "window",
 ]
 
+from . import rank
 from ._fft_based import butterworth
 from ._gabor import gabor, gabor_kernel
 from ._gaussian import difference_of_gaussians, gaussian