code: def keypoints_to_heatmap_labels(keypoints, rois):
      """Encode keypoint location in the target heatmap for use in
      SoftmaxWithLoss.
      """
      # 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.
      assert keypoints.shape[2] == cfg.KRCNN.NUM_KEYPOINTS
  
      shape = (len(rois), cfg.KRCNN.NUM_KEYPOINTS)
      heatmaps = blob_utils.zeros(shape)
      weights = blob_utils.zeros(shape)
  
      offset_x = rois[:, 0]
      offset_y = rois[:, 1]
      scale_x = cfg.KRCNN.HEATMAP_SIZE / (rois[:, 2] - rois[:, 0])
      scale_y = cfg.KRCNN.HEATMAP_SIZE / (rois[:, 3] - rois[:, 1])
  
      for kp in range(keypoints.shape[2]):
          vis = keypoints[:, 2, kp] > 0
          x = keypoints[:, 0, kp].astype(np.float32)
          y = keypoints[:, 1, kp].astype(np.float32)
          # Since we use floor below, if a keypoint is exactly on the roi's right
          # or bottom boundary, we shift it in by eps (conceptually) to keep it in
          # the ground truth heatmap.
          x_boundary_inds = np.where(x == rois[:, 2])[0]
          y_boundary_inds = np.where(y == rois[:, 3])[0]
          x = (x - offset_x) * scale_x
          x = np.floor(x)
          if len(x_boundary_inds) > 0:
              x[x_boundary_inds] = cfg.KRCNN.HEATMAP_SIZE - 1
  
          y = (y - offset_y) * scale_y
          y = np.floor(y)
          if len(y_boundary_inds) > 0:
              y[y_boundary_inds] = cfg.KRCNN.HEATMAP_SIZE - 1
  
          valid_loc = np.logical_and(
              np.logical_and(x >= 0, y >= 0),
              np.logical_and(
                  x < cfg.KRCNN.HEATMAP_SIZE, y < cfg.KRCNN.HEATMAP_SIZE
              ),
          )
  
          valid = np.logical_and(valid_loc, vis)
          valid = valid.astype(np.int32)
  
          lin_ind = y * cfg.KRCNN.HEATMAP_SIZE + x
          heatmaps[:, kp] = lin_ind * valid
          weights[:, kp] = valid
  
      return heatmaps, weights
  
file_path: dense-pose/detectron/utils/keypoints.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from __future__ import unicode_literals
  import cv2
  import numpy
  from detectron.core.config import cfg
  import detectron.utils.blob
label_desc: Use image node_id 6 for calling a global function with example usage: keypoints_to_heatmap_labels(keypoints, rois) and returns: heatmaps,  weights