code: def fourier_ellipsoid(input, size, n=-1, axis=-1, output=None):
      """
      Multi-dimensional ellipsoid fourier filter.
  
      The array is multiplied with the fourier transform of a ellipsoid of
      given sizes.
  
      Parameters
      ----------
      input : array_like
          The input array.
      size : float or sequence
          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.
      output : ndarray, optional
          If given, the result of filtering the input is placed in this array.
          None is returned in this case.
  
      Returns
      -------
      fourier_ellipsoid : ndarray
          The filtered input.
  
      Notes
      -----
      This function is implemented for arrays of rank 1, 2, or 3.
  
      Examples
      --------
      >>> from scipy import ndimage, misc
      >>> import numpy.fft
      >>> import matplotlib.pyplot as plt
      >>> fig, (ax1, ax2) = plt.subplots(1, 2)
      >>> plt.gray()  # show the filtered result in grayscale
      >>> ascent = misc.ascent()
      >>> input_ = numpy.fft.fft2(ascent)
      >>> result = ndimage.fourier_ellipsoid(input_, size=20)
      >>> result = numpy.fft.ifft2(result)
      >>> ax1.imshow(ascent)
      >>> ax2.imshow(result.real)  # the imaginary part is an artifact
      >>> plt.show()
      """
      input = numpy.asarray(input)
      output = _get_output_fourier(output, input)
      axis = _ni_support._check_axis(axis, input.ndim)
      sizes = _ni_support._normalize_sequence(size, input.ndim)
      sizes = numpy.asarray(sizes, dtype=numpy.float64)
      if not sizes.flags.contiguous:
          sizes = sizes.copy()
      _nd_image.fourier_filter(input, sizes, n, axis, output, 2)
      return output
  
file_path: catboost/contrib/python/scipy/py2/scipy/ndimage/fourier.py
imports: from __future__ import division, print_function, absolute_import
  import numpy
  from .None import _ni_support
  from .None import _nd_image
label_desc: Use image node_id 5 for calling a global function with example usage: fourier_ellipsoid(input, size, n, axis, output) and returns: output