docs: def ssd(minuend, subtrahend, normalized=True, signed=False, size=None, footprint=None, mode="reflect", cval=0.0, origin=0):
      r"""
      Computes the sum of squared difference (SSD) between patches of minuend and subtrahend.
      
      Parameters
      ----------
      minuend : array_like
          Input array from which to subtract the subtrahend.
      subtrahend : array_like
          Input array to subtract from the minuend.    
      normalized : bool, optional
          Whether the SSD of each patch should be divided through the filter size for
          normalization. Default is 'True'.
      signed : bool, optional
          Whether the accumulative sign of each patch should be returned as well. If
          'True', the second return value is a numpy.sign array, otherwise the scalar '1'.
          Default is 'False'.
      size : scalar or tuple, optional
          See footprint, below
      footprint : array, optional
          The patch over which to compute the SSD.
          Either `size` or `footprint` must be defined. `size` gives
          the shape that is taken from the input array, at every element
          position, to define the input to the filter function.
          `footprint` is a boolean array that specifies (implicitly) a
          shape, but also which of the elements within this shape will get
          passed to the filter function. Thus ``size=(n,m)`` is equivalent
          to ``footprint=np.ones((n,m))``. We adjust `size` to the number
          of dimensions of the input array, so that, if the input array is
          shape (10,10,10), and `size` is 2, then the actual size used is
          (2,2,2).
      mode : {'reflect', 'constant', 'nearest', 'mirror', 'wrap'}, optional
          The `mode` parameter determines how the array borders are
          handled, where `cval` is the value when mode is equal to
          'constant'. Default is 'reflect'
      cval : scalar, optional
          Value to fill past edges of input if `mode` is 'constant'. Default
          is 0.0
          
      Returns
      -------
      ssd : ndarray
          The patchwise sum of squared differences between minuend and subtrahend.
      """
      convolution_filter = average_filter if normalized else sum_filter
      output = numpy.float if normalized else minuend.dtype
      
      if signed:
          difference = minuend - subtrahend
          difference_squared = numpy.square(difference)
          distance_sign = numpy.sign(convolution_filter(numpy.sign(difference) * difference_squared, size=size, footprint=footprint, mode=mode, cval=cval, origin=origin, output=output))
          distance = convolution_filter(difference_squared, size=size, footprint=footprint, mode=mode, cval=cval, output=output)
      else:
          distance = convolution_filter(numpy.square(minuend - subtrahend), size=size, footprint=footprint, mode=mode, cval=cval, origin=origin, output=output)
          distance_sign = 1
      
      return distance, distance_sign