code: def get_gaussian_kernel3d(
      kernel_size: tuple[int, int, int] | int,
      sigma: tuple[float, float, float] | Tensor,
      force_even: bool = False,
      *,
      device: Optional[Device] = None,
      dtype: Optional[Dtype] = None,
  ) -> Tensor:
      r"""Function that returns Gaussian filter matrix coefficients.
  
      Args:
          kernel_size: filter sizes in the z, y and x direction. Sizes should be odd and positive.
          sigma: gaussian standard deviation in the z, y and x direction.
          force_even: overrides requirement for odd kernel size.
          device: This value will be used if sigma is a float. Device desired to compute.
          dtype: This value will be used if sigma is a float. Dtype desired for compute.
  
      Returns:
          3D tensor with gaussian filter matrix coefficients.
  
      Shape:
          - Output: :math:`(B, \text{kernel_size}_x, \text{kernel_size}_y,  \text{kernel_size}_z)`
  
      Examples:
          >>> get_gaussian_kernel3d((3, 3, 3), (1.5, 1.5, 1.5))
          tensor([[[[0.0292, 0.0364, 0.0292],
                    [0.0364, 0.0455, 0.0364],
                    [0.0292, 0.0364, 0.0292]],
          <BLANKLINE>
                   [[0.0364, 0.0455, 0.0364],
                    [0.0455, 0.0568, 0.0455],
                    [0.0364, 0.0455, 0.0364]],
          <BLANKLINE>
                   [[0.0292, 0.0364, 0.0292],
                    [0.0364, 0.0455, 0.0364],
                    [0.0292, 0.0364, 0.0292]]]])
          >>> get_gaussian_kernel3d((3, 3, 3), (1.5, 1.5, 1.5)).sum()
          tensor(1.)
          >>> get_gaussian_kernel3d((3, 3, 3), (1.5, 1.5, 1.5)).shape
          torch.Size([1, 3, 3, 3])
          >>> get_gaussian_kernel3d((3, 7, 5), torch.tensor([[1.5, 1.5, 1.5]])).shape
          torch.Size([1, 3, 7, 5])
      """
      if isinstance(sigma, tuple):
          sigma = tensor([sigma], device=device, dtype=dtype)
  
      KORNIA_CHECK_IS_TENSOR(sigma)
      KORNIA_CHECK_SHAPE(sigma, ["B", "3"])
  
      ksize_z, ksize_y, ksize_x = _unpack_3d_ks(kernel_size)
      sigma_z, sigma_y, sigma_x = (
          sigma[:, 0, None],
          sigma[:, 1, None],
          sigma[:, 2, None],
      )
  
      kernel_z = get_gaussian_kernel1d(
          ksize_z, sigma_z, force_even, device=device, dtype=dtype
      )
      kernel_y = get_gaussian_kernel1d(
          ksize_y, sigma_y, force_even, device=device, dtype=dtype
      )
      kernel_x = get_gaussian_kernel1d(
          ksize_x, sigma_x, force_even, device=device, dtype=dtype
      )
  
      return (
          kernel_z.view(-1, ksize_z, 1, 1)
          * kernel_y.view(-1, 1, ksize_y, 1)
          * kernel_x.view(-1, 1, 1, ksize_x)
      )
  
imports: from __future__ import annotations
  import math
  from math import sqrt
  from typing import Any, Optional
  import torch
  from kornia.core import Device, Dtype, Tensor, concatenate, cos, stack, tensor, where, zeros, zeros_like
  from kornia.core.check import KORNIA_CHECK, KORNIA_CHECK_IS_TENSOR, KORNIA_CHECK_SHAPE
  from kornia.utils import deprecated
label_desc: Use image node_id 31 for calling a global function with example usage: get_gaussian_kernel3d(kernel_size, sigma, force_even) and returns: unknown