code: def convolve2d(in1, in2, mode="full", boundary="fill", fillvalue=0):
      """
      Convolve two 2-dimensional arrays.
  
      Convolve `in1` and `in2` with output size determined by `mode`, and
      boundary conditions determined by `boundary` and `fillvalue`.
  
      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.
      boundary : str {'fill', 'wrap', 'symm'}, optional
          A flag indicating how to handle boundaries:
  
          ``fill``
             pad input arrays with fillvalue. (default)
          ``wrap``
             circular boundary conditions.
          ``symm``
             symmetrical boundary conditions.
  
      fillvalue : scalar, optional
          Value to fill pad input arrays with. Default is 0.
  
      Returns
      -------
      out : ndarray
          A 2-dimensional array containing a subset of the discrete linear
          convolution of `in1` with `in2`.
  
      Examples
      --------
      Compute the gradient of an image by 2D convolution with a complex Scharr
      operator.  (Horizontal operator is real, vertical is imaginary.)  Use
      symmetric boundary condition to avoid creating edges at the image
      boundaries.
  
      >>> from scipy import signal
      >>> from scipy import misc
      >>> ascent = misc.ascent()
      >>> scharr = np.array([[ -3-3j, 0-10j,  +3 -3j],
      ...                    [-10+0j, 0+ 0j, +10 +0j],
      ...                    [ -3+3j, 0+10j,  +3 +3j]]) # Gx + j*Gy
      >>> grad = signal.convolve2d(ascent, scharr, boundary='symm', mode='same')
  
      >>> import matplotlib.pyplot as plt
      >>> fig, (ax_orig, ax_mag, ax_ang) = plt.subplots(3, 1, figsize=(6, 15))
      >>> ax_orig.imshow(ascent, cmap='gray')
      >>> ax_orig.set_title('Original')
      >>> ax_orig.set_axis_off()
      >>> ax_mag.imshow(np.absolute(grad), cmap='gray')
      >>> ax_mag.set_title('Gradient magnitude')
      >>> ax_mag.set_axis_off()
      >>> ax_ang.imshow(np.angle(grad), cmap='hsv') # hsv is cyclic, like angles
      >>> ax_ang.set_title('Gradient orientation')
      >>> ax_ang.set_axis_off()
      >>> fig.show()
  
      """
      in1 = asarray(in1)
      in2 = asarray(in2)
  
      if not in1.ndim == in2.ndim == 2:
          raise ValueError("convolve2d inputs must both be 2D arrays")
  
      if _inputs_swap_needed(mode, in1.shape, in2.shape):
          in1, in2 = in2, in1
  
      val = _valfrommode(mode)
      bval = _bvalfromboundary(boundary)
      out = sigtools._convolve2d(in1, in2, 1, val, bval, fillvalue)
      return out
  
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 18 for calling a global function with example usage: convolve2d(in1, in2, mode, boundary, fillvalue) and returns: out