code: def gradient(
      tensor: torch.Tensor,
      kernel: torch.Tensor,
      structuring_element: Optional[torch.Tensor] = None,
      origin: Optional[List[int]] = None,
      border_type: str = "geodesic",
      border_value: float = 0.0,
      max_val: float = 1e4,
      engine: str = "unfold",
  ) -> torch.Tensor:
      r"""Return the morphological gradient of an image.
  
      .. image:: _static/img/gradient.png
  
      That means, (dilation - erosion) applying the same kernel in each channel.
      The kernel must have 2 dimensions.
  
      Args:
          tensor: Image with shape :math:`(B, C, H, W)`.
          kernel: Positions of non-infinite elements of a flat structuring element. Non-zero values give
              the set of neighbors of the center over which the operation is applied. Its shape is :math:`(k_x, k_y)`.
              For full structural elements use torch.ones_like(structural_element).
          structuring_element: Structuring element used for the grayscale dilation. It may be a
              non-flat structuring element.
          origin: Origin of the structuring element. Default is None and uses the center of
              the structuring element as origin (rounding towards zero).
          border_type: It determines how the image borders are handled, where ``border_value`` is the value
              when ``border_type`` is equal to ``constant``. Default: ``geodesic`` which ignores the values that are
              outside the image when applying the operation.
          border_value: Value to fill past edges of input if ``border_type`` is ``constant``.
          max_val: The value of the infinite elements in the kernel.
          engine: convolution is faster and less memory hungry, and unfold is more stable numerically
  
      Returns:
         Gradient image with shape :math:`(B, C, H, W)`.
  
      .. note::
         See a working example `here <https://kornia.github.io/tutorials/nbs/morphology_101.html>`__.
  
      Example:
          >>> tensor = torch.rand(1, 3, 5, 5)
          >>> kernel = torch.ones(3, 3)
          >>> gradient_img = gradient(tensor, kernel)
      """
  
      return dilation(
          tensor,
          kernel=kernel,
          structuring_element=structuring_element,
          origin=origin,
          border_type=border_type,
          border_value=border_value,
          max_val=max_val,
          engine=engine,
      ) - erosion(
          tensor,
          kernel=kernel,
          structuring_element=structuring_element,
          origin=origin,
          border_type=border_type,
          border_value=border_value,
          max_val=max_val,
          engine=engine,
      )
  
file_path: kornia/kornia/morphology/morphology.py
imports: from typing import List, Optional
  import torch
  import torch.nn.functional
label_desc: Use image node_id 6 for calling a global function with example usage: gradient(tensor, kernel, structuring_element, origin, border_type, border_value, max_val, engine) and returns: unknown