code: def correlate2d(in1, in2, mode="full", boundary="fill", fillvalue=0):
      """
      Cross-correlate two 2-dimensional arrays.
  
      Cross correlate `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 cross-correlation
             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
      -------
      correlate2d : ndarray
          A 2-dimensional array containing a subset of the discrete linear
          cross-correlation of `in1` with `in2`.
  
      Notes
      -----
      When using "same" mode with even-length inputs, the outputs of `correlate`
      and `correlate2d` differ: There is a 1-index offset between them.
  
      Examples
      --------
      Use 2D cross-correlation to find the location of a template in a noisy
      image:
  
      >>> from scipy import signal
      >>> from scipy import misc
      >>> rng = np.random.default_rng()
      >>> face = misc.face(gray=True) - misc.face(gray=True).mean()
      >>> template = np.copy(face[300:365, 670:750])  # right eye
      >>> template -= template.mean()
      >>> face = face + rng.standard_normal(face.shape) * 50  # add noise
      >>> corr = signal.correlate2d(face, template, boundary='symm', mode='same')
      >>> y, x = np.unravel_index(np.argmax(corr), corr.shape)  # find the match
  
      >>> import matplotlib.pyplot as plt
      >>> fig, (ax_orig, ax_template, ax_corr) = plt.subplots(3, 1,
      ...                                                     figsize=(6, 15))
      >>> ax_orig.imshow(face, cmap='gray')
      >>> ax_orig.set_title('Original')
      >>> ax_orig.set_axis_off()
      >>> ax_template.imshow(template, cmap='gray')
      >>> ax_template.set_title('Template')
      >>> ax_template.set_axis_off()
      >>> ax_corr.imshow(corr, cmap='gray')
      >>> ax_corr.set_title('Cross-correlation')
      >>> ax_corr.set_axis_off()
      >>> ax_orig.plot(x, y, 'ro')
      >>> fig.show()
  
      """
      in1 = np.asarray(in1)
      in2 = np.asarray(in2)
  
      if not in1.ndim == in2.ndim == 2:
          raise ValueError("correlate2d inputs must both be 2-D arrays")
  
      swapped_inputs = _inputs_swap_needed(mode, in1.shape, in2.shape)
      if swapped_inputs:
          in1, in2 = in2, in1
  
      val = _valfrommode(mode)
      bval = _bvalfromboundary(boundary)
      out = sigtools._convolve2d(
          in1, in2.conj(), 0, val, bval, fillvalue
      )
  
      if swapped_inputs:
          out = out[::-1, ::-1]
  
      return out
  
imports: import operator
  import math
  import timeit
  from scipy.spatial import cKDTree
  from .None import sigtools, dlti
  from ._upfirdn import upfirdn, _output_len, _upfirdn_modes
  from scipy import linalg, fft
  from scipy.fft._helper import _init_nd_shape_and_axes
  from scipy._lib._util import prod
  import numpy
  from scipy.special import lambertw
  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
  from ._sosfilt import _sosfilt
  import warnings
label_desc: Use image node_id 25 for calling a global function with example usage: correlate2d(in1, in2, mode, boundary, fillvalue) and returns: out