code: def _keypoints_to_heatmap(
      keypoints: torch.Tensor, rois: torch.Tensor, heatmap_size: int
  ) -> Tuple[torch.Tensor, torch.Tensor]:
      """
      Encode keypoint locations into a target heatmap for use in SoftmaxWithLoss across space.
  
      Maps keypoints from the half-open interval [x1, x2) on continuous image coordinates to the
      closed interval [0, heatmap_size - 1] on discrete image coordinates. We use the
      continuous-discrete conversion from Heckbert 1990 ("What is the coordinate of a pixel?"):
      d = floor(c) and c = d + 0.5, where d is a discrete coordinate and c is a continuous coordinate.
  
      Arguments:
          keypoints: tensor of keypoint locations in of shape (N, K, 3).
          rois: Nx4 tensor of rois in xyxy format
          heatmap_size: integer side length of square heatmap.
  
      Returns:
          heatmaps: A tensor of shape (N, K) containing an integer spatial label
              in the range [0, heatmap_size**2 - 1] for each keypoint in the input.
          valid: A tensor of shape (N, K) containing whether each keypoint is in
              the roi or not.
      """
  
      if rois.numel() == 0:
          return rois.new().long(), rois.new().long()
      offset_x = rois[:, 0]
      offset_y = rois[:, 1]
      scale_x = heatmap_size / (rois[:, 2] - rois[:, 0])
      scale_y = heatmap_size / (rois[:, 3] - rois[:, 1])
  
      offset_x = offset_x[:, None]
      offset_y = offset_y[:, None]
      scale_x = scale_x[:, None]
      scale_y = scale_y[:, None]
  
      x = keypoints[..., 0]
      y = keypoints[..., 1]
  
      x_boundary_inds = x == rois[:, 2][:, None]
      y_boundary_inds = y == rois[:, 3][:, None]
  
      x = (x - offset_x) * scale_x
      x = x.floor().long()
      y = (y - offset_y) * scale_y
      y = y.floor().long()
  
      x[x_boundary_inds] = heatmap_size - 1
      y[y_boundary_inds] = heatmap_size - 1
  
      valid_loc = (
          (x >= 0) & (y >= 0) & (x < heatmap_size) & (y < heatmap_size)
      )
      vis = keypoints[..., 2] > 0
      valid = (valid_loc & vis).long()
  
      lin_ind = y * heatmap_size + x
      heatmaps = lin_ind * valid
  
      return heatmaps, valid
  
file_path: gluon-cv/gluoncv/torch/data/structures/keypoints.py
imports: from typing import Any, List, Tuple, Union
  import numpy
  import torch
label_desc: Use image node_id 1 for calling a global function with example usage: _keypoints_to_heatmap(keypoints, rois, heatmap_size) and returns: heatmaps,  valid, rois,  rois