code: def center_crop_generator3d(
      batch_size: int,
      depth: int,
      height: int,
      width: int,
      size: Tuple[int, int, int],
      device: Device = torch.device("cpu"),
  ) -> Dict[str, Tensor]:
      r"""Get parameters for ```center_crop3d``` transformation for center crop transform.
  
      Args:
          batch_size (int): the tensor batch size.
          depth (int) : depth of the image.
          height (int) : height of the image.
          width (int): width of the image.
          size (tuple): Desired output size of the crop, like (d, h, w).
          device (Device): the device on which the random numbers will be generated. Default: cpu.
  
      Returns:
          params Dict[str, Tensor]: parameters to be passed for transformation.
              - src (Tensor): cropping bounding boxes with a shape of (B, 8, 3).
              - dst (Tensor): output bounding boxes with a shape (B, 8, 3).
  
      Note:
          No random number will be generated.
      """
      if not isinstance(size, (tuple, list)) and len(size) == 3:
          raise ValueError(
              f"Input size must be a tuple/list of length 3. Got {size}"
          )
      if not (
          isinstance(depth, int)
          and depth > 0
          and isinstance(height, int)
          and height > 0
          and isinstance(width, int)
          and width > 0
      ):
          raise AssertionError(
              f"'depth', 'height' and 'width' must be integers. Got {depth}, {height}, {width}."
          )
      if not (
          depth >= size[0] and height >= size[1] and width >= size[2]
      ):
          raise AssertionError(
              f"Crop size must be smaller than input size. Got ({depth}, {height}, {width}) and {size}."
          )
  
      if batch_size == 0:
          return {"src": zeros([0, 8, 3]), "dst": zeros([0, 8, 3])}
      # unpack input sizes
      dst_d, dst_h, dst_w = size
      src_d, src_h, src_w = (depth, height, width)
  
      # compute start/end offsets
      dst_d_half = dst_d / 2
      dst_h_half = dst_h / 2
      dst_w_half = dst_w / 2
      src_d_half = src_d / 2
      src_h_half = src_h / 2
      src_w_half = src_w / 2
  
      start_x = src_w_half - dst_w_half
      start_y = src_h_half - dst_h_half
      start_z = src_d_half - dst_d_half
  
      end_x = start_x + dst_w - 1
      end_y = start_y + dst_h - 1
      end_z = start_z + dst_d - 1
      # [x, y, z] origin
      # top-left-front, top-right-front, bottom-right-front, bottom-left-front
      # top-left-back, top-right-back, bottom-right-back, bottom-left-back
      # Note: DeprecationWarning: an integer is required (got type float).
      # Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
      points_src: Tensor = tensor(
          [
              [
                  [int(start_x), int(start_y), int(start_z)],
                  [int(end_x), int(start_y), int(start_z)],
                  [int(end_x), int(end_y), int(start_z)],
                  [int(start_x), int(end_y), int(start_z)],
                  [int(start_x), int(start_y), int(end_z)],
                  [int(end_x), int(start_y), int(end_z)],
                  [int(end_x), int(end_y), int(end_z)],
                  [int(start_x), int(end_y), int(end_z)],
              ]
          ],
          device=device,
          dtype=torch.long,
      ).expand(batch_size, -1, -1)
  
      # [x, y, z] destination
      # top-left-front, top-right-front, bottom-right-front, bottom-left-front
      # top-left-back, top-right-back, bottom-right-back, bottom-left-back
      points_dst: Tensor = tensor(
          [
              [
                  [0, 0, 0],
                  [dst_w - 1, 0, 0],
                  [dst_w - 1, dst_h - 1, 0],
                  [0, dst_h - 1, 0],
                  [0, 0, dst_d - 1],
                  [dst_w - 1, 0, dst_d - 1],
                  [dst_w - 1, dst_h - 1, dst_d - 1],
                  [0, dst_h - 1, dst_d - 1],
              ]
          ],
          device=device,
          dtype=torch.long,
      ).expand(batch_size, -1, -1)
      return {"src": points_src, "dst": points_dst}
  
file_path: kornia/kornia/augmentation/random_generator/_3d/crop.py
imports: from typing import Dict, Optional, Tuple, Union
  import torch
  from torch.distributions import Uniform
  from kornia.augmentation.random_generator.base import RandomGeneratorBase
  from kornia.augmentation.utils import _adapted_rsampling, _common_param_check
  from kornia.core import Device, Tensor, tensor, zeros
  from kornia.geometry.bbox import bbox_generator3d
  from kornia.utils.helpers import _extract_device_dtype
label_desc: Use image node_id 1 for calling a global function with example usage: center_crop_generator3d(batch_size, depth, height, width, size, device) and returns: dict, dict