Add files using upload-large-folder tool

.gitattributes

@@ -1441,3 +1441,5 @@ vllm/lib/python3.10/site-packages/huggingface_hub/inference/__pycache__/_client.
 vglm/bin/python filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/huggingface_hub/__pycache__/hf_api.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/numpy/lib/__pycache__/_function_base_impl.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+vllm/lib/python3.10/site-packages/pyzmq.libs/libzmq-a430b4ce.so.5.2.5 filter=lfs diff=lfs merge=lfs -text
+vllm/lib/python3.10/site-packages/pyzmq.libs/libsodium-1b1f72d5.so.26.1.0 filter=lfs diff=lfs merge=lfs -text

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/lstm.h

@@ -0,0 +1,35 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/lstm_ops.h>
+
+namespace at {
+
+
+// aten::lstm.input(Tensor input, Tensor[] hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional, bool batch_first) -> (Tensor, Tensor, Tensor)
+inline ::std::tuple<at::Tensor,at::Tensor,at::Tensor> lstm(const at::Tensor & input, at::TensorList hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first) {
+    return at::_ops::lstm_input::call(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
+}
+
+// aten::lstm.data(Tensor data, Tensor batch_sizes, Tensor[] hx, Tensor[] params, bool has_biases, int num_layers, float dropout, bool train, bool bidirectional) -> (Tensor, Tensor, Tensor)
+inline ::std::tuple<at::Tensor,at::Tensor,at::Tensor> lstm(const at::Tensor & data, const at::Tensor & batch_sizes, at::TensorList hx, at::TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional) {
+    return at::_ops::lstm_data::call(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/reciprocal_meta.h

@@ -0,0 +1,27 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeMetaFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/TensorIterator.h>
+#include <ATen/TensorMeta.h>
+#include <tuple>
+#include <vector>
+
+namespace at {
+namespace meta {
+
+struct TORCH_API structured_reciprocal : public TensorIteratorBase {
+    
+    
+    void meta(const at::Tensor & self);
+};
+
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/view_as_real_copy_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API at::Tensor & view_as_real_copy_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & view_as_real_copy_outf(const at::Tensor & self, at::Tensor & out);
+
+} // namespace compositeexplicitautograd
+} // namespace at

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/__init__.py

@@ -0,0 +1,73 @@
+from cupyx.scipy.ndimage._filters import correlate  # NOQA
+from cupyx.scipy.ndimage._filters import convolve  # NOQA
+from cupyx.scipy.ndimage._filters import correlate1d  # NOQA
+from cupyx.scipy.ndimage._filters import convolve1d  # NOQA
+from cupyx.scipy.ndimage._filters import uniform_filter1d  # NOQA
+from cupyx.scipy.ndimage._filters import uniform_filter  # NOQA
+from cupyx.scipy.ndimage._filters import gaussian_filter1d  # NOQA
+from cupyx.scipy.ndimage._filters import gaussian_filter  # NOQA
+from cupyx.scipy.ndimage._filters import prewitt  # NOQA
+from cupyx.scipy.ndimage._filters import sobel  # NOQA
+from cupyx.scipy.ndimage._filters import generic_laplace  # NOQA
+from cupyx.scipy.ndimage._filters import laplace  # NOQA
+from cupyx.scipy.ndimage._filters import gaussian_laplace  # NOQA
+from cupyx.scipy.ndimage._filters import generic_gradient_magnitude  # NOQA
+from cupyx.scipy.ndimage._filters import gaussian_gradient_magnitude  # NOQA
+from cupyx.scipy.ndimage._filters import minimum_filter  # NOQA
+from cupyx.scipy.ndimage._filters import maximum_filter  # NOQA
+from cupyx.scipy.ndimage._filters import minimum_filter1d  # NOQA
+from cupyx.scipy.ndimage._filters import maximum_filter1d  # NOQA
+from cupyx.scipy.ndimage._filters import median_filter  # NOQA
+from cupyx.scipy.ndimage._filters import rank_filter  # NOQA
+from cupyx.scipy.ndimage._filters import percentile_filter  # NOQA
+from cupyx.scipy.ndimage._filters import generic_filter  # NOQA
+from cupyx.scipy.ndimage._filters import generic_filter1d  # NOQA
+
+from cupyx.scipy.ndimage._fourier import fourier_ellipsoid  # NOQA
+from cupyx.scipy.ndimage._fourier import fourier_gaussian  # NOQA
+from cupyx.scipy.ndimage._fourier import fourier_shift  # NOQA
+from cupyx.scipy.ndimage._fourier import fourier_uniform  # NOQA
+
+from cupyx.scipy.ndimage._interpolation import affine_transform  # NOQA
+from cupyx.scipy.ndimage._interpolation import map_coordinates  # NOQA
+from cupyx.scipy.ndimage._interpolation import rotate  # NOQA
+from cupyx.scipy.ndimage._interpolation import shift  # NOQA
+from cupyx.scipy.ndimage._interpolation import spline_filter  # NOQA
+from cupyx.scipy.ndimage._interpolation import spline_filter1d  # NOQA
+from cupyx.scipy.ndimage._interpolation import zoom  # NOQA
+
+from cupyx.scipy.ndimage._measurements import label  # NOQA
+from cupyx.scipy.ndimage._measurements import sum  # NOQA
+from cupyx.scipy.ndimage._measurements import sum_labels  # NOQA
+from cupyx.scipy.ndimage._measurements import mean  # NOQA
+from cupyx.scipy.ndimage._measurements import variance  # NOQA
+from cupyx.scipy.ndimage._measurements import standard_deviation  # NOQA
+from cupyx.scipy.ndimage._measurements import minimum  # NOQA
+from cupyx.scipy.ndimage._measurements import maximum  # NOQA
+from cupyx.scipy.ndimage._measurements import minimum_position  # NOQA
+from cupyx.scipy.ndimage._measurements import maximum_position  # NOQA
+from cupyx.scipy.ndimage._measurements import median  # NOQA
+from cupyx.scipy.ndimage._measurements import extrema  # NOQA
+from cupyx.scipy.ndimage._measurements import center_of_mass  # NOQA
+from cupyx.scipy.ndimage._measurements import histogram  # NOQA
+from cupyx.scipy.ndimage._measurements import labeled_comprehension  # NOQA
+from cupyx.scipy.ndimage._measurements import value_indices  # NOQA
+
+from cupyx.scipy.ndimage._morphology import generate_binary_structure  # NOQA
+from cupyx.scipy.ndimage._morphology import iterate_structure  # NOQA
+from cupyx.scipy.ndimage._morphology import binary_erosion  # NOQA
+from cupyx.scipy.ndimage._morphology import binary_dilation  # NOQA
+from cupyx.scipy.ndimage._morphology import binary_opening  # NOQA
+from cupyx.scipy.ndimage._morphology import binary_closing  # NOQA
+from cupyx.scipy.ndimage._morphology import binary_hit_or_miss  # NOQA
+from cupyx.scipy.ndimage._morphology import binary_fill_holes  # NOQA
+from cupyx.scipy.ndimage._morphology import binary_propagation  # NOQA
+from cupyx.scipy.ndimage._morphology import grey_erosion  # NOQA
+from cupyx.scipy.ndimage._morphology import grey_dilation  # NOQA
+from cupyx.scipy.ndimage._morphology import grey_closing  # NOQA
+from cupyx.scipy.ndimage._morphology import grey_opening  # NOQA
+from cupyx.scipy.ndimage._morphology import morphological_gradient  # NOQA
+from cupyx.scipy.ndimage._morphology import morphological_laplace  # NOQA
+from cupyx.scipy.ndimage._morphology import white_tophat  # NOQA
+from cupyx.scipy.ndimage._morphology import black_tophat  # NOQA
+from cupyx.scipy.ndimage._distance_transform import distance_transform_edt  # NOQA

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/_distance_transform.py

@@ -0,0 +1,181 @@
+import numbers
+
+from ._pba_2d import _pba_2d
+from ._pba_3d import _pba_3d
+
+
+def distance_transform_edt(image, sampling=None, return_distances=True,
+                           return_indices=False, distances=None, indices=None,
+                           *, block_params=None, float64_distances=True):
+    r"""Exact Euclidean distance transform.
+
+    This function calculates the distance transform of the `input`, by
+    replacing each foreground (non-zero) element, with its shortest distance to
+    the background (any zero-valued element).
+
+    In addition to the distance transform, the feature transform can be
+    calculated. In this case the index of the closest background element to
+    each foreground element is returned in a separate array.
+
+    Parameters
+    ----------
+    image : array_like
+        Input data to transform. Can be any type but will be converted into
+        binary: 1 wherever image equates to True, 0 elsewhere.
+    sampling : float, or sequence of float, optional
+        Spacing of elements along each dimension. If a sequence, must be of
+        length equal to the image rank; if a single number, this is used for
+        all axes. If not specified, a grid spacing of unity is implied.
+    return_distances : bool, optional
+        Whether to calculate the distance transform.
+    return_indices : bool, optional
+        Whether to calculate the feature transform.
+    distances : cupy.ndarray, optional
+        An output array to store the calculated distance transform, instead of
+        returning it. `return_distances` must be ``True``. It must be the same
+        shape as `image`. Should have dtype ``cp.float32`` if
+        `float64_distances` is ``False``, otherwise it should be
+        ``cp.float64``.
+    indices : cupy.ndarray, optional
+        An output array to store the calculated feature transform, instead of
+        returning it. `return_indicies` must be ``True``. Its shape must be
+        ``(image.ndim,) + image.shape``. Its dtype must be a signed or unsigned
+        integer type of at least 16-bits in 2D or 32-bits in 3D.
+
+    Other Parameters
+    ----------------
+    block_params : 3-tuple of int
+        The m1, m2, m3 algorithm parameters as described in [2]_. If None,
+        suitable defaults will be chosen. Note: This parameter is specific to
+        cuCIM and does not exist in SciPy.
+    float64_distances : bool, optional
+        If True, use double precision in the distance computation (to match
+        SciPy behavior). Otherwise, single precision will be used for
+        efficiency. Note: This parameter is specific to cuCIM and does not
+        exist in SciPy.
+
+    Returns
+    -------
+    distances : cupy.ndarray, optional
+        The calculated distance transform. Returned only when
+        `return_distances` is ``True`` and `distances` is not supplied. It will
+        have the same shape as `image`. Will have dtype `cp.float64` if
+        `float64_distances` is ``True``, otherwise it will have dtype
+        ``cp.float32``.
+    indices : ndarray, optional
+        The calculated feature transform. It has an image-shaped array for each
+        dimension of the image. See example below. Returned only when
+        `return_indices` is ``True`` and `indices` is not supplied.
+
+    Notes
+    -----
+    The Euclidean distance transform gives values of the Euclidean distance.
+
+    .. math::
+
+      y_i = \sqrt{\sum_{i}^{n} (x[i] - b[i])^2}
+
+    where :math:`b[i]` is the background point (value 0) with the smallest
+    Euclidean distance to input points :math:`x[i]`, and :math:`n` is the
+    number of dimensions.
+
+    Note that the `indices` output may differ from the one given by
+    :func:`scipy.ndimage.distance_transform_edt` in the case of input pixels
+    that are equidistant from multiple background points.
+
+    The parallel banding algorithm implemented here was originally described in
+    [1]_. The kernels used here correspond to the revised PBA+ implementation
+    that is described on the author's website [2]_. The source code of the
+    author's PBA+ implementation is available at [3]_.
+
+    References
+    ----------
+    .. [1] Thanh-Tung Cao, Ke Tang, Anis Mohamed, and Tiow-Seng Tan. 2010.
+        Parallel Banding Algorithm to compute exact distance transform with the
+        GPU. In Proceedings of the 2010 ACM SIGGRAPH symposium on Interactive
+        3D Graphics and Games (I3D ’10). Association for Computing Machinery,
+        New York, NY, USA, 83–90.
+        DOI:https://doi.org/10.1145/1730804.1730818
+    .. [2] https://www.comp.nus.edu.sg/~tants/pba.html
+    .. [3] https://github.com/orzzzjq/Parallel-Banding-Algorithm-plus
+
+    Examples
+    --------
+    >>> import cupy as cp
+    >>> from cucim.core.operations import morphology
+    >>> a = cp.array(([0,1,1,1,1],
+    ...               [0,0,1,1,1],
+    ...               [0,1,1,1,1],
+    ...               [0,1,1,1,0],
+    ...               [0,1,1,0,0]))
+    >>> morphology.distance_transform_edt(a)
+    array([[ 0.    ,  1.    ,  1.4142,  2.2361,  3.    ],
+           [ 0.    ,  0.    ,  1.    ,  2.    ,  2.    ],
+           [ 0.    ,  1.    ,  1.4142,  1.4142,  1.    ],
+           [ 0.    ,  1.    ,  1.4142,  1.    ,  0.    ],
+           [ 0.    ,  1.    ,  1.    ,  0.    ,  0.    ]])
+
+    With a sampling of 2 units along x, 1 along y:
+
+    >>> morphology.distance_transform_edt(a, sampling=[2,1])
+    array([[ 0.    ,  1.    ,  2.    ,  2.8284,  3.6056],
+           [ 0.    ,  0.    ,  1.    ,  2.    ,  3.    ],
+           [ 0.    ,  1.    ,  2.    ,  2.2361,  2.    ],
+           [ 0.    ,  1.    ,  2.    ,  1.    ,  0.    ],
+           [ 0.    ,  1.    ,  1.    ,  0.    ,  0.    ]])
+
+    Asking for indices as well:
+
+    >>> edt, inds = morphology.distance_transform_edt(a, return_indices=True)
+    >>> inds
+    array([[[0, 0, 1, 1, 3],
+            [1, 1, 1, 1, 3],
+            [2, 2, 1, 3, 3],
+            [3, 3, 4, 4, 3],
+            [4, 4, 4, 4, 4]],
+           [[0, 0, 1, 1, 4],
+            [0, 1, 1, 1, 4],
+            [0, 0, 1, 4, 4],
+            [0, 0, 3, 3, 4],
+            [0, 0, 3, 3, 4]]])
+
+    """
+    scalar_sampling = None
+    if sampling is not None:
+        if isinstance(sampling, numbers.Number):
+            sampling = (sampling,)
+        if len(set(sampling)) == 1:
+            # In the isotropic case, can use the kernels without sample scaling
+            # and just adjust the final distance accordingly.
+            scalar_sampling = float(sampling[0])
+            sampling = None
+
+    if image.ndim == 3:
+        pba_func = _pba_3d
+    elif image.ndim == 2:
+        pba_func = _pba_2d
+    else:
+        raise NotImplementedError(
+            "Only 2D and 3D distance transforms are supported.")
+
+    vals = pba_func(
+        image,
+        sampling=sampling,
+        return_distances=return_distances,
+        return_indices=return_indices,
+        block_params=block_params,
+        distances=distances,
+        indices=indices,
+        float64_distances=float64_distances,
+    )
+
+    if return_distances and scalar_sampling is not None:
+        # inplace multiply in case distance != None
+        vals = list(vals)
+        vals[0] *= scalar_sampling
+        vals = tuple(vals)
+
+    if len(vals) == 1:
+        vals = vals[0]
+
+    return vals

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/_filters.py

@@ -0,0 +1,1255 @@
+import numpy
+
+import cupy
+
+from cupy import _core
+from cupy._core import internal
+from cupyx.scipy.ndimage import _util
+from cupyx.scipy.ndimage import _filters_core
+from cupyx.scipy.ndimage import _filters_generic
+
+
+def correlate(input, weights, output=None, mode='reflect', cval=0.0, origin=0):
+    """Multi-dimensional correlate.
+
+    The array is correlated with the given kernel.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        weights (cupy.ndarray): Array of weights, same number of dimensions as
+            input
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``constant``. Default is ``0.0``.
+        origin (scalar or tuple of scalar): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The result of correlate.
+
+    .. seealso:: :func:`scipy.ndimage.correlate`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    return _correlate_or_convolve(input, weights, output, mode, cval, origin)
+
+
+def convolve(input, weights, output=None, mode='reflect', cval=0.0, origin=0):
+    """Multi-dimensional convolution.
+
+    The array is convolved with the given kernel.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        weights (cupy.ndarray): Array of weights, same number of dimensions as
+            input
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``constant``. Default is ``0.0``.
+        origin (scalar or tuple of scalar): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The result of convolution.
+
+    .. seealso:: :func:`scipy.ndimage.convolve`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    return _correlate_or_convolve(input, weights, output, mode, cval, origin,
+                                  True)
+
+
+def correlate1d(input, weights, axis=-1, output=None, mode="reflect", cval=0.0,
+                origin=0):
+    """One-dimensional correlate.
+
+    The array is correlated with the given kernel.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        weights (cupy.ndarray): One-dimensional array of weights
+        axis (int): The axis of input along which to calculate. Default is -1.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        origin (int): The origin parameter controls the placement of the
+            filter, relative to the center of the current element of the
+            input. Default is ``0``.
+
+    Returns:
+        cupy.ndarray: The result of the 1D correlation.
+
+    .. seealso:: :func:`scipy.ndimage.correlate1d`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    weights, origins = _filters_core._convert_1d_args(input.ndim, weights,
+                                                      origin, axis)
+    return _correlate_or_convolve(input, weights, output, mode, cval, origins)
+
+
+def convolve1d(input, weights, axis=-1, output=None, mode="reflect", cval=0.0,
+               origin=0):
+    """One-dimensional convolution.
+
+    The array is convolved with the given kernel.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        weights (cupy.ndarray): One-dimensional array of weights
+        axis (int): The axis of input along which to calculate. Default is -1.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        origin (int): The origin parameter controls the placement of the
+            filter, relative to the center of the current element of the
+            input. Default is ``0``.
+    Returns:
+        cupy.ndarray: The result of the 1D convolution.
+
+    .. seealso:: :func:`scipy.ndimage.convolve1d`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    weights, origins = _filters_core._convert_1d_args(input.ndim, weights,
+                                                      origin, axis)
+    return _correlate_or_convolve(input, weights, output, mode, cval, origins,
+                                  True)
+
+
+def _correlate_or_convolve(input, weights, output, mode, cval, origin,
+                           convolution=False):
+    origins, int_type = _filters_core._check_nd_args(input, weights,
+                                                     mode, origin)
+    if weights.size == 0:
+        return cupy.zeros_like(input)
+
+    _util._check_cval(mode, cval, _util._is_integer_output(output, input))
+
+    if convolution:
+        weights = weights[tuple([slice(None, None, -1)] * weights.ndim)]
+        origins = list(origins)
+        for i, wsize in enumerate(weights.shape):
+            origins[i] = -origins[i]
+            if wsize % 2 == 0:
+                origins[i] -= 1
+        origins = tuple(origins)
+    elif weights.dtype.kind == "c":
+        # numpy.correlate conjugates weights rather than input.
+        weights = weights.conj()
+    weights_dtype = _util._get_weights_dtype(input, weights)
+    offsets = _filters_core._origins_to_offsets(origins, weights.shape)
+    kernel = _get_correlate_kernel(mode, weights.shape, int_type,
+                                   offsets, cval)
+    output = _filters_core._call_kernel(kernel, input, weights, output,
+                                        weights_dtype=weights_dtype)
+    return output
+
+
+@cupy._util.memoize(for_each_device=True)
+def _get_correlate_kernel(mode, w_shape, int_type, offsets, cval):
+    return _filters_core._generate_nd_kernel(
+        'correlate',
+        'W sum = (W)0;',
+        'sum += cast<W>({value}) * wval;',
+        'y = cast<Y>(sum);',
+        mode, w_shape, int_type, offsets, cval, ctype='W')
+
+
+def _run_1d_correlates(input, params, get_weights, output, mode, cval,
+                       origin=0):
+    """
+    Enhanced version of _run_1d_filters that uses correlate1d as the filter
+    function. The params are a list of values to pass to the get_weights
+    callable given. If duplicate param values are found, the weights are
+    reused from the first invocation of get_weights. The get_weights callable
+    must return a 1D array of weights to give to correlate1d.
+    """
+    wghts = {}
+    for param in params:
+        if param not in wghts:
+            wghts[param] = get_weights(param)
+    wghts = [wghts[param] for param in params]
+    return _filters_core._run_1d_filters(
+        [None if w is None else correlate1d for w in wghts],
+        input, wghts, output, mode, cval, origin)
+
+
+def uniform_filter1d(input, size, axis=-1, output=None, mode="reflect",
+                     cval=0.0, origin=0):
+    """One-dimensional uniform filter along the given axis.
+
+    The lines of the array along the given axis are filtered with a uniform
+    filter of the given size.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (int): Length of the uniform filter.
+        axis (int): The axis of input along which to calculate. Default is -1.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        origin (int): The origin parameter controls the placement of the
+            filter, relative to the center of the current element of the
+            input. Default is ``0``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.uniform_filter1d`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    weights_dtype = _util._init_weights_dtype(input)
+    weights = cupy.full(size, 1 / size, dtype=weights_dtype)
+    return correlate1d(input, weights, axis, output, mode, cval, origin)
+
+
+def uniform_filter(input, size=3, output=None, mode="reflect", cval=0.0,
+                   origin=0):
+    """Multi-dimensional uniform filter.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (int or sequence of int): Lengths of the uniform filter for each
+            dimension. A single value applies to all axes.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        origin (int or sequence of int): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of ``0`` is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.uniform_filter`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    sizes = _util._fix_sequence_arg(size, input.ndim, 'size', int)
+    weights_dtype = _util._init_weights_dtype(input)
+
+    def get(size, dtype=weights_dtype):
+        return None if size <= 1 else cupy.full(size, 1 / size, dtype=dtype)
+
+    return _run_1d_correlates(input, sizes, get, output, mode, cval, origin)
+
+
+def gaussian_filter1d(input, sigma, axis=-1, order=0, output=None,
+                      mode="reflect", cval=0.0, truncate=4.0):
+    """One-dimensional Gaussian filter along the given axis.
+
+    The lines of the array along the given axis are filtered with a Gaussian
+    filter of the given standard deviation.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        sigma (scalar): Standard deviation for Gaussian kernel.
+        axis (int): The axis of input along which to calculate. Default is -1.
+        order (int): An order of ``0``, the default, corresponds to convolution
+            with a Gaussian kernel. A positive order corresponds to convolution
+            with that derivative of a Gaussian.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        truncate (float): Truncate the filter at this many standard deviations.
+            Default is ``4.0``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.gaussian_filter1d`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    radius = int(float(truncate) * float(sigma) + 0.5)
+    weights_dtype = _util._init_weights_dtype(input)
+    weights = _gaussian_kernel1d(
+        sigma, int(order), radius, dtype=weights_dtype
+    )
+    return correlate1d(input, weights, axis, output, mode, cval)
+
+
+def gaussian_filter(input, sigma, order=0, output=None, mode="reflect",
+                    cval=0.0, truncate=4.0):
+    """Multi-dimensional Gaussian filter.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        sigma (scalar or sequence of scalar): Standard deviations for each axis
+            of Gaussian kernel. A single value applies to all axes.
+        order (int or sequence of scalar): An order of ``0``, the default,
+            corresponds to convolution with a Gaussian kernel. A positive order
+            corresponds to convolution with that derivative of a Gaussian. A
+            single value applies to all axes.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        truncate (float): Truncate the filter at this many standard deviations.
+            Default is ``4.0``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.gaussian_filter`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    sigmas = _util._fix_sequence_arg(sigma, input.ndim, 'sigma', float)
+    orders = _util._fix_sequence_arg(order, input.ndim, 'order', int)
+    truncate = float(truncate)
+    weights_dtype = _util._init_weights_dtype(input)
+
+    def get(param):
+        sigma, order = param
+        radius = int(truncate * float(sigma) + 0.5)
+        if radius <= 0:
+            return None
+        return _gaussian_kernel1d(sigma, order, radius, dtype=weights_dtype)
+
+    return _run_1d_correlates(input, list(zip(sigmas, orders)), get, output,
+                              mode, cval, 0)
+
+
+def _gaussian_kernel1d(sigma, order, radius, dtype=cupy.float64):
+    """
+    Computes a 1-D Gaussian correlation kernel.
+    """
+    if order < 0:
+        raise ValueError('order must be non-negative')
+    sigma2 = sigma * sigma
+    x = numpy.arange(-radius, radius+1)
+    phi_x = numpy.exp(-0.5 / sigma2 * x ** 2)
+    phi_x /= phi_x.sum()
+
+    if order == 0:
+        return cupy.asarray(phi_x)
+
+    # f(x) = q(x) * phi(x) = q(x) * exp(p(x))
+    # f'(x) = (q'(x) + q(x) * p'(x)) * phi(x)
+    # p'(x) = -1 / sigma ** 2
+    # Implement q'(x) + q(x) * p'(x) as a matrix operator and apply to the
+    # coefficients of q(x)
+    exponent_range = numpy.arange(order + 1)
+    q = numpy.zeros(order + 1)
+    q[0] = 1
+    D = numpy.diag(exponent_range[1:], 1)  # D @ q(x) = q'(x)
+    P = numpy.diag(numpy.ones(order)/-sigma2, -1)  # P @ q(x) = q(x) * p'(x)
+    Q_deriv = D + P
+    for _ in range(order):
+        q = Q_deriv.dot(q)
+    q = (x[:, None] ** exponent_range).dot(q)
+    return cupy.asarray((q * phi_x)[::-1], dtype=dtype)
+
+
+def prewitt(input, axis=-1, output=None, mode="reflect", cval=0.0):
+    """Compute a Prewitt filter along the given axis.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        axis (int): The axis of input along which to calculate. Default is -1.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.prewitt`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    weights_dtype = _util._init_weights_dtype(input)
+    weights = cupy.ones(3, dtype=weights_dtype)
+    return _prewitt_or_sobel(input, axis, output, mode, cval, weights)
+
+
+def sobel(input, axis=-1, output=None, mode="reflect", cval=0.0):
+    """Compute a Sobel filter along the given axis.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        axis (int): The axis of input along which to calculate. Default is -1.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.sobel`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    weights_dtype = _util._init_weights_dtype(input)
+    return _prewitt_or_sobel(input, axis, output, mode, cval,
+                             cupy.array([1, 2, 1], dtype=weights_dtype))
+
+
+def _prewitt_or_sobel(input, axis, output, mode, cval, weights):
+    axis = internal._normalize_axis_index(axis, input.ndim)
+
+    def get(is_diff):
+        return cupy.array([-1, 0, 1], dtype=weights.dtype) if is_diff else weights  # noqa
+
+    return _run_1d_correlates(input, [a == axis for a in range(input.ndim)],
+                              get, output, mode, cval)
+
+
+def generic_laplace(input, derivative2, output=None, mode="reflect",
+                    cval=0.0, extra_arguments=(), extra_keywords=None):
+    """Multi-dimensional Laplace filter using a provided second derivative
+    function.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        derivative2 (callable): Function or other callable with the following
+            signature that is called once per axis::
+
+                derivative2(input, axis, output, mode, cval,
+                            *extra_arguments, **extra_keywords)
+
+            where ``input`` and ``output`` are ``cupy.ndarray``, ``axis`` is an
+            ``int`` from ``0`` to the number of dimensions, and ``mode``,
+            ``cval``, ``extra_arguments``, ``extra_keywords`` are the values
+            given to this function.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        extra_arguments (sequence, optional):
+            Sequence of extra positional arguments to pass to ``derivative2``.
+        extra_keywords (dict, optional):
+            dict of extra keyword arguments to pass ``derivative2``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.generic_laplace`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    if extra_keywords is None:
+        extra_keywords = {}
+    ndim = input.ndim
+    modes = _util._fix_sequence_arg(mode, ndim, 'mode',
+                                    _util._check_mode)
+    output = _util._get_output(output, input)
+    if ndim == 0:
+        _core.elementwise_copy(input, output)
+        return output
+    derivative2(input, 0, output, modes[0], cval,
+                *extra_arguments, **extra_keywords)
+    if ndim > 1:
+        tmp = _util._get_output(output.dtype, input)
+        for i in range(1, ndim):
+            derivative2(input, i, tmp, modes[i], cval,
+                        *extra_arguments, **extra_keywords)
+            output += tmp
+    return output
+
+
+def laplace(input, output=None, mode="reflect", cval=0.0):
+    """Multi-dimensional Laplace filter based on approximate second
+    derivatives.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.laplace`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    weights_dtype = _util._init_weights_dtype(input)
+    weights = cupy.array([1, -2, 1], dtype=weights_dtype)
+
+    def derivative2(input, axis, output, mode, cval):
+        return correlate1d(input, weights, axis, output, mode, cval)
+
+    return generic_laplace(input, derivative2, output, mode, cval)
+
+
+def gaussian_laplace(input, sigma, output=None, mode="reflect",
+                     cval=0.0, **kwargs):
+    """Multi-dimensional Laplace filter using Gaussian second derivatives.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        sigma (scalar or sequence of scalar): Standard deviations for each axis
+            of Gaussian kernel. A single value applies to all axes.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        kwargs (dict, optional):
+            dict of extra keyword arguments to pass ``gaussian_filter()``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.gaussian_laplace`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    def derivative2(input, axis, output, mode, cval):
+        order = [0] * input.ndim
+        order[axis] = 2
+        return gaussian_filter(input, sigma, order, output, mode, cval,
+                               **kwargs)
+    return generic_laplace(input, derivative2, output, mode, cval)
+
+
+def generic_gradient_magnitude(input, derivative, output=None,
+                               mode="reflect", cval=0.0,
+                               extra_arguments=(), extra_keywords=None):
+    """Multi-dimensional gradient magnitude filter using a provided derivative
+    function.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        derivative (callable): Function or other callable with the following
+            signature that is called once per axis::
+
+                derivative(input, axis, output, mode, cval,
+                           *extra_arguments, **extra_keywords)
+
+            where ``input`` and ``output`` are ``cupy.ndarray``, ``axis`` is an
+            ``int`` from ``0`` to the number of dimensions, and ``mode``,
+            ``cval``, ``extra_arguments``, ``extra_keywords`` are the values
+            given to this function.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        extra_arguments (sequence, optional):
+            Sequence of extra positional arguments to pass to ``derivative2``.
+        extra_keywords (dict, optional):
+            dict of extra keyword arguments to pass ``derivative2``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.generic_gradient_magnitude`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    if extra_keywords is None:
+        extra_keywords = {}
+    ndim = input.ndim
+    modes = _util._fix_sequence_arg(mode, ndim, 'mode',
+                                    _util._check_mode)
+    output = _util._get_output(output, input)
+    if ndim == 0:
+        _core.elementwise_copy(input, output)
+        return output
+    derivative(input, 0, output, modes[0], cval,
+               *extra_arguments, **extra_keywords)
+    output *= output
+    if ndim > 1:
+        tmp = _util._get_output(output.dtype, input)
+        for i in range(1, ndim):
+            derivative(input, i, tmp, modes[i], cval,
+                       *extra_arguments, **extra_keywords)
+            tmp *= tmp
+            output += tmp
+    return cupy.sqrt(output, output, casting='unsafe')
+
+
+def gaussian_gradient_magnitude(input, sigma, output=None, mode="reflect",
+                                cval=0.0, **kwargs):
+    """Multi-dimensional gradient magnitude using Gaussian derivatives.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        sigma (scalar or sequence of scalar): Standard deviations for each axis
+            of Gaussian kernel. A single value applies to all axes.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        kwargs (dict, optional):
+            dict of extra keyword arguments to pass ``gaussian_filter()``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.gaussian_gradient_magnitude`
+
+    .. note::
+        When the output data type is integral (or when no output is provided
+        and input is integral) the results may not perfectly match the results
+        from SciPy due to floating-point rounding of intermediate results.
+    """
+    def derivative(input, axis, output, mode, cval):
+        order = [0] * input.ndim
+        order[axis] = 1
+        return gaussian_filter(input, sigma, order, output, mode, cval,
+                               **kwargs)
+    return generic_gradient_magnitude(input, derivative, output, mode, cval)
+
+
+def minimum_filter(input, size=None, footprint=None, output=None,
+                   mode="reflect", cval=0.0, origin=0):
+    """Multi-dimensional minimum filter.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (int or sequence of int): One of ``size`` or ``footprint`` must be
+            provided. If ``footprint`` is given, ``size`` is ignored. Otherwise
+            ``footprint = cupy.ones(size)`` with ``size`` automatically made to
+            match the number of dimensions in ``input``.
+        footprint (cupy.ndarray): a boolean array which specifies which of the
+            elements within this shape will get passed to the filter function.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        origin (int or sequence of int): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.minimum_filter`
+    """
+    return _min_or_max_filter(input, size, footprint, None, output, mode,
+                              cval, origin, 'min')
+
+
+def maximum_filter(input, size=None, footprint=None, output=None,
+                   mode="reflect", cval=0.0, origin=0):
+    """Multi-dimensional maximum filter.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (int or sequence of int): One of ``size`` or ``footprint`` must be
+            provided. If ``footprint`` is given, ``size`` is ignored. Otherwise
+            ``footprint = cupy.ones(size)`` with ``size`` automatically made to
+            match the number of dimensions in ``input``.
+        footprint (cupy.ndarray): a boolean array which specifies which of the
+            elements within this shape will get passed to the filter function.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        origin (int or sequence of int): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.maximum_filter`
+    """
+    return _min_or_max_filter(input, size, footprint, None, output, mode,
+                              cval, origin, 'max')
+
+
+def _min_or_max_filter(input, size, ftprnt, structure, output, mode, cval,
+                       origin, func):
+    # structure is used by morphology.grey_erosion() and grey_dilation()
+    # and not by the regular min/max filters
+
+    sizes, ftprnt, structure = _filters_core._check_size_footprint_structure(
+        input.ndim, size, ftprnt, structure)
+    if cval is cupy.nan:
+        raise NotImplementedError("NaN cval is unsupported")
+
+    if sizes is not None:
+        # Separable filter, run as a series of 1D filters
+        fltr = minimum_filter1d if func == 'min' else maximum_filter1d
+        return _filters_core._run_1d_filters(
+            [fltr if size > 1 else None for size in sizes],
+            input, sizes, output, mode, cval, origin)
+
+    origins, int_type = _filters_core._check_nd_args(input, ftprnt,
+                                                     mode, origin, 'footprint')
+    if structure is not None and structure.ndim != input.ndim:
+        raise RuntimeError('structure array has incorrect shape')
+
+    if ftprnt.size == 0:
+        return cupy.zeros_like(input)
+    offsets = _filters_core._origins_to_offsets(origins, ftprnt.shape)
+    kernel = _get_min_or_max_kernel(mode, ftprnt.shape, func,
+                                    offsets, float(cval), int_type,
+                                    has_structure=structure is not None,
+                                    has_central_value=bool(ftprnt[offsets]))
+    return _filters_core._call_kernel(kernel, input, ftprnt, output,
+                                      structure, weights_dtype=bool)
+
+
+def minimum_filter1d(input, size, axis=-1, output=None, mode="reflect",
+                     cval=0.0, origin=0):
+    """Compute the minimum filter along a single axis.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (int): Length of the minimum filter.
+        axis (int): The axis of input along which to calculate. Default is -1.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        origin (int): The origin parameter controls the placement of the
+            filter, relative to the center of the current element of the
+            input. Default is ``0``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.minimum_filter1d`
+    """
+    return _min_or_max_1d(input, size, axis, output, mode, cval, origin, 'min')
+
+
+def maximum_filter1d(input, size, axis=-1, output=None, mode="reflect",
+                     cval=0.0, origin=0):
+    """Compute the maximum filter along a single axis.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (int): Length of the maximum filter.
+        axis (int): The axis of input along which to calculate. Default is -1.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        origin (int): The origin parameter controls the placement of the
+            filter, relative to the center of the current element of the
+            input. Default is ``0``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.maximum_filter1d`
+    """
+    return _min_or_max_1d(input, size, axis, output, mode, cval, origin, 'max')
+
+
+def _min_or_max_1d(input, size, axis=-1, output=None, mode="reflect", cval=0.0,
+                   origin=0, func='min'):
+    ftprnt = cupy.ones(size, dtype=bool)
+    ftprnt, origin = _filters_core._convert_1d_args(input.ndim, ftprnt,
+                                                    origin, axis)
+    origins, int_type = _filters_core._check_nd_args(input, ftprnt,
+                                                     mode, origin, 'footprint')
+    offsets = _filters_core._origins_to_offsets(origins, ftprnt.shape)
+    kernel = _get_min_or_max_kernel(mode, ftprnt.shape, func, offsets,
+                                    float(cval), int_type, has_weights=False)
+    return _filters_core._call_kernel(kernel, input, None, output,
+                                      weights_dtype=bool)
+
+
+@cupy._util.memoize(for_each_device=True)
+def _get_min_or_max_kernel(mode, w_shape, func, offsets, cval, int_type,
+                           has_weights=True, has_structure=False,
+                           has_central_value=True):
+    # When there are no 'weights' (the footprint, for the 1D variants) then
+    # we need to make sure intermediate results are stored as doubles for
+    # consistent results with scipy.
+    ctype = 'X' if has_weights else 'double'
+    value = '{value}'
+    if not has_weights:
+        value = 'cast<double>({})'.format(value)
+
+    # Having a non-flat structure biases the values
+    if has_structure:
+        value += ('-' if func == 'min' else '+') + 'cast<X>(sval)'
+
+    if has_central_value:
+        pre = '{} value = x[i];'
+        found = 'value = {func}({value}, value);'
+    else:
+        # If the central pixel is not included in the footprint we cannot
+        # assume `x[i]` is not below the min or above the max and thus cannot
+        # seed with that value. Instead we keep track of having set `value`.
+        pre = '{} value; bool set = false;'
+        found = 'value = set ? {func}({value}, value) : {value}; set=true;'
+
+    return _filters_core._generate_nd_kernel(
+        func, pre.format(ctype),
+        found.format(func=func, value=value), 'y = cast<Y>(value);',
+        mode, w_shape, int_type, offsets, cval, ctype=ctype,
+        has_weights=has_weights, has_structure=has_structure)
+
+
+def rank_filter(input, rank, size=None, footprint=None, output=None,
+                mode="reflect", cval=0.0, origin=0):
+    """Multi-dimensional rank filter.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        rank (int): The rank of the element to get. Can be negative to count
+            from the largest value, e.g. ``-1`` indicates the largest value.
+        size (int or sequence of int): One of ``size`` or ``footprint`` must be
+            provided. If ``footprint`` is given, ``size`` is ignored. Otherwise
+            ``footprint = cupy.ones(size)`` with ``size`` automatically made to
+            match the number of dimensions in ``input``.
+        footprint (cupy.ndarray): a boolean array which specifies which of the
+            elements within this shape will get passed to the filter function.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        origin (int or sequence of int): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.rank_filter`
+    """
+    rank = int(rank)
+    return _rank_filter(input, lambda fs: rank+fs if rank < 0 else rank,
+                        size, footprint, output, mode, cval, origin)
+
+
+def median_filter(input, size=None, footprint=None, output=None,
+                  mode="reflect", cval=0.0, origin=0):
+    """Multi-dimensional median filter.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (int or sequence of int): One of ``size`` or ``footprint`` must be
+            provided. If ``footprint`` is given, ``size`` is ignored. Otherwise
+            ``footprint = cupy.ones(size)`` with ``size`` automatically made to
+            match the number of dimensions in ``input``.
+        footprint (cupy.ndarray): a boolean array which specifies which of the
+            elements within this shape will get passed to the filter function.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        origin (int or sequence of int): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.median_filter`
+    """
+    return _rank_filter(input, lambda fs: fs//2,
+                        size, footprint, output, mode, cval, origin)
+
+
+def percentile_filter(input, percentile, size=None, footprint=None,
+                      output=None, mode="reflect", cval=0.0, origin=0):
+    """Multi-dimensional percentile filter.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        percentile (scalar): The percentile of the element to get (from ``0``
+            to ``100``). Can be negative, thus ``-20`` equals ``80``.
+        size (int or sequence of int): One of ``size`` or ``footprint`` must be
+            provided. If ``footprint`` is given, ``size`` is ignored. Otherwise
+            ``footprint = cupy.ones(size)`` with ``size`` automatically made to
+            match the number of dimensions in ``input``.
+        footprint (cupy.ndarray): a boolean array which specifies which of the
+            elements within this shape will get passed to the filter function.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        origin (int or sequence of int): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. seealso:: :func:`scipy.ndimage.percentile_filter`
+    """
+    percentile = float(percentile)
+    if percentile < 0.0:
+        percentile += 100.0
+    if percentile < 0.0 or percentile > 100.0:
+        raise RuntimeError('invalid percentile')
+    if percentile == 100.0:
+        def get_rank(fs):
+            return fs - 1
+    else:
+        def get_rank(fs):
+            return int(float(fs) * percentile / 100.0)
+    return _rank_filter(input, get_rank,
+                        size, footprint, output, mode, cval, origin)
+
+
+def _rank_filter(input, get_rank, size=None, footprint=None, output=None,
+                 mode="reflect", cval=0.0, origin=0):
+    _, footprint, _ = _filters_core._check_size_footprint_structure(
+        input.ndim, size, footprint, None, force_footprint=True)
+    if cval is cupy.nan:
+        raise NotImplementedError("NaN cval is unsupported")
+    origins, int_type = _filters_core._check_nd_args(input, footprint,
+                                                     mode, origin, 'footprint')
+    if footprint.size == 0:
+        return cupy.zeros_like(input)
+    filter_size = int(footprint.sum())
+    rank = get_rank(filter_size)
+    if rank < 0 or rank >= filter_size:
+        raise RuntimeError('rank not within filter footprint size')
+    if rank == 0:
+        return _min_or_max_filter(input, None, footprint, None, output, mode,
+                                  cval, origins, 'min')
+    if rank == filter_size - 1:
+        return _min_or_max_filter(input, None, footprint, None, output, mode,
+                                  cval, origins, 'max')
+    offsets = _filters_core._origins_to_offsets(origins, footprint.shape)
+    kernel = _get_rank_kernel(filter_size, rank, mode, footprint.shape,
+                              offsets, float(cval), int_type)
+    return _filters_core._call_kernel(kernel, input, footprint, output,
+                                      weights_dtype=bool)
+
+
+__SHELL_SORT = '''
+__device__ void sort(X *array, int size) {{
+    int gap = {gap};
+    while (gap > 1) {{
+        gap /= 3;
+        for (int i = gap; i < size; ++i) {{
+            X value = array[i];
+            int j = i - gap;
+            while (j >= 0 && value < array[j]) {{
+                array[j + gap] = array[j];
+                j -= gap;
+            }}
+            array[j + gap] = value;
+        }}
+    }}
+}}'''
+
+
+@cupy._util.memoize()
+def _get_shell_gap(filter_size):
+    gap = 1
+    while gap < filter_size:
+        gap = 3*gap+1
+    return gap
+
+
+@cupy._util.memoize(for_each_device=True)
+def _get_rank_kernel(filter_size, rank, mode, w_shape, offsets, cval,
+                     int_type):
+    s_rank = min(rank, filter_size - rank - 1)
+    # The threshold was set based on the measurements on a V100
+    # TODO(leofang, anaruse): Use Optuna to automatically tune the threshold,
+    # as it may vary depending on the GPU in use, compiler version, dtype,
+    # filter size, etc.
+    if s_rank <= 80:
+        # When s_rank is small and register usage is low, this partial
+        # selection sort approach is faster than general sorting approach
+        # using shell sort.
+        if s_rank == rank:
+            comp_op = '<'
+        else:
+            comp_op = '>'
+        array_size = s_rank + 2
+        found_post = '''
+            if (iv > {rank} + 1) {{{{
+                int target_iv = 0;
+                X target_val = values[0];
+                for (int jv = 1; jv <= {rank} + 1; jv++) {{{{
+                    if (target_val {comp_op} values[jv]) {{{{
+                        target_val = values[jv];
+                        target_iv = jv;
+                    }}}}
+                }}}}
+                if (target_iv <= {rank}) {{{{
+                    values[target_iv] = values[{rank} + 1];
+                }}}}
+                iv = {rank} + 1;
+            }}}}'''.format(rank=s_rank, comp_op=comp_op)
+        post = '''
+            X target_val = values[0];
+            for (int jv = 1; jv <= {rank}; jv++) {{
+                if (target_val {comp_op} values[jv]) {{
+                    target_val = values[jv];
+                }}
+            }}
+            y=cast<Y>(target_val);'''.format(rank=s_rank, comp_op=comp_op)
+        sorter = ''
+    else:
+        array_size = filter_size
+        found_post = ''
+        post = 'sort(values,{});\ny=cast<Y>(values[{}]);'.format(
+            filter_size, rank)
+        sorter = __SHELL_SORT.format(gap=_get_shell_gap(filter_size))
+
+    return _filters_core._generate_nd_kernel(
+        'rank_{}_{}'.format(filter_size, rank),
+        'int iv = 0;\nX values[{}];'.format(array_size),
+        'values[iv++] = {value};' + found_post, post,
+        mode, w_shape, int_type, offsets, cval, preamble=sorter)
+
+
+def generic_filter(input, function, size=None, footprint=None,
+                   output=None, mode="reflect", cval=0.0, origin=0):
+    """Compute a multi-dimensional filter using the provided raw kernel or
+    reduction kernel.
+
+    Unlike the scipy.ndimage function, this does not support the
+    ``extra_arguments`` or ``extra_keywordsdict`` arguments and has significant
+    restrictions on the ``function`` provided.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        function (cupy.ReductionKernel or cupy.RawKernel):
+            The kernel or function to apply to each region.
+        size (int or sequence of int): One of ``size`` or ``footprint`` must be
+            provided. If ``footprint`` is given, ``size`` is ignored. Otherwise
+            ``footprint = cupy.ones(size)`` with ``size`` automatically made to
+            match the number of dimensions in ``input``.
+        footprint (cupy.ndarray): a boolean array which specifies which of the
+            elements within this shape will get passed to the filter function.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        origin (scalar or tuple of scalar): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. note::
+        If the `function` is a :class:`cupy.RawKernel` then it must be for a
+        function that has the following signature. Unlike most functions, this
+        should not utilize `blockDim`/`blockIdx`/`threadIdx`::
+
+            __global__ void func(double *buffer, int filter_size,
+                                 double *return_value)
+
+        If the `function` is a :class:`cupy.ReductionKernel` then it must be
+        for a kernel that takes 1 array input and produces 1 'scalar' output.
+
+    .. seealso:: :func:`scipy.ndimage.generic_filter`
+    """
+    _, footprint, _ = _filters_core._check_size_footprint_structure(
+        input.ndim, size, footprint, None, 2, True)
+    filter_size = int(footprint.sum())
+    origins, int_type = _filters_core._check_nd_args(input, footprint,
+                                                     mode, origin, 'footprint')
+    in_dtype = input.dtype
+    sub = _filters_generic._get_sub_kernel(function)
+    if footprint.size == 0:
+        return cupy.zeros_like(input)
+    output = _util._get_output(output, input)
+    offsets = _filters_core._origins_to_offsets(origins, footprint.shape)
+    args = (filter_size, mode, footprint.shape, offsets, float(cval), int_type)
+    if isinstance(sub, cupy.RawKernel):
+        kernel = _filters_generic._get_generic_filter_raw(sub, *args)
+    elif isinstance(sub, cupy.ReductionKernel):
+        kernel = _filters_generic._get_generic_filter_red(
+            sub, in_dtype, output.dtype, *args)
+    return _filters_core._call_kernel(kernel, input, footprint, output,
+                                      weights_dtype=bool)
+
+
+def generic_filter1d(input, function, filter_size, axis=-1, output=None,
+                     mode="reflect", cval=0.0, origin=0):
+    """Compute a 1D filter along the given axis using the provided raw kernel.
+
+    Unlike the scipy.ndimage function, this does not support the
+    ``extra_arguments`` or ``extra_keywordsdict`` arguments and has significant
+    restrictions on the ``function`` provided.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        function (cupy.RawKernel): The kernel to apply along each axis.
+        filter_size (int): Length of the filter.
+        axis (int): The axis of input along which to calculate. Default is -1.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output. Default is is same dtype as the input.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``'constant'``. Default is ``0.0``.
+        origin (int): The origin parameter controls the placement of the
+            filter, relative to the center of the current element of the
+            input. Default is ``0``.
+
+    Returns:
+        cupy.ndarray: The result of the filtering.
+
+    .. note::
+        The provided function (as a RawKernel) must have the following
+        signature. Unlike most functions, this should not utilize
+        `blockDim`/`blockIdx`/`threadIdx`::
+
+            __global__ void func(double *input_line, ptrdiff_t input_length,
+                                 double *output_line, ptrdiff_t output_length)
+
+    .. seealso:: :func:`scipy.ndimage.generic_filter1d`
+    """
+    # This filter is very different than all other filters (including
+    # generic_filter and all 1d filters) and it has a customized solution.
+    # It is also likely fairly terrible, but only so much can be done when
+    # matching the scipy interface of having the sub-kernel work on entire
+    # lines of data.
+    if input.dtype.kind == 'c':
+        raise TypeError('Complex type not supported')
+    if not isinstance(function, cupy.RawKernel):
+        raise TypeError('bad function type')
+    if filter_size < 1:
+        raise RuntimeError('invalid filter size')
+    axis = internal._normalize_axis_index(axis, input.ndim)
+    origin = _util._check_origin(origin, filter_size)
+    _util._check_mode(mode)
+    output = _util._get_output(output, input)
+    in_ctype = cupy._core._scalar.get_typename(input.dtype)
+    out_ctype = cupy._core._scalar.get_typename(output.dtype)
+    int_type = _util._get_inttype(input)
+    n_lines = input.size // input.shape[axis]
+    kernel = _filters_generic._get_generic_filter1d(
+        function, input.shape[axis], n_lines, filter_size,
+        origin, mode, float(cval), in_ctype, out_ctype, int_type)
+    data = cupy.array(
+        (axis, input.ndim) + input.shape + input.strides + output.strides,
+        dtype=cupy.int32 if int_type == 'int' else cupy.int64)
+    kernel(((n_lines+128-1) // 128,), (128,), (input, output, data))
+    return output

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/_filters_core.py

@@ -0,0 +1,308 @@
+import warnings
+
+import numpy
+import cupy
+
+from cupy_backends.cuda.api import runtime
+from cupy import _core
+from cupy._core import internal
+from cupyx.scipy.ndimage import _util
+
+
+def _origins_to_offsets(origins, w_shape):
+    return tuple(x//2+o for x, o in zip(w_shape, origins))
+
+
+def _check_size_footprint_structure(ndim, size, footprint, structure,
+                                    stacklevel=3, force_footprint=False):
+    if structure is None and footprint is None:
+        if size is None:
+            raise RuntimeError("no footprint or filter size provided")
+        sizes = _util._fix_sequence_arg(size, ndim, 'size', int)
+        if force_footprint:
+            return None, cupy.ones(sizes, bool), None
+        return sizes, None, None
+    if size is not None:
+        warnings.warn("ignoring size because {} is set".format(
+            'structure' if footprint is None else 'footprint'),
+            UserWarning, stacklevel=stacklevel+1)
+
+    if footprint is not None:
+        footprint = cupy.array(footprint, bool, True, 'C')
+        if not footprint.any():
+            raise ValueError("all-zero footprint is not supported")
+
+    if structure is None:
+        if not force_footprint and footprint.all():
+            if footprint.ndim != ndim:
+                raise RuntimeError("size must have length equal to input rank")
+            return footprint.shape, None, None
+        return None, footprint, None
+
+    structure = cupy.ascontiguousarray(structure)
+    if footprint is None:
+        footprint = cupy.ones(structure.shape, bool)
+    return None, footprint, structure
+
+
+def _convert_1d_args(ndim, weights, origin, axis):
+    if weights.ndim != 1 or weights.size < 1:
+        raise RuntimeError('incorrect filter size')
+    axis = internal._normalize_axis_index(axis, ndim)
+    w_shape = [1]*ndim
+    w_shape[axis] = weights.size
+    weights = weights.reshape(w_shape)
+    origins = [0]*ndim
+    origins[axis] = _util._check_origin(origin, weights.size)
+    return weights, tuple(origins)
+
+
+def _check_nd_args(input, weights, mode, origin, wghts_name='filter weights'):
+    _util._check_mode(mode)
+    # Weights must always be less than 2 GiB
+    if weights.nbytes >= (1 << 31):
+        raise RuntimeError('weights must be 2 GiB or less, use FFTs instead')
+    weight_dims = [x for x in weights.shape if x != 0]
+    if len(weight_dims) != input.ndim:
+        raise RuntimeError('{} array has incorrect shape'.format(wghts_name))
+    origins = _util._fix_sequence_arg(origin, len(weight_dims), 'origin', int)
+    for origin, width in zip(origins, weight_dims):
+        _util._check_origin(origin, width)
+    return tuple(origins), _util._get_inttype(input)
+
+
+def _run_1d_filters(filters, input, args, output, mode, cval, origin=0):
+    """
+    Runs a series of 1D filters forming an nd filter. The filters must be a
+    list of callables that take input, arg, axis, output, mode, cval, origin.
+    The args is a list of values that are passed for the arg value to the
+    filter. Individual filters can be None causing that axis to be skipped.
+    """
+    output = _util._get_output(output, input)
+    modes = _util._fix_sequence_arg(mode, input.ndim, 'mode',
+                                    _util._check_mode)
+    # for filters, "wrap" is a synonym for "grid-wrap".
+    modes = ['grid-wrap' if m == 'wrap' else m for m in modes]
+    origins = _util._fix_sequence_arg(origin, input.ndim, 'origin', int)
+    n_filters = sum(filter is not None for filter in filters)
+    if n_filters == 0:
+        _core.elementwise_copy(input, output)
+        return output
+    # We can't operate in-place efficiently, so use a 2-buffer system
+    temp = _util._get_output(output.dtype, input) if n_filters > 1 else None
+    iterator = zip(filters, args, modes, origins)
+    # skip any axes where the filter is None
+    for axis, (fltr, arg, mode, origin) in enumerate(iterator):
+        if fltr is not None:
+            break
+    # To avoid need for any additional copies, we have to start with a
+    # different output array depending on whether the total number of filters
+    # is odd or even.
+    if n_filters % 2 == 0:
+        fltr(input, arg, axis, temp, mode, cval, origin)
+        input = temp
+    else:
+        fltr(input, arg, axis, output, mode, cval, origin)
+        input, output = output, temp
+    for axis, (fltr, arg, mode, origin) in enumerate(iterator, start=axis + 1):
+        if fltr is None:
+            continue
+        fltr(input, arg, axis, output, mode, cval, origin)
+        input, output = output, input
+    return input
+
+
+def _call_kernel(kernel, input, weights, output, structure=None,
+                 weights_dtype=numpy.float64, structure_dtype=numpy.float64):
+    """
+    Calls a constructed ElementwiseKernel. The kernel must take an input image,
+    an optional array of weights, an optional array for the structure, and an
+    output array.
+
+    weights and structure can be given as None (structure defaults to None) in
+    which case they are not passed to the kernel at all. If the output is given
+    as None then it will be allocated in this function.
+
+    This function deals with making sure that the weights and structure are
+    contiguous and float64 (or bool for weights that are footprints)*, that the
+    output is allocated and appriopately shaped. This also deals with the
+    situation that the input and output arrays overlap in memory.
+
+    * weights is always cast to float64 or bool in order to get an output
+    compatible with SciPy, though float32 might be sufficient when input dtype
+    is low precision. If weights_dtype is passed as weights.dtype then no
+    dtype conversion will occur. The input and output are never converted.
+    """
+    args = [input]
+    complex_output = input.dtype.kind == 'c'
+    if weights is not None:
+        weights = cupy.ascontiguousarray(weights, weights_dtype)
+        complex_output = complex_output or weights.dtype.kind == 'c'
+        args.append(weights)
+    if structure is not None:
+        structure = cupy.ascontiguousarray(structure, structure_dtype)
+        args.append(structure)
+    output = _util._get_output(output, input, None, complex_output)
+    needs_temp = cupy.shares_memory(output, input, 'MAY_SHARE_BOUNDS')
+    if needs_temp:
+        output, temp = _util._get_output(output.dtype, input), output
+    args.append(output)
+    kernel(*args)
+    if needs_temp:
+        _core.elementwise_copy(temp, output)
+        output = temp
+    return output
+
+
+if runtime.is_hip:
+    includes = r'''
+// workaround for HIP: line begins with #include
+#include <cupy/math_constants.h>\n
+'''
+else:
+    includes = r'''
+#include <cupy/cuda_workaround.h>  // provide C++ std:: coverage
+#include <cupy/math_constants.h>
+
+template<> struct std::is_floating_point<float16> : std::true_type {};
+template<> struct std::is_signed<float16> : std::true_type {};
+'''
+
+
+_CAST_FUNCTION = """
+// Implements a casting function to make it compatible with scipy
+// Use like cast<to_type>(value)
+template <class B, class A>
+__device__ __forceinline__
+typename std::enable_if<(!std::is_floating_point<A>::value
+                         || std::is_signed<B>::value), B>::type
+cast(A a) { return (B)a; }
+
+template <class B, class A>
+__device__ __forceinline__
+typename std::enable_if<(std::is_floating_point<A>::value
+                         && (!std::is_signed<B>::value)), B>::type
+cast(A a) { return (a >= 0) ? (B)a : -(B)(-a); }
+
+template <class T>
+__device__ __forceinline__ bool nonzero(T x) { return x != static_cast<T>(0); }
+"""
+
+
+def _generate_nd_kernel(name, pre, found, post, mode, w_shape, int_type,
+                        offsets, cval, ctype='X', preamble='', options=(),
+                        has_weights=True, has_structure=False, has_mask=False,
+                        binary_morphology=False, all_weights_nonzero=False):
+    # Currently this code uses CArray for weights but avoids using CArray for
+    # the input data and instead does the indexing itself since it is faster.
+    # If CArray becomes faster than follow the comments that start with
+    # CArray: to switch over to using CArray for the input data as well.
+
+    ndim = len(w_shape)
+    in_params = 'raw X x'
+    if has_weights:
+        in_params += ', raw W w'
+    if has_structure:
+        in_params += ', raw S s'
+    if has_mask:
+        in_params += ', raw M mask'
+    out_params = 'Y y'
+
+    # for filters, "wrap" is a synonym for "grid-wrap"
+    mode = 'grid-wrap' if mode == 'wrap' else mode
+
+    # CArray: remove xstride_{j}=... from string
+    size = ('%s xsize_{j}=x.shape()[{j}], ysize_{j} = _raw_y.shape()[{j}]'
+            ', xstride_{j}=x.strides()[{j}];' % int_type)
+    sizes = [size.format(j=j) for j in range(ndim)]
+    inds = _util._generate_indices_ops(ndim, int_type, offsets)
+    # CArray: remove expr entirely
+    expr = ' + '.join(['ix_{}'.format(j) for j in range(ndim)])
+
+    ws_init = ws_pre = ws_post = ''
+    if has_weights or has_structure:
+        ws_init = 'int iws = 0;'
+        if has_structure:
+            ws_pre = 'S sval = s[iws];\n'
+        if has_weights:
+            ws_pre += 'W wval = w[iws];\n'
+            if not all_weights_nonzero:
+                ws_pre += 'if (nonzero(wval))'
+        ws_post = 'iws++;'
+
+    loops = []
+    for j in range(ndim):
+        if w_shape[j] == 1:
+            # CArray: string becomes 'inds[{j}] = ind_{j};', remove (int_)type
+            loops.append('{{ {type} ix_{j} = ind_{j} * xstride_{j};'.
+                         format(j=j, type=int_type))
+        else:
+            boundary = _util._generate_boundary_condition_ops(
+                mode, 'ix_{}'.format(j), 'xsize_{}'.format(j), int_type)
+            # CArray: last line of string becomes inds[{j}] = ix_{j};
+            loops.append('''
+    for (int iw_{j} = 0; iw_{j} < {wsize}; iw_{j}++)
+    {{
+        {type} ix_{j} = ind_{j} + iw_{j};
+        {boundary}
+        ix_{j} *= xstride_{j};
+        '''.format(j=j, wsize=w_shape[j], boundary=boundary, type=int_type))
+
+    # CArray: string becomes 'x[inds]', no format call needed
+    value = '(*(X*)&data[{expr}])'.format(expr=expr)
+    if mode == 'constant':
+        cond = ' || '.join(['(ix_{} < 0)'.format(j) for j in range(ndim)])
+
+    if cval is numpy.nan:
+        cval = 'CUDART_NAN'
+    elif cval == numpy.inf:
+        cval = 'CUDART_INF'
+    elif cval == -numpy.inf:
+        cval = '-CUDART_INF'
+
+    if binary_morphology:
+        found = found.format(cond=cond, value=value)
+    else:
+        if mode == 'constant':
+            value = '(({cond}) ? cast<{ctype}>({cval}) : {value})'.format(
+                cond=cond, ctype=ctype, cval=cval, value=value)
+        found = found.format(value=value)
+
+    # CArray: replace comment and next line in string with
+    #   {type} inds[{ndim}] = {{0}};
+    # and add ndim=ndim, type=int_type to format call
+    operation = '''
+    {sizes}
+    {inds}
+    // don't use a CArray for indexing (faster to deal with indexing ourselves)
+    const unsigned char* data = (const unsigned char*)&x[0];
+    {ws_init}
+    {pre}
+    {loops}
+        // inner-most loop
+        {ws_pre} {{
+            {found}
+        }}
+        {ws_post}
+    {end_loops}
+    {post}
+    '''.format(sizes='\n'.join(sizes), inds=inds, pre=pre, post=post,
+               ws_init=ws_init, ws_pre=ws_pre, ws_post=ws_post,
+               loops='\n'.join(loops), found=found, end_loops='}'*ndim)
+
+    mode_str = mode.replace('-', '_')  # avoid potential hyphen in kernel name
+    name = 'cupyx_scipy_ndimage_{}_{}d_{}_w{}'.format(
+        name, ndim, mode_str, '_'.join(['{}'.format(x) for x in w_shape]))
+    if all_weights_nonzero:
+        name += '_all_nonzero'
+    if int_type == 'ptrdiff_t':
+        name += '_i64'
+    if has_structure:
+        name += '_with_structure'
+    if has_mask:
+        name += '_with_mask'
+    preamble = includes + _CAST_FUNCTION + preamble
+    options += ('--std=c++11', )
+    return cupy.ElementwiseKernel(in_params, out_params, operation, name,
+                                  reduce_dims=False, preamble=preamble,
+                                  options=options)

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/_filters_generic.py

@@ -0,0 +1,272 @@
+import cupy
+from cupy_backends.cuda.api import runtime
+from cupy import _util
+from cupyx.scipy.ndimage import _filters_core
+
+
+def _get_sub_kernel(f):
+    """
+    Takes the "function" given to generic_filter and returns the "sub-kernel"
+    that will be called, one of RawKernel or ReductionKernel.
+
+    This supports:
+     * cupy.RawKernel
+       no checks are possible
+     * cupy.ReductionKernel
+       checks that there is a single input and output
+    """
+    if isinstance(f, cupy.RawKernel):
+        # We will assume that it has the correct API
+        return f
+    elif isinstance(f, cupy.ReductionKernel):
+        if f.nin != 1 or f.nout != 1:
+            raise TypeError('ReductionKernel must have 1 input and output')
+        return f
+    elif isinstance(f, cupy.ElementwiseKernel):
+        # special error message for ElementwiseKernels
+        raise TypeError('only ReductionKernel allowed (not ElementwiseKernel)')
+    else:
+        raise TypeError('bad function type')
+
+
+@_util.memoize(for_each_device=True)
+def _get_generic_filter_red(rk, in_dtype, out_dtype, filter_size, mode,
+                            wshape, offsets, cval, int_type):
+    """Generic filter implementation based on a reduction kernel."""
+    # Get the temporary output c type
+    in_param, out_param = rk.in_params[0], rk.out_params[0]
+    out_ctype = out_param.ctype
+    if out_param.dtype is None:  # resolve template
+        out_ctype = cupy._core._scalar.get_typename(
+            in_dtype if out_param.ctype == in_param.ctype else out_dtype)
+
+    # Get code chunks
+    setup = '''
+    int iv = 0;
+    X values[{size}];
+    CArray<X, 1, true, true> sub_in(values, {{{size}}});
+    {out_ctype} val_out;
+    CArray<{out_ctype}, 1, true, true> sub_out(&val_out, {{1}});
+    '''.format(size=filter_size, out_ctype=out_ctype)
+
+    sub_call = '''reduction_kernel::{}(sub_in, sub_out);
+    y = cast<Y>(val_out);'''.format(rk.name)
+
+    sub_kernel = _reduction_kernel_code(rk, filter_size, out_dtype, in_dtype)
+
+    # Get the final kernel
+    return _filters_core._generate_nd_kernel(
+        'generic_{}_{}'.format(filter_size, rk.name),
+        setup, 'values[iv++] = {value};', sub_call,
+        mode, wshape, int_type, offsets, cval, preamble=sub_kernel,
+        options=getattr(rk, 'options', ()))
+
+
+def _reduction_kernel_code(rk, filter_size, out_dtype, in_dtype):
+    # NOTE: differences from the code generated for real reduction kernels:
+    #  * input is always 1D and always less than 2^31 elements
+    #  * output is always 1D with a single element
+    #  * never across threads (no _block_stride, _sdata, _sdata_raw, _REDUCE,
+    #       _tid, _J, _i, _i_base, _j_offset, _J_offset, _j_stride, _J_stride)
+    # Also, the code is moved into a namespace so that clashes are minimized
+    # between the typedefs for the "template" variables.
+
+    # figure out the types
+    types = {}
+    in_param, out_param = rk.in_params[0], rk.out_params[0]
+    in_ctype = _get_type_info(in_param, in_dtype, types)
+    out_ctype = _get_type_info(out_param, out_dtype, types)
+    types = '\n'.join('typedef {} {};'.format(typ, name)
+                      for name, typ in types.items())
+
+    return '''namespace reduction_kernel {{
+{type_preamble}
+{preamble}
+__device__
+void {name}({in_const} CArray<{in_ctype}, 1, true, true>& _raw_{in_name},
+            CArray<{out_ctype}, 1, true, true>& _raw_{out_name}) {{
+    // these are just provided so if they are available for the RK
+    CIndexer<1> _in_ind({{{size}}});
+    CIndexer<0> _out_ind;
+
+    #define REDUCE(a, b) ({reduce_expr})
+    #define POST_MAP(a) ({post_map_expr})
+    typedef {reduce_type} _type_reduce;
+    _type_reduce _s = _type_reduce({identity});
+    for (int _j = 0; _j < {size}; ++_j) {{
+        _in_ind.set(_j);
+        {in_const} {in_ctype}& {in_name} = _raw_{in_name}[_j];
+        _type_reduce _a = static_cast<_type_reduce>({pre_map_expr});
+        _s = REDUCE(_s, _a);
+    }}
+    _out_ind.set(0);
+    {out_ctype} &{out_name} = _raw_{out_name}[0];
+    POST_MAP(_s);
+    #undef REDUCE
+    #undef POST_MAP
+}}
+}}'''.format(
+        name=rk.name, type_preamble=types, preamble=rk.preamble,
+        in_const='const' if in_param.is_const else '',
+        in_ctype=in_ctype, in_name=in_param.name,
+        out_ctype=out_ctype, out_name=out_param.name,
+
+        pre_map_expr=rk.map_expr,
+        identity='' if rk.identity is None else rk.identity,
+        size=filter_size,
+        reduce_type=rk.reduce_type, reduce_expr=rk.reduce_expr,
+        post_map_expr=rk.post_map_expr,
+    )
+
+
+def _get_type_info(param, dtype, types):
+    if param.dtype is not None:
+        return param.ctype
+    # Template type -> map to actual output type
+    ctype = cupy._core._scalar.get_typename(dtype)
+    types.setdefault(param.ctype, ctype)
+    return ctype
+
+
+@_util.memoize(for_each_device=True)
+def _get_generic_filter_raw(rk, filter_size, mode, wshape, offsets, cval,
+                            int_type):
+    """Generic filter implementation based on a raw kernel."""
+    setup = '''
+    int iv = 0;
+    double values[{}];
+    double val_out;'''.format(filter_size)
+
+    sub_call = '''raw_kernel::{}(values, {}, &val_out);
+    y = cast<Y>(val_out);'''.format(rk.name, filter_size)
+
+    return _filters_core._generate_nd_kernel(
+        'generic_{}_{}'.format(filter_size, rk.name),
+        setup, 'values[iv++] = cast<double>({value});', sub_call,
+        mode, wshape, int_type, offsets, cval,
+        preamble='namespace raw_kernel {{\n{}\n}}'.format(
+            # Users can test RawKernel independently, but when passed to here
+            # it must be used as a device function here. In fact, RawKernel
+            # wouldn't compile if code only contains device functions, so this
+            # is necessary.
+            rk.code.replace('__global__', '__device__')),
+        options=rk.options)
+
+
+@_util.memoize(for_each_device=True)
+def _get_generic_filter1d(rk, length, n_lines, filter_size, origin, mode, cval,
+                          in_ctype, out_ctype, int_type):
+    """
+    The generic 1d filter is different than all other filters and thus is the
+    only filter that doesn't use _generate_nd_kernel() and has a completely
+    custom raw kernel.
+    """
+    in_length = length + filter_size - 1
+    start = filter_size // 2 + origin
+    end = start + length
+
+    if mode == 'constant':
+        boundary, boundary_early = '', '''
+        for (idx_t j = 0; j < {start}; ++j) {{ input_line[j] = {cval}; }}
+        for (idx_t j = {end}; j<{in_length}; ++j) {{ input_line[j] = {cval}; }}
+        '''.format(start=start, end=end, in_length=in_length, cval=cval)
+    else:
+        if length == 1:
+            a = b = 'j_ = 0;'
+        elif mode == 'reflect':
+            j = ('j_ = ({j}) % ({length} * 2);\n'
+                 'j_ = min(j_, 2 * {length} - 1 - j_);')
+            a = j.format(j='-1 - j_', length=length)
+            b = j.format(j='j_', length=length)
+        elif mode == 'mirror':
+            j = ('j_ = 1 + (({j}) - 1) % (({length} - 1) * 2);\n'
+                 'j_ = min(j_, 2 * {length} - 2 - j_);')
+            a = j.format(j='-j_', length=length)
+            b = j.format(j='j_', length=length)
+        elif mode == 'nearest':
+            a, b = 'j_ = 0;', 'j_ = {length}-1;'.format(length=length)
+        elif mode == 'wrap':
+            a = 'j_ = j_ % {length} + {length};'.format(length=length)
+            b = 'j_ = j_ % {length};'.format(length=length)
+        loop = '''for (idx_t j = {{}}; j < {{}}; ++j) {{{{
+            idx_t j_ = j - {start};
+            {{}}
+            input_line[j] = input_line[j_ + {start}];
+        }}}}'''.format(start=start)
+        boundary_early = ''
+        boundary = (loop.format(0, start, a) + '\n' +
+                    loop.format(end, in_length, b))
+
+    name = 'generic1d_{}_{}_{}'.format(length, filter_size, rk.name)
+    if runtime.is_hip:
+        include_type_traits = ''
+    else:
+        include_type_traits = '''
+#include <cupy/cuda_workaround.h>  // provide C++ std:: coverage
+'''
+    code = '''#include "cupy/carray.cuh"
+#include "cupy/complex.cuh"
+{include_type_traits}
+
+namespace raw_kernel {{\n{rk_code}\n}}
+
+{CAST}
+
+typedef unsigned char byte;
+typedef {in_ctype} X;
+typedef {out_ctype} Y;
+typedef {int_type} idx_t;
+
+__device__ idx_t offset(idx_t i, idx_t axis, idx_t ndim,
+                        const idx_t* shape, const idx_t* strides) {{
+    idx_t index = 0;
+    for (idx_t a = ndim; --a > 0; ) {{
+        if (a == axis) {{ continue; }}
+        index += (i % shape[a]) * strides[a];
+        i /= shape[a];
+    }}
+    return index + strides[0] * i;
+}}
+
+extern "C" __global__
+void {name}(const byte* input, byte* output, const idx_t* x) {{
+    const idx_t axis = x[0], ndim = x[1],
+        *shape = x+2, *in_strides = x+2+ndim, *out_strides = x+2+2*ndim;
+
+    const idx_t in_elem_stride = in_strides[axis];
+    const idx_t out_elem_stride = out_strides[axis];
+
+    double input_line[{in_length}];
+    double output_line[{length}];
+    {boundary_early}
+
+    for (idx_t i = ((idx_t)blockIdx.x) * blockDim.x + threadIdx.x;
+            i < {n_lines};
+            i += ((idx_t)blockDim.x) * gridDim.x) {{
+        // Copy line from input (with boundary filling)
+        const byte* input_ = input + offset(i, axis, ndim, shape, in_strides);
+        for (idx_t j = 0; j < {length}; ++j) {{
+            input_line[j+{start}] = (double)*(X*)(input_+j*in_elem_stride);
+        }}
+        {boundary}
+
+        raw_kernel::{rk_name}(input_line, {in_length}, output_line, {length});
+
+        // Copy line to output
+        byte* output_ = output + offset(i, axis, ndim, shape, out_strides);
+        for (idx_t j = 0; j < {length}; ++j) {{
+            *(Y*)(output_+j*out_elem_stride) = cast<Y>(output_line[j]);
+        }}
+    }}
+}}'''.format(n_lines=n_lines, length=length, in_length=in_length, start=start,
+             in_ctype=in_ctype, out_ctype=out_ctype, int_type=int_type,
+             boundary_early=boundary_early, boundary=boundary,
+             name=name, rk_name=rk.name,
+             # Users can test RawKernel independently, but when passed to here
+             # it must be used as a device function here. In fact, RawKernel
+             # wouldn't compile if code only contains device functions, so this
+             # is necessary.
+             rk_code=rk.code.replace('__global__', '__device__'),
+             include_type_traits=include_type_traits,
+             CAST=_filters_core._CAST_FUNCTION)
+    return cupy.RawKernel(code, name, ('--std=c++11',) + rk.options)

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/_fourier.py

@@ -0,0 +1,253 @@
+import numpy
+
+import cupy
+from cupy import _core
+from cupy._core import internal
+from cupyx.scipy.ndimage import _util
+from cupyx.scipy import special
+
+
+def _get_output_fourier(output, input, complex_only=False):
+    types = [cupy.complex64, cupy.complex128]
+    if not complex_only:
+        types += [cupy.float32, cupy.float64]
+
+    if output is None:
+        if input.dtype in types:
+            output = cupy.empty(input.shape, dtype=input.dtype)
+        else:
+            output = cupy.empty(input.shape, dtype=types[-1])
+    elif type(output) is type:
+        if output not in types:
+            raise RuntimeError('output type not supported')
+        output = cupy.empty(input.shape, dtype=output)
+    elif output.shape != input.shape:
+        raise RuntimeError('output shape not correct')
+    return output
+
+
+def _reshape_nd(arr, ndim, axis):
+    """Promote a 1d array to ndim with non-singleton size along axis."""
+    nd_shape = (1,) * axis + (arr.size,) + (1,) * (ndim - axis - 1)
+    return arr.reshape(nd_shape)
+
+
+def fourier_gaussian(input, sigma, n=-1, axis=-1, output=None):
+    """Multidimensional Gaussian shift filter.
+
+    The array is multiplied with the Fourier transform of a (separable)
+    Gaussian kernel.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        sigma (float or sequence of float):  The sigma of the Gaussian kernel.
+            If a float, `sigma` is the same for all axes. If a sequence,
+            `sigma` has to contain one value for each axis.
+        n (int, optional):  If `n` is negative (default), then the input is
+            assumed to be the result of a complex fft. If `n` is larger than or
+            equal to zero, the input is assumed to be the result of a real fft,
+            and `n` gives the length of the array before transformation along
+            the real transform direction.
+        axis (int, optional): The axis of the real transform (only used when
+            ``n > -1``).
+        output (cupy.ndarray, optional):
+            If given, the result of shifting the input is placed in this array.
+
+    Returns:
+        output (cupy.ndarray): The filtered output.
+    """
+    ndim = input.ndim
+    output = _get_output_fourier(output, input)
+    axis = internal._normalize_axis_index(axis, ndim)
+    sigmas = _util._fix_sequence_arg(sigma, ndim, 'sigma')
+
+    _core.elementwise_copy(input, output)
+    for ax, (sigmak, ax_size) in enumerate(zip(sigmas, output.shape)):
+
+        # compute the frequency grid in Hz
+        if ax == axis and n > 0:
+            arr = cupy.arange(ax_size, dtype=output.real.dtype)
+            arr /= n
+        else:
+            arr = cupy.fft.fftfreq(ax_size)
+        arr = arr.astype(output.real.dtype, copy=False)
+
+        # compute the Gaussian weights
+        arr *= arr
+        scale = sigmak * sigmak / -2
+        arr *= (4 * numpy.pi * numpy.pi) * scale
+        cupy.exp(arr, out=arr)
+
+        # reshape for broadcasting
+        arr = _reshape_nd(arr, ndim=ndim, axis=ax)
+        output *= arr
+
+    return output
+
+
+def fourier_uniform(input, size, n=-1, axis=-1, output=None):
+    """Multidimensional uniform shift filter.
+
+    The array is multiplied with the Fourier transform of a box of given size.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (float or sequence of float):  The sigma of the box used for
+            filtering. If a float, `size` is the same for all axes. If a
+            sequence, `size` has to contain one value for each axis.
+        n (int, optional):  If `n` is negative (default), then the input is
+            assumed to be the result of a complex fft. If `n` is larger than or
+            equal to zero, the input is assumed to be the result of a real fft,
+            and `n` gives the length of the array before transformation along
+            the real transform direction.
+        axis (int, optional): The axis of the real transform (only used when
+            ``n > -1``).
+        output (cupy.ndarray, optional):
+            If given, the result of shifting the input is placed in this array.
+
+    Returns:
+        output (cupy.ndarray): The filtered output.
+    """
+    ndim = input.ndim
+    output = _get_output_fourier(output, input)
+    axis = internal._normalize_axis_index(axis, ndim)
+    sizes = _util._fix_sequence_arg(size, ndim, 'size')
+
+    _core.elementwise_copy(input, output)
+    for ax, (size, ax_size) in enumerate(zip(sizes, output.shape)):
+
+        # compute the frequency grid in Hz
+        if ax == axis and n > 0:
+            arr = cupy.arange(ax_size, dtype=output.real.dtype)
+            arr /= n
+        else:
+            arr = cupy.fft.fftfreq(ax_size)
+        arr = arr.astype(output.real.dtype, copy=False)
+
+        # compute the uniform filter weights
+        arr *= size
+        cupy.sinc(arr, out=arr)
+
+        # reshape for broadcasting
+        arr = _reshape_nd(arr, ndim=ndim, axis=ax)
+        output *= arr
+
+    return output
+
+
+def fourier_shift(input, shift, n=-1, axis=-1, output=None):
+    """Multidimensional Fourier shift filter.
+
+    The array is multiplied with the Fourier transform of a shift operation.
+
+    Args:
+        input (cupy.ndarray): The input array. This should be in the Fourier
+            domain.
+        shift (float or sequence of float):  The size of shift. If a float,
+            `shift` is the same for all axes. If a sequence, `shift` has to
+            contain one value for each axis.
+        n (int, optional):  If `n` is negative (default), then the input is
+            assumed to be the result of a complex fft. If `n` is larger than or
+            equal to zero, the input is assumed to be the result of a real fft,
+            and `n` gives the length of the array before transformation along
+            the real transform direction.
+        axis (int, optional): The axis of the real transform (only used when
+            ``n > -1``).
+        output (cupy.ndarray, optional):
+            If given, the result of shifting the input is placed in this array.
+
+    Returns:
+        output (cupy.ndarray): The shifted output (in the Fourier domain).
+    """
+    ndim = input.ndim
+    output = _get_output_fourier(output, input, complex_only=True)
+    axis = internal._normalize_axis_index(axis, ndim)
+    shifts = _util._fix_sequence_arg(shift, ndim, 'shift')
+
+    _core.elementwise_copy(input, output)
+    for ax, (shiftk, ax_size) in enumerate(zip(shifts, output.shape)):
+        if shiftk == 0:
+            continue
+        if ax == axis and n > 0:
+            # cp.fft.rfftfreq(ax_size) * (-2j * numpy.pi * shiftk *  ax_size/n)
+            arr = cupy.arange(ax_size, dtype=output.dtype)
+            arr *= -2j * numpy.pi * shiftk / n
+        else:
+            arr = cupy.fft.fftfreq(ax_size)
+            arr = arr * (-2j * numpy.pi * shiftk)
+        cupy.exp(arr, out=arr)
+
+        # reshape for broadcasting
+        arr = _reshape_nd(arr, ndim=ndim, axis=ax)
+        output *= arr
+
+    return output
+
+
+def fourier_ellipsoid(input, size, n=-1, axis=-1, output=None):
+    """Multidimensional ellipsoid Fourier filter.
+
+    The array is multiplied with the fourier transform of a ellipsoid of
+    given sizes.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (float or sequence of float):  The size of the box used for
+            filtering. If a float, `size` is the same for all axes. If a
+            sequence, `size` has to contain one value for each axis.
+        n (int, optional):  If `n` is negative (default), then the input is
+            assumed to be the result of a complex fft. If `n` is larger than or
+            equal to zero, the input is assumed to be the result of a real fft,
+            and `n` gives the length of the array before transformation along
+            the real transform direction.
+        axis (int, optional): The axis of the real transform (only used when
+            ``n > -1``).
+        output (cupy.ndarray, optional):
+            If given, the result of shifting the input is placed in this array.
+
+    Returns:
+        output (cupy.ndarray): The filtered output.
+    """
+    ndim = input.ndim
+    if ndim == 1:
+        return fourier_uniform(input, size, n, axis, output)
+
+    if ndim > 3:
+        # Note: SciPy currently does not do any filtering on >=4d inputs, but
+        #       does not warn about this!
+        raise NotImplementedError('Only 1d, 2d and 3d inputs are supported')
+    output = _get_output_fourier(output, input)
+    axis = internal._normalize_axis_index(axis, ndim)
+    sizes = _util._fix_sequence_arg(size, ndim, 'size')
+
+    _core.elementwise_copy(input, output)
+
+    # compute the distance from the origin for all samples in Fourier space
+    distance = 0
+    for ax, (size, ax_size) in enumerate(zip(sizes, output.shape)):
+        # compute the frequency grid in Hz
+        if ax == axis and n > 0:
+            arr = cupy.arange(ax_size, dtype=output.real.dtype)
+            arr *= numpy.pi * size / n
+        else:
+            arr = cupy.fft.fftfreq(ax_size)
+            arr *= numpy.pi * size
+        arr = arr.astype(output.real.dtype, copy=False)
+        arr *= arr
+        arr = _reshape_nd(arr, ndim=ndim, axis=ax)
+        distance = distance + arr
+    cupy.sqrt(distance, out=distance)
+
+    if ndim == 2:
+        special.j1(distance, out=output)
+        output *= 2
+        output /= distance
+    elif ndim == 3:
+        cupy.sin(distance, out=output)
+        output -= distance * cupy.cos(distance)
+        output *= 3
+        output /= distance ** 3
+    output[(0,) * ndim] = 1.0  # avoid NaN in corner at frequency=0 location
+    output *= input
+
+    return output

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/_interp_kernels.py

@@ -0,0 +1,598 @@
+import numpy
+
+import cupy
+import cupy._core.internal
+
+from cupyx.scipy.ndimage import _spline_prefilter_core
+from cupyx.scipy.ndimage import _spline_kernel_weights
+from cupyx.scipy.ndimage import _util
+
+math_constants_preamble = r'''
+// workaround for HIP: line begins with #include
+#include <cupy/math_constants.h>
+'''
+
+spline_weights_inline = _spline_kernel_weights.spline_weights_inline
+
+
+def _get_coord_map(ndim, nprepad=0):
+    """Extract target coordinate from coords array (for map_coordinates).
+
+    Notes
+    -----
+    Assumes the following variables have been initialized on the device::
+
+        coords (ndarray): array of shape (ncoords, ndim) containing the target
+            coordinates.
+        c_j: variables to hold the target coordinates
+
+    computes::
+
+        c_j = coords[i + j * ncoords];
+
+    ncoords is determined by the size of the output array, y.
+    y will be indexed by the CIndexer, _ind.
+    Thus ncoords = _ind.size();
+
+    """
+    ops = []
+    ops.append('ptrdiff_t ncoords = _ind.size();')
+    pre = f" + (W){nprepad}" if nprepad > 0 else ''
+    for j in range(ndim):
+        ops.append(f'''
+    W c_{j} = coords[i + {j} * ncoords]{pre};''')
+    return ops
+
+
+def _get_coord_zoom_and_shift(ndim, nprepad=0):
+    """Compute target coordinate based on a shift followed by a zoom.
+
+    This version zooms from the center of the edge pixels.
+
+    Notes
+    -----
+    Assumes the following variables have been initialized on the device::
+
+        in_coord[ndim]: array containing the source coordinate
+        zoom[ndim]: array containing the zoom for each axis
+        shift[ndim]: array containing the zoom for each axis
+
+    computes::
+
+        c_j = zoom[j] * (in_coord[j] - shift[j])
+
+    """
+    ops = []
+    pre = f" + (W){nprepad}" if nprepad > 0 else ''
+    for j in range(ndim):
+        ops.append(f'''
+    W c_{j} = zoom[{j}] * ((W)in_coord[{j}] - shift[{j}]){pre};''')
+    return ops
+
+
+def _get_coord_zoom_and_shift_grid(ndim, nprepad=0):
+    """Compute target coordinate based on a shift followed by a zoom.
+
+    This version zooms from the outer edges of the grid pixels.
+
+    Notes
+    -----
+    Assumes the following variables have been initialized on the device::
+
+        in_coord[ndim]: array containing the source coordinate
+        zoom[ndim]: array containing the zoom for each axis
+        shift[ndim]: array containing the zoom for each axis
+
+    computes::
+
+        c_j = zoom[j] * (in_coord[j] - shift[j] + 0.5) - 0.5
+
+    """
+    ops = []
+    pre = f" + (W){nprepad}" if nprepad > 0 else ''
+    for j in range(ndim):
+        ops.append(f'''
+    W c_{j} = zoom[{j}] * ((W)in_coord[{j}] - shift[j] + 0.5) - 0.5{pre};''')
+    return ops
+
+
+def _get_coord_zoom(ndim, nprepad=0):
+    """Compute target coordinate based on a zoom.
+
+    This version zooms from the center of the edge pixels.
+
+    Notes
+    -----
+    Assumes the following variables have been initialized on the device::
+
+        in_coord[ndim]: array containing the source coordinate
+        zoom[ndim]: array containing the zoom for each axis
+
+    computes::
+
+        c_j = zoom[j] * in_coord[j]
+
+    """
+    ops = []
+    pre = f" + (W){nprepad}" if nprepad > 0 else ''
+    for j in range(ndim):
+        ops.append(f'''
+    W c_{j} = zoom[{j}] * (W)in_coord[{j}]{pre};''')
+    return ops
+
+
+def _get_coord_zoom_grid(ndim, nprepad=0):
+    """Compute target coordinate based on a zoom (grid_mode=True version).
+
+    This version zooms from the outer edges of the grid pixels.
+
+    Notes
+    -----
+    Assumes the following variables have been initialized on the device::
+
+        in_coord[ndim]: array containing the source coordinate
+        zoom[ndim]: array containing the zoom for each axis
+
+    computes::
+
+        c_j = zoom[j] * (in_coord[j] + 0.5) - 0.5
+
+    """
+    ops = []
+    pre = f" + (W){nprepad}" if nprepad > 0 else ''
+    for j in range(ndim):
+        ops.append(f'''
+    W c_{j} = zoom[{j}] * ((W)in_coord[{j}] + 0.5) - 0.5{pre};''')
+    return ops
+
+
+def _get_coord_shift(ndim, nprepad=0):
+    """Compute target coordinate based on a shift.
+
+    Notes
+    -----
+    Assumes the following variables have been initialized on the device::
+
+        in_coord[ndim]: array containing the source coordinate
+        shift[ndim]: array containing the zoom for each axis
+
+    computes::
+
+        c_j = in_coord[j] - shift[j]
+
+    """
+    ops = []
+    pre = f" + (W){nprepad}" if nprepad > 0 else ''
+    for j in range(ndim):
+        ops.append(f'''
+    W c_{j} = (W)in_coord[{j}] - shift[{j}]{pre};''')
+    return ops
+
+
+def _get_coord_affine(ndim, nprepad=0):
+    """Compute target coordinate based on a homogeneous transformation matrix.
+
+    The homogeneous matrix has shape (ndim, ndim + 1). It corresponds to
+    affine matrix where the last row of the affine is assumed to be:
+    ``[0] * ndim + [1]``.
+
+    Notes
+    -----
+    Assumes the following variables have been initialized on the device::
+
+        mat(array): array containing the (ndim, ndim + 1) transform matrix.
+        in_coords(array): coordinates of the input
+
+    For example, in 2D:
+
+        c_0 = mat[0] * in_coords[0] + mat[1] * in_coords[1] + aff[2];
+        c_1 = mat[3] * in_coords[0] + mat[4] * in_coords[1] + aff[5];
+
+    """
+    ops = []
+    pre = f" + (W){nprepad}" if nprepad > 0 else ''
+    ncol = ndim + 1
+    for j in range(ndim):
+        ops.append(f'''
+            W c_{j} = (W)0.0;''')
+        for k in range(ndim):
+            ops.append(f'''
+            c_{j} += mat[{ncol * j + k}] * (W)in_coord[{k}];''')
+        ops.append(f'''
+            c_{j} += mat[{ncol * j + ndim}]{pre};''')
+    return ops
+
+
+def _unravel_loop_index(shape, uint_t='unsigned int'):
+    """
+    declare a multi-index array in_coord and unravel the 1D index, i into it.
+    This code assumes that the array is a C-ordered array.
+    """
+    ndim = len(shape)
+    code = [f'''
+        {uint_t} in_coord[{ndim}];
+        {uint_t} s, t, idx = i;''']
+    for j in range(ndim - 1, 0, -1):
+        code.append(f'''
+        s = {shape[j]};
+        t = idx / s;
+        in_coord[{j}] = idx - t * s;
+        idx = t;''')
+    code.append('''
+        in_coord[0] = idx;''')
+    return '\n'.join(code)
+
+
+def _generate_interp_custom(coord_func, ndim, large_int, yshape, mode, cval,
+                            order, name='', integer_output=False, nprepad=0,
+                            omit_in_coord=False):
+    """
+    Args:
+        coord_func (function): generates code to do the coordinate
+            transformation. See for example, `_get_coord_shift`.
+        ndim (int): The number of dimensions.
+        large_int (bool): If true use Py_ssize_t instead of int for indexing.
+        yshape (tuple): Shape of the output array.
+        mode (str): Signal extension mode to use at the array boundaries
+        cval (float): constant value used when `mode == 'constant'`.
+        name (str): base name for the interpolation kernel
+        integer_output (bool): boolean indicating whether the output has an
+            integer type.
+        nprepad (int): integer indicating the amount of prepadding at the
+            boundaries.
+
+    Returns:
+        operation (str): code body for the ElementwiseKernel
+        name (str): name for the ElementwiseKernel
+    """
+
+    ops = []
+    internal_dtype = 'double' if integer_output else 'Y'
+    ops.append(f'{internal_dtype} out = 0.0;')
+
+    if large_int:
+        uint_t = 'size_t'
+        int_t = 'ptrdiff_t'
+    else:
+        uint_t = 'unsigned int'
+        int_t = 'int'
+
+    # determine strides for x along each axis
+    for j in range(ndim):
+        ops.append(f'const {int_t} xsize_{j} = x.shape()[{j}];')
+    ops.append(f'const {uint_t} sx_{ndim - 1} = 1;')
+    for j in range(ndim - 1, 0, -1):
+        ops.append(f'const {uint_t} sx_{j - 1} = sx_{j} * xsize_{j};')
+
+    if not omit_in_coord:
+        # create in_coords array to store the unraveled indices
+        ops.append(_unravel_loop_index(yshape, uint_t))
+
+    # compute the transformed (target) coordinates, c_j
+    ops = ops + coord_func(ndim, nprepad)
+
+    if cval is numpy.nan:
+        cval = '(Y)CUDART_NAN'
+    elif cval == numpy.inf:
+        cval = '(Y)CUDART_INF'
+    elif cval == -numpy.inf:
+        cval = '(Y)(-CUDART_INF)'
+    else:
+        cval = f'({internal_dtype}){cval}'
+
+    if mode == 'constant':
+        # use cval if coordinate is outside the bounds of x
+        _cond = ' || '.join(
+            [f'(c_{j} < 0) || (c_{j} > xsize_{j} - 1)' for j in range(ndim)])
+        ops.append(f'''
+        if ({_cond})
+        {{
+            out = {cval};
+        }}
+        else
+        {{''')
+
+    if order == 0:
+        if mode == 'wrap':
+            ops.append('double dcoord;')  # mode 'wrap' requires this to work
+        for j in range(ndim):
+            # determine nearest neighbor
+            if mode == 'wrap':
+                ops.append(f'''
+                dcoord = c_{j};''')
+            else:
+                ops.append(f'''
+                {int_t} cf_{j} = ({int_t})floor((double)c_{j} + 0.5);''')
+
+            # handle boundary
+            if mode != 'constant':
+                if mode == 'wrap':
+                    ixvar = 'dcoord'
+                    float_ix = True
+                else:
+                    ixvar = f'cf_{j}'
+                    float_ix = False
+                ops.append(
+                    _util._generate_boundary_condition_ops(
+                        mode, ixvar, f'xsize_{j}', int_t, float_ix))
+                if mode == 'wrap':
+                    ops.append(f'''
+                {int_t} cf_{j} = ({int_t})floor(dcoord + 0.5);''')
+
+            # sum over ic_j will give the raveled coordinate in the input
+            ops.append(f'''
+            {int_t} ic_{j} = cf_{j} * sx_{j};''')
+        _coord_idx = ' + '.join([f'ic_{j}' for j in range(ndim)])
+        if mode == 'grid-constant':
+            _cond = ' || '.join([f'(ic_{j} < 0)' for j in range(ndim)])
+            ops.append(f'''
+            if ({_cond}) {{
+                out = {cval};
+            }} else {{
+                out = ({internal_dtype})x[{_coord_idx}];
+            }}''')
+        else:
+            ops.append(f'''
+            out = ({internal_dtype})x[{_coord_idx}];''')
+
+    elif order == 1:
+        for j in range(ndim):
+            # get coordinates for linear interpolation along axis j
+            ops.append(f'''
+            {int_t} cf_{j} = ({int_t})floor((double)c_{j});
+            {int_t} cc_{j} = cf_{j} + 1;
+            {int_t} n_{j} = (c_{j} == cf_{j}) ? 1 : 2;  // points needed
+            ''')
+
+            if mode == 'wrap':
+                ops.append(f'''
+                double dcoordf = c_{j};
+                double dcoordc = c_{j} + 1;''')
+            else:
+                # handle boundaries for extension modes.
+                ops.append(f'''
+                {int_t} cf_bounded_{j} = cf_{j};
+                {int_t} cc_bounded_{j} = cc_{j};''')
+
+            if mode != 'constant':
+                if mode == 'wrap':
+                    ixvar = 'dcoordf'
+                    float_ix = True
+                else:
+                    ixvar = f'cf_bounded_{j}'
+                    float_ix = False
+                ops.append(
+                    _util._generate_boundary_condition_ops(
+                        mode, ixvar, f'xsize_{j}', int_t, float_ix))
+
+                ixvar = 'dcoordc' if mode == 'wrap' else f'cc_bounded_{j}'
+                ops.append(
+                    _util._generate_boundary_condition_ops(
+                        mode, ixvar, f'xsize_{j}', int_t, float_ix))
+                if mode == 'wrap':
+                    ops.append(
+                        f'''
+                    {int_t} cf_bounded_{j} = ({int_t})floor(dcoordf);;
+                    {int_t} cc_bounded_{j} = ({int_t})floor(dcoordf + 1);;
+                    '''
+                    )
+
+            ops.append(f'''
+            for (int s_{j} = 0; s_{j} < n_{j}; s_{j}++)
+                {{
+                    W w_{j};
+                    {int_t} ic_{j};
+                    if (s_{j} == 0)
+                    {{
+                        w_{j} = (W)cc_{j} - c_{j};
+                        ic_{j} = cf_bounded_{j} * sx_{j};
+                    }} else
+                    {{
+                        w_{j} = c_{j} - (W)cf_{j};
+                        ic_{j} = cc_bounded_{j} * sx_{j};
+                    }}''')
+    elif order > 1:
+        if mode == 'grid-constant':
+            spline_mode = 'constant'
+        elif mode == 'nearest':
+            spline_mode = 'nearest'
+        else:
+            spline_mode = _spline_prefilter_core._get_spline_mode(mode)
+
+        # wx, wy are temporary variables used during spline weight computation
+        ops.append(f'''
+            W wx, wy;
+            {int_t} start;''')
+        for j in range(ndim):
+            # determine weights along the current axis
+            ops.append(f'''
+            W weights_{j}[{order + 1}];''')
+            ops.append(spline_weights_inline[order].format(j=j, order=order))
+
+            # get starting coordinate for spline interpolation along axis j
+            if mode in ['wrap']:
+                ops.append(f'double dcoord = c_{j};')
+                coord_var = 'dcoord'
+                ops.append(
+                    _util._generate_boundary_condition_ops(
+                        mode, coord_var, f'xsize_{j}', int_t, True))
+            else:
+                coord_var = f'(double)c_{j}'
+
+            if order & 1:
+                op_str = '''
+                start = ({int_t})floor({coord_var}) - {order_2};'''
+            else:
+                op_str = '''
+                start = ({int_t})floor({coord_var} + 0.5) - {order_2};'''
+            ops.append(
+                op_str.format(
+                    int_t=int_t, coord_var=coord_var, order_2=order // 2
+                ))
+
+            # set of coordinate values within spline footprint along axis j
+            ops.append(f'''{int_t} ci_{j}[{order + 1}];''')
+            for k in range(order + 1):
+                ixvar = f'ci_{j}[{k}]'
+                ops.append(f'''
+                {ixvar} = start + {k};''')
+                ops.append(
+                    _util._generate_boundary_condition_ops(
+                        spline_mode, ixvar, f'xsize_{j}', int_t))
+
+            # loop over the order + 1 values in the spline filter
+            ops.append(f'''
+            W w_{j};
+            {int_t} ic_{j};
+            for (int k_{j} = 0; k_{j} <= {order}; k_{j}++)
+                {{
+                    w_{j} = weights_{j}[k_{j}];
+                    ic_{j} = ci_{j}[k_{j}] * sx_{j};
+            ''')
+
+    if order > 0:
+
+        _weight = ' * '.join([f'w_{j}' for j in range(ndim)])
+        _coord_idx = ' + '.join([f'ic_{j}' for j in range(ndim)])
+        if mode == 'grid-constant' or (order > 1 and mode == 'constant'):
+            _cond = ' || '.join([f'(ic_{j} < 0)' for j in range(ndim)])
+            ops.append(f'''
+            if ({_cond}) {{
+                out += {cval} * ({internal_dtype})({_weight});
+            }} else {{
+                {internal_dtype} val = ({internal_dtype})x[{_coord_idx}];
+                out += val * ({internal_dtype})({_weight});
+            }}''')
+        else:
+            ops.append(f'''
+            {internal_dtype} val = ({internal_dtype})x[{_coord_idx}];
+            out += val * ({internal_dtype})({_weight});''')
+
+        ops.append('}' * ndim)
+
+    if mode == 'constant':
+        ops.append('}')
+
+    if integer_output:
+        ops.append('y = (Y)rint((double)out);')
+    else:
+        ops.append('y = (Y)out;')
+    operation = '\n'.join(ops)
+
+    mode_str = mode.replace('-', '_')  # avoid hyphen in kernel name
+    name = 'cupyx_scipy_ndimage_interpolate_{}_order{}_{}_{}d_y{}'.format(
+        name, order, mode_str, ndim, '_'.join([f'{j}' for j in yshape]),
+    )
+    if uint_t == 'size_t':
+        name += '_i64'
+    return operation, name
+
+
+@cupy._util.memoize(for_each_device=True)
+def _get_map_kernel(ndim, large_int, yshape, mode, cval=0.0, order=1,
+                    integer_output=False, nprepad=0):
+    in_params = 'raw X x, raw W coords'
+    out_params = 'Y y'
+    operation, name = _generate_interp_custom(
+        coord_func=_get_coord_map,
+        ndim=ndim,
+        large_int=large_int,
+        yshape=yshape,
+        mode=mode,
+        cval=cval,
+        order=order,
+        name='map',
+        integer_output=integer_output,
+        nprepad=nprepad,
+        omit_in_coord=True,  # input image coordinates are not needed
+    )
+    return cupy.ElementwiseKernel(in_params, out_params, operation, name,
+                                  preamble=math_constants_preamble)
+
+
+@cupy._util.memoize(for_each_device=True)
+def _get_shift_kernel(ndim, large_int, yshape, mode, cval=0.0, order=1,
+                      integer_output=False, nprepad=0):
+    in_params = 'raw X x, raw W shift'
+    out_params = 'Y y'
+    operation, name = _generate_interp_custom(
+        coord_func=_get_coord_shift,
+        ndim=ndim,
+        large_int=large_int,
+        yshape=yshape,
+        mode=mode,
+        cval=cval,
+        order=order,
+        name='shift',
+        integer_output=integer_output,
+        nprepad=nprepad,
+    )
+    return cupy.ElementwiseKernel(in_params, out_params, operation, name,
+                                  preamble=math_constants_preamble)
+
+
+@cupy._util.memoize(for_each_device=True)
+def _get_zoom_shift_kernel(ndim, large_int, yshape, mode, cval=0.0, order=1,
+                           integer_output=False, grid_mode=False, nprepad=0):
+    in_params = 'raw X x, raw W shift, raw W zoom'
+    out_params = 'Y y'
+    if grid_mode:
+        zoom_shift_func = _get_coord_zoom_and_shift_grid
+    else:
+        zoom_shift_func = _get_coord_zoom_and_shift
+    operation, name = _generate_interp_custom(
+        coord_func=zoom_shift_func,
+        ndim=ndim,
+        large_int=large_int,
+        yshape=yshape,
+        mode=mode,
+        cval=cval,
+        order=order,
+        name="zoom_shift_grid" if grid_mode else "zoom_shift",
+        integer_output=integer_output,
+        nprepad=nprepad,
+    )
+    return cupy.ElementwiseKernel(in_params, out_params, operation, name,
+                                  preamble=math_constants_preamble)
+
+
+@cupy._util.memoize(for_each_device=True)
+def _get_zoom_kernel(ndim, large_int, yshape, mode, cval=0.0, order=1,
+                     integer_output=False, grid_mode=False, nprepad=0):
+    in_params = 'raw X x, raw W zoom'
+    out_params = 'Y y'
+    operation, name = _generate_interp_custom(
+        coord_func=_get_coord_zoom_grid if grid_mode else _get_coord_zoom,
+        ndim=ndim,
+        large_int=large_int,
+        yshape=yshape,
+        mode=mode,
+        cval=cval,
+        order=order,
+        name="zoom_grid" if grid_mode else "zoom",
+        integer_output=integer_output,
+        nprepad=nprepad,
+    )
+    return cupy.ElementwiseKernel(in_params, out_params, operation, name,
+                                  preamble=math_constants_preamble)
+
+
+@cupy._util.memoize(for_each_device=True)
+def _get_affine_kernel(ndim, large_int, yshape, mode, cval=0.0, order=1,
+                       integer_output=False, nprepad=0):
+    in_params = 'raw X x, raw W mat'
+    out_params = 'Y y'
+    operation, name = _generate_interp_custom(
+        coord_func=_get_coord_affine,
+        ndim=ndim,
+        large_int=large_int,
+        yshape=yshape,
+        mode=mode,
+        cval=cval,
+        order=order,
+        name='affine',
+        integer_output=integer_output,
+        nprepad=nprepad,
+    )
+    return cupy.ElementwiseKernel(in_params, out_params, operation, name,
+                                  preamble=math_constants_preamble)

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/_interpolation.py

@@ -0,0 +1,780 @@
+import math
+import warnings
+
+import cupy
+import numpy
+
+from cupy import _core
+from cupy._core import internal
+from cupy.cuda import runtime
+from cupyx import _texture
+from cupyx.scipy.ndimage import _util
+from cupyx.scipy.ndimage import _interp_kernels
+from cupyx.scipy.ndimage import _spline_prefilter_core
+
+_prod = cupy._core.internal.prod
+
+
+def _check_parameter(func_name, order, mode):
+    if order is None:
+        warnings.warn(f'Currently the default order of {func_name} is 1. In a '
+                      'future release this may change to 3 to match '
+                      'scipy.ndimage ')
+    elif order < 0 or 5 < order:
+        raise ValueError('spline order is not supported')
+
+    if mode not in ('constant', 'grid-constant', 'nearest', 'mirror',
+                    'reflect', 'grid-mirror', 'wrap', 'grid-wrap', 'opencv',
+                    '_opencv_edge'):
+        raise ValueError('boundary mode ({}) is not supported'.format(mode))
+
+
+def _get_spline_output(input, output):
+    """Create workspace array, temp, and the final dtype for the output.
+
+    Differs from SciPy by not always forcing the internal floating point dtype
+    to be double precision.
+    """
+    complex_data = input.dtype.kind == 'c'
+    if complex_data:
+        min_float_dtype = cupy.complex64
+    else:
+        min_float_dtype = cupy.float32
+    if isinstance(output, cupy.ndarray):
+        if complex_data and output.dtype.kind != 'c':
+            raise ValueError(
+                'output must have complex dtype for complex inputs'
+            )
+        float_dtype = cupy.promote_types(output.dtype, min_float_dtype)
+        output_dtype = output.dtype
+    else:
+        if output is None:
+            output = output_dtype = input.dtype
+        else:
+            output_dtype = cupy.dtype(output)
+        float_dtype = cupy.promote_types(output, min_float_dtype)
+
+    if (isinstance(output, cupy.ndarray)
+            and output.dtype == float_dtype == output_dtype
+            and output.flags.c_contiguous):
+        if output is not input:
+            _core.elementwise_copy(input, output)
+        temp = output
+    else:
+        temp = input.astype(float_dtype, copy=False)
+        temp = cupy.ascontiguousarray(temp)
+        if cupy.shares_memory(temp, input, 'MAY_SHARE_BOUNDS'):
+            temp = temp.copy()
+    return temp, float_dtype, output_dtype
+
+
+def spline_filter1d(input, order=3, axis=-1, output=cupy.float64,
+                    mode='mirror'):
+    """
+    Calculate a 1-D spline filter along the given axis.
+
+    The lines of the array along the given axis are filtered by a
+    spline filter. The order of the spline must be >= 2 and <= 5.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        order (int): The order of the spline interpolation, default is 3. Must
+            be in the range 0-5.
+        axis (int): The axis along which the spline filter is applied. Default
+            is the last axis.
+        output (cupy.ndarray or dtype, optional): The array in which to place
+            the output, or the dtype of the returned array. Default is
+            ``numpy.float64``.
+        mode (str): Points outside the boundaries of the input are filled
+            according to the given mode (``'constant'``, ``'nearest'``,
+            ``'mirror'``, ``'reflect'``, ``'wrap'``, ``'grid-mirror'``,
+            ``'grid-wrap'``, ``'grid-constant'`` or ``'opencv'``).
+
+    Returns:
+        cupy.ndarray: The result of prefiltering the input.
+
+    .. seealso:: :func:`scipy.spline_filter1d`
+    """
+    if order < 0 or order > 5:
+        raise RuntimeError('spline order not supported')
+    x = input
+    ndim = x.ndim
+    axis = internal._normalize_axis_index(axis, ndim)
+
+    # order 0, 1 don't require reshaping as no CUDA kernel will be called
+    # scalar or size 1 arrays also don't need to be filtered
+    run_kernel = not (order < 2 or x.ndim == 0 or x.shape[axis] == 1)
+    if not run_kernel:
+        output = _util._get_output(output, input)
+        _core.elementwise_copy(x, output)
+        return output
+
+    temp, data_dtype, output_dtype = _get_spline_output(x, output)
+    data_type = cupy._core._scalar.get_typename(temp.dtype)
+    pole_type = cupy._core._scalar.get_typename(temp.real.dtype)
+
+    index_type = _util._get_inttype(input)
+    index_dtype = cupy.int32 if index_type == 'int' else cupy.int64
+
+    n_samples = x.shape[axis]
+    n_signals = x.size // n_samples
+    info = cupy.array((n_signals, n_samples) + x.shape, dtype=index_dtype)
+
+    # empirical choice of block size that seemed to work well
+    block_size = max(2 ** math.ceil(numpy.log2(n_samples / 32)), 8)
+    kern = _spline_prefilter_core.get_raw_spline1d_kernel(
+        axis,
+        ndim,
+        mode,
+        order=order,
+        index_type=index_type,
+        data_type=data_type,
+        pole_type=pole_type,
+        block_size=block_size,
+    )
+
+    # Due to recursive nature, a given line of data must be processed by a
+    # single thread. n_signals lines will be processed in total.
+    block = (block_size,)
+    grid = ((n_signals + block[0] - 1) // block[0],)
+
+    # apply prefilter gain
+    poles = _spline_prefilter_core.get_poles(order=order)
+    temp *= _spline_prefilter_core.get_gain(poles)
+
+    # apply caual + anti-causal IIR spline filters
+    kern(grid, block, (temp, info))
+
+    if isinstance(output, cupy.ndarray) and temp is not output:
+        # copy kernel output into the user-provided output array
+        _core.elementwise_copy(temp, output)
+        return output
+    return temp.astype(output_dtype, copy=False)
+
+
+def spline_filter(input, order=3, output=cupy.float64, mode='mirror'):
+    """Multidimensional spline filter.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        order (int): The order of the spline interpolation, default is 3. Must
+            be in the range 0-5.
+        output (cupy.ndarray or dtype, optional): The array in which to place
+            the output, or the dtype of the returned array. Default is
+            ``numpy.float64``.
+        mode (str): Points outside the boundaries of the input are filled
+            according to the given mode (``'constant'``, ``'nearest'``,
+            ``'mirror'``, ``'reflect'``, ``'wrap'``, ``'grid-mirror'``,
+            ``'grid-wrap'``, ``'grid-constant'`` or ``'opencv'``).
+
+    Returns:
+        cupy.ndarray: The result of prefiltering the input.
+
+    .. seealso:: :func:`scipy.spline_filter1d`
+    """
+    if order < 2 or order > 5:
+        raise RuntimeError('spline order not supported')
+
+    x = input
+    temp, data_dtype, output_dtype = _get_spline_output(x, output)
+    if order not in [0, 1] and input.ndim > 0:
+        for axis in range(x.ndim):
+            spline_filter1d(x, order, axis, output=temp, mode=mode)
+            x = temp
+    if isinstance(output, cupy.ndarray):
+        _core.elementwise_copy(temp, output)
+    else:
+        output = temp
+    if output.dtype != output_dtype:
+        output = output.astype(output_dtype)
+    return output
+
+
+def _check_coordinates(coordinates, order, allow_float32=True):
+    if coordinates.dtype.kind == 'f':
+        if allow_float32:
+            coord_dtype = cupy.promote_types(coordinates.dtype, cupy.float32)
+        else:
+            coord_dtype = cupy.promote_types(coordinates.dtype, cupy.float64)
+        coordinates = coordinates.astype(coord_dtype, copy=False)
+    elif coordinates.dtype.kind in 'iu':
+        if order > 1:
+            # order > 1 (spline) kernels require floating-point coordinates
+            if allow_float32:
+                coord_dtype = cupy.promote_types(
+                    coordinates.dtype, cupy.float32
+                )
+            else:
+                coord_dtype = cupy.promote_types(
+                    coordinates.dtype, cupy.float64
+                )
+            coordinates = coordinates.astype(coord_dtype)
+    else:
+        raise ValueError('coordinates should have floating point dtype')
+    if not coordinates.flags.c_contiguous:
+        coordinates = cupy.ascontiguousarray(coordinates)
+    return coordinates
+
+
+def _prepad_for_spline_filter(input, mode, cval):
+    if mode in ['nearest', 'grid-constant']:
+        # these modes need padding to get accurate boundary values
+        npad = 12  # empirical factor chosen by SciPy
+        if mode == 'grid-constant':
+            kwargs = dict(mode='constant', constant_values=cval)
+        else:
+            kwargs = dict(mode='edge')
+        padded = cupy.pad(input, npad, **kwargs)
+    else:
+        npad = 0
+        padded = input
+    return padded, npad
+
+
+def _filter_input(image, prefilter, mode, cval, order):
+    """Perform spline prefiltering when needed.
+
+    Spline orders > 1 need a prefiltering stage to preserve resolution.
+
+    For boundary modes without analytical spline boundary conditions, some
+    prepadding of the input with cupy.pad is used to maintain accuracy.
+    ``npad`` is an integer corresponding to the amount of padding at each edge
+    of the array.
+    """
+    if not prefilter or order < 2:
+        return (cupy.ascontiguousarray(image), 0)
+    padded, npad = _prepad_for_spline_filter(image, mode, cval)
+    float_dtype = cupy.promote_types(image.dtype, cupy.float32)
+    filtered = spline_filter(padded, order, output=float_dtype, mode=mode)
+    return cupy.ascontiguousarray(filtered), npad
+
+
+def map_coordinates(input, coordinates, output=None, order=3,
+                    mode='constant', cval=0.0, prefilter=True):
+    """Map the input array to new coordinates by interpolation.
+
+    The array of coordinates is used to find, for each point in the output, the
+    corresponding coordinates in the input. The value of the input at those
+    coordinates is determined by spline interpolation of the requested order.
+
+    The shape of the output is derived from that of the coordinate array by
+    dropping the first axis. The values of the array along the first axis are
+    the coordinates in the input array at which the output value is found.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        coordinates (array_like): The coordinates at which ``input`` is
+            evaluated.
+        output (cupy.ndarray or ~cupy.dtype): The array in which to place the
+            output, or the dtype of the returned array.
+        order (int): The order of the spline interpolation, default is 3. Must
+            be in the range 0-5.
+        mode (str): Points outside the boundaries of the input are filled
+            according to the given mode (``'constant'``, ``'nearest'``,
+            ``'mirror'``, ``'reflect'``, ``'wrap'``, ``'grid-mirror'``,
+            ``'grid-wrap'``, ``'grid-constant'`` or ``'opencv'``).
+        cval (scalar): Value used for points outside the boundaries of
+            the input if ``mode='constant'`` or ``mode='opencv'``. Default is
+            0.0
+        prefilter (bool): Determines if the input array is prefiltered with
+            ``spline_filter`` before interpolation. The default is True, which
+            will create a temporary ``float64`` array of filtered values if
+            ``order > 1``. If setting this to False, the output will be
+            slightly blurred if ``order > 1``, unless the input is prefiltered,
+            i.e. it is the result of calling ``spline_filter`` on the original
+            input.
+
+    Returns:
+        cupy.ndarray:
+            The result of transforming the input. The shape of the output is
+            derived from that of ``coordinates`` by dropping the first axis.
+
+    .. seealso:: :func:`scipy.ndimage.map_coordinates`
+    """
+
+    _check_parameter('map_coordinates', order, mode)
+
+    if mode == 'opencv' or mode == '_opencv_edge':
+        input = cupy.pad(input, [(1, 1)] * input.ndim, 'constant',
+                         constant_values=cval)
+        coordinates = cupy.add(coordinates, 1)
+        mode = 'constant'
+
+    ret = _util._get_output(output, input, coordinates.shape[1:])
+    integer_output = ret.dtype.kind in 'iu'
+    _util._check_cval(mode, cval, integer_output)
+
+    if input.dtype.kind in 'iu':
+        input = input.astype(cupy.float32)
+    coordinates = _check_coordinates(coordinates, order)
+    filtered, nprepad = _filter_input(input, prefilter, mode, cval, order)
+    large_int = max(_prod(input.shape), coordinates.shape[0]) > 1 << 31
+    kern = _interp_kernels._get_map_kernel(
+        input.ndim, large_int, yshape=coordinates.shape, mode=mode, cval=cval,
+        order=order, integer_output=integer_output, nprepad=nprepad)
+    kern(filtered, coordinates, ret)
+    return ret
+
+
+def affine_transform(input, matrix, offset=0.0, output_shape=None, output=None,
+                     order=3, mode='constant', cval=0.0, prefilter=True, *,
+                     texture_memory=False):
+    """Apply an affine transformation.
+
+    Given an output image pixel index vector ``o``, the pixel value is
+    determined from the input image at position
+    ``cupy.dot(matrix, o) + offset``.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        matrix (cupy.ndarray): The inverse coordinate transformation matrix,
+            mapping output coordinates to input coordinates. If ``ndim`` is the
+            number of dimensions of ``input``, the given matrix must have one
+            of the following shapes:
+
+                - ``(ndim, ndim)``: the linear transformation matrix for each
+                  output coordinate.
+                - ``(ndim,)``: assume that the 2D transformation matrix is
+                  diagonal, with the diagonal specified by the given value.
+                - ``(ndim + 1, ndim + 1)``: assume that the transformation is
+                  specified using homogeneous coordinates. In this case, any
+                  value passed to ``offset`` is ignored.
+                - ``(ndim, ndim + 1)``: as above, but the bottom row of a
+                  homogeneous transformation matrix is always
+                  ``[0, 0, ..., 1]``, and may be omitted.
+
+        offset (float or sequence): The offset into the array where the
+            transform is applied. If a float, ``offset`` is the same for each
+            axis. If a sequence, ``offset`` should contain one value for each
+            axis.
+        output_shape (tuple of ints): Shape tuple.
+        output (cupy.ndarray or ~cupy.dtype): The array in which to place the
+            output, or the dtype of the returned array.
+        order (int): The order of the spline interpolation, default is 3. Must
+            be in the range 0-5.
+        mode (str): Points outside the boundaries of the input are filled
+            according to the given mode (``'constant'``, ``'nearest'``,
+            ``'mirror'``, ``'reflect'``, ``'wrap'``, ``'grid-mirror'``,
+            ``'grid-wrap'``, ``'grid-constant'`` or ``'opencv'``).
+        cval (scalar): Value used for points outside the boundaries of
+            the input if ``mode='constant'`` or ``mode='opencv'``. Default is
+            0.0
+        prefilter (bool): Determines if the input array is prefiltered with
+            ``spline_filter`` before interpolation. The default is True, which
+            will create a temporary ``float64`` array of filtered values if
+            ``order > 1``. If setting this to False, the output will be
+            slightly blurred if ``order > 1``, unless the input is prefiltered,
+            i.e. it is the result of calling ``spline_filter`` on the original
+            input.
+        texture_memory (bool): If True, uses GPU texture memory. Supports only:
+
+            - 2D and 3D float32 arrays as input
+            - ``(ndim + 1, ndim + 1)`` homogeneous float32 transformation
+                matrix
+            - ``mode='constant'`` and ``mode='nearest'``
+            - ``order=0`` (nearest neighbor) and ``order=1`` (linear
+                interpolation)
+            - NVIDIA CUDA GPUs
+
+    Returns:
+        cupy.ndarray or None:
+            The transformed input. If ``output`` is given as a parameter,
+            ``None`` is returned.
+
+    .. seealso:: :func:`scipy.ndimage.affine_transform`
+    """
+
+    if texture_memory:
+        if runtime.is_hip:
+            raise RuntimeError(
+                'HIP currently does not support texture acceleration')
+        tm_interp = 'linear' if order > 0 else 'nearest'
+        return _texture.affine_transformation(data=input,
+                                              transformation_matrix=matrix,
+                                              output_shape=output_shape,
+                                              output=output,
+                                              interpolation=tm_interp,
+                                              mode=mode,
+                                              border_value=cval)
+
+    _check_parameter('affine_transform', order, mode)
+
+    offset = _util._fix_sequence_arg(offset, input.ndim, 'offset', float)
+
+    if matrix.ndim not in [1, 2] or matrix.shape[0] < 1:
+        raise RuntimeError('no proper affine matrix provided')
+    if matrix.ndim == 2:
+        if matrix.shape[0] == matrix.shape[1] - 1:
+            offset = matrix[:, -1]
+            matrix = matrix[:, :-1]
+        elif matrix.shape[0] == input.ndim + 1:
+            offset = matrix[:-1, -1]
+            matrix = matrix[:-1, :-1]
+        if matrix.shape != (input.ndim, input.ndim):
+            raise RuntimeError('improper affine shape')
+
+    if mode == 'opencv':
+        m = cupy.zeros((input.ndim + 1, input.ndim + 1))
+        m[:-1, :-1] = matrix
+        m[:-1, -1] = offset
+        m[-1, -1] = 1
+        m = cupy.linalg.inv(m)
+        m[:2] = cupy.roll(m[:2], 1, axis=0)
+        m[:2, :2] = cupy.roll(m[:2, :2], 1, axis=1)
+        matrix = m[:-1, :-1]
+        offset = m[:-1, -1]
+
+    if output_shape is None:
+        output_shape = input.shape
+
+    if mode == 'opencv' or mode == '_opencv_edge':
+        if matrix.ndim == 1:
+            matrix = cupy.diag(matrix)
+        coordinates = cupy.indices(output_shape, dtype=cupy.float64)
+        coordinates = cupy.dot(matrix, coordinates.reshape((input.ndim, -1)))
+        coordinates += cupy.expand_dims(cupy.asarray(offset), -1)
+        ret = _util._get_output(output, input, shape=output_shape)
+        ret[:] = map_coordinates(input, coordinates, ret.dtype, order, mode,
+                                 cval, prefilter).reshape(output_shape)
+        return ret
+
+    matrix = matrix.astype(cupy.float64, copy=False)
+    ndim = input.ndim
+    output = _util._get_output(output, input, shape=output_shape)
+    if input.dtype.kind in 'iu':
+        input = input.astype(cupy.float32)
+    filtered, nprepad = _filter_input(input, prefilter, mode, cval, order)
+
+    integer_output = output.dtype.kind in 'iu'
+    _util._check_cval(mode, cval, integer_output)
+    large_int = max(_prod(input.shape), _prod(output_shape)) > 1 << 31
+    if matrix.ndim == 1:
+        offset = cupy.asarray(offset, dtype=cupy.float64)
+        offset = -offset / matrix
+        kern = _interp_kernels._get_zoom_shift_kernel(
+            ndim, large_int, output_shape, mode, cval=cval, order=order,
+            integer_output=integer_output, nprepad=nprepad)
+        kern(filtered, offset, matrix, output)
+    else:
+        kern = _interp_kernels._get_affine_kernel(
+            ndim, large_int, output_shape, mode, cval=cval, order=order,
+            integer_output=integer_output, nprepad=nprepad)
+        m = cupy.zeros((ndim, ndim + 1), dtype=cupy.float64)
+        m[:, :-1] = matrix
+        m[:, -1] = cupy.asarray(offset, dtype=cupy.float64)
+        kern(filtered, m, output)
+    return output
+
+
+def _minmax(coor, minc, maxc):
+    if coor[0] < minc[0]:
+        minc[0] = coor[0]
+    if coor[0] > maxc[0]:
+        maxc[0] = coor[0]
+    if coor[1] < minc[1]:
+        minc[1] = coor[1]
+    if coor[1] > maxc[1]:
+        maxc[1] = coor[1]
+    return minc, maxc
+
+
+def rotate(input, angle, axes=(1, 0), reshape=True, output=None, order=3,
+           mode='constant', cval=0.0, prefilter=True):
+    """Rotate an array.
+
+    The array is rotated in the plane defined by the two axes given by the
+    ``axes`` parameter using spline interpolation of the requested order.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        angle (float): The rotation angle in degrees.
+        axes (tuple of 2 ints): The two axes that define the plane of rotation.
+            Default is the first two axes.
+        reshape (bool): If ``reshape`` is True, the output shape is adapted so
+            that the input array is contained completely in the output. Default
+            is True.
+        output (cupy.ndarray or ~cupy.dtype): The array in which to place the
+            output, or the dtype of the returned array.
+        order (int): The order of the spline interpolation, default is 3. Must
+            be in the range 0-5.
+        mode (str): Points outside the boundaries of the input are filled
+            according to the given mode (``'constant'``, ``'nearest'``,
+            ``'mirror'``, ``'reflect'``, ``'wrap'``, ``'grid-mirror'``,
+            ``'grid-wrap'``, ``'grid-constant'`` or ``'opencv'``).
+        cval (scalar): Value used for points outside the boundaries of
+            the input if ``mode='constant'`` or ``mode='opencv'``. Default is
+            0.0
+        prefilter (bool): Determines if the input array is prefiltered with
+            ``spline_filter`` before interpolation. The default is True, which
+            will create a temporary ``float64`` array of filtered values if
+            ``order > 1``. If setting this to False, the output will be
+            slightly blurred if ``order > 1``, unless the input is prefiltered,
+            i.e. it is the result of calling ``spline_filter`` on the original
+            input.
+
+    Returns:
+        cupy.ndarray or None:
+            The rotated input.
+
+    .. seealso:: :func:`scipy.ndimage.rotate`
+    """
+
+    _check_parameter('rotate', order, mode)
+
+    if mode == 'opencv':
+        mode = '_opencv_edge'
+
+    input_arr = input
+    axes = list(axes)
+    if axes[0] < 0:
+        axes[0] += input_arr.ndim
+    if axes[1] < 0:
+        axes[1] += input_arr.ndim
+    if axes[0] > axes[1]:
+        axes = [axes[1], axes[0]]
+    if axes[0] < 0 or input_arr.ndim <= axes[1]:
+        raise ValueError('invalid rotation plane specified')
+
+    ndim = input_arr.ndim
+    rad = numpy.deg2rad(angle)
+    sin = math.sin(rad)
+    cos = math.cos(rad)
+
+    # determine offsets and output shape as in scipy.ndimage.rotate
+    rot_matrix = numpy.array([[cos, sin],
+                              [-sin, cos]])
+
+    img_shape = numpy.asarray(input_arr.shape)
+    in_plane_shape = img_shape[axes]
+    if reshape:
+        # Compute transformed input bounds
+        iy, ix = in_plane_shape
+        out_bounds = rot_matrix @ [[0, 0, iy, iy],
+                                   [0, ix, 0, ix]]
+        # Compute the shape of the transformed input plane
+        out_plane_shape = (numpy.ptp(out_bounds, axis=1) +
+                           0.5).astype(cupy.int64)
+    else:
+        out_plane_shape = img_shape[axes]
+
+    out_center = rot_matrix @ ((out_plane_shape - 1) / 2)
+    in_center = (in_plane_shape - 1) / 2
+
+    output_shape = img_shape
+    output_shape[axes] = out_plane_shape
+    output_shape = tuple(output_shape)
+
+    matrix = numpy.identity(ndim)
+    matrix[axes[0], axes[0]] = cos
+    matrix[axes[0], axes[1]] = sin
+    matrix[axes[1], axes[0]] = -sin
+    matrix[axes[1], axes[1]] = cos
+
+    offset = numpy.zeros(ndim, dtype=cupy.float64)
+    offset[axes] = in_center - out_center
+
+    matrix = cupy.asarray(matrix)
+    offset = cupy.asarray(offset)
+
+    return affine_transform(input, matrix, offset, output_shape, output, order,
+                            mode, cval, prefilter)
+
+
+def shift(input, shift, output=None, order=3, mode='constant', cval=0.0,
+          prefilter=True):
+    """Shift an array.
+
+    The array is shifted using spline interpolation of the requested order.
+    Points outside the boundaries of the input are filled according to the
+    given mode.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        shift (float or sequence): The shift along the axes. If a float,
+            ``shift`` is the same for each axis. If a sequence, ``shift``
+            should contain one value for each axis.
+        output (cupy.ndarray or ~cupy.dtype): The array in which to place the
+            output, or the dtype of the returned array.
+        order (int): The order of the spline interpolation, default is 3. Must
+            be in the range 0-5.
+        mode (str): Points outside the boundaries of the input are filled
+            according to the given mode (``'constant'``, ``'nearest'``,
+            ``'mirror'``, ``'reflect'``, ``'wrap'``, ``'grid-mirror'``,
+            ``'grid-wrap'``, ``'grid-constant'`` or ``'opencv'``).
+        cval (scalar): Value used for points outside the boundaries of
+            the input if ``mode='constant'`` or ``mode='opencv'``. Default is
+            0.0
+        prefilter (bool): Determines if the input array is prefiltered with
+            ``spline_filter`` before interpolation. The default is True, which
+            will create a temporary ``float64`` array of filtered values if
+            ``order > 1``. If setting this to False, the output will be
+            slightly blurred if ``order > 1``, unless the input is prefiltered,
+            i.e. it is the result of calling ``spline_filter`` on the original
+            input.
+
+    Returns:
+        cupy.ndarray or None:
+            The shifted input.
+
+    .. seealso:: :func:`scipy.ndimage.shift`
+    """
+
+    _check_parameter('shift', order, mode)
+
+    shift = _util._fix_sequence_arg(shift, input.ndim, 'shift', float)
+
+    if mode == 'opencv':
+        mode = '_opencv_edge'
+
+        output = affine_transform(
+            input,
+            cupy.ones(input.ndim, input.dtype),
+            cupy.negative(cupy.asarray(shift)),
+            None,
+            output,
+            order,
+            mode,
+            cval,
+            prefilter,
+        )
+    else:
+        output = _util._get_output(output, input)
+        if input.dtype.kind in 'iu':
+            input = input.astype(cupy.float32)
+        filtered, nprepad = _filter_input(input, prefilter, mode, cval, order)
+        integer_output = output.dtype.kind in 'iu'
+        _util._check_cval(mode, cval, integer_output)
+        large_int = _prod(input.shape) > 1 << 31
+        kern = _interp_kernels._get_shift_kernel(
+            input.ndim, large_int, input.shape, mode, cval=cval, order=order,
+            integer_output=integer_output, nprepad=nprepad)
+        shift = cupy.asarray(shift, dtype=cupy.float64, order='C')
+        if shift.ndim != 1:
+            raise ValueError('shift must be 1d')
+        if shift.size != filtered.ndim:
+            raise ValueError('len(shift) must equal input.ndim')
+        kern(filtered, shift, output)
+    return output
+
+
+def zoom(input, zoom, output=None, order=3, mode='constant', cval=0.0,
+         prefilter=True, *, grid_mode=False):
+    """Zoom an array.
+
+    The array is zoomed using spline interpolation of the requested order.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        zoom (float or sequence): The zoom factor along the axes. If a float,
+            ``zoom`` is the same for each axis. If a sequence, ``zoom`` should
+            contain one value for each axis.
+        output (cupy.ndarray or ~cupy.dtype): The array in which to place the
+            output, or the dtype of the returned array.
+        order (int): The order of the spline interpolation, default is 3. Must
+            be in the range 0-5.
+        mode (str): Points outside the boundaries of the input are filled
+            according to the given mode (``'constant'``, ``'nearest'``,
+            ``'mirror'``, ``'reflect'``, ``'wrap'``, ``'grid-mirror'``,
+            ``'grid-wrap'``, ``'grid-constant'`` or ``'opencv'``).
+        cval (scalar): Value used for points outside the boundaries of
+            the input if ``mode='constant'`` or ``mode='opencv'``. Default is
+            0.0
+        prefilter (bool): Determines if the input array is prefiltered with
+            ``spline_filter`` before interpolation. The default is True, which
+            will create a temporary ``float64`` array of filtered values if
+            ``order > 1``. If setting this to False, the output will be
+            slightly blurred if ``order > 1``, unless the input is prefiltered,
+            i.e. it is the result of calling ``spline_filter`` on the original
+            input.
+        grid_mode (bool, optional): If False, the distance from the pixel
+            centers is zoomed. Otherwise, the distance including the full pixel
+            extent is used. For example, a 1d signal of length 5 is considered
+            to have length 4 when ``grid_mode`` is False, but length 5 when
+            ``grid_mode`` is True. See the following visual illustration:
+
+            .. code-block:: text
+
+                    | pixel 1 | pixel 2 | pixel 3 | pixel 4 | pixel 5 |
+                         |<-------------------------------------->|
+                                            vs.
+                    |<----------------------------------------------->|
+
+            The starting point of the arrow in the diagram above corresponds to
+            coordinate location 0 in each mode.
+
+    Returns:
+        cupy.ndarray or None:
+            The zoomed input.
+
+    .. seealso:: :func:`scipy.ndimage.zoom`
+    """
+
+    _check_parameter('zoom', order, mode)
+
+    zoom = _util._fix_sequence_arg(zoom, input.ndim, 'zoom', float)
+
+    output_shape = []
+    for s, z in zip(input.shape, zoom):
+        output_shape.append(int(round(s * z)))
+    output_shape = tuple(output_shape)
+
+    if mode == 'opencv':
+        zoom = []
+        offset = []
+        for in_size, out_size in zip(input.shape, output_shape):
+            if out_size > 0:
+                zoom.append(float(in_size) / out_size)
+                offset.append((zoom[-1] - 1) / 2.0)
+            else:
+                zoom.append(0)
+                offset.append(0)
+        mode = 'nearest'
+
+        output = affine_transform(
+            input,
+            cupy.asarray(zoom),
+            offset,
+            output_shape,
+            output,
+            order,
+            mode,
+            cval,
+            prefilter,
+        )
+    else:
+        if grid_mode:
+
+            # warn about modes that may have surprising behavior
+            suggest_mode = None
+            if mode == 'constant':
+                suggest_mode = 'grid-constant'
+            elif mode == 'wrap':
+                suggest_mode = 'grid-wrap'
+            if suggest_mode is not None:
+                warnings.warn(
+                    f'It is recommended to use mode = {suggest_mode} instead '
+                    f'of {mode} when grid_mode is True.')
+
+        zoom = []
+        for in_size, out_size in zip(input.shape, output_shape):
+            if grid_mode and out_size > 0:
+                zoom.append(in_size / out_size)
+            elif out_size > 1:
+                zoom.append((in_size - 1) / (out_size - 1))
+            else:
+                zoom.append(0)
+
+        output = _util._get_output(output, input, shape=output_shape)
+        if input.dtype.kind in 'iu':
+            input = input.astype(cupy.float32)
+        filtered, nprepad = _filter_input(input, prefilter, mode, cval, order)
+        integer_output = output.dtype.kind in 'iu'
+        _util._check_cval(mode, cval, integer_output)
+        large_int = max(_prod(input.shape), _prod(output_shape)) > 1 << 31
+        kern = _interp_kernels._get_zoom_kernel(
+            input.ndim, large_int, output_shape, mode, order=order,
+            integer_output=integer_output, grid_mode=grid_mode,
+            nprepad=nprepad)
+        zoom = cupy.asarray(zoom, dtype=cupy.float64)
+        kern(filtered, zoom, output)
+    return output

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/_measurements.py

@@ -0,0 +1,1380 @@
+import warnings
+
+import numpy
+
+import cupy
+from cupy import _core
+from cupy import _util
+
+
+def label(input, structure=None, output=None):
+    """Labels features in an array.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        structure (array_like or None): A structuring element that defines
+            feature connections. ```structure``` must be centersymmetric. If
+            None, structure is automatically generated with a squared
+            connectivity equal to one.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output.
+    Returns:
+        label (cupy.ndarray): An integer array where each unique feature in
+        ```input``` has a unique label in the array.
+
+        num_features (int): Number of features found.
+
+    .. warning::
+
+        This function may synchronize the device.
+
+    .. seealso:: :func:`scipy.ndimage.label`
+    """
+    if not isinstance(input, cupy.ndarray):
+        raise TypeError('input must be cupy.ndarray')
+    if input.dtype.char in 'FD':
+        raise TypeError('Complex type not supported')
+    if structure is None:
+        structure = _generate_binary_structure(input.ndim, 1)
+    elif isinstance(structure, cupy.ndarray):
+        structure = cupy.asnumpy(structure)
+    structure = numpy.array(structure, dtype=bool)
+    if structure.ndim != input.ndim:
+        raise RuntimeError('structure and input must have equal rank')
+    for i in structure.shape:
+        if i != 3:
+            raise ValueError('structure dimensions must be equal to 3')
+
+    if isinstance(output, cupy.ndarray):
+        if output.shape != input.shape:
+            raise ValueError("output shape not correct")
+        caller_provided_output = True
+    else:
+        caller_provided_output = False
+        if output is None:
+            output = cupy.empty(input.shape, numpy.int32)
+        else:
+            output = cupy.empty(input.shape, output)
+
+    if input.size == 0:
+        # empty
+        maxlabel = 0
+    elif input.ndim == 0:
+        # 0-dim array
+        maxlabel = 0 if input.item() == 0 else 1
+        output.fill(maxlabel)
+    else:
+        if output.dtype != numpy.int32:
+            y = cupy.empty(input.shape, numpy.int32)
+        else:
+            y = output
+        maxlabel = _label(input, structure, y)
+        if output.dtype != numpy.int32:
+            _core.elementwise_copy(y, output)
+
+    if caller_provided_output:
+        return maxlabel
+    else:
+        return output, maxlabel
+
+
+def _generate_binary_structure(rank, connectivity):
+    if connectivity < 1:
+        connectivity = 1
+    if rank < 1:
+        return numpy.array(True, dtype=bool)
+    output = numpy.fabs(numpy.indices([3] * rank) - 1)
+    output = numpy.add.reduce(output, 0)
+    return output <= connectivity
+
+
+def _label(x, structure, y):
+    elems = numpy.where(structure != 0)
+    vecs = [elems[dm] - 1 for dm in range(x.ndim)]
+    offset = vecs[0]
+    for dm in range(1, x.ndim):
+        offset = offset * 3 + vecs[dm]
+    indxs = numpy.where(offset < 0)[0]
+    dirs = [[vecs[dm][dr] for dm in range(x.ndim)] for dr in indxs]
+    dirs = cupy.array(dirs, dtype=numpy.int32)
+    ndirs = indxs.shape[0]
+    y_shape = cupy.array(y.shape, dtype=numpy.int32)
+    count = cupy.zeros(2, dtype=numpy.int32)
+    _kernel_init()(x, y)
+    _kernel_connect()(y_shape, dirs, ndirs, x.ndim, y, size=y.size)
+    _kernel_count()(y, count, size=y.size)
+    maxlabel = int(count[0])
+    labels = cupy.empty(maxlabel, dtype=numpy.int32)
+    _kernel_labels()(y, count, labels, size=y.size)
+    _kernel_finalize()(maxlabel, cupy.sort(labels), y, size=y.size)
+    return maxlabel
+
+
+def _kernel_init():
+    return _core.ElementwiseKernel(
+        'X x', 'Y y', 'if (x == 0) { y = -1; } else { y = i; }',
+        'cupyx_scipy_ndimage_label_init')
+
+
+def _kernel_connect():
+    return _core.ElementwiseKernel(
+        'raw int32 shape, raw int32 dirs, int32 ndirs, int32 ndim',
+        'raw Y y',
+        '''
+        if (y[i] < 0) continue;
+        for (int dr = 0; dr < ndirs; dr++) {
+            int j = i;
+            int rest = j;
+            int stride = 1;
+            int k = 0;
+            for (int dm = ndim-1; dm >= 0; dm--) {
+                int pos = rest % shape[dm] + dirs[dm + dr * ndim];
+                if (pos < 0 || pos >= shape[dm]) {
+                    k = -1;
+                    break;
+                }
+                k += pos * stride;
+                rest /= shape[dm];
+                stride *= shape[dm];
+            }
+            if (k < 0) continue;
+            if (y[k] < 0) continue;
+            while (1) {
+                while (j != y[j]) { j = y[j]; }
+                while (k != y[k]) { k = y[k]; }
+                if (j == k) break;
+                if (j < k) {
+                    int old = atomicCAS( &y[k], k, j );
+                    if (old == k) break;
+                    k = old;
+                }
+                else {
+                    int old = atomicCAS( &y[j], j, k );
+                    if (old == j) break;
+                    j = old;
+                }
+            }
+        }
+        ''',
+        'cupyx_scipy_ndimage_label_connect')
+
+
+def _kernel_count():
+    return _core.ElementwiseKernel(
+        '', 'raw Y y, raw int32 count',
+        '''
+        if (y[i] < 0) continue;
+        int j = i;
+        while (j != y[j]) { j = y[j]; }
+        if (j != i) y[i] = j;
+        else atomicAdd(&count[0], 1);
+        ''',
+        'cupyx_scipy_ndimage_label_count')
+
+
+def _kernel_labels():
+    return _core.ElementwiseKernel(
+        '', 'raw Y y, raw int32 count, raw int32 labels',
+        '''
+        if (y[i] != i) continue;
+        int j = atomicAdd(&count[1], 1);
+        labels[j] = i;
+        ''',
+        'cupyx_scipy_ndimage_label_labels')
+
+
+def _kernel_finalize():
+    return _core.ElementwiseKernel(
+        'int32 maxlabel', 'raw int32 labels, raw Y y',
+        '''
+        if (y[i] < 0) {
+            y[i] = 0;
+            continue;
+        }
+        int yi = y[i];
+        int j_min = 0;
+        int j_max = maxlabel - 1;
+        int j = (j_min + j_max) / 2;
+        while (j_min < j_max) {
+            if (yi == labels[j]) break;
+            if (yi < labels[j]) j_max = j - 1;
+            else j_min = j + 1;
+            j = (j_min + j_max) / 2;
+        }
+        y[i] = j + 1;
+        ''',
+        'cupyx_scipy_ndimage_label_finalize')
+
+
+_ndimage_variance_kernel = _core.ElementwiseKernel(
+    'T input, R labels, raw X index, uint64 size, raw float64 mean',
+    'raw float64 out',
+    """
+    for (ptrdiff_t j = 0; j < size; j++) {
+      if (labels == index[j]) {
+        atomicAdd(&out[j], (input - mean[j]) * (input - mean[j]));
+        break;
+      }
+    }
+    """,
+    'cupyx_scipy_ndimage_variance')
+
+
+_ndimage_sum_kernel = _core.ElementwiseKernel(
+    'T input, R labels, raw X index, uint64 size',
+    'raw float64 out',
+    """
+    for (ptrdiff_t j = 0; j < size; j++) {
+      if (labels == index[j]) {
+        atomicAdd(&out[j], input);
+        break;
+      }
+    }
+    """,
+    'cupyx_scipy_ndimage_sum')
+
+
+def _ndimage_sum_kernel_2(input, labels, index, sum_val, batch_size=4):
+    for i in range(0, index.size, batch_size):
+        matched = labels == index[i:i + batch_size].reshape(
+            (-1,) + (1,) * input.ndim)
+        sum_axes = tuple(range(1, 1 + input.ndim))
+        sum_val[i:i + batch_size] = cupy.where(matched, input, 0).sum(
+            axis=sum_axes)
+    return sum_val
+
+
+_ndimage_mean_kernel = _core.ElementwiseKernel(
+    'T input, R labels, raw X index, uint64 size',
+    'raw float64 out, raw uint64 count',
+    """
+    for (ptrdiff_t j = 0; j < size; j++) {
+      if (labels == index[j]) {
+        atomicAdd(&out[j], input);
+        atomicAdd(&count[j], 1);
+        break;
+      }
+    }
+    """,
+    'cupyx_scipy_ndimage_mean')
+
+
+def _ndimage_mean_kernel_2(input, labels, index, batch_size=4,
+                           return_count=False):
+    sum_val = cupy.empty_like(index, dtype=cupy.float64)
+    count = cupy.empty_like(index, dtype=cupy.uint64)
+    for i in range(0, index.size, batch_size):
+        matched = labels == index[i:i + batch_size].reshape(
+            (-1,) + (1,) * input.ndim)
+        mean_axes = tuple(range(1, 1 + input.ndim))
+        count[i:i + batch_size] = matched.sum(axis=mean_axes)
+        sum_val[i:i + batch_size] = cupy.where(matched, input, 0).sum(
+            axis=mean_axes)
+    if return_count:
+        return sum_val / count, count
+    return sum_val / count
+
+
+def _mean_driver(input, labels, index, return_count=False, use_kern=False):
+    if use_kern:
+        return _ndimage_mean_kernel_2(input, labels, index,
+                                      return_count=return_count)
+
+    out = cupy.zeros_like(index, cupy.float64)
+    count = cupy.zeros_like(index, dtype=cupy.uint64)
+    sum, count = _ndimage_mean_kernel(input,
+                                      labels, index, index.size, out, count)
+    if return_count:
+        return sum / count, count
+    return sum / count
+
+
+def variance(input, labels=None, index=None):
+    """Calculates the variance of the values of an n-D image array, optionally
+    at specified sub-regions.
+
+    Args:
+        input (cupy.ndarray): Nd-image data to process.
+        labels (cupy.ndarray or None): Labels defining sub-regions in `input`.
+            If not None, must be same shape as `input`.
+        index (cupy.ndarray or None): `labels` to include in output. If None
+            (default), all values where `labels` is non-zero are used.
+
+    Returns:
+        cupy.ndarray: Values of variance, for each sub-region if
+        `labels` and `index` are specified.
+
+    .. seealso:: :func:`scipy.ndimage.variance`
+    """
+    if not isinstance(input, cupy.ndarray):
+        raise TypeError('input must be cupy.ndarray')
+
+    if input.dtype in (cupy.complex64, cupy.complex128):
+        raise TypeError("cupyx.scipy.ndimage.variance doesn't support %{}"
+                        "".format(input.dtype.type))
+
+    use_kern = False
+    # There are constraints on types because of atomicAdd() in CUDA.
+    if input.dtype not in [cupy.int32, cupy.float16, cupy.float32,
+                           cupy.float64, cupy.uint32, cupy.uint64,
+                           cupy.ulonglong]:
+        warnings.warn(
+            'Using the slower implementation because the provided '
+            f'type {input.dtype} is not supported by cupyx.scipy.ndimage.sum. '
+            'Consider using an array of type int32, float16, '
+            'float32, float64, uint32, uint64 as data types '
+            'for the fast implementation', _util.PerformanceWarning)
+        use_kern = True
+
+    def calc_var_with_intermediate_float(input):
+        vals_c = input - input.mean()
+        count = vals_c.size
+        # Does not use `ndarray.mean()` here to return the same results as
+        # SciPy does, especially in case `input`'s dtype is float16.
+        return cupy.square(vals_c).sum() / cupy.asanyarray(count).astype(float)
+
+    if labels is None:
+        return calc_var_with_intermediate_float(input)
+
+    if not isinstance(labels, cupy.ndarray):
+        raise TypeError('label must be cupy.ndarray')
+
+    input, labels = cupy.broadcast_arrays(input, labels)
+
+    if index is None:
+        return calc_var_with_intermediate_float(input[labels > 0])
+
+    if cupy.isscalar(index):
+        return calc_var_with_intermediate_float(input[labels == index])
+
+    if not isinstance(index, cupy.ndarray):
+        if not isinstance(index, int):
+            raise TypeError('index must be cupy.ndarray or a scalar int')
+        else:
+            return (input[labels == index]).var().astype(cupy.float64,
+                                                         copy=False)
+
+    mean_val, count = _mean_driver(input, labels, index, True, use_kern)
+    if use_kern:
+        new_axis = (..., *(cupy.newaxis for _ in range(input.ndim)))
+        return cupy.where(labels[None, ...] == index[new_axis],
+                          cupy.square(input - mean_val[new_axis]),
+                          0).sum(tuple(range(1, input.ndim + 1))) / count
+    out = cupy.zeros_like(index, dtype=cupy.float64)
+    return _ndimage_variance_kernel(input, labels, index, index.size, mean_val,
+                                    out) / count
+
+
+def sum_labels(input, labels=None, index=None):
+    """Calculates the sum of the values of an n-D image array, optionally
+       at specified sub-regions.
+
+    Args:
+        input (cupy.ndarray): Nd-image data to process.
+        labels (cupy.ndarray or None): Labels defining sub-regions in `input`.
+            If not None, must be same shape as `input`.
+        index (cupy.ndarray or None): `labels` to include in output. If None
+            (default), all values where `labels` is non-zero are used.
+
+    Returns:
+       sum (cupy.ndarray): sum of values, for each sub-region if
+       `labels` and `index` are specified.
+
+    .. seealso:: :func:`scipy.ndimage.sum_labels`
+    """
+    if not isinstance(input, cupy.ndarray):
+        raise TypeError('input must be cupy.ndarray')
+
+    if input.dtype in (cupy.complex64, cupy.complex128):
+        raise TypeError("cupyx.scipy.ndimage.sum does not support %{}".format(
+            input.dtype.type))
+
+    use_kern = False
+    # There is constraints on types because of atomicAdd() in CUDA.
+    if input.dtype not in [cupy.int32, cupy.float16, cupy.float32,
+                           cupy.float64, cupy.uint32, cupy.uint64,
+                           cupy.ulonglong]:
+        warnings.warn(
+            'Using the slower implementation as '
+            'cupyx.scipy.ndimage.sum supports int32, float16, '
+            'float32, float64, uint32, uint64 as data types'
+            'for the fast implmentation', _util.PerformanceWarning)
+        use_kern = True
+
+    if labels is None:
+        return input.sum()
+
+    if not isinstance(labels, cupy.ndarray):
+        raise TypeError('label must be cupy.ndarray')
+
+    input, labels = cupy.broadcast_arrays(input, labels)
+
+    if index is None:
+        return input[labels != 0].sum()
+
+    if not isinstance(index, cupy.ndarray):
+        if not isinstance(index, int):
+            raise TypeError('index must be cupy.ndarray or a scalar int')
+        else:
+            return (input[labels == index]).sum()
+
+    if index.size == 0:
+        return cupy.array([], dtype=cupy.int64)
+
+    out = cupy.zeros_like(index, dtype=cupy.float64)
+
+    # The following parameters for sum where determined using a Tesla P100.
+    if (input.size >= 262144 and index.size <= 4) or use_kern:
+        return _ndimage_sum_kernel_2(input, labels, index, out)
+    return _ndimage_sum_kernel(input, labels, index, index.size, out)
+
+
+def sum(input, labels=None, index=None):
+    """Calculates the sum of the values of an n-D image array, optionally
+       at specified sub-regions.
+
+    Args:
+        input (cupy.ndarray): Nd-image data to process.
+        labels (cupy.ndarray or None): Labels defining sub-regions in `input`.
+            If not None, must be same shape as `input`.
+        index (cupy.ndarray or None): `labels` to include in output. If None
+            (default), all values where `labels` is non-zero are used.
+
+    Returns:
+       sum (cupy.ndarray): sum of values, for each sub-region if
+       `labels` and `index` are specified.
+
+    Notes:
+        This is an alias for `cupyx.scipy.ndimage.sum_labels` kept for
+        backwards compatibility reasons. For new code please prefer
+        `sum_labels`.
+
+    .. seealso:: :func:`scipy.ndimage.sum`
+    """
+    return sum_labels(input, labels, index)
+
+
+def mean(input, labels=None, index=None):
+    """Calculates the mean of the values of an n-D image array, optionally
+       at specified sub-regions.
+
+    Args:
+        input (cupy.ndarray): Nd-image data to process.
+        labels (cupy.ndarray or None): Labels defining sub-regions in `input`.
+            If not None, must be same shape as `input`.
+        index (cupy.ndarray or None): `labels` to include in output. If None
+            (default), all values where `labels` is non-zero are used.
+
+    Returns:
+        mean (cupy.ndarray): mean of values, for each sub-region if
+        `labels` and `index` are specified.
+
+
+    .. seealso:: :func:`scipy.ndimage.mean`
+    """
+    if not isinstance(input, cupy.ndarray):
+        raise TypeError('input must be cupy.ndarray')
+
+    if input.dtype in (cupy.complex64, cupy.complex128):
+        raise TypeError("cupyx.scipy.ndimage.mean does not support %{}".format(
+            input.dtype.type))
+
+    use_kern = False
+    # There is constraints on types because of atomicAdd() in CUDA.
+    if input.dtype not in [cupy.int32, cupy.float16, cupy.float32,
+                           cupy.float64, cupy.uint32, cupy.uint64,
+                           cupy.ulonglong]:
+        warnings.warn(
+            'Using the slower implementation as '
+            'cupyx.scipy.ndimage.mean supports int32, float16, '
+            'float32, float64, uint32, uint64 as data types '
+            'for the fast implmentation', _util.PerformanceWarning)
+        use_kern = True
+
+    def calc_mean_with_intermediate_float(input):
+        sum = input.sum()
+        count = input.size
+        # Does not use `ndarray.mean()` here to return the same results as
+        # SciPy does, especially in case `input`'s dtype is float16.
+        return sum / cupy.asanyarray(count).astype(float)
+
+    if labels is None:
+        return calc_mean_with_intermediate_float(input)
+
+    if not isinstance(labels, cupy.ndarray):
+        raise TypeError('label must be cupy.ndarray')
+
+    input, labels = cupy.broadcast_arrays(input, labels)
+
+    if index is None:
+        return calc_mean_with_intermediate_float(input[labels > 0])
+
+    if cupy.isscalar(index):
+        return calc_mean_with_intermediate_float(input[labels == index])
+
+    if not isinstance(index, cupy.ndarray):
+        if not isinstance(index, int):
+            raise TypeError('index must be cupy.ndarray or a scalar int')
+        else:
+            return (input[labels == index]).mean(dtype=cupy.float64)
+
+    return _mean_driver(input, labels, index, use_kern=use_kern)
+
+
+def standard_deviation(input, labels=None, index=None):
+    """Calculates the standard deviation of the values of an n-D image array,
+    optionally at specified sub-regions.
+
+    Args:
+        input (cupy.ndarray): Nd-image data to process.
+        labels (cupy.ndarray or None): Labels defining sub-regions in `input`.
+            If not None, must be same shape as `input`.
+        index (cupy.ndarray or None): `labels` to include in output. If None
+            (default), all values where `labels` is non-zero are used.
+
+    Returns:
+        standard_deviation (cupy.ndarray): standard deviation of values, for
+        each sub-region if `labels` and `index` are specified.
+
+    .. seealso:: :func:`scipy.ndimage.standard_deviation`
+    """
+    return cupy.sqrt(variance(input, labels, index))
+
+
+def _safely_castable_to_int(dt):
+    """Test whether the NumPy data type `dt` can be safely cast to an int."""
+    int_size = cupy.dtype(int).itemsize
+    safe = (
+        cupy.issubdtype(dt, cupy.signedinteger) and dt.itemsize <= int_size
+    ) or (cupy.issubdtype(dt, cupy.unsignedinteger) and dt.itemsize < int_size)
+    return safe
+
+
+def _get_values(arrays, func):
+    """Concatenated result of applying func to a list of arrays.
+
+    func should be cupy.min, cupy.max or cupy.median
+    """
+    dtype = arrays[0].dtype
+    return cupy.concatenate(
+        [
+            func(a, keepdims=True)
+            if a.size != 0 else cupy.asarray([0], dtype=dtype)
+            for a in arrays
+        ]
+    )
+
+
+def _get_positions(arrays, position_arrays, arg_func):
+    """Concatenated positions from applying arg_func to arrays.
+
+    arg_func should be cupy.argmin or cupy.argmax
+    """
+    return cupy.concatenate(
+        [
+            pos[arg_func(a, keepdims=True)]
+            if a.size != 0 else cupy.asarray([0], dtype=int)
+            for pos, a in zip(position_arrays, arrays)
+        ]
+    )
+
+
+def _select_via_looping(input, labels, idxs, positions, find_min,
+                        find_min_positions, find_max, find_max_positions,
+                        find_median):
+    """Internal helper routine for _select.
+
+    With relatively few labels it is faster to call this function rather than
+    using the implementation based on cupy.lexsort.
+    """
+    find_positions = find_min_positions or find_max_positions
+
+    # extract labeled regions into separate arrays
+    arrays = []
+    position_arrays = []
+    for i in idxs:
+        label_idx = labels == i
+        arrays.append(input[label_idx])
+        if find_positions:
+            position_arrays.append(positions[label_idx])
+
+    result = []
+    # the order below matches the order expected by cupy.ndimage.extrema
+    if find_min:
+        result += [_get_values(arrays, cupy.min)]
+    if find_min_positions:
+        result += [_get_positions(arrays, position_arrays, cupy.argmin)]
+    if find_max:
+        result += [_get_values(arrays, cupy.max)]
+    if find_max_positions:
+        result += [_get_positions(arrays, position_arrays, cupy.argmax)]
+    if find_median:
+        result += [_get_values(arrays, cupy.median)]
+    return result
+
+
+def _select(input, labels=None, index=None, find_min=False, find_max=False,
+            find_min_positions=False, find_max_positions=False,
+            find_median=False):
+    """Return one or more of: min, max, min position, max position, median.
+
+    If neither `labels` or `index` is provided, these are the global values
+    in `input`. If `index` is None, but `labels` is provided, a global value
+    across all non-zero labels is given. When both `labels` and `index` are
+    provided, lists of values are provided for each labeled region specified
+    in `index`. See further details in :func:`cupyx.scipy.ndimage.minimum`,
+    etc.
+
+    Used by minimum, maximum, minimum_position, maximum_position, extrema.
+    """
+    find_positions = find_min_positions or find_max_positions
+    positions = None
+    if find_positions:
+        positions = cupy.arange(input.size).reshape(input.shape)
+
+    def single_group(vals, positions):
+        result = []
+        if find_min:
+            result += [vals.min()]
+        if find_min_positions:
+            result += [positions[vals == vals.min()][0]]
+        if find_max:
+            result += [vals.max()]
+        if find_max_positions:
+            result += [positions[vals == vals.max()][0]]
+        if find_median:
+            result += [cupy.median(vals)]
+        return result
+
+    if labels is None:
+        return single_group(input, positions)
+
+    # ensure input and labels match sizes
+    input, labels = cupy.broadcast_arrays(input, labels)
+
+    if index is None:
+        mask = labels > 0
+        masked_positions = None
+        if find_positions:
+            masked_positions = positions[mask]
+        return single_group(input[mask], masked_positions)
+
+    if cupy.isscalar(index):
+        mask = labels == index
+        masked_positions = None
+        if find_positions:
+            masked_positions = positions[mask]
+        return single_group(input[mask], masked_positions)
+
+    index = cupy.asarray(index)
+
+    safe_int = _safely_castable_to_int(labels.dtype)
+    min_label = labels.min()
+    max_label = labels.max()
+
+    # Remap labels to unique integers if necessary, or if the largest label is
+    # larger than the number of values.
+    if (not safe_int or min_label < 0 or max_label > labels.size):
+        # Remap labels, and indexes
+        unique_labels, labels = cupy.unique(labels, return_inverse=True)
+        idxs = cupy.searchsorted(unique_labels, index)
+
+        # Make all of idxs valid
+        idxs[idxs >= unique_labels.size] = 0
+        found = unique_labels[idxs] == index
+    else:
+        # Labels are an integer type, and there aren't too many
+        idxs = cupy.asanyarray(index, int).copy()
+        found = (idxs >= 0) & (idxs <= max_label)
+
+    idxs[~found] = max_label + 1
+
+    input = input.ravel()
+    labels = labels.ravel()
+    if find_positions:
+        positions = positions.ravel()
+
+    using_cub = _core._accelerator.ACCELERATOR_CUB in \
+        cupy._core.get_routine_accelerators()
+
+    if using_cub:
+        # Cutoff values below were determined empirically for relatively large
+        # input arrays.
+        if find_positions or find_median:
+            n_label_cutoff = 15
+        else:
+            n_label_cutoff = 30
+    else:
+        n_label_cutoff = 0
+
+    if n_label_cutoff and len(idxs) <= n_label_cutoff:
+        return _select_via_looping(
+            input, labels, idxs, positions, find_min, find_min_positions,
+            find_max, find_max_positions, find_median
+        )
+
+    order = cupy.lexsort(cupy.stack((input.ravel(), labels.ravel())))
+    input = input[order]
+    labels = labels[order]
+    if find_positions:
+        positions = positions[order]
+
+    # Determine indices corresponding to the min or max value for each label
+    label_change_index = cupy.searchsorted(labels,
+                                           cupy.arange(1, max_label + 2))
+    if find_min or find_min_positions or find_median:
+        # index corresponding to the minimum value at each label
+        min_index = label_change_index[:-1]
+    if find_max or find_max_positions or find_median:
+        # index corresponding to the maximum value at each label
+        max_index = label_change_index[1:] - 1
+
+    result = []
+    # the order below matches the order expected by cupy.ndimage.extrema
+    if find_min:
+        mins = cupy.zeros(int(labels.max()) + 2, input.dtype)
+        mins[labels[min_index]] = input[min_index]
+        result += [mins[idxs]]
+    if find_min_positions:
+        minpos = cupy.zeros(labels.max().item() + 2, int)
+        minpos[labels[min_index]] = positions[min_index]
+        result += [minpos[idxs]]
+    if find_max:
+        maxs = cupy.zeros(int(labels.max()) + 2, input.dtype)
+        maxs[labels[max_index]] = input[max_index]
+        result += [maxs[idxs]]
+    if find_max_positions:
+        maxpos = cupy.zeros(labels.max().item() + 2, int)
+        maxpos[labels[max_index]] = positions[max_index]
+        result += [maxpos[idxs]]
+    if find_median:
+        locs = cupy.arange(len(labels))
+        lo = cupy.zeros(int(labels.max()) + 2, int)
+        lo[labels[min_index]] = locs[min_index]
+        hi = cupy.zeros(int(labels.max()) + 2, int)
+        hi[labels[max_index]] = locs[max_index]
+        lo = lo[idxs]
+        hi = hi[idxs]
+        # lo is an index to the lowest value in input for each label,
+        # hi is an index to the largest value.
+        # move them to be either the same ((hi - lo) % 2 == 0) or next
+        # to each other ((hi - lo) % 2 == 1), then average.
+        step = (hi - lo) // 2
+        lo += step
+        hi -= step
+        if input.dtype.kind in 'iub':
+            # fix for https://github.com/scipy/scipy/issues/12836
+            result += [(input[lo].astype(float) + input[hi].astype(float)) /
+                       2.0]
+        else:
+            result += [(input[lo] + input[hi]) / 2.0]
+
+    return result
+
+
+def minimum(input, labels=None, index=None):
+    """Calculate the minimum of the values of an array over labeled regions.
+
+    Args:
+        input (cupy.ndarray):
+            Array of values. For each region specified by `labels`, the
+            minimal values of `input` over the region is computed.
+        labels (cupy.ndarray, optional): An array of integers marking different
+            regions over which the minimum value of `input` is to be computed.
+            `labels` must have the same shape as `input`. If `labels` is not
+            specified, the minimum over the whole array is returned.
+        index (array_like, optional): A list of region labels that are taken
+            into account for computing the minima. If `index` is None, the
+            minimum over all elements where `labels` is non-zero is returned.
+
+    Returns:
+        cupy.ndarray: Array of minima of `input` over the regions
+        determined by `labels` and whose index is in `index`. If `index` or
+        `labels` are not specified, a 0-dimensional cupy.ndarray is
+        returned: the minimal value of `input` if `labels` is None,
+        and the minimal value of elements where `labels` is greater than
+        zero if `index` is None.
+
+    .. seealso:: :func:`scipy.ndimage.minimum`
+    """
+    return _select(input, labels, index, find_min=True)[0]
+
+
+def maximum(input, labels=None, index=None):
+    """Calculate the maximum of the values of an array over labeled regions.
+
+    Args:
+        input (cupy.ndarray):
+            Array of values. For each region specified by `labels`, the
+            maximal values of `input` over the region is computed.
+        labels (cupy.ndarray, optional): An array of integers marking different
+            regions over which the maximum value of `input` is to be computed.
+            `labels` must have the same shape as `input`. If `labels` is not
+            specified, the maximum over the whole array is returned.
+        index (array_like, optional): A list of region labels that are taken
+            into account for computing the maxima. If `index` is None, the
+            maximum over all elements where `labels` is non-zero is returned.
+
+    Returns:
+        cupy.ndarray: Array of maxima of `input` over the regions
+        determaxed by `labels` and whose index is in `index`. If `index` or
+        `labels` are not specified, a 0-dimensional cupy.ndarray is
+        returned: the maximal value of `input` if `labels` is None,
+        and the maximal value of elements where `labels` is greater than
+        zero if `index` is None.
+
+    .. seealso:: :func:`scipy.ndimage.maximum`
+    """
+    return _select(input, labels, index, find_max=True)[0]
+
+
+def median(input, labels=None, index=None):
+    """Calculate the median of the values of an array over labeled regions.
+
+    Args:
+        input (cupy.ndarray):
+            Array of values. For each region specified by `labels`, the
+            median values of `input` over the region is computed.
+        labels (cupy.ndarray, optional): An array of integers marking different
+            regions over which the median value of `input` is to be computed.
+            `labels` must have the same shape as `input`. If `labels` is not
+            specified, the median over the whole array is returned.
+        index (array_like, optional): A list of region labels that are taken
+            into account for computing the medians. If `index` is None, the
+            median over all elements where `labels` is non-zero is returned.
+
+    Returns:
+        cupy.ndarray: Array of medians of `input` over the regions
+        determined by `labels` and whose index is in `index`. If `index` or
+        `labels` are not specified, a 0-dimensional cupy.ndarray is
+        returned: the median value of `input` if `labels` is None,
+        and the median value of elements where `labels` is greater than
+        zero if `index` is None.
+
+    .. seealso:: :func:`scipy.ndimage.median`
+    """
+    return _select(input, labels, index, find_median=True)[0]
+
+
+def minimum_position(input, labels=None, index=None):
+    """Find the positions of the minimums of the values of an array at labels.
+
+    For each region specified by `labels`, the position of the minimum
+    value of `input` within the region is returned.
+
+    Args:
+        input (cupy.ndarray):
+            Array of values. For each region specified by `labels`, the
+            minimal values of `input` over the region is computed.
+        labels (cupy.ndarray, optional): An array of integers marking different
+            regions over which the position of the minimum value of `input` is
+            to be computed. `labels` must have the same shape as `input`. If
+            `labels` is not specified, the location of the first minimum over
+            the whole array is returned.
+
+            The `labels` argument only works when `index` is specified.
+        index (array_like, optional): A list of region labels that are taken
+            into account for finding the location of the minima. If `index` is
+            None, the ``first`` minimum over all elements where `labels` is
+            non-zero is returned.
+
+            The `index` argument only works when `labels` is specified.
+
+    Returns:
+        Tuple of ints or list of tuples of ints that specify the location of
+        minima of `input` over the regions determined by `labels` and  whose
+        index is in `index`.
+
+        If `index` or `labels` are not specified, a tuple of ints is returned
+        specifying the location of the first minimal value of `input`.
+
+    .. note::
+        When `input` has multiple identical minima within a labeled region,
+        the coordinates returned are not guaranteed to match those returned by
+        SciPy.
+
+    .. seealso:: :func:`scipy.ndimage.minimum_position`
+    """
+    dims = numpy.asarray(input.shape)
+    # see numpy.unravel_index to understand this line.
+    dim_prod = numpy.cumprod([1] + list(dims[:0:-1]))[::-1]
+
+    result = _select(input, labels, index, find_min_positions=True)[0]
+
+    # have to transfer result back to the CPU to return index tuples
+    if result.ndim == 0:
+        result = int(result)  # synchronize
+    else:
+        result = cupy.asnumpy(result)  # synchronize
+
+    if cupy.isscalar(result):
+        return tuple((result // dim_prod) % dims)
+
+    return [tuple(v) for v in (result.reshape(-1, 1) // dim_prod) % dims]
+
+
+def maximum_position(input, labels=None, index=None):
+    """Find the positions of the maximums of the values of an array at labels.
+
+    For each region specified by `labels`, the position of the maximum
+    value of `input` within the region is returned.
+
+    Args:
+        input (cupy.ndarray):
+            Array of values. For each region specified by `labels`, the
+            maximal values of `input` over the region is computed.
+        labels (cupy.ndarray, optional): An array of integers marking different
+            regions over which the position of the maximum value of `input` is
+            to be computed. `labels` must have the same shape as `input`. If
+            `labels` is not specified, the location of the first maximum over
+            the whole array is returned.
+
+            The `labels` argument only works when `index` is specified.
+        index (array_like, optional): A list of region labels that are taken
+            into account for finding the location of the maxima. If `index` is
+            None, the ``first`` maximum over all elements where `labels` is
+            non-zero is returned.
+
+            The `index` argument only works when `labels` is specified.
+
+    Returns:
+        Tuple of ints or list of tuples of ints that specify the location of
+        maxima of `input` over the regions determaxed by `labels` and  whose
+        index is in `index`.
+
+        If `index` or `labels` are not specified, a tuple of ints is returned
+        specifying the location of the first maximal value of `input`.
+
+    .. note::
+        When `input` has multiple identical maxima within a labeled region,
+        the coordinates returned are not guaranteed to match those returned by
+        SciPy.
+
+    .. seealso:: :func:`scipy.ndimage.maximum_position`
+    """
+    dims = numpy.asarray(input.shape)
+    # see numpy.unravel_index to understand this line.
+    dim_prod = numpy.cumprod([1] + list(dims[:0:-1]))[::-1]
+
+    result = _select(input, labels, index, find_max_positions=True)[0]
+
+    # have to transfer result back to the CPU to return index tuples
+    if result.ndim == 0:
+        result = int(result)
+    else:
+        result = cupy.asnumpy(result)
+
+    if cupy.isscalar(result):
+        return tuple((result // dim_prod) % dims)
+
+    return [tuple(v) for v in (result.reshape(-1, 1) // dim_prod) % dims]
+
+
+def extrema(input, labels=None, index=None):
+    """Calculate the minimums and maximums of the values of an array at labels,
+    along with their positions.
+
+    Args:
+        input (cupy.ndarray): N-D image data to process.
+        labels (cupy.ndarray, optional): Labels of features in input. If not
+            None, must be same shape as `input`.
+        index (int or sequence of ints, optional): Labels to include in output.
+            If None (default), all values where non-zero `labels` are used.
+
+    Returns:
+        A tuple that contains the following values.
+
+        **minimums (cupy.ndarray)**: Values of minimums in each feature.
+
+        **maximums (cupy.ndarray)**: Values of maximums in each feature.
+
+        **min_positions (tuple or list of tuples)**: Each tuple gives the N-D
+        coordinates of the corresponding minimum.
+
+        **max_positions (tuple or list of tuples)**: Each tuple gives the N-D
+        coordinates of the corresponding maximum.
+
+    .. seealso:: :func:`scipy.ndimage.extrema`
+    """
+    dims = numpy.array(input.shape)
+    # see numpy.unravel_index to understand this line.
+    dim_prod = numpy.cumprod([1] + list(dims[:0:-1]))[::-1]
+
+    minimums, min_positions, maximums, max_positions = _select(
+        input,
+        labels,
+        index,
+        find_min=True,
+        find_max=True,
+        find_min_positions=True,
+        find_max_positions=True,
+    )
+
+    if min_positions.ndim == 0:
+        # scalar output case
+        min_positions = min_positions.item()
+        max_positions = max_positions.item()
+        return (
+            minimums,
+            maximums,
+            tuple((min_positions // dim_prod) % dims),
+            tuple((max_positions // dim_prod) % dims),
+        )
+
+    # convert indexes to tuples on the host
+    min_positions = cupy.asnumpy(min_positions)
+    max_positions = cupy.asnumpy(max_positions)
+    min_positions = [
+        tuple(v) for v in (min_positions.reshape(-1, 1) // dim_prod) % dims
+    ]
+    max_positions = [
+        tuple(v) for v in (max_positions.reshape(-1, 1) // dim_prod) % dims
+    ]
+
+    return minimums, maximums, min_positions, max_positions
+
+
+def center_of_mass(input, labels=None, index=None):
+    """
+    Calculate the center of mass of the values of an array at labels.
+
+    Args:
+        input (cupy.ndarray): Data from which to calculate center-of-mass. The
+            masses can either be positive or negative.
+        labels (cupy.ndarray, optional): Labels for objects in `input`, as
+            enerated by `ndimage.label`. Only used with `index`. Dimensions
+            must be the same as `input`.
+        index (int or sequence of ints, optional): Labels for which to
+            calculate centers-of-mass. If not specified, all labels greater
+            than zero are used. Only used with `labels`.
+
+    Returns:
+        tuple or list of tuples: Coordinates of centers-of-mass.
+
+    .. seealso:: :func:`scipy.ndimage.center_of_mass`
+    """
+    normalizer = sum(input, labels, index)
+    grids = cupy.ogrid[[slice(0, i) for i in input.shape]]
+
+    results = [
+        sum(input * grids[dir].astype(float), labels, index) / normalizer
+        for dir in range(input.ndim)
+    ]
+
+    # have to transfer 0-dim array back to CPU?
+    # may want to modify to avoid this
+    is_0dim_array = (
+        isinstance(results[0], cupy.ndarray) and results[0].ndim == 0
+    )
+    if is_0dim_array:
+        # tuple of 0-dimensional cupy arrays
+        return tuple(res for res in results)
+    # list of cupy coordinate arrays
+    return [v for v in cupy.stack(results, axis=-1)]
+
+
+def labeled_comprehension(
+    input, labels, index, func, out_dtype, default, pass_positions=False
+):
+    """Array resulting from applying ``func`` to each labeled region.
+
+    Roughly equivalent to [func(input[labels == i]) for i in index].
+
+    Sequentially applies an arbitrary function (that works on array_like input)
+    to subsets of an N-D image array specified by `labels` and `index`.
+    The option exists to provide the function with positional parameters as the
+    second argument.
+
+    Args:
+        input (cupy.ndarray): Data from which to select `labels` to process.
+        labels (cupy.ndarray or None):  Labels to objects in `input`. If not
+            None, array must be same shape as `input`. If None, `func` is
+            applied to raveled `input`.
+        index (int, sequence of ints or None): Subset of `labels` to which to
+            apply `func`. If a scalar, a single value is returned. If None,
+            `func` is applied to all non-zero values of `labels`.
+        func (callable): Python function to apply to `labels` from `input`.
+        out_dtype (dtype): Dtype to use for `result`.
+        default (int, float or None): Default return value when a element of
+            `index` does not exist in `labels`.
+        pass_positions (bool, optional): If True, pass linear indices to `func`
+            as a second argument.
+
+    Returns:
+        cupy.ndarray: Result of applying `func` to each of `labels` to `input`
+        in `index`.
+
+    .. seealso:: :func:`scipy.ndimage.labeled_comprehension`
+    """
+    as_scalar = cupy.isscalar(index)
+    input = cupy.asarray(input)
+
+    if pass_positions:
+        positions = cupy.arange(input.size).reshape(input.shape)
+
+    if labels is None:
+        if index is not None:
+            raise ValueError('index without defined labels')
+        if not pass_positions:
+            return func(input.ravel())
+        else:
+            return func(input.ravel(), positions.ravel())
+
+    try:
+        input, labels = cupy.broadcast_arrays(input, labels)
+    except ValueError:
+        raise ValueError(
+            'input and labels must have the same shape '
+            '(excepting dimensions with width 1)'
+        )
+
+    if index is None:
+        if not pass_positions:
+            return func(input[labels > 0])
+        else:
+            return func(input[labels > 0], positions[labels > 0])
+
+    index = cupy.atleast_1d(index)
+    if cupy.any(index.astype(labels.dtype).astype(index.dtype) != index):
+        raise ValueError(
+            'Cannot convert index values from <%s> to <%s> '
+            '(labels.dtype) without loss of precision'
+            % (index.dtype, labels.dtype)
+        )
+
+    index = index.astype(labels.dtype)
+
+    # optimization: find min/max in index, and select those parts of labels,
+    #               input, and positions
+    lo = index.min()
+    hi = index.max()
+    mask = (labels >= lo) & (labels <= hi)
+
+    # this also ravels the arrays
+    labels = labels[mask]
+    input = input[mask]
+    if pass_positions:
+        positions = positions[mask]
+
+    # sort everything by labels
+    label_order = labels.argsort()
+    labels = labels[label_order]
+    input = input[label_order]
+    if pass_positions:
+        positions = positions[label_order]
+
+    index_order = index.argsort()
+    sorted_index = index[index_order]
+
+    def do_map(inputs, output):
+        """labels must be sorted"""
+        nidx = sorted_index.size
+
+        # Find boundaries for each stretch of constant labels
+        # This could be faster, but we already paid N log N to sort labels.
+        lo = cupy.searchsorted(labels, sorted_index, side='left')
+        hi = cupy.searchsorted(labels, sorted_index, side='right')
+
+        for i, low, high in zip(range(nidx), lo, hi):
+            if low == high:
+                continue
+            output[i] = func(*[inp[low:high] for inp in inputs])
+
+    if out_dtype == object:  # noqa: E721
+        temp = {i: default for i in range(index.size)}
+    else:
+        temp = cupy.empty(index.shape, out_dtype)
+        if default is None and temp.dtype.kind in 'fc':
+            default = numpy.nan  # match NumPy floating-point None behavior
+        temp[:] = default
+
+    if not pass_positions:
+        do_map([input], temp)
+    else:
+        do_map([input, positions], temp)
+
+    if out_dtype == object:  # noqa: E721
+        # use a list of arrays since object arrays are not supported
+        index_order = cupy.asnumpy(index_order)
+        output = [temp[i] for i in index_order.argsort()]
+    else:
+        output = cupy.zeros(index.shape, out_dtype)
+        output[cupy.asnumpy(index_order)] = temp
+    if as_scalar:
+        output = output[0]
+    return output
+
+
+def histogram(input, min, max, bins, labels=None, index=None):
+    """Calculate the histogram of the values of an array, optionally at labels.
+
+    Histogram calculates the frequency of values in an array within bins
+    determined by `min`, `max`, and `bins`. The `labels` and `index`
+    keywords can limit the scope of the histogram to specified sub-regions
+    within the array.
+
+    Args:
+        input (cupy.ndarray): Data for which to calculate histogram.
+        min (int): Minimum values of range of histogram bins.
+        max (int): Maximum values of range of histogram bins.
+        bins (int): Number of bins.
+        labels (cupy.ndarray, optional): Labels for objects in `input`. If not
+            None, must be same shape as `input`.
+        index (int or sequence of ints, optional): Label or labels for which to
+            calculate histogram. If None, all values where label is greater
+            than zero are used.
+
+    Returns:
+        cupy.ndarray: Histogram counts.
+
+    .. seealso:: :func:`scipy.ndimage.histogram`
+    """
+    _bins = cupy.linspace(min, max, bins + 1)
+
+    def _hist(vals):
+        return cupy.histogram(vals, _bins)[0]
+
+    return labeled_comprehension(
+        input, labels, index, _hist, object, None, pass_positions=False
+    )
+
+
+def value_indices(arr, *, ignore_value=None, adaptive_index_dtype=False):
+    """
+    Find indices of each distinct value in given array.
+
+    Parameters
+    ----------
+    arr : ndarray of ints
+        Array containing integer values.
+    ignore_value : int, optional
+        This value will be ignored in searching the `arr` array. If not
+        given, all values found will be included in output. Default
+        is None.
+    adaptive_index_dtype : bool, optional
+        If ``True``, instead of returning the default CuPy signed integer
+        dtype, the smallest signed integer dtype capable of representing the
+        image coordinate range will be used. This can substantially reduce
+        memory usage and slightly reduce runtime. Note that this optional
+        parameter is not available in the SciPy API.
+
+    Returns
+    -------
+    indices : dictionary
+        A Python dictionary of array indices for each distinct value. The
+        dictionary is keyed by the distinct values, the entries are array
+        index tuples covering all occurrences of the value within the
+        array.
+
+        This dictionary can occupy significant memory, often several times
+        the size of the input array. To help reduce memory overhead, the
+        argument `adaptive_index_dtype` can be set to ``True``.
+
+    Notes
+    -----
+    For a small array with few distinct values, one might use
+    `numpy.unique()` to find all possible values, and ``(arr == val)`` to
+    locate each value within that array. However, for large arrays,
+    with many distinct values, this can become extremely inefficient,
+    as locating each value would require a new search through the entire
+    array. Using this function, there is essentially one search, with
+    the indices saved for all distinct values.
+
+    This is useful when matching a categorical image (e.g. a segmentation
+    or classification) to an associated image of other data, allowing
+    any per-class statistic(s) to then be calculated. Provides a
+    more flexible alternative to functions like ``scipy.ndimage.mean()``
+    and ``scipy.ndimage.variance()``.
+
+    Some other closely related functionality, with different strengths and
+    weaknesses, can also be found in ``scipy.stats.binned_statistic()`` and
+    the `scikit-image <https://scikit-image.org/>`_ function
+    ``skimage.measure.regionprops()``.
+
+    Note for IDL users: this provides functionality equivalent to IDL's
+    REVERSE_INDICES option (as per the IDL documentation for the
+    `HISTOGRAM <https://www.l3harrisgeospatial.com/docs/histogram.html>`_
+    function).
+
+    .. versionadded:: 1.10.0
+
+    See Also
+    --------
+    label, maximum, median, minimum_position, extrema, sum, mean, variance,
+    standard_deviation, cupy.where, cupy.unique
+
+    Examples
+    --------
+    >>> import cupy
+    >>> from cupyx.scipy import ndimage
+    >>> a = cupy.zeros((6, 6), dtype=int)
+    >>> a[2:4, 2:4] = 1
+    >>> a[4, 4] = 1
+    >>> a[:2, :3] = 2
+    >>> a[0, 5] = 3
+    >>> a
+    array([[2, 2, 2, 0, 0, 3],
+           [2, 2, 2, 0, 0, 0],
+           [0, 0, 1, 1, 0, 0],
+           [0, 0, 1, 1, 0, 0],
+           [0, 0, 0, 0, 1, 0],
+           [0, 0, 0, 0, 0, 0]])
+    >>> val_indices = ndimage.value_indices(a)
+
+    The dictionary `val_indices` will have an entry for each distinct
+    value in the input array.
+
+    >>> val_indices.keys()
+    dict_keys([0, 1, 2, 3])
+
+    The entry for each value is an index tuple, locating the elements
+    with that value.
+
+    >>> ndx1 = val_indices[1]
+    >>> ndx1
+    (array([2, 2, 3, 3, 4]), array([2, 3, 2, 3, 4]))
+
+    This can be used to index into the original array, or any other
+    array with the same shape.
+
+    >>> a[ndx1]
+    array([1, 1, 1, 1, 1])
+
+    If the zeros were to be ignored, then the resulting dictionary
+    would no longer have an entry for zero.
+
+    >>> val_indices = ndimage.value_indices(a, ignore_value=0)
+    >>> val_indices.keys()
+    dict_keys([1, 2, 3])
+
+    """
+    if arr.dtype.kind not in 'iu':
+        raise ValueError('Parameter \'arr\' must be an integer array')
+    if adaptive_index_dtype:
+        # determined the minimum signed integer type needed to store the
+        # index rangle
+        raveled_int_type = cupy.min_scalar_type(-(int(arr.size) + 1))
+        coord_int_type = cupy.min_scalar_type(-(max(arr.shape) + 1))
+    arr1d = arr.reshape(-1)
+    counts = cupy.bincount(arr1d)
+
+    isort = cupy.argsort(arr1d, axis=None)
+    if adaptive_index_dtype:
+        isort = isort.astype(raveled_int_type, copy=False)
+
+    coords = cupy.unravel_index(isort, arr.shape)
+    if adaptive_index_dtype:
+        coords = tuple(c.astype(coord_int_type, copy=False) for c in coords)
+
+    offset = 0
+    out = {}
+    counts = cupy.asnumpy(counts)  # need the counts on the host
+    for value, count in enumerate(counts):
+        if count == 0:
+            continue
+        elif value == ignore_value:
+            offset += count
+            continue
+        out[value] = tuple(c[offset:offset + count] for c in coords)
+        offset += count
+    return out

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/_morphology.py

@@ -0,0 +1,1017 @@
+import operator
+import warnings
+
+import numpy
+
+import cupy
+from cupy import _core
+
+from cupyx.scipy.ndimage import _filters_core
+from cupyx.scipy.ndimage import _util
+from cupyx.scipy.ndimage import _filters
+
+
+@cupy.memoize(for_each_device=True)
+def _get_binary_erosion_kernel(
+    w_shape, int_type, offsets, center_is_true, border_value, invert, masked,
+    all_weights_nonzero
+):
+    if invert:
+        border_value = int(not border_value)
+        true_val = 0
+        false_val = 1
+    else:
+        true_val = 1
+        false_val = 0
+
+    if masked:
+        pre = """
+            bool mv = (bool)mask[i];
+            bool _in = (bool)x[i];
+            if (!mv) {{
+                y = cast<Y>(_in);
+                return;
+            }} else if ({center_is_true} && _in == {false_val}) {{
+                y = cast<Y>(_in);
+                return;
+            }}""".format(center_is_true=int(center_is_true),
+                         false_val=false_val)
+    else:
+        pre = """
+            bool _in = (bool)x[i];
+            if ({center_is_true} && _in == {false_val}) {{
+                y = cast<Y>(_in);
+                return;
+            }}""".format(center_is_true=int(center_is_true),
+                         false_val=false_val)
+    pre = pre + """
+            y = cast<Y>({true_val});""".format(true_val=true_val)
+
+    # {{{{ required because format is called again within _generate_nd_kernel
+    found = """
+        if ({{cond}}) {{{{
+            if (!{border_value}) {{{{
+                y = cast<Y>({false_val});
+                return;
+            }}}}
+        }}}} else {{{{
+            bool nn = {{value}} ? {true_val} : {false_val};
+            if (!nn) {{{{
+                y = cast<Y>({false_val});
+                return;
+            }}}}
+        }}}}""".format(true_val=int(true_val),
+                       false_val=int(false_val),
+                       border_value=int(border_value),)
+
+    name = 'binary_erosion'
+    if false_val:
+        name += '_invert'
+    return _filters_core._generate_nd_kernel(
+        name,
+        pre,
+        found,
+        '',
+        'constant', w_shape, int_type, offsets, 0, ctype='Y', has_weights=True,
+        has_structure=False, has_mask=masked, binary_morphology=True,
+        all_weights_nonzero=all_weights_nonzero)
+
+
+def _center_is_true(structure, origin):
+    coor = tuple([oo + ss // 2 for ss, oo in zip(structure.shape, origin)])
+    return bool(structure[coor])  # device synchronization
+
+
+def iterate_structure(structure, iterations, origin=None):
+    """Iterate a structure by dilating it with itself.
+
+    Args:
+        structure(array_like): Structuring element (an array of bools,
+            for example), to be dilated with itself.
+        iterations(int): The number of dilations performed on the structure
+            with itself.
+        origin(int or tuple of int, optional): If origin is None, only the
+            iterated structure is returned. If not, a tuple of the iterated
+            structure and the modified origin is returned.
+
+    Returns:
+        cupy.ndarray: A new structuring element obtained by dilating
+        ``structure`` (``iterations`` - 1) times with itself.
+
+    .. seealso:: :func:`scipy.ndimage.iterate_structure`
+    """
+    if iterations < 2:
+        return structure.copy()
+    ni = iterations - 1
+    shape = [ii + ni * (ii - 1) for ii in structure.shape]
+    pos = [ni * (structure.shape[ii] // 2) for ii in range(len(shape))]
+    slc = tuple(
+        slice(pos[ii], pos[ii] + structure.shape[ii], None)
+        for ii in range(len(shape))
+    )
+    out = cupy.zeros(shape, bool)
+    out[slc] = structure != 0
+    out = binary_dilation(out, structure, iterations=ni)
+    if origin is None:
+        return out
+    else:
+        origin = _util._fix_sequence_arg(origin, structure.ndim, 'origin', int)
+        origin = [iterations * o for o in origin]
+        return out, origin
+
+
+def generate_binary_structure(rank, connectivity):
+    """Generate a binary structure for binary morphological operations.
+
+    Args:
+        rank(int): Number of dimensions of the array to which the structuring
+            element will be applied, as returned by ``np.ndim``.
+        connectivity(int): ``connectivity`` determines which elements of the
+            output array belong to the structure, i.e., are considered as
+            neighbors of the central element. Elements up to a squared distance
+            of ``connectivity`` from the center are considered neighbors.
+            ``connectivity`` may range from 1 (no diagonal elements are
+            neighbors) to ``rank`` (all elements are neighbors).
+
+    Returns:
+        cupy.ndarray: Structuring element which may be used for binary
+        morphological operations, with ``rank`` dimensions and all
+        dimensions equal to 3.
+
+    .. seealso:: :func:`scipy.ndimage.generate_binary_structure`
+    """
+    if connectivity < 1:
+        connectivity = 1
+    if rank < 1:
+        return cupy.asarray(True, dtype=bool)
+    output = numpy.fabs(numpy.indices([3] * rank) - 1)
+    output = numpy.add.reduce(output, 0)
+    output = output <= connectivity
+    return cupy.asarray(output)
+
+
+def _binary_erosion(input, structure, iterations, mask, output, border_value,
+                    origin, invert, brute_force=True):
+    try:
+        iterations = operator.index(iterations)
+    except TypeError:
+        raise TypeError('iterations parameter should be an integer')
+
+    if input.dtype.kind == 'c':
+        raise TypeError('Complex type not supported')
+    if structure is None:
+        structure = generate_binary_structure(input.ndim, 1)
+        all_weights_nonzero = input.ndim == 1
+        center_is_true = True
+        default_structure = True
+    else:
+        structure = structure.astype(dtype=bool, copy=False)
+        # transfer to CPU for use in determining if it is fully dense
+        # structure_cpu = cupy.asnumpy(structure)
+        default_structure = False
+    if structure.ndim != input.ndim:
+        raise RuntimeError('structure and input must have same dimensionality')
+    if not structure.flags.c_contiguous:
+        structure = cupy.ascontiguousarray(structure)
+    if structure.size < 1:
+        raise RuntimeError('structure must not be empty')
+
+    if mask is not None:
+        if mask.shape != input.shape:
+            raise RuntimeError('mask and input must have equal sizes')
+        if not mask.flags.c_contiguous:
+            mask = cupy.ascontiguousarray(mask)
+        masked = True
+    else:
+        masked = False
+    origin = _util._fix_sequence_arg(origin, input.ndim, 'origin', int)
+
+    if isinstance(output, cupy.ndarray):
+        if output.dtype.kind == 'c':
+            raise TypeError('Complex output type not supported')
+    else:
+        output = bool
+    output = _util._get_output(output, input)
+    temp_needed = cupy.shares_memory(output, input, 'MAY_SHARE_BOUNDS')
+    if temp_needed:
+        # input and output arrays cannot share memory
+        temp = output
+        output = _util._get_output(output.dtype, input)
+    if structure.ndim == 0:
+        # kernel doesn't handle ndim=0, so special case it here
+        if float(structure):
+            output[...] = cupy.asarray(input, dtype=bool)
+        else:
+            output[...] = ~cupy.asarray(input, dtype=bool)
+        return output
+    origin = tuple(origin)
+    int_type = _util._get_inttype(input)
+    offsets = _filters_core._origins_to_offsets(origin, structure.shape)
+    if not default_structure:
+        # synchronize required to determine if all weights are non-zero
+        nnz = int(cupy.count_nonzero(structure))
+        all_weights_nonzero = nnz == structure.size
+        if all_weights_nonzero:
+            center_is_true = True
+        else:
+            center_is_true = _center_is_true(structure, origin)
+
+    erode_kernel = _get_binary_erosion_kernel(
+        structure.shape, int_type, offsets, center_is_true, border_value,
+        invert, masked, all_weights_nonzero,
+    )
+
+    if iterations == 1:
+        if masked:
+            output = erode_kernel(input, structure, mask, output)
+        else:
+            output = erode_kernel(input, structure, output)
+    elif center_is_true and not brute_force:
+        raise NotImplementedError(
+            'only brute_force iteration has been implemented'
+        )
+    else:
+        if cupy.shares_memory(output, input, 'MAY_SHARE_BOUNDS'):
+            raise ValueError('output and input may not overlap in memory')
+        tmp_in = cupy.empty_like(input, dtype=output.dtype)
+        tmp_out = output
+        if iterations >= 1 and not iterations & 1:
+            tmp_in, tmp_out = tmp_out, tmp_in
+        if masked:
+            tmp_out = erode_kernel(input, structure, mask, tmp_out)
+        else:
+            tmp_out = erode_kernel(input, structure, tmp_out)
+        # TODO: kernel doesn't return the changed status, so determine it here
+        changed = not (input == tmp_out).all()  # synchronize!
+        ii = 1
+        while ii < iterations or ((iterations < 1) and changed):
+            tmp_in, tmp_out = tmp_out, tmp_in
+            if masked:
+                tmp_out = erode_kernel(tmp_in, structure, mask, tmp_out)
+            else:
+                tmp_out = erode_kernel(tmp_in, structure, tmp_out)
+            changed = not (tmp_in == tmp_out).all()
+            ii += 1
+            if not changed and (not ii & 1):  # synchronize!
+                # can exit early if nothing changed
+                # (only do this after even number of tmp_in/out swaps)
+                break
+        output = tmp_out
+    if temp_needed:
+        _core.elementwise_copy(output, temp)
+        output = temp
+    return output
+
+
+def binary_erosion(input, structure=None, iterations=1, mask=None, output=None,
+                   border_value=0, origin=0, brute_force=False):
+    """Multidimensional binary erosion with a given structuring element.
+
+    Binary erosion is a mathematical morphology operation used for image
+    processing.
+
+    Args:
+        input(cupy.ndarray): The input binary array_like to be eroded.
+            Non-zero (True) elements form the subset to be eroded.
+        structure(cupy.ndarray, optional): The structuring element used for the
+            erosion. Non-zero elements are considered True. If no structuring
+            element is provided an element is generated with a square
+            connectivity equal to one. (Default value = None).
+        iterations(int, optional): The erosion is repeated ``iterations`` times
+            (one, by default). If iterations is less than 1, the erosion is
+            repeated until the result does not change anymore. Only an integer
+            of iterations is accepted.
+        mask(cupy.ndarray or None, optional): If a mask is given, only those
+            elements with a True value at the corresponding mask element are
+            modified at each iteration. (Default value = None)
+        output(cupy.ndarray, optional): Array of the same shape as input, into
+            which the output is placed. By default, a new array is created.
+        border_value(int (cast to 0 or 1), optional): Value at the
+            border in the output array. (Default value = 0)
+        origin(int or tuple of ints, optional): Placement of the filter, by
+            default 0.
+        brute_force(boolean, optional): Memory condition: if False, only the
+            pixels whose value was changed in the last iteration are tracked as
+            candidates to be updated (eroded) in the current iteration; if
+            True all pixels are considered as candidates for erosion,
+            regardless of what happened in the previous iteration.
+
+    Returns:
+        cupy.ndarray: The result of binary erosion.
+
+    .. warning::
+
+        This function may synchronize the device.
+
+    .. seealso:: :func:`scipy.ndimage.binary_erosion`
+    """
+    return _binary_erosion(input, structure, iterations, mask, output,
+                           border_value, origin, 0, brute_force)
+
+
+def binary_dilation(input, structure=None, iterations=1, mask=None,
+                    output=None, border_value=0, origin=0, brute_force=False):
+    """Multidimensional binary dilation with the given structuring element.
+
+    Args:
+        input(cupy.ndarray): The input binary array_like to be dilated.
+            Non-zero (True) elements form the subset to be dilated.
+        structure(cupy.ndarray, optional): The structuring element used for the
+            dilation. Non-zero elements are considered True. If no structuring
+            element is provided an element is generated with a square
+            connectivity equal to one. (Default value = None).
+        iterations(int, optional): The dilation is repeated ``iterations``
+            times (one, by default). If iterations is less than 1, the dilation
+            is repeated until the result does not change anymore. Only an
+            integer of iterations is accepted.
+        mask(cupy.ndarray or None, optional): If a mask is given, only those
+            elements with a True value at the corresponding mask element are
+            modified at each iteration. (Default value = None)
+        output(cupy.ndarray, optional): Array of the same shape as input, into
+            which the output is placed. By default, a new array is created.
+        border_value(int (cast to 0 or 1), optional): Value at the
+            border in the output array. (Default value = 0)
+        origin(int or tuple of ints, optional): Placement of the filter, by
+            default 0.
+        brute_force(boolean, optional): Memory condition: if False, only the
+            pixels whose value was changed in the last iteration are tracked as
+            candidates to be updated (dilated) in the current iteration; if
+            True all pixels are considered as candidates for dilation,
+            regardless of what happened in the previous iteration.
+
+    Returns:
+        cupy.ndarray: The result of binary dilation.
+
+    .. warning::
+
+        This function may synchronize the device.
+
+    .. seealso:: :func:`scipy.ndimage.binary_dilation`
+    """
+    if structure is None:
+        structure = generate_binary_structure(input.ndim, 1)
+    origin = _util._fix_sequence_arg(origin, input.ndim, 'origin', int)
+    structure = structure[tuple([slice(None, None, -1)] * structure.ndim)]
+    for ii in range(len(origin)):
+        origin[ii] = -origin[ii]
+        if not structure.shape[ii] & 1:
+            origin[ii] -= 1
+    return _binary_erosion(input, structure, iterations, mask, output,
+                           border_value, origin, 1, brute_force)
+
+
+def binary_opening(input, structure=None, iterations=1, output=None, origin=0,
+                   mask=None, border_value=0, brute_force=False):
+    """
+    Multidimensional binary opening with the given structuring element.
+
+    The *opening* of an input image by a structuring element is the
+    *dilation* of the *erosion* of the image by the structuring element.
+
+    Args:
+        input(cupy.ndarray): The input binary array to be opened.
+            Non-zero (True) elements form the subset to be opened.
+        structure(cupy.ndarray, optional): The structuring element used for the
+            opening. Non-zero elements are considered True. If no structuring
+            element is provided an element is generated with a square
+            connectivity equal to one. (Default value = None).
+        iterations(int, optional): The opening is repeated ``iterations`` times
+            (one, by default). If iterations is less than 1, the opening is
+            repeated until the result does not change anymore. Only an integer
+            of iterations is accepted.
+        output(cupy.ndarray, optional): Array of the same shape as input, into
+            which the output is placed. By default, a new array is created.
+        origin(int or tuple of ints, optional): Placement of the filter, by
+            default 0.
+        mask(cupy.ndarray or None, optional): If a mask is given, only those
+            elements with a True value at the corresponding mask element are
+            modified at each iteration. (Default value = None)
+        border_value(int (cast to 0 or 1), optional): Value at the
+            border in the output array. (Default value = 0)
+        brute_force(boolean, optional): Memory condition: if False, only the
+            pixels whose value was changed in the last iteration are tracked as
+            candidates to be updated (dilated) in the current iteration; if
+            True all pixels are considered as candidates for opening,
+            regardless of what happened in the previous iteration.
+
+    Returns:
+        cupy.ndarray: The result of binary opening.
+
+    .. warning::
+
+        This function may synchronize the device.
+
+    .. seealso:: :func:`scipy.ndimage.binary_opening`
+    """
+    if structure is None:
+        rank = input.ndim
+        structure = generate_binary_structure(rank, 1)
+    tmp = binary_erosion(input, structure, iterations, mask, None,
+                         border_value, origin, brute_force)
+    return binary_dilation(tmp, structure, iterations, mask, output,
+                           border_value, origin, brute_force)
+
+
+def binary_closing(input, structure=None, iterations=1, output=None, origin=0,
+                   mask=None, border_value=0, brute_force=False):
+    """
+    Multidimensional binary closing with the given structuring element.
+
+    The *closing* of an input image by a structuring element is the
+    *erosion* of the *dilation* of the image by the structuring element.
+
+    Args:
+        input(cupy.ndarray): The input binary array to be closed.
+            Non-zero (True) elements form the subset to be closed.
+        structure(cupy.ndarray, optional): The structuring element used for the
+            closing. Non-zero elements are considered True. If no structuring
+            element is provided an element is generated with a square
+            connectivity equal to one. (Default value = None).
+        iterations(int, optional): The closing is repeated ``iterations`` times
+            (one, by default). If iterations is less than 1, the closing is
+            repeated until the result does not change anymore. Only an integer
+            of iterations is accepted.
+        output(cupy.ndarray, optional): Array of the same shape as input, into
+            which the output is placed. By default, a new array is created.
+        origin(int or tuple of ints, optional): Placement of the filter, by
+            default 0.
+        mask(cupy.ndarray or None, optional): If a mask is given, only those
+            elements with a True value at the corresponding mask element are
+            modified at each iteration. (Default value = None)
+        border_value(int (cast to 0 or 1), optional): Value at the
+            border in the output array. (Default value = 0)
+        brute_force(boolean, optional): Memory condition: if False, only the
+            pixels whose value was changed in the last iteration are tracked as
+            candidates to be updated (dilated) in the current iteration; if
+            True all pixels are considered as candidates for closing,
+            regardless of what happened in the previous iteration.
+
+    Returns:
+        cupy.ndarray: The result of binary closing.
+
+    .. warning::
+
+        This function may synchronize the device.
+
+    .. seealso:: :func:`scipy.ndimage.binary_closing`
+    """
+    if structure is None:
+        rank = input.ndim
+        structure = generate_binary_structure(rank, 1)
+    tmp = binary_dilation(input, structure, iterations, mask, None,
+                          border_value, origin, brute_force)
+    return binary_erosion(tmp, structure, iterations, mask, output,
+                          border_value, origin, brute_force)
+
+
+def binary_hit_or_miss(input, structure1=None, structure2=None, output=None,
+                       origin1=0, origin2=None):
+    """
+    Multidimensional binary hit-or-miss transform.
+
+    The hit-or-miss transform finds the locations of a given pattern
+    inside the input image.
+
+    Args:
+        input (cupy.ndarray): Binary image where a pattern is to be detected.
+        structure1 (cupy.ndarray, optional): Part of the structuring element to
+            be fitted to the foreground (non-zero elements) of ``input``. If no
+            value is provided, a structure of square connectivity 1 is chosen.
+        structure2 (cupy.ndarray, optional): Second part of the structuring
+            element that has to miss completely the foreground. If no value is
+            provided, the complementary of ``structure1`` is taken.
+        output (cupy.ndarray, dtype or None, optional): Array of the same shape
+            as input, into which the output is placed. By default, a new array
+            is created.
+        origin1 (int or tuple of ints, optional): Placement of the first part
+            of the structuring element ``structure1``, by default 0 for a
+            centered structure.
+        origin2 (int or tuple of ints or None, optional): Placement of the
+            second part of the structuring element ``structure2``, by default 0
+            for a centered structure. If a value is provided for ``origin1``
+            and not for ``origin2``, then ``origin2`` is set to ``origin1``.
+
+    Returns:
+        cupy.ndarray: Hit-or-miss transform of ``input`` with the given
+        structuring element (``structure1``, ``structure2``).
+
+    .. warning::
+
+        This function may synchronize the device.
+
+    .. seealso:: :func:`scipy.ndimage.binary_hit_or_miss`
+    """
+    if structure1 is None:
+        structure1 = generate_binary_structure(input.ndim, 1)
+    if structure2 is None:
+        structure2 = cupy.logical_not(structure1)
+    origin1 = _util._fix_sequence_arg(origin1, input.ndim, 'origin1', int)
+    if origin2 is None:
+        origin2 = origin1
+    else:
+        origin2 = _util._fix_sequence_arg(origin2, input.ndim, 'origin2', int)
+
+    tmp1 = _binary_erosion(input, structure1, 1, None, None, 0, origin1, 0,
+                           False)
+    inplace = isinstance(output, cupy.ndarray)
+    result = _binary_erosion(input, structure2, 1, None, output, 0, origin2, 1,
+                             False)
+    if inplace:
+        cupy.logical_not(output, output)
+        cupy.logical_and(tmp1, output, output)
+    else:
+        cupy.logical_not(result, result)
+        return cupy.logical_and(tmp1, result)
+
+
+def binary_propagation(input, structure=None, mask=None, output=None,
+                       border_value=0, origin=0):
+    """
+    Multidimensional binary propagation with the given structuring element.
+
+    Args:
+        input (cupy.ndarray): Binary image to be propagated inside ``mask``.
+        structure (cupy.ndarray, optional): Structuring element used in the
+            successive dilations. The output may depend on the structuring
+            element, especially if ``mask`` has several connex components. If
+            no structuring element is provided, an element is generated with a
+            squared connectivity equal to one.
+        mask (cupy.ndarray, optional): Binary mask defining the region into
+            which ``input`` is allowed to propagate.
+        output (cupy.ndarray, optional): Array of the same shape as input, into
+            which the output is placed. By default, a new array is created.
+        border_value (int, optional): Value at the border in the output array.
+            The value is cast to 0 or 1.
+        origin (int or tuple of ints, optional): Placement of the filter.
+
+    Returns:
+        cupy.ndarray : Binary propagation of ``input`` inside ``mask``.
+
+    .. warning::
+
+        This function may synchronize the device.
+
+    .. seealso:: :func:`scipy.ndimage.binary_propagation`
+    """
+    return binary_dilation(input, structure, -1, mask, output, border_value,
+                           origin, brute_force=True)
+
+
+def binary_fill_holes(input, structure=None, output=None, origin=0):
+    """Fill the holes in binary objects.
+
+    Args:
+        input (cupy.ndarray): N-D binary array with holes to be filled.
+        structure (cupy.ndarray, optional):  Structuring element used in the
+            computation; large-size elements make computations faster but may
+            miss holes separated from the background by thin regions. The
+            default element (with a square connectivity equal to one) yields
+            the intuitive result where all holes in the input have been filled.
+        output (cupy.ndarray, dtype or None, optional): Array of the same shape
+            as input, into which the output is placed. By default, a new array
+            is created.
+        origin (int, tuple of ints, optional): Position of the structuring
+            element.
+
+    Returns:
+        cupy.ndarray: Transformation of the initial image ``input`` where holes
+        have been filled.
+
+    .. warning::
+
+        This function may synchronize the device.
+
+    .. seealso:: :func:`scipy.ndimage.binary_fill_holes`
+    """
+    mask = cupy.logical_not(input)
+    tmp = cupy.zeros(mask.shape, bool)
+    inplace = isinstance(output, cupy.ndarray)
+    # TODO (grlee77): set brute_force=False below once implemented
+    if inplace:
+        binary_dilation(tmp, structure, -1, mask, output, 1, origin,
+                        brute_force=True)
+        cupy.logical_not(output, output)
+    else:
+        output = binary_dilation(tmp, structure, -1, mask, None, 1, origin,
+                                 brute_force=True)
+        cupy.logical_not(output, output)
+        return output
+
+
+def grey_erosion(input, size=None, footprint=None, structure=None, output=None,
+                 mode='reflect', cval=0.0, origin=0):
+    """Calculates a greyscale erosion.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (tuple of ints): Shape of a flat and full structuring element used
+            for the greyscale erosion. Optional if ``footprint`` or
+            ``structure`` is provided.
+        footprint (array of ints): Positions of non-infinite elements of a flat
+            structuring element used for greyscale erosion. Non-zero values
+            give the set of neighbors of the center over which minimum is
+            chosen.
+        structure (array of ints): Structuring element used for the greyscale
+            erosion. ``structure`` may be a non-flat structuring element.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``constant``. Default is ``0.0``.
+        origin (scalar or tuple of scalar): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The result of greyscale erosion.
+
+    .. seealso:: :func:`scipy.ndimage.grey_erosion`
+    """
+
+    if size is None and footprint is None and structure is None:
+        raise ValueError('size, footprint or structure must be specified')
+
+    return _filters._min_or_max_filter(input, size, footprint, structure,
+                                       output, mode, cval, origin, 'min')
+
+
+def grey_dilation(input, size=None, footprint=None, structure=None,
+                  output=None, mode='reflect', cval=0.0, origin=0):
+    """Calculates a greyscale dilation.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (tuple of ints): Shape of a flat and full structuring element used
+            for the greyscale dilation. Optional if ``footprint`` or
+            ``structure`` is provided.
+        footprint (array of ints): Positions of non-infinite elements of a flat
+            structuring element used for greyscale dilation. Non-zero values
+            give the set of neighbors of the center over which maximum is
+            chosen.
+        structure (array of ints): Structuring element used for the greyscale
+            dilation. ``structure`` may be a non-flat structuring element.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``constant``. Default is ``0.0``.
+        origin (scalar or tuple of scalar): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The result of greyscale dilation.
+
+    .. seealso:: :func:`scipy.ndimage.grey_dilation`
+    """
+
+    if size is None and footprint is None and structure is None:
+        raise ValueError('size, footprint or structure must be specified')
+    if structure is not None:
+        structure = cupy.array(structure)
+        structure = structure[tuple([slice(None, None, -1)] * structure.ndim)]
+    if footprint is not None:
+        footprint = cupy.array(footprint)
+        footprint = footprint[tuple([slice(None, None, -1)] * footprint.ndim)]
+
+    origin = _util._fix_sequence_arg(origin, input.ndim, 'origin', int)
+    for i in range(len(origin)):
+        origin[i] = -origin[i]
+        if footprint is not None:
+            sz = footprint.shape[i]
+        elif structure is not None:
+            sz = structure.shape[i]
+        elif numpy.isscalar(size):
+            sz = size
+        else:
+            sz = size[i]
+        if sz % 2 == 0:
+            origin[i] -= 1
+
+    return _filters._min_or_max_filter(input, size, footprint, structure,
+                                       output, mode, cval, origin, 'max')
+
+
+def grey_closing(input, size=None, footprint=None, structure=None,
+                 output=None, mode='reflect', cval=0.0, origin=0):
+    """Calculates a multi-dimensional greyscale closing.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (tuple of ints): Shape of a flat and full structuring element used
+            for the greyscale closing. Optional if ``footprint`` or
+            ``structure`` is provided.
+        footprint (array of ints): Positions of non-infinite elements of a flat
+            structuring element used for greyscale closing. Non-zero values
+            give the set of neighbors of the center over which closing is
+            chosen.
+        structure (array of ints): Structuring element used for the greyscale
+            closing. ``structure`` may be a non-flat structuring element.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``constant``. Default is ``0.0``.
+        origin (scalar or tuple of scalar): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The result of greyscale closing.
+
+    .. seealso:: :func:`scipy.ndimage.grey_closing`
+    """
+    if (size is not None) and (footprint is not None):
+        warnings.warn('ignoring size because footprint is set', UserWarning,
+                      stacklevel=2)
+    tmp = grey_dilation(input, size, footprint, structure, None, mode, cval,
+                        origin)
+    return grey_erosion(tmp, size, footprint, structure, output, mode, cval,
+                        origin)
+
+
+def grey_opening(input, size=None, footprint=None, structure=None,
+                 output=None, mode='reflect', cval=0.0, origin=0):
+    """Calculates a multi-dimensional greyscale opening.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (tuple of ints): Shape of a flat and full structuring element used
+            for the greyscale opening. Optional if ``footprint`` or
+            ``structure`` is provided.
+        footprint (array of ints): Positions of non-infinite elements of a flat
+            structuring element used for greyscale opening. Non-zero values
+            give the set of neighbors of the center over which opening is
+            chosen.
+        structure (array of ints): Structuring element used for the greyscale
+            opening. ``structure`` may be a non-flat structuring element.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``constant``. Default is ``0.0``.
+        origin (scalar or tuple of scalar): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The result of greyscale opening.
+
+    .. seealso:: :func:`scipy.ndimage.grey_opening`
+    """
+    if (size is not None) and (footprint is not None):
+        warnings.warn('ignoring size because footprint is set', UserWarning,
+                      stacklevel=2)
+    tmp = grey_erosion(input, size, footprint, structure, None, mode, cval,
+                       origin)
+    return grey_dilation(tmp, size, footprint, structure, output, mode, cval,
+                         origin)
+
+
+def morphological_gradient(
+    input,
+    size=None,
+    footprint=None,
+    structure=None,
+    output=None,
+    mode='reflect',
+    cval=0.0,
+    origin=0,
+):
+    """
+    Multidimensional morphological gradient.
+
+    The morphological gradient is calculated as the difference between a
+    dilation and an erosion of the input with a given structuring element.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (tuple of ints): Shape of a flat and full structuring element used
+            for the morphological gradient. Optional if ``footprint`` or
+            ``structure`` is provided.
+        footprint (array of ints): Positions of non-infinite elements of a flat
+            structuring element used for morphological gradient. Non-zero
+            values give the set of neighbors of the center over which opening
+            is chosen.
+        structure (array of ints): Structuring element used for the
+            morphological gradient. ``structure`` may be a non-flat
+            structuring element.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``constant``. Default is ``0.0``.
+        origin (scalar or tuple of scalar): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The morphological gradient of the input.
+
+    .. seealso:: :func:`scipy.ndimage.morphological_gradient`
+    """
+    tmp = grey_dilation(
+        input, size, footprint, structure, None, mode, cval, origin
+    )
+    if isinstance(output, cupy.ndarray):
+        grey_erosion(
+            input, size, footprint, structure, output, mode, cval, origin
+        )
+        return cupy.subtract(tmp, output, output)
+    else:
+        return tmp - grey_erosion(
+            input, size, footprint, structure, None, mode, cval, origin
+        )
+
+
+def morphological_laplace(
+    input,
+    size=None,
+    footprint=None,
+    structure=None,
+    output=None,
+    mode='reflect',
+    cval=0.0,
+    origin=0,
+):
+    """
+    Multidimensional morphological laplace.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (tuple of ints): Shape of a flat and full structuring element used
+            for the morphological laplace. Optional if ``footprint`` or
+            ``structure`` is provided.
+        footprint (array of ints): Positions of non-infinite elements of a flat
+            structuring element used for morphological laplace. Non-zero
+            values give the set of neighbors of the center over which opening
+            is chosen.
+        structure (array of ints): Structuring element used for the
+            morphological laplace. ``structure`` may be a non-flat
+            structuring element.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``constant``. Default is ``0.0``.
+        origin (scalar or tuple of scalar): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: The morphological laplace of the input.
+
+    .. seealso:: :func:`scipy.ndimage.morphological_laplace`
+    """
+    tmp1 = grey_dilation(
+        input, size, footprint, structure, None, mode, cval, origin
+    )
+    if isinstance(output, cupy.ndarray):
+        grey_erosion(
+            input, size, footprint, structure, output, mode, cval, origin
+        )
+        cupy.add(tmp1, output, output)
+        cupy.subtract(output, input, output)
+        return cupy.subtract(output, input, output)
+    else:
+        tmp2 = grey_erosion(
+            input, size, footprint, structure, None, mode, cval, origin
+        )
+        cupy.add(tmp1, tmp2, tmp2)
+        cupy.subtract(tmp2, input, tmp2)
+        cupy.subtract(tmp2, input, tmp2)
+        return tmp2
+
+
+def white_tophat(
+    input,
+    size=None,
+    footprint=None,
+    structure=None,
+    output=None,
+    mode='reflect',
+    cval=0.0,
+    origin=0,
+):
+    """
+    Multidimensional white tophat filter.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (tuple of ints): Shape of a flat and full structuring element used
+            for the white tophat. Optional if ``footprint`` or ``structure`` is
+            provided.
+        footprint (array of ints): Positions of non-infinite elements of a flat
+            structuring element used for the white tophat. Non-zero values
+            give the set of neighbors of the center over which opening is
+            chosen.
+        structure (array of ints): Structuring element used for the white
+            tophat. ``structure`` may be a non-flat structuring element.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``constant``. Default is ``0.0``.
+        origin (scalar or tuple of scalar): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarray: Result of the filter of ``input`` with ``structure``.
+
+    .. seealso:: :func:`scipy.ndimage.white_tophat`
+    """
+    if (size is not None) and (footprint is not None):
+        warnings.warn(
+            'ignoring size because footprint is set', UserWarning, stacklevel=2
+        )
+    tmp = grey_erosion(
+        input, size, footprint, structure, None, mode, cval, origin
+    )
+    tmp = grey_dilation(
+        tmp, size, footprint, structure, output, mode, cval, origin
+    )
+    if input.dtype == numpy.bool_ and tmp.dtype == numpy.bool_:
+        cupy.bitwise_xor(input, tmp, out=tmp)
+    else:
+        cupy.subtract(input, tmp, out=tmp)
+    return tmp
+
+
+def black_tophat(
+    input,
+    size=None,
+    footprint=None,
+    structure=None,
+    output=None,
+    mode='reflect',
+    cval=0.0,
+    origin=0,
+):
+    """
+    Multidimensional black tophat filter.
+
+    Args:
+        input (cupy.ndarray): The input array.
+        size (tuple of ints): Shape of a flat and full structuring element used
+            for the black tophat. Optional if ``footprint`` or ``structure`` is
+            provided.
+        footprint (array of ints): Positions of non-infinite elements of a flat
+            structuring element used for the black tophat. Non-zero values
+            give the set of neighbors of the center over which opening is
+            chosen.
+        structure (array of ints): Structuring element used for the black
+            tophat. ``structure`` may be a non-flat structuring element.
+        output (cupy.ndarray, dtype or None): The array in which to place the
+            output.
+        mode (str): The array borders are handled according to the given mode
+            (``'reflect'``, ``'constant'``, ``'nearest'``, ``'mirror'``,
+            ``'wrap'``). Default is ``'reflect'``.
+        cval (scalar): Value to fill past edges of input if mode is
+            ``constant``. Default is ``0.0``.
+        origin (scalar or tuple of scalar): The origin parameter controls the
+            placement of the filter, relative to the center of the current
+            element of the input. Default of 0 is equivalent to
+            ``(0,)*input.ndim``.
+
+    Returns:
+        cupy.ndarry : Result of the filter of ``input`` with ``structure``.
+
+    .. seealso:: :func:`scipy.ndimage.black_tophat`
+    """
+    if (size is not None) and (footprint is not None):
+        warnings.warn(
+            'ignoring size because footprint is set', UserWarning, stacklevel=2
+        )
+    tmp = grey_dilation(
+        input, size, footprint, structure, None, mode, cval, origin
+    )
+    tmp = grey_erosion(
+        tmp, size, footprint, structure, output, mode, cval, origin
+    )
+    if input.dtype == numpy.bool_ and tmp.dtype == numpy.bool_:
+        cupy.bitwise_xor(tmp, input, out=tmp)
+    else:
+        cupy.subtract(tmp, input, out=tmp)
+    return tmp

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/_pba_2d.py

@@ -0,0 +1,503 @@
+import math
+import numbers
+import os
+
+import cupy
+
+from ._util import _get_inttype
+
+if hasattr(math, 'lcm'):
+    lcm = math.lcm
+else:
+    """Fallback implementation of least common multiple (lcm)"""
+    def _lcm(a, b):
+        return abs(b * (a // math.gcd(a, b)))
+
+    def lcm(*integers):
+        nargs = len(integers)
+        if not all(isinstance(a, numbers.Integral) for a in integers):
+            raise TypeError("all arguments must be integers")
+        if nargs == 0:
+            return 1
+        res = int(integers[0])
+        if nargs == 1:
+            return abs(res)
+        for i in range(1, nargs):
+            x = int(integers[i])
+            res = _lcm(res, x)
+        return res
+
+
+pba2d_defines_template = """
+
+// MARKER is used to mark blank pixels in the texture.
+// Any uncolored pixels will have x = MARKER.
+// Input texture should have x = MARKER for all pixels other than sites
+#define MARKER      {marker}
+#define BLOCKSIZE   {block_size_2d}
+#define pixel_int2_t {pixel_int2_t}                // typically short2 (int2 for images with > 32k pixels per side)
+#define make_pixel(x, y)  {make_pixel_func}(x, y)  // typically make_short2 (make_int2 images with > 32k pixels per side
+
+"""  # noqa
+
+
+def _init_marker(int_dtype):
+    """use a minimum value that is appropriate to the integer dtype"""
+    if int_dtype == cupy.int16:
+        # marker = cupy.iinfo(int_dtype).min
+        marker = -32768
+    elif int_dtype == cupy.int32:
+        # divide by two so we don't have to promote other intermediate int
+        # variables to 64-bit int
+        marker = -2147483648 // 2
+    else:
+        raise ValueError(
+            "expected int_dtype to be either cupy.int16 or cupy.int32"
+        )
+    return marker
+
+
+@cupy.memoize(True)
+def get_pba2d_src(block_size_2d=64, marker=-32768, pixel_int2_t="short2"):
+    make_pixel_func = "make_" + pixel_int2_t
+
+    pba2d_code = pba2d_defines_template.format(
+        block_size_2d=block_size_2d,
+        marker=marker,
+        pixel_int2_t=pixel_int2_t,
+        make_pixel_func=make_pixel_func
+    )
+    kernel_directory = os.path.join(os.path.dirname(__file__), "cuda")
+    with open(os.path.join(kernel_directory, "pba_kernels_2d.h"), "rt") as f:
+        pba2d_kernels = "\n".join(f.readlines())
+
+    pba2d_code += pba2d_kernels
+    return pba2d_code
+
+
+def _get_block_size(check_warp_size=False):
+    if check_warp_size:
+        dev = cupy.cuda.runtime.getDevice()
+        device_properties = cupy.cuda.runtime.getDeviceProperties(dev)
+        return int(device_properties["warpSize"])
+    else:
+        return 32
+
+
+@cupy.memoize(for_each_device=True)
+def _get_pack_kernel(int_type, marker=-32768):
+    """Pack coordinates into array of type short2 (or int2).
+
+    This kernel works with 2D input data, `arr` (typically boolean).
+
+    The output array, `out` will be 3D with a signed integer dtype.
+    It will have size 2 on the last axis so that it can be viewed as a CUDA
+    vector type such as `int2` or `float2`.
+    """
+    code = f"""
+    if (arr[i]) {{
+        out[2*i] = {marker};
+        out[2*i + 1] = {marker};
+    }} else {{
+        int shape_1 = arr.shape()[1];
+        int _i = i;
+        int ind_1 = _i % shape_1;
+        _i /= shape_1;
+        out[2*i] = ind_1;   // out.x
+        out[2*i + 1] = _i;  // out.y
+    }}
+    """
+    return cupy.ElementwiseKernel(
+        in_params="raw B arr",
+        out_params="raw I out",
+        operation=code,
+        options=("--std=c++11",),
+    )
+
+
+def _pack_int2(arr, marker=-32768, int_dtype=cupy.int16):
+    if arr.ndim != 2:
+        raise ValueError("only 2d arr supported")
+    int2_dtype = cupy.dtype({"names": ["x", "y"], "formats": [int_dtype] * 2})
+    out = cupy.zeros(arr.shape + (2,), dtype=int_dtype)
+    assert out.size == 2 * arr.size
+    pack_kernel = _get_pack_kernel(
+        int_type="short" if int_dtype == cupy.int16 else "int",
+        marker=marker
+    )
+    pack_kernel(arr, out, size=arr.size)
+    out = cupy.squeeze(out.view(int2_dtype))
+    return out
+
+
+def _unpack_int2(img, make_copy=False, int_dtype=cupy.int16):
+    temp = img.view(int_dtype).reshape(img.shape + (2,))
+    if make_copy:
+        temp = temp.copy()
+    return temp
+
+
+def _determine_padding(shape, padded_size, block_size):
+    # all kernels assume equal size along both axes, so pad up to equal size if
+    # shape is not isotropic
+    orig_sy, orig_sx = shape
+    if orig_sx != padded_size or orig_sy != padded_size:
+        padding_width = (
+            (0, padded_size - orig_sy), (0, padded_size - orig_sx)
+        )
+    else:
+        padding_width = None
+    return padding_width
+
+
+def _generate_shape(ndim, int_type, var_name="out", raw_var=True):
+    code = ""
+    if not raw_var:
+        var_name = "_raw_" + var_name
+    for i in range(ndim):
+        code += f"{int_type} shape_{i} = {var_name}.shape()[{i}];\n"
+    return code
+
+
+def _generate_indices_ops(ndim, int_type):
+    code = f"{int_type} _i = i;\n"
+    for j in range(ndim - 1, 0, -1):
+        code += f"{int_type} ind_{j} = _i % shape_{j};\n_i /= shape_{j};\n"
+    code += f"{int_type} ind_0 = _i;"
+    return code
+
+
+def _get_distance_kernel_code(int_type, dist_int_type, raw_out_var=True):
+    code = _generate_shape(
+        ndim=2, int_type=int_type, var_name="dist", raw_var=raw_out_var
+    )
+    code += _generate_indices_ops(ndim=2, int_type=int_type)
+    code += f"""
+    {int_type} tmp;
+    {dist_int_type} sq_dist;
+    tmp = y[i] - ind_0;
+    sq_dist = tmp * tmp;
+    tmp = x[i] - ind_1;
+    sq_dist += tmp * tmp;
+    dist[i] = sqrt(static_cast<F>(sq_dist));
+    """
+    return code
+
+
+@cupy.memoize(for_each_device=True)
+def _get_distance_kernel(int_type, dist_int_type):
+    """Returns kernel computing the Euclidean distance from coordinates."""
+    operation = _get_distance_kernel_code(
+        int_type, dist_int_type, raw_out_var=True
+    )
+    return cupy.ElementwiseKernel(
+        in_params="raw I y, raw I x",
+        out_params="raw F dist",
+        operation=operation,
+        options=("--std=c++11",),
+    )
+
+
+def _get_aniso_distance_kernel_code(int_type, raw_out_var=True):
+    code = _generate_shape(
+        ndim=2, int_type=int_type, var_name="dist", raw_var=raw_out_var
+    )
+    code += _generate_indices_ops(ndim=2, int_type=int_type)
+    code += """
+    F tmp;
+    F sq_dist;
+    tmp = static_cast<F>(y[i] - ind_0) * sampling[0];
+    sq_dist = tmp * tmp;
+    tmp = static_cast<F>(x[i] - ind_1) * sampling[1];
+    sq_dist += tmp * tmp;
+    dist[i] = sqrt(sq_dist);
+    """
+    return code
+
+
+@cupy.memoize(for_each_device=True)
+def _get_aniso_distance_kernel(int_type):
+    """Returns kernel computing the Euclidean distance from coordinates."""
+    operation = _get_aniso_distance_kernel_code(int_type, raw_out_var=True)
+    return cupy.ElementwiseKernel(
+        in_params="raw I y, raw I x, raw F sampling",
+        out_params="raw F dist",
+        operation=operation,
+        options=("--std=c++11",),
+    )
+
+
+def _distance_tranform_arg_check(distances_out, indices_out,
+                                 return_distances, return_indices):
+    """Raise a RuntimeError if the arguments are invalid"""
+    error_msgs = []
+    if (not return_distances) and (not return_indices):
+        error_msgs.append(
+            "at least one of return_distances/return_indices must be True")
+    if distances_out and not return_distances:
+        error_msgs.append(
+            "return_distances must be True if distances is supplied"
+        )
+    if indices_out and not return_indices:
+        error_msgs.append("return_indices must be True if indices is supplied")
+    if error_msgs:
+        raise RuntimeError(", ".join(error_msgs))
+
+
+def _check_distances(distances, shape, dtype):
+    if distances.shape != shape:
+        raise RuntimeError("distances array has wrong shape")
+    if distances.dtype != dtype:
+        raise RuntimeError(
+            f"distances array must have dtype: {dtype}")
+
+
+def _check_indices(indices, shape, itemsize):
+    if indices.shape != shape:
+        raise RuntimeError("indices array has wrong shape")
+    if indices.dtype.kind not in 'iu':
+        raise RuntimeError(
+            "indices array must have an integer dtype"
+        )
+    elif indices.dtype.itemsize < itemsize:
+        raise RuntimeError(
+            f"indices dtype must have itemsize > {itemsize}"
+        )
+
+
+def _pba_2d(arr, sampling=None, return_distances=True, return_indices=False,
+            block_params=None, check_warp_size=False, *,
+            float64_distances=False, distances=None, indices=None):
+
+    indices_inplace = isinstance(indices, cupy.ndarray)
+    dt_inplace = isinstance(distances, cupy.ndarray)
+    _distance_tranform_arg_check(
+        dt_inplace, indices_inplace, return_distances, return_indices
+    )
+
+    # input_arr: a 2D image
+    #    For each site at (x, y), the pixel at coordinate (x, y) should contain
+    #    the pair (x, y). Pixels that are not sites should contain the pair
+    #    (MARKER, MARKER)
+
+    # Note: could query warp size here, but for now just assume 32 to avoid
+    #       overhead of querying properties
+    block_size = _get_block_size(check_warp_size)
+
+    if block_params is None:
+        padded_size = math.ceil(max(arr.shape) / block_size) * block_size
+
+        # should be <= size / block_size. sy must be a multiple of m1
+        m1 = padded_size // block_size
+        # size must be a multiple of m2
+        m2 = max(1, min(padded_size // block_size, block_size))
+        # m2 must also be a power of two
+        m2 = 2**math.floor(math.log2(m2))
+        if padded_size % m2 != 0:
+            raise RuntimeError("error in setting default m2")
+        m3 = min(min(m1, m2), 2)
+    else:
+        if any(p < 1 for p in block_params):
+            raise ValueError("(m1, m2, m3) in blockparams must be >= 1")
+        m1, m2, m3 = block_params
+        if math.log2(m2) % 1 > 1e-5:
+            raise ValueError("m2 must be a power of 2")
+        multiple = lcm(block_size, m1, m2, m3)
+        padded_size = math.ceil(max(arr.shape) / multiple) * multiple
+
+    if m1 > padded_size // block_size:
+        raise ValueError(
+            f"m1 too large. must be <= padded arr.shape[0] // {block_size}"
+        )
+    if m2 > padded_size // block_size:
+        raise ValueError(
+            f"m2 too large. must be <= padded arr.shape[1] // {block_size}"
+        )
+    if m3 > padded_size // block_size:
+        raise ValueError(
+            f"m3 too large. must be <= padded arr.shape[1] // {block_size}"
+        )
+    for m in (m1, m2, m3):
+        if padded_size % m != 0:
+            raise ValueError(
+                f"Largest dimension of image ({padded_size}) must be evenly "
+                f"disivible by each element of block_params: {(m1, m2, m3)}."
+            )
+
+    shape_max = max(arr.shape)
+    if shape_max <= 32768:
+        int_dtype = cupy.int16
+        pixel_int2_type = "short2"
+    else:
+        if shape_max > (1 << 24):
+            # limit to coordinate range to 2**24 due to use of __mul24 in
+            # coordinate TOID macro
+            raise ValueError(
+                f"maximum axis size of {1 << 24} exceeded, for image with "
+                f"shape {arr.shape}"
+            )
+        int_dtype = cupy.int32
+        pixel_int2_type = "int2"
+
+    marker = _init_marker(int_dtype)
+
+    orig_sy, orig_sx = arr.shape
+    padding_width = _determine_padding(arr.shape, padded_size, block_size)
+    if padding_width is not None:
+        arr = cupy.pad(arr, padding_width, mode="constant", constant_values=1)
+    size = arr.shape[0]
+
+    input_arr = _pack_int2(arr, marker=marker, int_dtype=int_dtype)
+    output = cupy.zeros_like(input_arr)
+
+    int2_dtype = cupy.dtype({"names": ["x", "y"], "formats": [int_dtype] * 2})
+    margin = cupy.empty((2 * m1 * size,), dtype=int2_dtype)
+
+    # phase 1 of PBA. m1 must divide texture size and be <= 64
+    pba2d = cupy.RawModule(
+        code=get_pba2d_src(
+            block_size_2d=block_size,
+            marker=marker,
+            pixel_int2_t=pixel_int2_type,
+        )
+    )
+    kernelFloodDown = pba2d.get_function("kernelFloodDown")
+    kernelFloodUp = pba2d.get_function("kernelFloodUp")
+    kernelPropagateInterband = pba2d.get_function("kernelPropagateInterband")
+    kernelUpdateVertical = pba2d.get_function("kernelUpdateVertical")
+    kernelCreateForwardPointers = pba2d.get_function(
+        "kernelCreateForwardPointers"
+    )
+    kernelDoubleToSingleList = pba2d.get_function("kernelDoubleToSingleList")
+
+    if sampling is None:
+        kernelProximatePoints = pba2d.get_function("kernelProximatePoints")
+        kernelMergeBands = pba2d.get_function("kernelMergeBands")
+        kernelColor = pba2d.get_function("kernelColor")
+    else:
+        kernelProximatePoints = pba2d.get_function(
+            "kernelProximatePointsWithSpacing"
+        )
+        kernelMergeBands = pba2d.get_function("kernelMergeBandsWithSpacing")
+        kernelColor = pba2d.get_function("kernelColorWithSpacing")
+
+    block = (block_size, 1, 1)
+    grid = (math.ceil(size / block[0]), m1, 1)
+    bandSize1 = size // m1
+    # kernelFloodDown modifies input_arr in-place
+    kernelFloodDown(
+        grid,
+        block,
+        (input_arr, input_arr, size, bandSize1),
+    )
+    # kernelFloodUp modifies input_arr in-place
+    kernelFloodUp(
+        grid,
+        block,
+        (input_arr, input_arr, size, bandSize1),
+    )
+    # kernelFloodUp fills values into margin
+    kernelPropagateInterband(
+        grid,
+        block,
+        (input_arr, margin, size, bandSize1),
+    )
+    # kernelUpdateVertical stores output into an intermediate array of
+    # transposed shape
+    kernelUpdateVertical(
+        grid,
+        block,
+        (input_arr, margin, output, size, bandSize1),
+    )
+
+    # phase 2
+    block = (block_size, 1, 1)
+    grid = (math.ceil(size / block[0]), m2, 1)
+    bandSize2 = size // m2
+    if sampling is None:
+        sampling_args = ()
+    else:
+        # Originally the shape is (y, x) and sampling[1] corresponds to y.
+        # However, kernelUpdateVertical transposed the image, so
+        # we are now working with (x, y) instead. Need sampling ordered
+        # accordingly.
+        sampling = tuple(map(float, sampling))
+        sampling_args = (sampling[0], sampling[1])
+    kernelProximatePoints(
+        grid,
+        block,
+        (output, input_arr, size, bandSize2) + sampling_args,
+    )
+    kernelCreateForwardPointers(
+        grid,
+        block,
+        (input_arr, input_arr, size, bandSize2),
+    )
+    # Repeatedly merging two bands into one
+    noBand = m2
+    while noBand > 1:
+        grid = (math.ceil(size / block[0]), noBand // 2)
+        kernelMergeBands(
+            grid,
+            block,
+            (output, input_arr, input_arr, size, size // noBand) + sampling_args,  # noqa
+        )
+        noBand //= 2
+    # Replace the forward link with the X coordinate of the seed to remove
+    # the need of looking at the other texture. We need it for coloring.
+    grid = (math.ceil(size / block[0]), size)
+    kernelDoubleToSingleList(
+        grid,
+        block,
+        (output, input_arr, input_arr, size),
+    )
+
+    # Phase 3 of PBA
+    block = (block_size, m3, 1)
+    grid = (math.ceil(size / block[0]), 1, 1)
+    kernelColor(
+        grid,
+        block,
+        (input_arr, output, size) + sampling_args,
+    )
+
+    output = _unpack_int2(output, make_copy=False, int_dtype=int_dtype)
+    # make sure to crop any padding that was added here!
+    x = output[:orig_sy, :orig_sx, 0]
+    y = output[:orig_sy, :orig_sx, 1]
+
+    vals = ()
+    if return_distances:
+        dtype_out = cupy.float64 if float64_distances else cupy.float32
+        if dt_inplace:
+            _check_distances(distances, y.shape, dtype_out)
+        else:
+            distances = cupy.zeros(y.shape, dtype=dtype_out)
+
+        # make sure maximum possible distance doesn"t overflow
+        max_possible_dist = sum((s - 1)**2 for s in y.shape)
+        dist_int_type = "int" if max_possible_dist < 2**31 else "ptrdiff_t"
+
+        if sampling is None:
+            distance_kernel = _get_distance_kernel(
+                int_type=_get_inttype(distances),
+                dist_int_type=dist_int_type,
+            )
+            distance_kernel(y, x, distances, size=distances.size)
+        else:
+            distance_kernel = _get_aniso_distance_kernel(
+                int_type=_get_inttype(distances),
+            )
+            sampling = cupy.asarray(sampling, dtype=dtype_out)
+            distance_kernel(y, x, sampling, distances, size=distances.size)
+
+        vals = vals + (distances,)
+    if return_indices:
+        if indices_inplace:
+            _check_indices(indices, (arr.ndim,) + arr.shape, x.dtype.itemsize)
+            indices[0, ...] = y
+            indices[1, ...] = x
+        else:
+            indices = cupy.stack((y, x), axis=0)
+        vals = vals + (indices,)
+    return vals

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/_pba_3d.py

@@ -0,0 +1,491 @@
+import math
+import os
+
+import cupy
+import numpy as np
+
+from ._util import _get_inttype
+from ._pba_2d import (_check_distances, _check_indices,
+                      _distance_tranform_arg_check, _generate_indices_ops,
+                      _generate_shape, _get_block_size, lcm)
+
+pba3d_defines_template = """
+
+#define MARKER     {marker}
+#define MAX_INT    {max_int}
+#define BLOCKSIZE  {block_size_3d}
+
+"""
+
+# For efficiency, the original PBA+ packs three 10-bit integers and two binary
+# flags into a single 32-bit integer. The defines in
+# `pba3d_defines_encode_32bit` handle this format.
+pba3d_defines_encode_32bit = """
+// Sites     : ENCODE(x, y, z, 0, 0)
+// Not sites : ENCODE(0, 0, 0, 1, 0) or MARKER
+#define ENCODED_INT_TYPE int
+#define ZERO 0
+#define ONE 1
+#define ENCODE(x, y, z, a, b)  (((x) << 20) | ((y) << 10) | (z) | ((a) << 31) | ((b) << 30))
+#define DECODE(value, x, y, z) \
+    x = ((value) >> 20) & 0x3ff; \
+    y = ((value) >> 10) & 0x3ff; \
+    z = (value) & 0x3ff
+
+#define NOTSITE(value)  (((value) >> 31) & 1)
+#define HASNEXT(value)  (((value) >> 30) & 1)
+
+#define GET_X(value)    (((value) >> 20) & 0x3ff)
+#define GET_Y(value)    (((value) >> 10) & 0x3ff)
+#define GET_Z(value)    ((NOTSITE((value))) ? MAX_INT : ((value) & 0x3ff))
+
+"""  # noqa
+
+
+# 64bit version of ENCODE/DECODE to allow a 20-bit integer per coordinate axis.
+pba3d_defines_encode_64bit = """
+// Sites     : ENCODE(x, y, z, 0, 0)
+// Not sites : ENCODE(0, 0, 0, 1, 0) or MARKER
+#define ENCODED_INT_TYPE long long
+#define ZERO 0L
+#define ONE 1L
+#define ENCODE(x, y, z, a, b)  (((x) << 40) | ((y) << 20) | (z) | ((a) << 61) | ((b) << 60))
+#define DECODE(value, x, y, z) \
+    x = ((value) >> 40) & 0xfffff; \
+    y = ((value) >> 20) & 0xfffff; \
+    z = (value) & 0xfffff
+
+#define NOTSITE(value)  (((value) >> 61) & 1)
+#define HASNEXT(value)  (((value) >> 60) & 1)
+
+#define GET_X(value)    (((value) >> 40) & 0xfffff)
+#define GET_Y(value)    (((value) >> 20) & 0xfffff)
+#define GET_Z(value)    ((NOTSITE((value))) ? MAX_INT : ((value) & 0xfffff))
+
+"""  # noqa
+
+
+@cupy.memoize(True)
+def get_pba3d_src(block_size_3d=32, marker=-2147483648, max_int=2147483647,
+                  size_max=1024):
+    pba3d_code = pba3d_defines_template.format(
+        block_size_3d=block_size_3d, marker=marker, max_int=max_int
+    )
+    if size_max > 1024:
+        pba3d_code += pba3d_defines_encode_64bit
+    else:
+        pba3d_code += pba3d_defines_encode_32bit
+    kernel_directory = os.path.join(os.path.dirname(__file__), "cuda")
+    with open(os.path.join(kernel_directory, "pba_kernels_3d.h"), "rt") as f:
+        pba3d_kernels = "\n".join(f.readlines())
+    pba3d_code += pba3d_kernels
+    return pba3d_code
+
+
+@cupy.memoize(for_each_device=True)
+def _get_encode3d_kernel(size_max, marker=-2147483648):
+    """Pack array coordinates into a single integer."""
+    if size_max > 1024:
+        int_type = "ptrdiff_t"  # int64_t
+    else:
+        int_type = "int"        # int32_t
+
+    # value must match TOID macro in the C++ code!
+    if size_max > 1024:
+        value = """(((x) << 40) | ((y) << 20) | (z))"""
+    else:
+        value = """(((x) << 20) | ((y) << 10) | (z))"""
+
+    code = f"""
+    if (arr[i]) {{
+        out[i] = {marker};
+    }} else {{
+        {int_type} shape_2 = arr.shape()[2];
+        {int_type} shape_1 = arr.shape()[1];
+        {int_type} _i = i;
+        {int_type} x = _i % shape_2;
+        _i /= shape_2;
+        {int_type} y = _i % shape_1;
+        _i /= shape_1;
+        {int_type} z = _i;
+        out[i] = {value};
+    }}
+    """
+    return cupy.ElementwiseKernel(
+        in_params="raw B arr",
+        out_params="raw I out",
+        operation=code,
+        options=("--std=c++11",),
+    )
+
+
+def encode3d(arr, marker=-2147483648, bit_depth=32, size_max=1024):
+    if arr.ndim != 3:
+        raise ValueError("only 3d arr supported")
+    if bit_depth not in [32, 64]:
+        raise ValueError("only bit_depth of 32 or 64 is supported")
+    if size_max > 1024:
+        dtype = np.int64
+    else:
+        dtype = np.int32
+    image = cupy.zeros(arr.shape, dtype=dtype, order="C")
+    kern = _get_encode3d_kernel(size_max, marker=marker)
+    kern(arr, image, size=image.size)
+    return image
+
+
+def _get_decode3d_code(size_max, int_type=""):
+    # bit shifts here must match those used in the encode3d kernel
+    if size_max > 1024:
+        code = f"""
+        {int_type} x = (encoded >> 40) & 0xfffff;
+        {int_type} y = (encoded >> 20) & 0xfffff;
+        {int_type} z = encoded & 0xfffff;
+        """
+    else:
+        code = f"""
+        {int_type} x = (encoded >> 20) & 0x3ff;
+        {int_type} y = (encoded >> 10) & 0x3ff;
+        {int_type} z = encoded & 0x3ff;
+        """
+    return code
+
+
+@cupy.memoize(for_each_device=True)
+def _get_decode3d_kernel(size_max):
+    """Unpack 3 coordinates encoded as a single integer."""
+
+    # int_type = "" here because x, y, z were already allocated externally
+    code = _get_decode3d_code(size_max, int_type="")
+
+    return cupy.ElementwiseKernel(
+        in_params="E encoded",
+        out_params="I x, I y, I z",
+        operation=code,
+        options=("--std=c++11",),
+    )
+
+
+def decode3d(encoded, size_max=1024):
+    coord_dtype = cupy.int32 if size_max < 2**31 else cupy.int64
+    x = cupy.empty_like(encoded, dtype=coord_dtype)
+    y = cupy.empty_like(x)
+    z = cupy.empty_like(x)
+    kern = _get_decode3d_kernel(size_max)
+    kern(encoded, x, y, z)
+    return (x, y, z)
+
+
+def _determine_padding(shape, block_size, m1, m2, m3, blockx, blocky):
+    # TODO: can possibly revise to consider only particular factors for LCM on
+    #       a given axis
+    LCM = lcm(block_size, m1, m2, m3, blockx, blocky)
+    orig_sz, orig_sy, orig_sx = shape
+    round_up = False
+    if orig_sx % LCM != 0:
+        # round up size to a multiple of the band size
+        round_up = True
+        sx = LCM * math.ceil(orig_sx / LCM)
+    else:
+        sx = orig_sx
+    if orig_sy % LCM != 0:
+        # round up size to a multiple of the band size
+        round_up = True
+        sy = LCM * math.ceil(orig_sy / LCM)
+    else:
+        sy = orig_sy
+    if orig_sz % LCM != 0:
+        # round up size to a multiple of the band size
+        round_up = True
+        sz = LCM * math.ceil(orig_sz / LCM)
+    else:
+        sz = orig_sz
+
+    aniso = not (sx == sy == sz)
+    if aniso or round_up:
+        smax = max(sz, sy, sx)
+        padding_width = (
+            (0, smax - orig_sz), (0, smax - orig_sy), (0, smax - orig_sx)
+        )
+    else:
+        padding_width = None
+    return padding_width
+
+
+def _generate_distance_computation(int_type, dist_int_type):
+    """
+    Compute euclidean distance from current coordinate (ind_0, ind_1, ind_2) to
+    the coordinates of the nearest point (z, y, x)."""
+    return f"""
+    {int_type} tmp = z - ind_0;
+    {dist_int_type} sq_dist = tmp * tmp;
+    tmp = y - ind_1;
+    sq_dist += tmp * tmp;
+    tmp = x - ind_2;
+    sq_dist += tmp * tmp;
+    dist[i] = sqrt(static_cast<F>(sq_dist));
+    """
+
+
+def _get_distance_kernel_code(int_type, dist_int_type, raw_out_var=True):
+    code = _generate_shape(
+        ndim=3, int_type=int_type, var_name="dist", raw_var=raw_out_var
+    )
+    code += _generate_indices_ops(ndim=3, int_type=int_type)
+    code += _generate_distance_computation(int_type, dist_int_type)
+    return code
+
+
+@cupy.memoize(for_each_device=True)
+def _get_distance_kernel(int_type, large_dist=False):
+    """Returns kernel computing the Euclidean distance from coordinates."""
+    dist_int_type = "ptrdiff_t" if large_dist else "int"
+    operation = _get_distance_kernel_code(
+        int_type, dist_int_type, raw_out_var=True
+    )
+    return cupy.ElementwiseKernel(
+        in_params="I z, I y, I x",
+        out_params="raw F dist",
+        operation=operation,
+        options=("--std=c++11",),
+    )
+
+
+def _generate_aniso_distance_computation():
+    """
+    Compute euclidean distance from current coordinate (ind_0, ind_1, ind_2) to
+    the coordinates of the nearest point (z, y, x)."""
+    return """
+    F tmp = static_cast<F>(z - ind_0) * sampling[0];
+    F sq_dist = tmp * tmp;
+    tmp = static_cast<F>(y - ind_1) * sampling[1];
+    sq_dist += tmp * tmp;
+    tmp = static_cast<F>(x - ind_2) * sampling[2];
+    sq_dist += tmp * tmp;
+    dist[i] = sqrt(static_cast<F>(sq_dist));
+    """
+
+
+def _get_aniso_distance_kernel_code(int_type, raw_out_var=True):
+    code = _generate_shape(
+        ndim=3, int_type=int_type, var_name="dist", raw_var=raw_out_var
+    )
+    code += _generate_indices_ops(ndim=3, int_type=int_type)
+    code += _generate_aniso_distance_computation()
+    return code
+
+
+@cupy.memoize(for_each_device=True)
+def _get_aniso_distance_kernel(int_type):
+    """Returns kernel computing the Euclidean distance from coordinates with
+    axis spacing != 1."""
+    operation = _get_aniso_distance_kernel_code(
+        int_type, raw_out_var=True
+    )
+    return cupy.ElementwiseKernel(
+        in_params="I z, I y, I x, raw F sampling",
+        out_params="raw F dist",
+        operation=operation,
+        options=("--std=c++11",),
+    )
+
+
+@cupy.memoize(for_each_device=True)
+def _get_decode_as_distance_kernel(size_max, large_dist=False, sampling=None):
+    """Fused decode3d and distance computation.
+
+    This kernel is for use when `return_distances=True`, but
+    `return_indices=False`. It replaces the separate calls to
+    `_get_decode3d_kernel` and `_get_distance_kernel`, avoiding the overhead of
+    generating full arrays containing the coordinates since the coordinate
+    arrays are not going to be returned.
+    """
+    if sampling is None:
+        dist_int_type = "ptrdiff_t" if large_dist else "int"
+    int_type = "int"
+
+    # Step 1: decode the (z, y, x) coordinate
+    code = _get_decode3d_code(size_max, int_type=int_type)
+
+    # Step 2: compute the Euclidean distance based on this (z, y, x).
+    code += _generate_shape(
+        ndim=3, int_type=int_type, var_name="dist", raw_var=True
+    )
+    code += _generate_indices_ops(ndim=3, int_type=int_type)
+    if sampling is None:
+        code += _generate_distance_computation(int_type, dist_int_type)
+        in_params = "E encoded"
+    else:
+        code += _generate_aniso_distance_computation()
+        in_params = "E encoded, raw F sampling"
+    return cupy.ElementwiseKernel(
+        in_params=in_params,
+        out_params="raw F dist",
+        operation=code,
+        options=("--std=c++11",),
+    )
+
+
+def _pba_3d(arr, sampling=None, return_distances=True, return_indices=False,
+            block_params=None, check_warp_size=False, *,
+            float64_distances=False, distances=None, indices=None):
+
+    indices_inplace = isinstance(indices, cupy.ndarray)
+    dt_inplace = isinstance(distances, cupy.ndarray)
+    _distance_tranform_arg_check(
+        dt_inplace, indices_inplace, return_distances, return_indices
+    )
+
+    if arr.ndim != 3:
+        raise ValueError(f"expected a 3D array, got {arr.ndim}D")
+
+    if block_params is None:
+        m1 = 1
+        m2 = 1
+        m3 = 2
+    else:
+        m1, m2, m3 = block_params
+
+    # reduce blockx for small inputs
+    s_min = min(arr.shape)
+    if s_min <= 4:
+        blockx = 4
+    elif s_min <= 8:
+        blockx = 8
+    elif s_min <= 16:
+        blockx = 16
+    else:
+        blockx = 32
+    blocky = 4
+
+    block_size = _get_block_size(check_warp_size)
+
+    orig_sz, orig_sy, orig_sx = arr.shape
+    padding_width = _determine_padding(
+        arr.shape, block_size, m1, m2, m3, blockx, blocky
+    )
+    if padding_width is not None:
+        arr = cupy.pad(arr, padding_width, mode="constant", constant_values=1)
+    size = arr.shape[0]
+
+    # pba algorithm was implemented to use 32-bit integer to store compressed
+    # coordinates. input_arr will be C-contiguous, int32
+    size_max = max(arr.shape)
+    input_arr = encode3d(arr, size_max=size_max)
+    buffer_idx = 0
+    output = cupy.zeros_like(input_arr)
+    pba_images = [input_arr, output]
+
+    block = (blockx, blocky, 1)
+    grid = (size // block[0], size // block[1], 1)
+    pba3d = cupy.RawModule(
+        code=get_pba3d_src(block_size_3d=block_size, size_max=size_max)
+    )
+
+    kernelFloodZ = pba3d.get_function("kernelFloodZ")
+    if sampling is None:
+        kernelMaurerAxis = pba3d.get_function("kernelMaurerAxis")
+        kernelColorAxis = pba3d.get_function("kernelColorAxis")
+        sampling_args = ()
+    else:
+        kernelMaurerAxis = pba3d.get_function("kernelMaurerAxisWithSpacing")
+        kernelColorAxis = pba3d.get_function("kernelColorAxisWithSpacing")
+        sampling = tuple(map(float, sampling))
+        sampling_args = (sampling[2], sampling[1], sampling[0])
+
+    kernelFloodZ(
+        grid,
+        block,
+        (pba_images[buffer_idx], pba_images[1 - buffer_idx], size)
+    )
+    buffer_idx = 1 - buffer_idx
+
+    block = (blockx, blocky, 1)
+    grid = (size // block[0], size // block[1], 1)
+    kernelMaurerAxis(
+        grid,
+        block,
+        (pba_images[buffer_idx], pba_images[1 - buffer_idx], size) + sampling_args,  # noqa
+    )
+
+    block = (block_size, m3, 1)
+    grid = (size // block[0], size, 1)
+    kernelColorAxis(
+        grid,
+        block,
+        (pba_images[1 - buffer_idx], pba_images[buffer_idx], size) + sampling_args,  # noqa
+    )
+
+    if sampling is not None:
+        # kernelColorAxis transposes the first two axis, so have to reorder
+        # the sampling_args tuple correspondingly
+        sampling_args = (sampling[1], sampling[2], sampling[0])
+
+    block = (blockx, blocky, 1)
+    grid = (size // block[0], size // block[1], 1)
+    kernelMaurerAxis(
+        grid,
+        block,
+        (pba_images[buffer_idx], pba_images[1 - buffer_idx], size) + sampling_args,  # noqa
+    )
+
+    block = (block_size, m3, 1)
+    grid = (size // block[0], size, 1)
+    kernelColorAxis(
+        grid,
+        block,
+        (pba_images[1 - buffer_idx], pba_images[buffer_idx], size) + sampling_args,  # noqa
+    )
+    output = pba_images[buffer_idx]
+
+    if return_distances:
+        out_shape = (orig_sz, orig_sy, orig_sx)
+        dtype_out = cupy.float64 if float64_distances else cupy.float32
+        if dt_inplace:
+            _check_distances(distances, out_shape, dtype_out)
+        else:
+            distances = cupy.zeros(out_shape, dtype=dtype_out)
+
+        # make sure maximum possible distance doesn't overflow
+        max_possible_dist = sum((s - 1)**2 for s in out_shape)
+        large_dist = max_possible_dist >= 2**31
+
+        if not return_indices:
+            # Compute distances without forming explicit coordinate arrays.
+            kern = _get_decode_as_distance_kernel(
+                size_max=size_max,
+                large_dist=large_dist,
+                sampling=sampling
+            )
+            if sampling is None:
+                kern(output[:orig_sz, :orig_sy, :orig_sx], distances)
+            else:
+                sampling = cupy.asarray(sampling, dtype=distances.dtype)
+                kern(output[:orig_sz, :orig_sy, :orig_sx], sampling, distances)
+            return (distances,)
+
+    if return_indices:
+        x, y, z = decode3d(output[:orig_sz, :orig_sy, :orig_sx],
+                           size_max=size_max)
+    vals = ()
+    if return_distances:
+        if sampling is None:
+            kern = _get_distance_kernel(
+                int_type=_get_inttype(distances), large_dist=large_dist,
+            )
+            kern(z, y, x, distances)
+        else:
+            kern = _get_aniso_distance_kernel(int_type=_get_inttype(distances))
+            sampling = cupy.asarray(sampling, dtype=distances.dtype)
+            kern(z, y, x, sampling, distances)
+        vals = vals + (distances,)
+    if return_indices:
+        if indices_inplace:
+            _check_indices(indices, (arr.ndim,) + arr.shape, x.dtype.itemsize)
+            indices[0, ...] = z
+            indices[1, ...] = y
+            indices[2, ...] = x
+        else:
+            indices = cupy.stack((z, y, x), axis=0)
+        vals = vals + (indices,)
+    return vals

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/_spline_kernel_weights.py

@@ -0,0 +1,73 @@
+"""Determination of spline kernel weights (adapted from SciPy)
+
+See more verbose comments for each case there:
+https://github.com/scipy/scipy/blob/eba29d69846ab1299976ff4af71c106188397ccc/scipy/ndimage/src/ni_splines.c#L7
+
+``spline_weights_inline`` is a dict where the key is the spline order and the
+value is the spline weight initialization code.
+"""
+
+spline_weights_inline = {}
+
+# Note: This order = 1 case is currently unused (order = 1 has a different code
+# path in _interp_kernels.py). I think that existing code is a bit more
+# efficient.
+spline_weights_inline[1] = '''
+wx = c_{j} - floor({order} & 1 ? c_{j} : c_{j} + 0.5);
+weights_{j}[0] = 1.0 - wx;
+weights_{j}[1] = wx;
+'''
+
+spline_weights_inline[2] = '''
+wx = c_{j} - floor({order} & 1 ? c_{j} : c_{j} + 0.5);
+weights_{j}[1] = 0.75 - wx * wx;
+wy = 0.5 - wx;
+weights_{j}[0] = 0.5 * wy * wy;
+weights_{j}[2] = 1.0 - weights_{j}[0] - weights_{j}[1];
+'''
+
+spline_weights_inline[3] = '''
+wx = c_{j} - floor({order} & 1 ? c_{j} : c_{j} + 0.5);
+wy = 1.0 - wx;
+weights_{j}[1] = (wx * wx * (wx - 2.0) * 3.0 + 4.0) / 6.0;
+weights_{j}[2] = (wy * wy * (wy - 2.0) * 3.0 + 4.0) / 6.0;
+weights_{j}[0] = wy * wy * wy / 6.0;
+weights_{j}[3] = 1.0 - weights_{j}[0] - weights_{j}[1] - weights_{j}[2];
+'''
+
+spline_weights_inline[4] = '''
+wx = c_{j} - floor({order} & 1 ? c_{j} : c_{j} + 0.5);
+wy = wx * wx;
+weights_{j}[2] = wy * (wy * 0.25 - 0.625) + 115.0 / 192.0;
+wy = 1.0 + wx;
+weights_{j}[1] = wy * (wy * (wy * (5.0 - wy) / 6.0 - 1.25) + 5.0 / 24.0) +
+             55.0 / 96.0;
+wy = 1.0 - wx;
+weights_{j}[3] = wy * (wy * (wy * (5.0 - wy) / 6.0 - 1.25) + 5.0 / 24.0) +
+             55.0 / 96.0;
+wy = 0.5 - wx;
+wy = wy * wy;
+weights_{j}[0] = wy * wy / 24.0;
+weights_{j}[4] = 1.0 - weights_{j}[0] - weights_{j}[1]
+                     - weights_{j}[2] - weights_{j}[3];
+'''
+
+spline_weights_inline[5] = '''
+wx = c_{j} - floor({order} & 1 ? c_{j} : c_{j} + 0.5);
+wy = wx * wx;
+weights_{j}[2] = wy * (wy * (0.25 - wx / 12.0) - 0.5) + 0.55;
+wy = 1.0 - wx;
+wy = wy * wy;
+weights_{j}[3] = wy * (wy * (0.25 - (1.0 - wx) / 12.0) - 0.5) + 0.55;
+wy = wx + 1.0;
+weights_{j}[1] = wy * (wy * (wy * (wy * (wy / 24.0 - 0.375) + 1.25) - 1.75)
+                   + 0.625) + 0.425;
+wy = 2.0 - wx;
+weights_{j}[4] = wy * (wy * (wy * (wy * (wy / 24.0 - 0.375) + 1.25) - 1.75)
+                  + 0.625) + 0.425;
+wy = 1.0 - wx;
+wy = wy * wy;
+weights_{j}[0] = (1.0 - wx) * wy * wy / 120.0;
+weights_{j}[5] = 1.0 - weights_{j}[0] - weights_{j}[1] - weights_{j}[2]
+                     - weights_{j}[3] - weights_{j}[4];
+'''

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/_spline_prefilter_core.py

@@ -0,0 +1,261 @@
+"""
+Spline poles and boundary handling implemented as in SciPy
+
+https://github.com/scipy/scipy/blob/master/scipy/ndimage/src/ni_splines.c
+"""
+import functools
+import math
+import operator
+import textwrap
+
+import cupy
+
+
+def get_poles(order):
+    if order == 2:
+        # sqrt(8.0) - 3.0
+        return (-0.171572875253809902396622551580603843,)
+    elif order == 3:
+        # sqrt(3.0) - 2.0
+        return (-0.267949192431122706472553658494127633,)
+    elif order == 4:
+        # sqrt(664.0 - sqrt(438976.0)) + sqrt(304.0) - 19.0
+        # sqrt(664.0 + sqrt(438976.0)) - sqrt(304.0) - 19.0
+        return (-0.361341225900220177092212841325675255,
+                -0.013725429297339121360331226939128204)
+    elif order == 5:
+        # sqrt(67.5 - sqrt(4436.25)) + sqrt(26.25) - 6.5
+        # sqrt(67.5 + sqrt(4436.25)) - sqrt(26.25) - 6.5
+        return (-0.430575347099973791851434783493520110,
+                -0.043096288203264653822712376822550182)
+    else:
+        raise ValueError('only order 2-5 supported')
+
+
+def get_gain(poles):
+    return functools.reduce(operator.mul,
+                            [(1.0 - z) * (1.0 - 1.0 / z) for z in poles])
+
+
+def _causal_init_code(mode):
+    """Code for causal initialization step of IIR filtering.
+
+    c is a 1d array of length n and z is a filter pole
+    """
+    code = f'''
+        // causal init for mode={mode}'''
+    if mode == 'mirror':
+        code += '''
+        z_i = z;
+        z_n_1 = pow(z, (P)(n - 1));
+
+        c[0] = c[0] + z_n_1 * c[(n - 1) * element_stride];
+        for (i = 1; i < min(n - 1, static_cast<idx_t>({n_boundary})); ++i) {{
+            c[0] += z_i * (c[i * element_stride] +
+                           z_n_1 * c[(n - 1 - i) * element_stride]);
+            z_i *= z;
+        }}
+        c[0] /= 1 - z_n_1 * z_n_1;'''
+    elif mode == 'grid-wrap':
+        code += '''
+        z_i = z;
+
+        for (i = 1; i < min(n, static_cast<idx_t>({n_boundary})); ++i) {{
+            c[0] += z_i * c[(n - i) * element_stride];
+            z_i *= z;
+        }}
+        c[0] /= 1 - z_i; /* z_i = pow(z, n) */'''
+    elif mode == 'reflect':
+        code += '''
+        z_i = z;
+        z_n = pow(z, (P)n);
+        c0 = c[0];
+
+        c[0] = c[0] + z_n * c[(n - 1) * element_stride];
+        for (i = 1; i < min(n, static_cast<idx_t>({n_boundary})); ++i) {{
+            c[0] += z_i * (c[i * element_stride] +
+                           z_n * c[(n - 1 - i) * element_stride]);
+            z_i *= z;
+        }}
+        c[0] *= z / (1 - z_n * z_n);
+        c[0] += c0;'''
+    else:
+        raise ValueError('invalid mode: {}'.format(mode))
+    return code
+
+
+def _anticausal_init_code(mode):
+    """Code for the anti-causal initialization step of IIR filtering.
+
+    c is a 1d array of length n and z is a filter pole
+    """
+    code = f'''
+        // anti-causal init for mode={mode}'''
+    if mode == 'mirror':
+        code += '''
+        c[(n - 1) * element_stride] = (
+            z * c[(n - 2) * element_stride] +
+            c[(n - 1) * element_stride]) * z / (z * z - 1);'''
+    elif mode == 'grid-wrap':
+        code += '''
+        z_i = z;
+
+        for (i = 0; i < min(n - 1, static_cast<idx_t>({n_boundary})); ++i) {{
+            c[(n - 1) * element_stride] += z_i * c[i * element_stride];
+            z_i *= z;
+        }}
+        c[(n - 1) * element_stride] *= z / (z_i - 1); /* z_i = pow(z, n) */'''
+    elif mode == 'reflect':
+        code += '''
+        c[(n - 1) * element_stride] *= z / (z - 1);'''
+    else:
+        raise ValueError('invalid mode: {}'.format(mode))
+    return code
+
+
+def _get_spline_mode(mode):
+    """spline boundary mode for interpolation with order >= 2."""
+    if mode in ['mirror', 'reflect', 'grid-wrap']:
+        # exact analytic boundary conditions exist for these modes.
+        return mode
+    elif mode == 'grid-mirror':
+        # grid-mirror is a synonym for 'reflect'
+        return 'reflect'
+    # No exact analytical spline boundary condition implemented. Reflect gives
+    # lower error than using mirror or wrap for mode 'nearest'. Otherwise, a
+    # mirror spline boundary condition is used.
+    return 'reflect' if mode == 'nearest' else 'mirror'
+
+
+def _get_spline1d_code(mode, poles, n_boundary):
+    """Generates the code required for IIR filtering of a single 1d signal.
+
+    Prefiltering is done by causal filtering followed by anti-causal filtering.
+    Multiple boundary conditions have been implemented.
+    """
+    code = ['''
+    __device__ void spline_prefilter1d(
+        T* __restrict__ c, idx_t signal_length, idx_t element_stride)
+    {{''']
+
+    # variables common to all boundary modes
+    code.append('''
+        idx_t i, n = signal_length;
+        P z, z_i;''')
+
+    # retrieve the spline boundary extension mode to use
+    mode = _get_spline_mode(mode)
+
+    if mode == 'mirror':
+        # variables specific to mirror boundary mode
+        code.append('''
+        P z_n_1;''')
+    elif mode == 'reflect':
+        # variables specific to reflect boundary mode
+        code.append('''
+        P z_n;
+        T c0;''')
+
+    for pole in poles:
+
+        code.append(f'''
+        // select the current pole
+        z = {pole};''')
+
+        # initialize and apply the causal filter
+        code.append(_causal_init_code(mode))
+        code.append('''
+        // apply the causal filter for the current pole
+        for (i = 1; i < n; ++i) {{
+            c[i * element_stride] += z * c[(i - 1) * element_stride];
+        }}''')
+        code.append('''
+        #ifdef __HIP_DEVICE_COMPILE__
+        __syncthreads();
+        #endif
+        ''')
+        # initialize and apply the anti-causal filter
+        code.append(_anticausal_init_code(mode))
+        code.append('''
+        // apply the anti-causal filter for the current pole
+        for (i = n - 2; i >= 0; --i) {{
+            c[i * element_stride] = z * (c[(i + 1) * element_stride] -
+                                         c[i * element_stride]);
+        }}''')
+
+    code += ['''
+    }}''']
+    return textwrap.dedent('\n'.join(code)).format(n_boundary=n_boundary)
+
+
+_FILTER_GENERAL = '''
+#include "cupy/carray.cuh"
+#include "cupy/complex.cuh"
+typedef {data_type} T;
+typedef {pole_type} P;
+typedef {index_type} idx_t;
+template <typename T>
+__device__ T* row(
+        T* ptr, idx_t i, idx_t axis, idx_t ndim, const idx_t* shape) {{
+    idx_t index = 0, stride = 1;
+    for (idx_t a = ndim - 1; a > 0; --a) {{
+        if (a != axis) {{
+            index += (i % shape[a]) * stride;
+            i /= shape[a];
+        }}
+        stride *= shape[a];
+    }}
+    return ptr + index + stride * i;
+}}
+'''
+
+
+_batch_spline1d_strided_template = """
+extern "C" __global__
+__launch_bounds__({block_size})
+void {kernel_name}(T* __restrict__ y, const idx_t* __restrict__ info) {{
+    const idx_t n_signals = info[0], n_samples = info[1],
+        * __restrict__ shape = info+2;
+    idx_t y_elem_stride = 1;
+    for (int a = {ndim} - 1; a > {axis}; --a) {{ y_elem_stride *= shape[a]; }}
+    idx_t unraveled_idx = blockDim.x * blockIdx.x + threadIdx.x;
+    idx_t batch_idx = unraveled_idx;
+    if (batch_idx < n_signals)
+    {{
+        T* __restrict__ y_i = row(y, batch_idx, {axis}, {ndim}, shape);
+        spline_prefilter1d(y_i, n_samples, y_elem_stride);
+    }}
+}}
+"""
+
+
+@cupy.memoize(for_each_device=True)
+def get_raw_spline1d_kernel(axis, ndim, mode, order, index_type='int',
+                            data_type='double', pole_type='double',
+                            block_size=128):
+    """Generate a kernel for applying a spline prefilter along a given axis."""
+    poles = get_poles(order)
+
+    # determine number of samples for the boundary approximation
+    # (SciPy uses n_boundary = n_samples but this is excessive)
+    largest_pole = max([abs(p) for p in poles])
+    # tol < 1e-7 fails test cases comparing to SciPy at atol = rtol = 1e-5
+    tol = 1e-10 if pole_type == 'float' else 1e-18
+    n_boundary = math.ceil(math.log(tol, largest_pole))
+
+    # headers and general utility function for extracting rows of data
+    code = _FILTER_GENERAL.format(index_type=index_type,
+                                  data_type=data_type,
+                                  pole_type=pole_type)
+
+    # generate source for a 1d function for a given boundary mode and poles
+    code += _get_spline1d_code(mode, poles, n_boundary)
+
+    # generate code handling batch operation of the 1d filter
+    mode_str = mode.replace('-', '_')  # cannot have '-' in kernel name
+    kernel_name = (f'cupyx_scipy_ndimage_spline_filter_{ndim}d_ord{order}_'
+                   f'axis{axis}_{mode_str}')
+    code += _batch_spline1d_strided_template.format(ndim=ndim, axis=axis,
+                                                    block_size=block_size,
+                                                    kernel_name=kernel_name)
+    return cupy.RawKernel(code, kernel_name)

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/_util.py

@@ -0,0 +1,160 @@
+import warnings
+
+import cupy
+
+
+def _is_integer_output(output, input):
+    if output is None:
+        return input.dtype.kind in 'iu'
+    elif isinstance(output, cupy.ndarray):
+        return output.dtype.kind in 'iu'
+    return cupy.dtype(output).kind in 'iu'
+
+
+def _check_cval(mode, cval, integer_output):
+    if mode == 'constant' and integer_output and not cupy.isfinite(cval):
+        raise NotImplementedError("Non-finite cval is not supported for "
+                                  "outputs with integer dtype.")
+
+
+def _init_weights_dtype(input):
+    """Initialize filter weights based on the input array.
+
+    This helper is only used during initialization of some internal filters
+    like prewitt and sobel to avoid costly double-precision computation.
+    """
+    if input.dtype.kind == "c":
+        return cupy.promote_types(input.real.dtype, cupy.complex64)
+    return cupy.promote_types(input.real.dtype, cupy.float32)
+
+
+def _get_weights_dtype(input, weights):
+    if weights.dtype.kind == "c" or input.dtype.kind == "c":
+        return cupy.promote_types(input.real.dtype, cupy.complex64)
+    elif weights.dtype.kind in 'iub':
+        # convert integer dtype weights to double as in SciPy
+        return cupy.float64
+    return cupy.promote_types(input.real.dtype, cupy.float32)
+
+
+def _get_output(output, input, shape=None, complex_output=False):
+    shape = input.shape if shape is None else shape
+    if output is None:
+        if complex_output:
+            _dtype = cupy.promote_types(input.dtype, cupy.complex64)
+        else:
+            _dtype = input.dtype
+        output = cupy.empty(shape, dtype=_dtype)
+    elif isinstance(output, (type, cupy.dtype)):
+        if complex_output and cupy.dtype(output).kind != 'c':
+            warnings.warn("promoting specified output dtype to complex")
+            output = cupy.promote_types(output, cupy.complex64)
+        output = cupy.empty(shape, dtype=output)
+    elif isinstance(output, str):
+        output = cupy.dtype(output)
+        if complex_output and output.kind != 'c':
+            raise RuntimeError("output must have complex dtype")
+        output = cupy.empty(shape, dtype=output)
+    elif output.shape != shape:
+        raise RuntimeError("output shape not correct")
+    elif complex_output and output.dtype.kind != 'c':
+        raise RuntimeError("output must have complex dtype")
+    return output
+
+
+def _fix_sequence_arg(arg, ndim, name, conv=lambda x: x):
+    if isinstance(arg, str):
+        return [conv(arg)] * ndim
+    try:
+        arg = iter(arg)
+    except TypeError:
+        return [conv(arg)] * ndim
+    lst = [conv(x) for x in arg]
+    if len(lst) != ndim:
+        msg = "{} must have length equal to input rank".format(name)
+        raise RuntimeError(msg)
+    return lst
+
+
+def _check_origin(origin, width):
+    origin = int(origin)
+    if (width // 2 + origin < 0) or (width // 2 + origin >= width):
+        raise ValueError('invalid origin')
+    return origin
+
+
+def _check_mode(mode):
+    if mode not in ('reflect', 'constant', 'nearest', 'mirror', 'wrap',
+                    'grid-mirror', 'grid-wrap', 'grid-reflect'):
+        msg = f'boundary mode not supported (actual: {mode})'
+        raise RuntimeError(msg)
+    return mode
+
+
+def _get_inttype(input):
+    # The integer type to use for indices in the input array
+    # The indices actually use byte positions and we can't just use
+    # input.nbytes since that won't tell us the number of bytes between the
+    # first and last elements when the array is non-contiguous
+    nbytes = sum((x-1)*abs(stride) for x, stride in
+                 zip(input.shape, input.strides)) + input.dtype.itemsize
+    return 'int' if nbytes < (1 << 31) else 'ptrdiff_t'
+
+
+def _generate_boundary_condition_ops(mode, ix, xsize, int_t="int",
+                                     float_ix=False):
+    min_func = "fmin" if float_ix else "min"
+    max_func = "fmax" if float_ix else "max"
+    if mode in ['reflect', 'grid-mirror']:
+        ops = '''
+        if ({ix} < 0) {{
+            {ix} = - 1 -{ix};
+        }}
+        {ix} %= {xsize} * 2;
+        {ix} = {min}({ix}, 2 * {xsize} - 1 - {ix});'''.format(
+            ix=ix, xsize=xsize, min=min_func)
+    elif mode == 'mirror':
+        ops = '''
+        if ({xsize} == 1) {{
+            {ix} = 0;
+        }} else {{
+            if ({ix} < 0) {{
+                {ix} = -{ix};
+            }}
+            {ix} = 1 + ({ix} - 1) % (({xsize} - 1) * 2);
+            {ix} = {min}({ix}, 2 * {xsize} - 2 - {ix});
+        }}'''.format(ix=ix, xsize=xsize, min=min_func)
+    elif mode == 'nearest':
+        ops = '''
+        {ix} = {min}({max}(({T}){ix}, ({T})0), ({T})({xsize} - 1));'''.format(
+            ix=ix, xsize=xsize, min=min_func, max=max_func,
+            # force using 64-bit signed integer for ptrdiff_t,
+            # see cupy/cupy#6048
+            T=('int' if int_t == 'int' else 'long long'))
+    elif mode == 'grid-wrap':
+        ops = '''
+        {ix} %= {xsize};
+        while ({ix} < 0) {{
+            {ix} += {xsize};
+        }}'''.format(ix=ix, xsize=xsize)
+    elif mode == 'wrap':
+        ops = '''
+        if ({ix} < 0) {{
+            {ix} += ({sz} - 1) * (({int_t})(-{ix} / ({sz} - 1)) + 1);
+        }} else if ({ix} > ({sz} - 1)) {{
+            {ix} -= ({sz} - 1) * ({int_t})({ix} / ({sz} - 1));
+        }};'''.format(ix=ix, sz=xsize, int_t=int_t)
+    elif mode in ['constant', 'grid-constant']:
+        ops = '''
+        if (({ix} < 0) || {ix} >= {xsize}) {{
+            {ix} = -1;
+        }}'''.format(ix=ix, xsize=xsize)
+    return ops
+
+
+def _generate_indices_ops(ndim, int_type, offsets):
+    code = '{type} ind_{j} = _i % ysize_{j} - {offset}; _i /= ysize_{j};'
+    body = [code.format(type=int_type, j=j, offset=offsets[j])
+            for j in range(ndim-1, 0, -1)]
+    return '{type} _i = i;\n{body}\n{type} ind_0 = _i - {offset};'.format(
+        type=int_type, body='\n'.join(body), offset=offsets[0])

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/cuda/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 School of Computing, National University of Singapore
+
+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.

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/cuda/pba_kernels_2d.h

@@ -0,0 +1,695 @@
+// Euclidean Distance Transform
+// 
+// Kernels for the 2D version of the Parallel Banding Algorithm (PBA+). 
+// 
+// MIT license: see LICENSE in this folder
+// Copyright: (c) 2019 School of Computing, National University of Singapore
+//
+// Modifications by Gregory Lee (2022) (NVIDIA)
+// - add user-defined pixel_int2_t to enable
+// - replace __mul24 operations with standard multiplication operator
+// - Add variant kernels with support for non-isotropic pixel dimensions. These
+//   kernels differ from the originals in that they also take sx and sy values
+//   indicating the pixel size along the x and y axes. The kernels are identical
+//   except that the `dominate` function is replaced by `dominate_sp` and the
+//   physical spacings are used when computing distances.
+//
+
+
+// START OF DEFINITIONS OVERRIDDEN BY THE PYTHON SCRIPT
+
+// The values included in this header file are those defined in the original
+// PBA+ implementation
+
+// However, the Python code generation can potentially generate a different
+// ENCODE/DECODE that use 20 bits per coordinates instead of 10 bits per
+// coordinate with ENCODED_INT_TYPE as `long long`.
+
+#ifndef MARKER
+#define MARKER -32768
+#endif
+
+#ifndef BLOCKSIZE
+#define BLOCKSIZE 32
+#endif
+
+#ifndef pixel_int2_t
+#define pixel_int2_t short2
+#define make_pixel(x, y)  make_short2(x, y)
+#endif
+
+// END OF DEFINITIONS OVERRIDDEN BY THE PYTHON SCRIPT
+
+
+#define TOID(x, y, size)  ((y) * (size) + (x))
+
+#define LL long long
+__device__ bool dominate(LL x1, LL y1, LL x2, LL y2, LL x3, LL y3, LL x0)
+{
+    LL k1 = y2 - y1, k2 = y3 - y2;
+    return (k1 * (y1 + y2) + (x2 - x1) * ((x1 + x2) - (x0 << 1))) * k2 > \
+            (k2 * (y2 + y3) + (x3 - x2) * ((x2 + x3) - (x0 << 1))) * k1;
+}
+#undef LL
+
+// version of dominate, but with per-axis floating-point spacing
+__device__ bool dominate_sp(int _x1, int _y1, int _x2, int _y2, int _x3, int _y3, int _x0, float sx, float sy)
+{
+    float x1 = static_cast<float>(_x1) * sx;
+    float x2 = static_cast<float>(_x2) * sx;
+    float x3 = static_cast<float>(_x3) * sx;
+    float y1 = static_cast<float>(_y1) * sy;
+    float y2 = static_cast<float>(_y2) * sy;
+    float y3 = static_cast<float>(_y3) * sy;
+    float x0_2 = static_cast<float>(_x0 << 1) * sx;
+    float k1 = (y2 - y1);
+    float k2 = (y3 - y2);
+    return (k1 * (y1 + y2) + (x2 - x1) * ((x1 + x2) - x0_2)) * k2 > \
+            (k2 * (y2 + y3) + (x3 - x2) * ((x2 + x3) - x0_2)) * k1;
+}
+
+
+extern "C"{
+
+__global__ void kernelFloodDown(pixel_int2_t *input, pixel_int2_t *output, int size, int bandSize)
+{
+    int tx = blockIdx.x * blockDim.x + threadIdx.x;
+    int ty = blockIdx.y * bandSize;
+    int id = TOID(tx, ty, size);
+
+    pixel_int2_t pixel1, pixel2;
+
+    pixel1 = make_pixel(MARKER, MARKER);
+
+    for (int i = 0; i < bandSize; i++, id += size) {
+        pixel2 = input[id];
+
+        if (pixel2.x != MARKER)
+            pixel1 = pixel2;
+
+        output[id] = pixel1;
+    }
+}
+
+__global__ void kernelFloodUp(pixel_int2_t *input, pixel_int2_t *output, int size, int bandSize)
+{
+    int tx = blockIdx.x * blockDim.x + threadIdx.x;
+    int ty = (blockIdx.y+1) * bandSize - 1;
+    int id = TOID(tx, ty, size);
+
+    pixel_int2_t pixel1, pixel2;
+    int dist1, dist2;
+
+    pixel1 = make_pixel(MARKER, MARKER);
+
+    for (int i = 0; i < bandSize; i++, id -= size) {
+        dist1 = abs(pixel1.y - ty + i);
+
+        pixel2 = input[id];
+        dist2 = abs(pixel2.y - ty + i);
+
+        if (dist2 < dist1)
+            pixel1 = pixel2;
+
+        output[id] = pixel1;
+    }
+}
+
+__global__ void kernelPropagateInterband(pixel_int2_t *input, pixel_int2_t *margin_out, int size, int bandSize)
+{
+    int tx = blockIdx.x * blockDim.x + threadIdx.x;
+    int inc = bandSize * size;
+    int ny, nid, nDist;
+    pixel_int2_t pixel;
+
+    // Top row, look backward
+    int ty = blockIdx.y * bandSize;
+    int topId = TOID(tx, ty, size);
+    int bottomId = TOID(tx, ty + bandSize - 1, size);
+    int tid = blockIdx.y * size + tx;
+    int bid = tid + (size * size / bandSize);
+
+    pixel = input[topId];
+    int myDist = abs(pixel.y - ty);
+    margin_out[tid] = pixel;
+
+    for (nid = bottomId - inc; nid >= 0; nid -= inc) {
+        pixel = input[nid];
+
+        if (pixel.x != MARKER) {
+            nDist = abs(pixel.y - ty);
+
+            if (nDist < myDist)
+                margin_out[tid] = pixel;
+
+            break;
+        }
+    }
+
+    // Last row, look downward
+    ty = ty + bandSize - 1;
+    pixel = input[bottomId];
+    myDist = abs(pixel.y - ty);
+    margin_out[bid] = pixel;
+
+    for (ny = ty + 1, nid = topId + inc; ny < size; ny += bandSize, nid += inc) {
+        pixel = input[nid];
+
+        if (pixel.x != MARKER) {
+            nDist = abs(pixel.y - ty);
+
+            if (nDist < myDist)
+                margin_out[bid] = pixel;
+
+            break;
+        }
+    }
+}
+
+__global__ void kernelUpdateVertical(pixel_int2_t *color, pixel_int2_t *margin, pixel_int2_t *output, int size, int bandSize)
+{
+    __shared__ pixel_int2_t block[BLOCKSIZE][BLOCKSIZE];
+
+    int tx = blockIdx.x * blockDim.x + threadIdx.x;
+    int ty = blockIdx.y * bandSize;
+
+    pixel_int2_t top = margin[blockIdx.y * size + tx];
+    pixel_int2_t bottom = margin[(blockIdx.y + size / bandSize) * size + tx];
+    pixel_int2_t pixel;
+
+    int dist, myDist;
+
+    int id = TOID(tx, ty, size);
+
+    int n_step = bandSize / blockDim.x;
+    for(int step = 0; step < n_step; ++step) {
+        int y_start = blockIdx.y * bandSize + step * blockDim.x;
+        int y_end = y_start + blockDim.x;
+
+        for (ty = y_start; ty < y_end; ++ty, id += size) {
+            pixel = color[id];
+            myDist = abs(pixel.y - ty);
+
+            dist = abs(top.y - ty);
+            if (dist < myDist) { myDist = dist; pixel = top; }
+
+            dist = abs(bottom.y - ty);
+            if (dist < myDist) pixel = bottom;
+
+            // temporary result is stored in block
+            block[threadIdx.x][ty - y_start] = make_pixel(pixel.y, pixel.x);
+        }
+
+        __syncthreads();
+
+        // block is written to a transposed location in the output
+
+        int tid = TOID(blockIdx.y * bandSize + step * blockDim.x + threadIdx.x, \
+                        blockIdx.x * blockDim.x, size);
+
+        for(int i = 0; i < blockDim.x; ++i, tid += size) {
+            output[tid] = block[i][threadIdx.x];
+        }
+
+        __syncthreads();
+    }
+}
+
+__global__ void kernelProximatePoints(pixel_int2_t *input, pixel_int2_t *stack, int size, int bandSize)
+{
+    int tx = blockIdx.x * blockDim.x + threadIdx.x;
+    int ty = blockIdx.y * bandSize;
+    int id = TOID(tx, ty, size);
+    int lasty = -1;
+    pixel_int2_t last1, last2, current;
+
+    last1.y = -1; last2.y = -1;
+
+    for (int i = 0; i < bandSize; i++, id += size) {
+        current = input[id];
+
+        if (current.x != MARKER) {
+            while (last2.y >= 0) {
+                if (!dominate(last1.x, last2.y, last2.x, \
+                    lasty, current.x, current.y, tx))
+                    break;
+
+                lasty = last2.y; last2 = last1;
+
+                if (last1.y >= 0)
+                    last1 = stack[TOID(tx, last1.y, size)];
+            }
+
+            last1 = last2; last2 = make_pixel(current.x, lasty); lasty = current.y;
+
+            stack[id] = last2;
+        }
+    }
+
+    // Store the pointer to the tail at the last pixel of this band
+    if (lasty != ty + bandSize - 1)
+        stack[TOID(tx, ty + bandSize - 1, size)] = make_pixel(MARKER, lasty);
+}
+
+
+__global__ void kernelProximatePointsWithSpacing(pixel_int2_t *input, pixel_int2_t *stack, int size, int bandSize, double sx, double sy)
+{
+    int tx = blockIdx.x * blockDim.x + threadIdx.x;
+    int ty = blockIdx.y * bandSize;
+    int id = TOID(tx, ty, size);
+    int lasty = -1;
+    pixel_int2_t last1, last2, current;
+
+    last1.y = -1; last2.y = -1;
+
+    for (int i = 0; i < bandSize; i++, id += size) {
+        current = input[id];
+
+        if (current.x != MARKER) {
+            while (last2.y >= 0) {
+                if (!dominate_sp(last1.x, last2.y, last2.x, \
+                    lasty, current.x, current.y, tx, sx, sy))
+                    break;
+
+                lasty = last2.y; last2 = last1;
+
+                if (last1.y >= 0)
+                    last1 = stack[TOID(tx, last1.y, size)];
+            }
+
+            last1 = last2; last2 = make_pixel(current.x, lasty); lasty = current.y;
+
+            stack[id] = last2;
+        }
+    }
+
+    // Store the pointer to the tail at the last pixel of this band
+    if (lasty != ty + bandSize - 1)
+        stack[TOID(tx, ty + bandSize - 1, size)] = make_pixel(MARKER, lasty);
+}
+
+__global__ void kernelCreateForwardPointers(pixel_int2_t *input, pixel_int2_t *output, int size, int bandSize)
+{
+    int tx = blockIdx.x * blockDim.x + threadIdx.x;
+    int ty = (blockIdx.y+1) * bandSize - 1;
+    int id = TOID(tx, ty, size);
+    int lasty = -1, nexty;
+    pixel_int2_t current;
+
+    // Get the tail pointer
+    current = input[id];
+
+    if (current.x == MARKER)
+        nexty = current.y;
+    else
+        nexty = ty;
+
+    for (int i = 0; i < bandSize; i++, id -= size)
+        if (ty - i == nexty) {
+            current = make_pixel(lasty, input[id].y);
+            output[id] = current;
+
+            lasty = nexty;
+            nexty = current.y;
+        }
+
+    // Store the pointer to the head at the first pixel of this band
+    if (lasty != ty - bandSize + 1)
+        output[id + size] = make_pixel(lasty, MARKER);
+}
+
+__global__ void kernelMergeBands(pixel_int2_t *color, pixel_int2_t *link, pixel_int2_t *output, int size, int bandSize)
+{
+    int tx = blockIdx.x * blockDim.x + threadIdx.x;
+    int band1 = blockIdx.y * 2;
+    int band2 = band1 + 1;
+    int firsty, lasty;
+    pixel_int2_t last1, last2, current;
+    // last1 and last2: x component store the x coordinate of the site,
+    // y component store the backward pointer
+    // current: y component store the x coordinate of the site,
+    // x component store the forward pointer
+
+    // Get the two last items of the first list
+    lasty = band2 * bandSize - 1;
+    last2 = make_pixel(color[TOID(tx, lasty, size)].x,
+        link[TOID(tx, lasty, size)].y);
+
+    if (last2.x == MARKER) {
+        lasty = last2.y;
+
+        if (lasty >= 0)
+            last2 = make_pixel(color[TOID(tx, lasty, size)].x,
+            link[TOID(tx, lasty, size)].y);
+        else
+            last2 = make_pixel(MARKER, MARKER);
+    }
+
+    if (last2.y >= 0) {
+        // Second item at the top of the stack
+        last1 = make_pixel(color[TOID(tx, last2.y, size)].x,
+            link[TOID(tx, last2.y, size)].y);
+    }
+
+    // Get the first item of the second band
+    firsty = band2 * bandSize;
+    current = make_pixel(link[TOID(tx, firsty, size)].x,
+        color[TOID(tx, firsty, size)].x);
+
+    if (current.y == MARKER) {
+        firsty = current.x;
+
+        if (firsty >= 0)
+            current = make_pixel(link[TOID(tx, firsty, size)].x,
+            color[TOID(tx, firsty, size)].x);
+        else
+            current = make_pixel(MARKER, MARKER);
+    }
+
+    // Count the number of item in the second band that survive so far.
+    // Once it reaches 2, we can stop.
+    int top = 0;
+
+    while (top < 2 && current.y >= 0) {
+        // While there's still something on the left
+        while (last2.y >= 0) {
+
+            if (!dominate(last1.x, last2.y, last2.x, \
+                lasty, current.y, firsty, tx))
+                break;
+
+            lasty = last2.y; last2 = last1;
+            top--;
+
+            if (last1.y >= 0)
+                last1 = make_pixel(color[TOID(tx, last1.y, size)].x,
+                link[TOID(tx, last1.y, size)].y);
+        }
+
+        // Update the current pointer
+        output[TOID(tx, firsty, size)] = make_pixel(current.x, lasty);
+
+        if (lasty >= 0)
+            output[TOID(tx, lasty, size)] = make_pixel(firsty, last2.y);
+
+        last1 = last2; last2 = make_pixel(current.y, lasty); lasty = firsty;
+        firsty = current.x;
+
+        top = max(1, top + 1);
+
+        // Advance the current pointer to the next one
+        if (firsty >= 0)
+            current = make_pixel(link[TOID(tx, firsty, size)].x,
+            color[TOID(tx, firsty, size)].x);
+        else
+            current = make_pixel(MARKER, MARKER);
+    }
+
+    // Update the head and tail pointer.
+    firsty = band1 * bandSize;
+    lasty = band2 * bandSize;
+    current = link[TOID(tx, firsty, size)];
+
+    if (current.y == MARKER && current.x < 0) { // No head?
+        last1 = link[TOID(tx, lasty, size)];
+
+        if (last1.y == MARKER)
+            current.x = last1.x;
+        else
+            current.x = lasty;
+
+        output[TOID(tx, firsty, size)] = current;
+    }
+
+    firsty = band1 * bandSize + bandSize - 1;
+    lasty = band2 * bandSize + bandSize - 1;
+    current = link[TOID(tx, lasty, size)];
+
+    if (current.x == MARKER && current.y < 0) { // No tail?
+        last1 = link[TOID(tx, firsty, size)];
+
+        if (last1.x == MARKER)
+            current.y = last1.y;
+        else
+            current.y = firsty;
+
+        output[TOID(tx, lasty, size)] = current;
+    }
+}
+
+
+__global__ void kernelMergeBandsWithSpacing(pixel_int2_t *color, pixel_int2_t *link, pixel_int2_t *output, int size, int bandSize, double sx, double sy)
+{
+    int tx = blockIdx.x * blockDim.x + threadIdx.x;
+    int band1 = blockIdx.y * 2;
+    int band2 = band1 + 1;
+    int firsty, lasty;
+    pixel_int2_t last1, last2, current;
+    // last1 and last2: x component store the x coordinate of the site,
+    // y component store the backward pointer
+    // current: y component store the x coordinate of the site,
+    // x component store the forward pointer
+
+    // Get the two last items of the first list
+    lasty = band2 * bandSize - 1;
+    last2 = make_pixel(color[TOID(tx, lasty, size)].x,
+        link[TOID(tx, lasty, size)].y);
+
+    if (last2.x == MARKER) {
+        lasty = last2.y;
+
+        if (lasty >= 0)
+            last2 = make_pixel(color[TOID(tx, lasty, size)].x,
+            link[TOID(tx, lasty, size)].y);
+        else
+            last2 = make_pixel(MARKER, MARKER);
+    }
+
+    if (last2.y >= 0) {
+        // Second item at the top of the stack
+        last1 = make_pixel(color[TOID(tx, last2.y, size)].x,
+            link[TOID(tx, last2.y, size)].y);
+    }
+
+    // Get the first item of the second band
+    firsty = band2 * bandSize;
+    current = make_pixel(link[TOID(tx, firsty, size)].x,
+        color[TOID(tx, firsty, size)].x);
+
+    if (current.y == MARKER) {
+        firsty = current.x;
+
+        if (firsty >= 0)
+            current = make_pixel(link[TOID(tx, firsty, size)].x,
+            color[TOID(tx, firsty, size)].x);
+        else
+            current = make_pixel(MARKER, MARKER);
+    }
+
+    // Count the number of item in the second band that survive so far.
+    // Once it reaches 2, we can stop.
+    int top = 0;
+
+    while (top < 2 && current.y >= 0) {
+        // While there's still something on the left
+        while (last2.y >= 0) {
+
+            if (!dominate_sp(last1.x, last2.y, last2.x, \
+                lasty, current.y, firsty, tx, sx, sy))
+                break;
+
+            lasty = last2.y; last2 = last1;
+            top--;
+
+            if (last1.y >= 0)
+                last1 = make_pixel(color[TOID(tx, last1.y, size)].x,
+                link[TOID(tx, last1.y, size)].y);
+        }
+
+        // Update the current pointer
+        output[TOID(tx, firsty, size)] = make_pixel(current.x, lasty);
+
+        if (lasty >= 0)
+            output[TOID(tx, lasty, size)] = make_pixel(firsty, last2.y);
+
+        last1 = last2; last2 = make_pixel(current.y, lasty); lasty = firsty;
+        firsty = current.x;
+
+        top = max(1, top + 1);
+
+        // Advance the current pointer to the next one
+        if (firsty >= 0)
+            current = make_pixel(link[TOID(tx, firsty, size)].x,
+            color[TOID(tx, firsty, size)].x);
+        else
+            current = make_pixel(MARKER, MARKER);
+    }
+
+    // Update the head and tail pointer.
+    firsty = band1 * bandSize;
+    lasty = band2 * bandSize;
+    current = link[TOID(tx, firsty, size)];
+
+    if (current.y == MARKER && current.x < 0) { // No head?
+        last1 = link[TOID(tx, lasty, size)];
+
+        if (last1.y == MARKER)
+            current.x = last1.x;
+        else
+            current.x = lasty;
+
+        output[TOID(tx, firsty, size)] = current;
+    }
+
+    firsty = band1 * bandSize + bandSize - 1;
+    lasty = band2 * bandSize + bandSize - 1;
+    current = link[TOID(tx, lasty, size)];
+
+    if (current.x == MARKER && current.y < 0) { // No tail?
+        last1 = link[TOID(tx, firsty, size)];
+
+        if (last1.x == MARKER)
+            current.y = last1.y;
+        else
+            current.y = firsty;
+
+        output[TOID(tx, lasty, size)] = current;
+    }
+}
+
+__global__ void kernelDoubleToSingleList(pixel_int2_t *color, pixel_int2_t *link, pixel_int2_t *output, int size)
+{
+    int tx = blockIdx.x * blockDim.x + threadIdx.x;
+    int ty = blockIdx.y;
+    int id = TOID(tx, ty, size);
+
+    output[id] = make_pixel(color[id].x, link[id].y);
+}
+
+__global__ void kernelColor(pixel_int2_t *input, pixel_int2_t *output, int size)
+{
+    __shared__ pixel_int2_t block[BLOCKSIZE][BLOCKSIZE];
+
+    int col = threadIdx.x;
+    int tid = threadIdx.y;
+    int tx = blockIdx.x * blockDim.x + col;
+    int dx, dy, lasty;
+    unsigned int best, dist;
+    pixel_int2_t last1, last2;
+
+    lasty = size - 1;
+
+    last2 = input[TOID(tx, lasty, size)];
+
+    if (last2.x == MARKER) {
+        lasty = max(last2.y, 0);
+        last2 = input[TOID(tx, lasty, size)];
+    }
+
+    if (last2.y >= 0)
+        last1 = input[TOID(tx, last2.y, size)];
+
+    int y_start, y_end, n_step = size / blockDim.x;
+    for(int step = 0; step < n_step; ++step) {
+        y_start = size - step * blockDim.x - 1;
+        y_end = size - (step + 1) * blockDim.x;
+
+        for (int ty = y_start - tid; ty >= y_end; ty -= blockDim.y) {
+            dx = last2.x - tx; dy = lasty - ty;
+            best = dist = dx * dx + dy * dy;
+
+            while (last2.y >= 0) {
+                dx = last1.x - tx; dy = last2.y - ty;
+                dist = dx * dx + dy * dy;
+
+                if (dist > best)
+                    break;
+
+                best = dist; lasty = last2.y; last2 = last1;
+
+                if (last2.y >= 0)
+                    last1 = input[TOID(tx, last2.y, size)];
+            }
+
+            block[threadIdx.x][ty - y_end] = make_pixel(lasty, last2.x);
+        }
+
+        __syncthreads();
+
+        // note: transposes back to original shape here
+        if(!threadIdx.y) {
+            int id = TOID(y_end + threadIdx.x, blockIdx.x * blockDim.x, size);
+            for(int i = 0; i < blockDim.x; ++i, id+=size) {
+                output[id] = block[i][threadIdx.x];
+            }
+        }
+
+        __syncthreads();
+    }
+}
+
+
+__global__ void kernelColorWithSpacing(pixel_int2_t *input, pixel_int2_t *output, int size, double sx, double sy)
+{
+    __shared__ pixel_int2_t block[BLOCKSIZE][BLOCKSIZE];
+
+    int col = threadIdx.x;
+    int tid = threadIdx.y;
+    int tx = blockIdx.x * blockDim.x + col;
+    int lasty;
+    double dx, dy, best, dist;
+    pixel_int2_t last1, last2;
+
+    lasty = size - 1;
+
+    last2 = input[TOID(tx, lasty, size)];
+
+    if (last2.x == MARKER) {
+        lasty = max(last2.y, 0);
+        last2 = input[TOID(tx, lasty, size)];
+    }
+
+    if (last2.y >= 0)
+        last1 = input[TOID(tx, last2.y, size)];
+
+    int y_start, y_end, n_step = size / blockDim.x;
+    for(int step = 0; step < n_step; ++step) {
+        y_start = size - step * blockDim.x - 1;
+        y_end = size - (step + 1) * blockDim.x;
+
+        for (int ty = y_start - tid; ty >= y_end; ty -= blockDim.y) {
+            dx = static_cast<double>(last2.x - tx) * sx;
+            dy = static_cast<double>(lasty - ty) * sy;
+            best = dist = dx * dx + dy * dy;
+
+            while (last2.y >= 0) {
+                dx = static_cast<double>(last1.x - tx) * sx;
+                dy = static_cast<double>(last2.y - ty) * sy;
+                dist = dx * dx + dy * dy;
+
+                if (dist > best)
+                    break;
+
+                best = dist; lasty = last2.y; last2 = last1;
+
+                if (last2.y >= 0)
+                    last1 = input[TOID(tx, last2.y, size)];
+            }
+
+            block[threadIdx.x][ty - y_end] = make_pixel(lasty, last2.x);
+        }
+
+        __syncthreads();
+
+        // note: transposes back to original shape here
+        if(!threadIdx.y) {
+            int id = TOID(y_end + threadIdx.x, blockIdx.x * blockDim.x, size);
+            for(int i = 0; i < blockDim.x; ++i, id+=size) {
+                output[id] = block[i][threadIdx.x];
+            }
+        }
+
+        __syncthreads();
+    }
+}
+} // extern C

vllm/lib/python3.10/site-packages/cupyx/scipy/ndimage/cuda/pba_kernels_3d.h

@@ -0,0 +1,387 @@
+// Euclidean Distance Transform
+// 
+// Kernels for the 3D version of the Parallel Banding Algorithm (PBA+). 
+// 
+// MIT license: see LICENSE in this folder
+// Copyright: (c) 2019 School of Computing, National University of Singapore
+//
+// Modifications by Gregory Lee (2022) (NVIDIA)
+// - allow user-defined ENCODED_INT_TYPE, ENCODE, DECODE
+// - Add variant kernels with support for non-isotropic pixel dimensions
+//   These kernels differ from the originals in that they also take sx, sy and
+//   sz values indicating the pixel size along the x, y and z axes. The kernels
+//   are identical except that the `dominate` function is replaced by
+//   `dominate_sp` and the physical spacings are used when computing distances.
+
+
+// START OF DEFINITIONS OVERRIDDEN BY THE PYTHON SCRIPT
+
+// The values included in this header file are those defined in the original
+// PBA+ implementation
+
+// However, the Python code generation can potentially generate a different
+// ENCODE/DECODE that use 20 bits per coordinates instead of 10 bits per
+// coordinate with ENCODED_INT_TYPE as `long long`.
+
+
+#ifndef MARKER
+#define MARKER     -2147483648
+#endif  // MARKER
+
+#ifndef MAX_INT
+#define MAX_INT    2147483647
+#endif
+
+#ifndef BLOCKSIZE
+#define BLOCKSIZE  32
+#endif
+
+#ifndef ENCODE
+
+// Sites     : ENCODE(x, y, z, 0, 0)
+// Not sites : ENCODE(0, 0, 0, 1, 0) or MARKER
+#define ENCODED_INT_TYPE int
+#define ZERO 0
+#define ONE 1
+#define ENCODE(x, y, z, a, b)  (((x) << 20) | ((y) << 10) | (z) | ((a) << 31) | ((b) << 30))
+#define DECODE(value, x, y, z) \
+    x = ((value) >> 20) & 0x3ff; \
+    y = ((value) >> 10) & 0x3ff; \
+    z = (value) & 0x3ff
+
+#define NOTSITE(value)  (((value) >> 31) & 1)
+#define HASNEXT(value)  (((value) >> 30) & 1)
+
+#define GET_X(value)    (((value) >> 20) & 0x3ff)
+#define GET_Y(value)    (((value) >> 10) & 0x3ff)
+#define GET_Z(value)    ((NOTSITE((value))) ? MAX_INT : ((value) & 0x3ff))
+
+#endif // ENCODE
+
+// END OF DEFINITIONS DEFINED IN THE PYTHON SCRIPT
+
+
+#define LL long long
+__device__ bool dominate(LL x_1, LL y_1, LL z_1, LL x_2, LL y_2, LL z_2, LL x_3, LL y_3, LL z_3, LL x_0, LL z_0)
+{
+    LL k_1 = y_2 - y_1, k_2 = y_3 - y_2;
+
+    return (((y_1 + y_2) * k_1 + ((x_2 - x_1) * (x_1 + x_2 - (x_0 << 1)) + (z_2 - z_1) * (z_1 + z_2 - (z_0 << 1)))) * k_2 > \
+            ((y_2 + y_3) * k_2 + ((x_3 - x_2) * (x_2 + x_3 - (x_0 << 1)) + (z_3 - z_2) * (z_2 + z_3 - (z_0 << 1)))) * k_1);
+}
+#undef LL
+
+__device__ bool dominate_sp(int _x_1, int _y_1, int _z_1, int _x_2, int _y_2, int _z_2, int _x_3, int _y_3, int _z_3, int _x_0, int _z_0, float sx, float sy, float sz)
+{
+    float x_1 = static_cast<float>(_x_1) * sx;
+    float y_1 = static_cast<float>(_y_1) * sy;
+    float z_1 = static_cast<float>(_z_1) * sz;
+    float x_2 = static_cast<float>(_x_2) * sx;
+    float y_2 = static_cast<float>(_y_2) * sy;
+    float z_2 = static_cast<float>(_z_2) * sz;
+    float x_3 = static_cast<float>(_x_3) * sx;
+    float y_3 = static_cast<float>(_y_3) * sy;
+    float z_3 = static_cast<float>(_z_3) * sz;
+    float x_0_2 = static_cast<float>(_x_0 << 1) * sx;
+    float z_0_2 = static_cast<float>(_z_0 << 1) * sz;
+    float k_1 = y_2 - y_1;
+    float k_2 = y_3 - y_2;
+
+    return (((y_1 + y_2) * k_1 + ((x_2 - x_1) * (x_1 + x_2 - (x_0_2)) + (z_2 - z_1) * (z_1 + z_2 - (z_0_2)))) * k_2 > \
+            ((y_2 + y_3) * k_2 + ((x_3 - x_2) * (x_2 + x_3 - (x_0_2)) + (z_3 - z_2) * (z_2 + z_3 - (z_0_2)))) * k_1);
+}
+
+#define TOID(x, y, z, size)    ((((z) * (size)) + (y)) * (size) + (x))
+
+
+extern "C"{
+
+__global__ void kernelFloodZ(ENCODED_INT_TYPE *input, ENCODED_INT_TYPE *output, int size)
+{
+
+    int tx = blockIdx.x * blockDim.x + threadIdx.x;
+    int ty = blockIdx.y * blockDim.y + threadIdx.y;
+    int tz = 0;
+
+    int plane = size * size;
+    int id = TOID(tx, ty, tz, size);
+    ENCODED_INT_TYPE pixel1, pixel2;
+
+    pixel1 = ENCODE(ZERO,ZERO,ZERO,ONE,ZERO);
+
+    // Sweep down
+    for (int i = 0; i < size; i++, id += plane) {
+        pixel2 = input[id];
+
+        if (!NOTSITE(pixel2))
+            pixel1 = pixel2;
+
+        output[id] = pixel1;
+    }
+
+    ENCODED_INT_TYPE dist1, dist2, nz;
+
+    id -= plane + plane;
+
+    // Sweep up
+    for (int i = size - 2; i >= 0; i--, id -= plane) {
+        nz = GET_Z(pixel1);
+        dist1 = abs(nz - (tz + i));
+
+        pixel2 = output[id];
+        nz = GET_Z(pixel2);
+        dist2 = abs(nz - (tz + i));
+
+        if (dist2 < dist1)
+            pixel1 = pixel2;
+
+        output[id] = pixel1;
+    }
+}
+
+
+__global__ void kernelMaurerAxis(ENCODED_INT_TYPE *input, ENCODED_INT_TYPE *stack, int size)
+{
+    int tx = blockIdx.x * blockDim.x + threadIdx.x;
+    int tz = blockIdx.y * blockDim.y + threadIdx.y;
+    int ty = 0;
+
+    int id = TOID(tx, ty, tz, size);
+
+    ENCODED_INT_TYPE lasty = 0;
+    ENCODED_INT_TYPE x1, y1, z1, x2, y2, z2, nx, ny, nz;
+    ENCODED_INT_TYPE p = ENCODE(ZERO,ZERO,ZERO,ONE,ZERO), s1 = ENCODE(ZERO,ZERO,ZERO,ONE,ZERO), s2 = ENCODE(ZERO,ZERO,ZERO,ONE,ZERO);
+    ENCODED_INT_TYPE flag = 0;
+
+    for (ty = 0; ty < size; ++ty, id += size) {
+        p = input[id];
+
+        if (!NOTSITE(p)) {
+
+            while (HASNEXT(s2)) {
+                DECODE(s1, x1, y1, z1);
+                DECODE(s2, x2, y2, z2);
+                DECODE(p, nx, ny, nz);
+
+                if (!dominate(x1, y2, z1, x2, lasty, z2, nx, ty, nz, tx, tz))
+                    break;
+
+                lasty = y2; s2 = s1; y2 = y1;
+
+                if (HASNEXT(s2))
+                    s1 = stack[TOID(tx, y2, tz, size)];
+            }
+
+            DECODE(p, nx, ny, nz);
+            s1 = s2;
+            s2 = ENCODE(nx, lasty, nz, ZERO, flag);
+            y2 = lasty;
+            lasty = ty;
+
+            stack[id] = s2;
+
+            flag = ONE;
+        }
+    }
+
+    if (NOTSITE(p))
+        stack[TOID(tx, ty - 1, tz, size)] = ENCODE(ZERO, lasty, ZERO, ONE, flag);
+}
+
+__global__ void kernelMaurerAxisWithSpacing(ENCODED_INT_TYPE *input, ENCODED_INT_TYPE *stack, int size, double sx, double sy, double sz)
+{
+    int tx = blockIdx.x * blockDim.x + threadIdx.x;
+    int tz = blockIdx.y * blockDim.y + threadIdx.y;
+    int ty = 0;
+
+    int id = TOID(tx, ty, tz, size);
+
+    ENCODED_INT_TYPE lasty = 0;
+    ENCODED_INT_TYPE x1, y1, z1, x2, y2, z2, nx, ny, nz;
+    ENCODED_INT_TYPE p = ENCODE(ZERO,ZERO,ZERO,ONE,ZERO), s1 = ENCODE(ZERO,ZERO,ZERO,ONE,ZERO), s2 = ENCODE(ZERO,ZERO,ZERO,ONE,ZERO);
+    ENCODED_INT_TYPE flag = 0;
+
+    for (ty = 0; ty < size; ++ty, id += size) {
+        p = input[id];
+
+        if (!NOTSITE(p)) {
+
+            while (HASNEXT(s2)) {
+                DECODE(s1, x1, y1, z1);
+                DECODE(s2, x2, y2, z2);
+                DECODE(p, nx, ny, nz);
+
+                if (!dominate_sp(x1, y2, z1, x2, lasty, z2, nx, ty, nz, tx, tz, sx, sy, sz))
+                    break;
+
+                lasty = y2; s2 = s1; y2 = y1;
+
+                if (HASNEXT(s2))
+                    s1 = stack[TOID(tx, y2, tz, size)];
+            }
+
+            DECODE(p, nx, ny, nz);
+            s1 = s2;
+            s2 = ENCODE(nx, lasty, nz, ZERO, flag);
+            y2 = lasty;
+            lasty = ty;
+
+            stack[id] = s2;
+
+            flag = ONE;
+        }
+    }
+
+    if (NOTSITE(p))
+        stack[TOID(tx, ty - 1, tz, size)] = ENCODE(ZERO, lasty, ZERO, ONE, flag);
+}
+
+__global__ void kernelColorAxis(ENCODED_INT_TYPE *input, ENCODED_INT_TYPE *output, int size)
+{
+    __shared__ ENCODED_INT_TYPE block[BLOCKSIZE][BLOCKSIZE];
+
+    int col = threadIdx.x;
+    int tid = threadIdx.y;
+    int tx = blockIdx.x * blockDim.x + col;
+    int tz = blockIdx.y;
+
+    ENCODED_INT_TYPE x1, y1, z1, x2, y2, z2;
+    ENCODED_INT_TYPE last1 = ENCODE(ZERO,ZERO,ZERO,ONE,ZERO), last2 = ENCODE(ZERO,ZERO,ZERO,ONE,ZERO), lasty;
+    long long dx, dy, dz, best, dist;
+
+    lasty = size - 1;
+
+    last2 = input[TOID(tx, lasty, tz, size)];
+    DECODE(last2, x2, y2, z2);
+
+    if (NOTSITE(last2)) {
+        lasty = y2;
+        if(HASNEXT(last2)) {
+            last2 = input[TOID(tx, lasty, tz, size)];
+            DECODE(last2, x2, y2, z2);
+        }
+    }
+
+    if (HASNEXT(last2)) {
+        last1 = input[TOID(tx, y2, tz, size)];
+        DECODE(last1, x1, y1, z1);
+    }
+
+    int y_start, y_end, n_step = size / blockDim.x;
+    for(int step = 0; step < n_step; ++step) {
+        y_start = size - step * blockDim.x - 1;
+        y_end = size - (step + 1) * blockDim.x;
+
+        for (int ty = y_start - tid; ty >= y_end; ty -= blockDim.y) {
+            dx = x2 - tx; dy = lasty - ty; dz = z2 - tz;
+            best = dx * dx + dy * dy + dz * dz;
+
+            while (HASNEXT(last2)) {
+                dx = x1 - tx; dy = y2 - ty; dz = z1 - tz;
+                dist = dx * dx + dy * dy + dz * dz;
+
+                if(dist > best) break;
+
+                best = dist; lasty = y2; last2 = last1;
+                DECODE(last2, x2, y2, z2);
+
+                if (HASNEXT(last2)) {
+                    last1 = input[TOID(tx, y2, tz, size)];
+                    DECODE(last1, x1, y1, z1);
+                }
+            }
+
+            block[threadIdx.x][ty - y_end] = ENCODE(lasty, x2, z2, NOTSITE(last2), ZERO);
+        }
+
+        __syncthreads();
+
+        if(!threadIdx.y) {
+            int id = TOID(y_end + threadIdx.x, blockIdx.x * blockDim.x, tz, size);
+            for(int i = 0; i < blockDim.x; i++, id+=size) {
+                output[id] = block[i][threadIdx.x];
+            }
+        }
+
+        __syncthreads();
+    }
+}
+
+
+__global__ void kernelColorAxisWithSpacing(ENCODED_INT_TYPE *input, ENCODED_INT_TYPE *output, int size, double sx, double sy, double sz)
+{
+    __shared__ ENCODED_INT_TYPE block[BLOCKSIZE][BLOCKSIZE];
+
+    int col = threadIdx.x;
+    int tid = threadIdx.y;
+    int tx = blockIdx.x * blockDim.x + col;
+    int tz = blockIdx.y;
+
+    ENCODED_INT_TYPE x1, y1, z1, x2, y2, z2;
+    ENCODED_INT_TYPE last1 = ENCODE(ZERO,ZERO,ZERO,ONE,ZERO), last2 = ENCODE(ZERO,ZERO,ZERO,ONE,ZERO), lasty;
+    double dx, dy, dz, best, dist;
+
+    lasty = size - 1;
+
+    last2 = input[TOID(tx, lasty, tz, size)];
+    DECODE(last2, x2, y2, z2);
+
+    if (NOTSITE(last2)) {
+        lasty = y2;
+        if(HASNEXT(last2)) {
+            last2 = input[TOID(tx, lasty, tz, size)];
+            DECODE(last2, x2, y2, z2);
+        }
+    }
+
+    if (HASNEXT(last2)) {
+        last1 = input[TOID(tx, y2, tz, size)];
+        DECODE(last1, x1, y1, z1);
+    }
+
+    int y_start, y_end, n_step = size / blockDim.x;
+    for(int step = 0; step < n_step; ++step) {
+        y_start = size - step * blockDim.x - 1;
+        y_end = size - (step + 1) * blockDim.x;
+
+        for (int ty = y_start - tid; ty >= y_end; ty -= blockDim.y) {
+            dx = static_cast<double>(x2 - tx) * sx;
+            dy = static_cast<double>(lasty - ty) * sy;
+            dz = static_cast<double>(z2 - tz) * sz;
+            best = dx * dx + dy * dy + dz * dz;
+
+            while (HASNEXT(last2)) {
+                dx = static_cast<double>(x1 - tx) * sx;
+                dy = static_cast<double>(y2 - ty) * sy;
+                dz = static_cast<double>(z1 - tz) * sz;
+                dist = dx * dx + dy * dy + dz * dz;
+
+                if(dist > best) break;
+
+                best = dist; lasty = y2; last2 = last1;
+                DECODE(last2, x2, y2, z2);
+
+                if (HASNEXT(last2)) {
+                    last1 = input[TOID(tx, y2, tz, size)];
+                    DECODE(last1, x1, y1, z1);
+                }
+            }
+
+            block[threadIdx.x][ty - y_end] = ENCODE(lasty, x2, z2, NOTSITE(last2), ZERO);
+        }
+
+        __syncthreads();
+
+        if(!threadIdx.y) {
+            int id = TOID(y_end + threadIdx.x, blockIdx.x * blockDim.x, tz, size);
+            for(int i = 0; i < blockDim.x; i++, id+=size) {
+                output[id] = block[i][threadIdx.x];
+            }
+        }
+
+        __syncthreads();
+    }
+}
+
+
+} // extern C

vllm/lib/python3.10/site-packages/packaging/__init__.py

@@ -0,0 +1,15 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+__title__ = "packaging"
+__summary__ = "Core utilities for Python packages"
+__uri__ = "https://github.com/pypa/packaging"
+
+__version__ = "24.2"
+
+__author__ = "Donald Stufft and individual contributors"
+__email__ = "donald@stufft.io"
+
+__license__ = "BSD-2-Clause or Apache-2.0"
+__copyright__ = f"2014 {__author__}"