code: def center_crop(
      input_tensor: Tensor,
      size: Tuple[int, int],
      mode: str = "bilinear",
      padding_mode: str = "zeros",
      align_corners: bool = True,
  ) -> Tensor:
      r"""Crop the 2D images (4D tensor) from the center.
  
      Args:
          input_tensor: the 2D image tensor with shape (B, C, H, W).
          size: a tuple with the expected height and width
            of the output patch.
          mode: interpolation mode to calculate output values
            ``'bilinear'`` | ``'nearest'``.
          padding_mode: padding mode for outside grid values
            ``'zeros'`` | ``'border'`` | ``'reflection'``.
          align_corners: mode for grid_generation.
  
      Returns:
          the output tensor with patches.
  
      Examples:
          >>> input = torch.tensor([[[
          ...     [1., 2., 3., 4.],
          ...     [5., 6., 7., 8.],
          ...     [9., 10., 11., 12.],
          ...     [13., 14., 15., 16.],
          ...  ]]])
          >>> center_crop(input, (2, 4), mode='nearest', align_corners=True)
          tensor([[[[ 5.,  6.,  7.,  8.],
                    [ 9., 10., 11., 12.]]]])
      """
      if not isinstance(input_tensor, Tensor):
          raise TypeError(
              f"Input tensor type is not a Tensor. Got {type(input_tensor)}"
          )
  
      if not isinstance(size, (tuple, list)) and len(size) == 2:
          raise ValueError(
              f"Input size must be a tuple/list of length 2. Got {size}"
          )
  
      if len(input_tensor.shape) != 4:
          raise AssertionError(
              f"Only tensor with shape (B, C, H, W) supported. Got {input_tensor.shape}."
          )
  
      # unpack input sizes
      dst_h, dst_w = size
      src_h, src_w = input_tensor.shape[-2:]
  
      # compute start/end offsets
      dst_h_half: float = dst_h / 2
      dst_w_half: float = dst_w / 2
      src_h_half: float = src_h / 2
      src_w_half: float = src_w / 2
  
      start_x: float = src_w_half - dst_w_half
      start_y: float = src_h_half - dst_h_half
  
      end_x: float = start_x + dst_w - 1
      end_y: float = start_y + dst_h - 1
  
      # [y, x] origin
      # top-left, top-right, bottom-right, bottom-left
      points_src: Tensor = tensor(
          [
              [
                  [start_x, start_y],
                  [end_x, start_y],
                  [end_x, end_y],
                  [start_x, end_y],
              ]
          ],
          device=input_tensor.device,
          dtype=input_tensor.dtype,
      )
  
      # [y, x] destination
      # top-left, top-right, bottom-right, bottom-left
      points_dst: Tensor = tensor(
          [
              [
                  [0, 0],
                  [dst_w - 1, 0],
                  [dst_w - 1, dst_h - 1],
                  [0, dst_h - 1],
              ]
          ],
          device=input_tensor.device,
          dtype=input_tensor.dtype,
      ).expand(points_src.shape[0], -1, -1)
  
      return crop_by_boxes(
          input_tensor,
          points_src,
          points_dst,
          mode,
          padding_mode,
          align_corners,
      )
  
file_path: kornia/kornia/geometry/transform/crop2d.py
imports: from typing import Optional, Tuple
  import torch
  from kornia.core import Tensor, as_tensor, pad, tensor
  from kornia.geometry.bbox import infer_bbox_shape, validate_bbox
  from .affwarp import resize
  from .imgwarp import get_perspective_transform, warp_affine
label_desc: Use image node_id 2 for calling a global function with example usage: center_crop(input_tensor, size, mode, padding_mode, align_corners) and returns: crop_by_boxes