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.
  
      >>> import cusignal
      >>> import cupy as cp
      >>> from scipy import misc
      >>> ascent = cp.asarray(misc.ascent())
      >>> scharr = cp.array([[ -3-3j, 0-10j,  +3 -3j],
      ...                    [-10+0j, 0+ 0j, +10 +0j],
      ...                    [ -3+3j, 0+10j,  +3 +3j]]) # Gx + j*Gy
      >>> grad = cusignal.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(cp.asnumpy(ascent), cmap='gray')
      >>> ax_orig.set_title('Original')
      >>> ax_orig.set_axis_off()
      >>> ax_mag.imshow(cp.asnumpy(cp.absolute(grad)), cmap='gray')
      >>> ax_mag.set_title('Gradient magnitude')
      >>> ax_mag.set_axis_off()
      >>> ax_ang.imshow(cp.asnumpy(cp.angle(grad)), cmap='hsv')
      >>> ax_ang.set_title('Gradient orientation')
      >>> ax_ang.set_axis_off()
      >>> fig.show()
  
      """
  
      in1 = cp.asarray(in1)
      in2 = cp.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
  
      return _convolution_cuda._convolve2d(
          in1,
          in2,
          1,
          mode,
          boundary,
          fillvalue,
      )
  
file_path: cusignal/python/cusignal/convolution/convolve.py
imports: import sys
  import cupy
  import numpy
  from ..utils.fftpack_helper import _init_nd_shape_and_axes_sorted, next_fast_len
  from .None import _convolution_cuda
  from .convolution_utils import _centered, _fftconv_faster, _inputs_swap_needed, _numeric_arrays, _timeit_fast
label_desc: Use image node_id 3 for calling a global function with example usage: convolve2d(in1, in2, mode, boundary, fillvalue) and returns: _convolution_cuda