code: def fftconvolve(in1, in2, mode="full", axes=None):
      """Convolve two N-dimensional arrays using FFT.
  
      Convolve `in1` and `in2` using the fast Fourier transform method, with
      the output size determined by the `mode` argument.
  
      This is generally much faster than `convolve` for large arrays (n > ~500),
      but can be slower when only a few output values are needed, and can only
      output float arrays (int or object array inputs will be cast to float).
  
      As of v0.19, `convolve` automatically chooses this method or the direct
      method based on an estimation of which is faster.
  
      Parameters
      ----------
      in1 : array_like
          First input.
      in2 : array_like
          Second input. Should have the same number of dimensions as `in1`.
      mode : str {'full', 'valid', 'same'}, optional
          A string indicating the size of the output:
  
          ``full``
             The output is the full discrete linear convolution
             of the inputs. (Default)
          ``valid``
             The output consists only of those elements that do not
             rely on the zero-padding. In 'valid' mode, either `in1` or `in2`
             must be at least as large as the other in every dimension.
          ``same``
             The output is the same size as `in1`, centered
             with respect to the 'full' output.
             axis : tuple, optional
      axes : int or array_like of ints or None, optional
          Axes over which to compute the convolution.
          The default is over all axes.
  
  
      Returns
      -------
      out : array
          An N-dimensional array containing a subset of the discrete linear
          convolution of `in1` with `in2`.
  
      Examples
      --------
      Autocorrelation of white noise is an impulse.
  
      >>> from scipy import signal
      >>> sig = np.random.randn(1000)
      >>> autocorr = signal.fftconvolve(sig, sig[::-1], mode='full')
  
      >>> import matplotlib.pyplot as plt
      >>> fig, (ax_orig, ax_mag) = plt.subplots(2, 1)
      >>> ax_orig.plot(sig)
      >>> ax_orig.set_title('White noise')
      >>> ax_mag.plot(np.arange(-len(sig)+1,len(sig)), autocorr)
      >>> ax_mag.set_title('Autocorrelation')
      >>> fig.tight_layout()
      >>> fig.show()
  
      Gaussian blur implemented using FFT convolution.  Notice the dark borders
      around the image, due to the zero-padding beyond its boundaries.
      The `convolve2d` function allows for other types of image boundaries,
      but is far slower.
  
      >>> from scipy import misc
      >>> face = misc.face(gray=True)
      >>> kernel = np.outer(signal.gaussian(70, 8), signal.gaussian(70, 8))
      >>> blurred = signal.fftconvolve(face, kernel, mode='same')
  
      >>> fig, (ax_orig, ax_kernel, ax_blurred) = plt.subplots(3, 1,
      ...                                                      figsize=(6, 15))
      >>> ax_orig.imshow(face, cmap='gray')
      >>> ax_orig.set_title('Original')
      >>> ax_orig.set_axis_off()
      >>> ax_kernel.imshow(kernel, cmap='gray')
      >>> ax_kernel.set_title('Gaussian kernel')
      >>> ax_kernel.set_axis_off()
      >>> ax_blurred.imshow(blurred, cmap='gray')
      >>> ax_blurred.set_title('Blurred')
      >>> ax_blurred.set_axis_off()
      >>> fig.show()
  
      """
      in1 = asarray(in1)
      in2 = asarray(in2)
      noaxes = axes is None
  
      if in1.ndim == in2.ndim == 0:  # scalar inputs
          return in1 * in2
      elif in1.ndim != in2.ndim:
          raise ValueError(
              "in1 and in2 should have the same dimensionality"
          )
      elif in1.size == 0 or in2.size == 0:  # empty arrays
          return array([])
  
      _, axes = _init_nd_shape_and_axes_sorted(
          in1, shape=None, axes=axes
      )
  
      if not noaxes and not axes.size:
          raise ValueError("when provided, axes cannot be empty")
  
      if noaxes:
          other_axes = array([], dtype=np.intc)
      else:
          other_axes = np.setdiff1d(np.arange(in1.ndim), axes)
  
      s1 = array(in1.shape)
      s2 = array(in2.shape)
  
      if not np.all(
          (s1[other_axes] == s2[other_axes])
          | (s1[other_axes] == 1)
          | (s2[other_axes] == 1)
      ):
          raise ValueError(
              "incompatible shapes for in1 and in2:"
              " {0} and {1}".format(in1.shape, in2.shape)
          )
  
      complex_result = np.issubdtype(
          in1.dtype, np.complexfloating
      ) or np.issubdtype(in2.dtype, np.complexfloating)
      shape = np.maximum(s1, s2)
      shape[axes] = s1[axes] + s2[axes] - 1
  
      # Check that input sizes are compatible with 'valid' mode
      if _inputs_swap_needed(mode, s1, s2):
          # Convolution is commutative; order doesn't have any effect on output
          in1, s1, in2, s2 = in2, s2, in1, s1
  
      # Speed up FFT by padding to optimal size for FFTPACK
      fshape = [fftpack.helper.next_fast_len(d) for d in shape[axes]]
      fslice = tuple([slice(sz) for sz in shape])
      # Pre-1.9 NumPy FFT routines are not threadsafe.  For older NumPys, make
      # sure we only call rfftn/irfftn from one thread at a time.
      if not complex_result and (
          _rfft_mt_safe or _rfft_lock.acquire(False)
      ):
          try:
              sp1 = np.fft.rfftn(in1, fshape, axes=axes)
              sp2 = np.fft.rfftn(in2, fshape, axes=axes)
              ret = np.fft.irfftn(sp1 * sp2, fshape, axes=axes)[
                  fslice
              ].copy()
          finally:
              if not _rfft_mt_safe:
                  _rfft_lock.release()
      else:
          # If we're here, it's either because we need a complex result, or we
          # failed to acquire _rfft_lock (meaning rfftn isn't threadsafe and
          # is already in use by another thread).  In either case, use the
          # (threadsafe but slower) SciPy complex-FFT routines instead.
          sp1 = fftpack.fftn(in1, fshape, axes=axes)
          sp2 = fftpack.fftn(in2, fshape, axes=axes)
          ret = fftpack.ifftn(sp1 * sp2, axes=axes)[fslice].copy()
          if not complex_result:
              ret = ret.real
  
      if mode == "full":
          return ret
      elif mode == "same":
          return _centered(ret, s1)
      elif mode == "valid":
          shape_valid = shape.copy()
          shape_valid[axes] = s1[axes] - s2[axes] + 1
          return _centered(ret, shape_valid)
      else:
          raise ValueError(
              "acceptable mode flags are 'valid'," " 'same', or 'full'"
          )
  
imports: from __future__ import division, print_function, absolute_import
  import operator
  import threading
  import sys
  import timeit
  from scipy.spatial import cKDTree
  from .None import sigtools, dlti
  from ._upfirdn import upfirdn, _output_len
  from scipy._lib.six import callable
  from scipy._lib._version import NumpyVersion
  from scipy import fftpack, linalg
  from scipy.fftpack.helper import _init_nd_shape_and_axes_sorted
  from numpy import allclose, angle, arange, argsort, array, asarray, atleast_1d, atleast_2d, cast, dot, exp, expand_dims, iscomplexobj, mean, ndarray, newaxis, ones, pi, poly, polyadd, polyder, polydiv, polymul, polysub, polyval, product, r_, ravel, real_if_close, reshape, roots, sort, take, transpose, unique, where, zeros, zeros_like
  import numpy
  import math
  from scipy.special import factorial
  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
label_desc: Use image node_id 6 for calling a global function with example usage: fftconvolve(in1, in2, mode, axes) and returns: unknown, ret, _centered, array, _centered