code: def matching_batch(
      iou_fn: Callable[[np.ndarray, np.ndarray], np.ndarray],
      iou_thresholds: Sequence[float],
      pred_boxes: Sequence[np.ndarray],
      pred_classes: Sequence[np.ndarray],
      pred_scores: Sequence[np.ndarray],
      gt_boxes: Sequence[np.ndarray],
      gt_classes: Sequence[np.ndarray],
      gt_ignore: Sequence[Sequence[bool]]
      | Sequence[np.ndarray]
      | None = None,
      max_detections: int = 100,
  ) -> list[dict[int, dict[str, np.ndarray]]]:
      """
      Match boxes of a batch to corresponding ground truth for each category
      independently.
  
      Args:
          iou_fn: compute overlap for each pair
          iou_thresholds: defined which IoU thresholds should be evaluated
          pred_boxes: predicted boxes from single batch; List[[D, dim * 2]],
              D number of predictions
          pred_classes: predicted classes from a single batch; List[[D]],
              D number of predictions
          pred_scores: predicted score for each bounding box; List[[D]],
              D number of predictions
          gt_boxes: ground truth boxes; List[[G, dim * 2]], G number of ground
              truth
          gt_classes: ground truth classes; List[[G]], G number of ground truth
          gt_ignore: specified if which ground truth boxes are not counted as
              true positives. If not given, when use all the gt_boxes.
              (detections which match theses boxes are not counted as false
              positives either); List[[G]], G number of ground truth
          max_detections: maximum number of detections which should be evaluated
  
      Returns:
          List[Dict[int, Dict[str, np.ndarray]]], each Dict[str, np.ndarray] corresponds to an image.
          Dict has the following keys.
  
          - `dtMatches`: matched detections [T, D], where T = number of
            thresholds, D = number of detections
          - `gtMatches`: matched ground truth boxes [T, G], where T = number
            of thresholds, G = number of ground truth
          - `dtScores`: prediction scores [D] detection scores
          - `gtIgnore`: ground truth boxes which should be ignored
            [G] indicate whether ground truth should be ignored
          - `dtIgnore`: detections which should be ignored [T, D],
            indicate which detections should be ignored
  
      Example:
  
          .. code-block:: python
  
              from monai.data.box_utils import box_iou
              from monai.apps.detection.metrics.coco import COCOMetric
              from monai.apps.detection.metrics.matching import matching_batch
              # 3D example outputs of one image from detector
              val_outputs_all = [
                      {"boxes": torch.tensor([[1,1,1,3,4,5]],dtype=torch.float16),
                      "labels": torch.randint(3,(1,)),
                      "scores": torch.randn((1,)).absolute()},
              ]
              val_targets_all = [
                      {"boxes": torch.tensor([[1,1,1,2,6,4]],dtype=torch.float16),
                      "labels": torch.randint(3,(1,))},
              ]
  
              coco_metric = COCOMetric(
                  classes=['c0','c1','c2'], iou_list=[0.1], max_detection=[10]
              )
              results_metric = matching_batch(
                  iou_fn=box_iou,
                  iou_thresholds=coco_metric.iou_thresholds,
                  pred_boxes=[val_data_i["boxes"].numpy() for val_data_i in val_outputs_all],
                  pred_classes=[val_data_i["labels"].numpy() for val_data_i in val_outputs_all],
                  pred_scores=[val_data_i["scores"].numpy() for val_data_i in val_outputs_all],
                  gt_boxes=[val_data_i["boxes"].numpy() for val_data_i in val_targets_all],
                  gt_classes=[val_data_i["labels"].numpy() for val_data_i in val_targets_all],
              )
              val_metric_dict = coco_metric(results_metric)
              print(val_metric_dict)
      """
      results = []
      if gt_ignore is None:
          gt_ignore = [np.full_like(gt_c, False) for gt_c in gt_classes]
      # iterate over images/batches
      for pboxes, pclasses, pscores, gboxes, gclasses, gignore in zip(
          pred_boxes,
          pred_classes,
          pred_scores,
          gt_boxes,
          gt_classes,
          gt_ignore,
      ):
          # for each image
          img_classes = np.union1d(
              pclasses, gclasses
          )  # possible class labels
          result = (
              {}
          )  # dict contains results for each class in one image
          for c in img_classes:
              pred_mask = (
                  pclasses == c
              )  # bool mask predictions with current class
              gt_mask = (
                  gclasses == c
              )  # bool mask ground truth with current class
  
              if not np.any(gt_mask):  # no ground truth
                  result[c] = _matching_no_gt(
                      iou_thresholds=iou_thresholds,
                      pred_scores=pscores[pred_mask],
                      max_detections=max_detections,
                  )
              elif not np.any(pred_mask):  # no predictions
                  result[c] = _matching_no_pred(
                      iou_thresholds=iou_thresholds,
                      gt_ignore=gignore[gt_mask],
                  )
              else:  # at least one prediction and one ground truth
                  result[c] = _matching_single_image_single_class(
                      iou_fn=iou_fn,
                      pred_boxes=pboxes[pred_mask],
                      pred_scores=pscores[pred_mask],
                      gt_boxes=gboxes[gt_mask],
                      gt_ignore=gignore[gt_mask],
                      max_detections=max_detections,
                      iou_thresholds=iou_thresholds,
                  )
          results.append(result)
      return results
  
imports: from __future__ import annotations
  from collections.abc import Callable, Sequence
  import numpy
label_desc: Use image node_id 1 for calling a global function with example usage: matching_batch(iou_fn, iou_thresholds, pred_boxes, pred_classes, pred_scores, gt_boxes, gt_classes, gt_ignore, max_detections) and returns: results