code: def laplacian(
      input: Tensor,
      kernel_size: tuple[int, int] | int,
      border_type: str = "reflect",
      normalized: bool = True,
  ) -> Tensor:
      r"""Create an operator that returns a tensor using a Laplacian filter.
  
      .. image:: _static/img/laplacian.png
  
      The operator smooths the given tensor with a laplacian kernel by convolving
      it to each channel. It supports batched operation.
  
      Args:
          input: the input image tensor with shape :math:`(B, C, H, W)`.
          kernel_size: the size of the kernel.
          border_type: the padding mode to be applied before convolving.
            The expected modes are: ``'constant'``, ``'reflect'``,
            ``'replicate'`` or ``'circular'``.
          normalized: if True, L1 norm of the kernel is set to 1.
  
      Return:
          the blurred image with shape :math:`(B, C, H, W)`.
  
      .. note::
         See a working example `here <https://kornia.github.io/tutorials/nbs/filtering_edges.html>`__.
  
      Examples:
          >>> input = torch.rand(2, 4, 5, 5)
          >>> output = laplacian(input, 3)
          >>> output.shape
          torch.Size([2, 4, 5, 5])
      """
      kernel = get_laplacian_kernel2d(
          kernel_size, device=input.device, dtype=input.dtype
      )[None, ...]
  
      if normalized:
          kernel = normalize_kernel2d(kernel)
  
      return filter2d(input, kernel, border_type)
  
file_path: kornia/kornia/filters/laplacian.py
imports: from __future__ import annotations
  from kornia.core import Module, Tensor
  from .filter import filter2d
  from .kernels import get_laplacian_kernel2d, normalize_kernel2d
label_desc: Use image node_id 1 for calling a global function with example usage: laplacian(input, kernel_size, border_type, normalized) and returns: filter2d