code: def uniform_filter(
      input, size=3, output=None, mode="reflect", cval=0.0, origin=0
  ):
      """Multi-dimensional uniform filter.
  
      Parameters
      ----------
      %(input)s
      size : int or sequence of ints, optional
          The sizes of the uniform filter are given for each axis as a
          sequence, or as a single number, in which case the size is
          equal for all axes.
      %(output)s
      %(mode_multiple)s
      %(cval)s
      %(origin_multiple)s
  
      Returns
      -------
      uniform_filter : ndarray
          Filtered array. Has the same shape as `input`.
  
      Notes
      -----
      The multi-dimensional filter is implemented as a sequence of
      one-dimensional uniform filters. The intermediate arrays are stored
      in the same data type as the output. Therefore, for output types
      with a limited precision, the results may be imprecise because
      intermediate results may be stored with insufficient precision.
  
      Examples
      --------
      >>> from scipy import ndimage, misc
      >>> import matplotlib.pyplot as plt
      >>> fig = plt.figure()
      >>> plt.gray()  # show the filtered result in grayscale
      >>> ax1 = fig.add_subplot(121)  # left side
      >>> ax2 = fig.add_subplot(122)  # right side
      >>> ascent = misc.ascent()
      >>> result = ndimage.uniform_filter(ascent, size=20)
      >>> ax1.imshow(ascent)
      >>> ax2.imshow(result)
      >>> plt.show()
      """
      input = numpy.asarray(input)
      output = _ni_support._get_output(output, input)
      sizes = _ni_support._normalize_sequence(size, input.ndim)
      origins = _ni_support._normalize_sequence(origin, input.ndim)
      modes = _ni_support._normalize_sequence(mode, input.ndim)
      axes = list(range(input.ndim))
      axes = [
          (axes[ii], sizes[ii], origins[ii], modes[ii])
          for ii in range(len(axes))
          if sizes[ii] > 1
      ]
      if len(axes) > 0:
          for axis, size, origin, mode in axes:
              uniform_filter1d(
                  input, int(size), axis, output, mode, cval, origin
              )
              input = output
      else:
          output[...] = input[...]
      return output
  
imports: from __future__ import division, print_function, absolute_import
  import warnings
  import numbers
  import numpy
  import operator
  from .None import _ni_support
  from .None import _nd_image
  from .None import _ni_docstrings
label_desc: Use image node_id 18 for calling a global function with example usage: uniform_filter(input, size, output, mode, cval, origin) and returns: output