code: def render_gaussian2d(
      mean: Tensor,
      std: Tensor,
      size: tuple[int, int],
      normalized_coordinates: bool = True,
  ) -> Tensor:
      r"""Render the PDF of a 2D Gaussian distribution.
  
      Args:
          mean: the mean location of the Gaussian to render, :math:`(\mu_x, \mu_y)`. Shape: :math:`(*, 2)`.
          std: the standard deviation of the Gaussian to render, :math:`(\sigma_x, \sigma_y)`.
            Shape :math:`(*, 2)`. Should be able to be broadcast with `mean`.
          size: the (height, width) of the output image.
          normalized_coordinates: whether ``mean`` and ``std`` are assumed to use coordinates normalized
            in the range of :math:`[-1, 1]`. Otherwise, coordinates are assumed to be in the range of the output shape.
  
      Returns:
          tensor including rendered points with shape :math:`(*, H, W)`.
      """
      if not (std.dtype == mean.dtype and std.device == mean.device):
          raise TypeError(
              "Expected inputs to have the same dtype and device"
          )
  
      height, width = size
  
      # Create coordinates grid.
      grid = create_meshgrid(
          height, width, normalized_coordinates, mean.device
      )
      grid = grid.to(mean.dtype)
      pos_x = grid[..., 0].view(height, width)
      pos_y = grid[..., 1].view(height, width)
  
      # Gaussian PDF = exp(-(x - \mu)^2 / (2 \sigma^2))
      #              = exp(dists * ks),
      #                where dists = (x - \mu)^2 and ks = -1 / (2 \sigma^2)
  
      # dists <- (x - \mu)^2
      dist_x = (pos_x - mean[..., 0, None, None]) ** 2
      dist_y = (pos_y - mean[..., 1, None, None]) ** 2
  
      # ks <- -1 / (2 \sigma^2)
      k_x = -0.5 * torch.reciprocal(std[..., 0, None, None])
      k_y = -0.5 * torch.reciprocal(std[..., 1, None, None])
  
      # Assemble the 2D Gaussian.
      exps_x = torch.exp(dist_x * k_x)
      exps_y = torch.exp(dist_y * k_y)
      gauss = exps_x * exps_y
  
      # Rescale so that values sum to one.
      val_sum = gauss.sum(-2, keepdim=True).sum(-1, keepdim=True)
      gauss = _safe_zero_division(gauss, val_sum)
  
      return gauss
  
file_path: kornia/kornia/geometry/subpix/dsnt.py
imports: from __future__ import annotations
  import torch
  from kornia.core import Tensor, concatenate, softmax
  from kornia.core.check import KORNIA_CHECK_IS_TENSOR, KORNIA_CHECK_SHAPE
  from kornia.utils.grid import create_meshgrid
label_desc: Use image node_id 5 for calling a global function with example usage: render_gaussian2d(mean, std, size, normalized_coordinates) and returns: gauss