code: def gaussian_filter(
      array,
      sigma,
      order=0,
      mode="reflect",
      cval=0.0,
      out=None,
      output=None,
  ):
      """
      filtered = gaussian_filter(array, sigma, order=0, mode='reflect', cval=0., out={np.empty_like(array)})
  
      Multi-dimensional Gaussian filter.
  
      Parameters
      ----------
      array : ndarray
          input array, any dimension is supported. If the array is an integer
          array, it will be converted to a double array.
      sigma : scalar or sequence of scalars
          standard deviation for Gaussian kernel. The standard
          deviations of the Gaussian filter are given for each axis as a
          sequence, or as a single number, in which case it is equal for
          all axes.
      order : {0, 1, 2, 3} or sequence from same set, optional
          The order of the filter along each axis is given as a sequence
          of integers, or as a single number.  An order of 0 corresponds
          to convolution with a Gaussian kernel. An order of 1, 2, or 3
          corresponds to convolution with the first, second or third
          derivatives of a Gaussian. Higher order derivatives are not
          implemented
      mode : {'reflect' [default], 'nearest', 'wrap', 'mirror', 'constant', 'ignore'}
          How to handle borders
      cval : double, optional
          If `mode` is constant, which constant to use (default: 0.0)
      out : ndarray, optional
          Output array. Must have same shape as `array` as well as be
          C-contiguous. If `array` is an integer array, this must be a double
          array; otherwise, it must have the same type as `array`.
  
      Returns
      -------
      filtered : ndarray
          Filtered version of `array`
  
      Notes
      -----
      The multi-dimensional filter is implemented as a sequence of
      one-dimensional convolution 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.
      """
      array = _as_floating_point_array(array)
      output = _get_output(array, out, "gaussian_filter", output=output)
      orders = _normalize_sequence(array, order, "gaussian_filter")
      sigmas = _normalize_sequence(array, sigma, "gaussian_filter")
      output[...] = array[...]
      noutput = None
      for axis in range(array.ndim):
          sigma = sigmas[axis]
          order = orders[axis]
          noutput = gaussian_filter1d(
              output, sigma, axis, order, mode, cval, noutput
          )
          output, noutput = noutput, output
      return output
  
imports: import numpy
  from .None import _convolve
  from .None import morph
  from .internal import _get_output, _normalize_sequence, _verify_is_floatingpoint_type, _as_floating_point_array
  from ._filters import mode2int, modes, _check_mode
label_desc: Use image node_id 9 for calling a global function with example usage: gaussian_filter(array, sigma, order, mode, cval, out, output) and returns: output