code: def medfilt(volume, kernel_size=None):
      """
      Perform a median filter on an N-dimensional array.
  
      Apply a median filter to the input array using a local window-size
      given by `kernel_size`. The array will automatically be zero-padded.
  
      Parameters
      ----------
      volume : array_like
          An N-dimensional input array.
      kernel_size : array_like, optional
          A scalar or an N-length list giving the size of the median filter
          window in each dimension.  Elements of `kernel_size` should be odd.
          If `kernel_size` is a scalar, then this scalar is used as the size in
          each dimension. Default size is 3 for each dimension.
  
      Returns
      -------
      out : ndarray
          An array the same size as input containing the median filtered
          result.
  
      Warns
      -----
      UserWarning
          If array size is smaller than kernel size along any dimension
  
      See Also
      --------
      scipy.ndimage.median_filter
      scipy.signal.medfilt2d
  
      Notes
      -----
      The more general function `scipy.ndimage.median_filter` has a more
      efficient implementation of a median filter and therefore runs much faster.
  
      For 2-dimensional images with ``uint8``, ``float32`` or ``float64`` dtypes,
      the specialised function `scipy.signal.medfilt2d` may be faster.
  
      """
      volume = np.atleast_1d(volume)
      if kernel_size is None:
          kernel_size = [3] * volume.ndim
      kernel_size = np.asarray(kernel_size)
      if kernel_size.shape == ():
          kernel_size = np.repeat(kernel_size.item(), volume.ndim)
  
      for k in range(volume.ndim):
          if (kernel_size[k] % 2) != 1:
              raise ValueError(
                  "Each element of kernel_size should be odd."
              )
      if any(k > s for k, s in zip(kernel_size, volume.shape)):
          warnings.warn(
              "kernel_size exceeds volume extent: the volume will be "
              "zero-padded."
          )
  
      domain = np.ones(kernel_size, dtype=volume.dtype)
  
      numels = np.prod(kernel_size, axis=0)
      order = numels // 2
      return sigtools._order_filterND(volume, domain, order)
  
imports: import operator
  import math
  import timeit
  from scipy.spatial import cKDTree
  from .None import sigtools, dlti
  from ._upfirdn import upfirdn, _output_len, _upfirdn_modes
  from scipy import linalg, fft
  from scipy.fft._helper import _init_nd_shape_and_axes
  from scipy._lib._util import prod
  import numpy
  from scipy.special import lambertw
  from .windows import get_window
  from ._arraytools import axis_slice, axis_reverse, odd_ext, even_ext, const_ext
  from .filter_design import cheby1, _validate_sos
  from .fir_filter_design import firwin
  from ._sosfilt import _sosfilt
  import warnings
label_desc: Use image node_id 22 for calling a global function with example usage: medfilt(volume, kernel_size) and returns: sigtools