docs: def calc_detection_voc_ap(prec, rec, use_07_metric=False):
      """Calculate average precisions based on evaluation code of PASCAL VOC.
      This function calculates average precisions
      from given precisions and recalls.
      The code is based on the evaluation code used in PASCAL VOC Challenge.
      Args:
          prec (list of numpy.array): A list of arrays.
              :obj:`prec[l]` indicates precision for class :math:`l`.
              If :obj:`prec[l]` is :obj:`None`, this function returns
              :obj:`numpy.nan` for class :math:`l`.
          rec (list of numpy.array): A list of arrays.
              :obj:`rec[l]` indicates recall for class :math:`l`.
              If :obj:`rec[l]` is :obj:`None`, this function returns
              :obj:`numpy.nan` for class :math:`l`.
          use_07_metric (bool): Whether to use PASCAL VOC 2007 evaluation metric
              for calculating average precision. The default value is
              :obj:`False`.
      Returns:
          ~numpy.ndarray:
          This function returns an array of average precisions.
          The :math:`l`-th value corresponds to the average precision
          for class :math:`l`. If :obj:`prec[l]` or :obj:`rec[l]` is
          :obj:`None`, the corresponding value is set to :obj:`numpy.nan`.
      """
  
      n_fg_class = len(prec)
      ap = np.empty(n_fg_class)
      for l in range(n_fg_class):
          if prec[l] is None or rec[l] is None:
              ap[l] = np.nan
              continue
  
          if use_07_metric:
              # 11 point metric
              ap[l] = 0
              for t in np.arange(0.0, 1.1, 0.1):
                  if np.sum(rec[l] >= t) == 0:
                      p = 0
                  else:
                      p = np.max(np.nan_to_num(prec[l])[rec[l] >= t])
                  ap[l] += p / 11
          else:
              # correct AP calculation
              # first append sentinel values at the end
              mpre = np.concatenate(([0], np.nan_to_num(prec[l]), [0]))
              mrec = np.concatenate(([0], rec[l], [1]))
  
              mpre = np.maximum.accumulate(mpre[::-1])[::-1]
  
              # to calculate area under PR curve, look for points
              # where X axis (recall) changes value
              i = np.where(mrec[1:] != mrec[:-1])[0]
  
              # and sum (\Delta recall) * prec
              ap[l] = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
  
      return ap