class_docstr: This caller enables the default Detectron2 mapper to read an additional basis semantic label
docstr: Args:
      dataset_dict (dict): Metadata of one image, in Detectron2 Dataset format.
  
  Returns:
      dict: a format that builtin models in detectron2 accept
docstr_tok: ["Args",":","dataset_dict","(","dict",")",":","Metadata","of","one","image",",","in","Detectron2","Dataset","format",".","Returns",":","dict",":","a","format","that","builtin","models","in","detectron2","accept"]
code: def __call__(self, dataset_dict):
      """
      Args:
          dataset_dict (dict): Metadata of one image, in Detectron2 Dataset format.
  
      Returns:
          dict: a format that builtin models in detectron2 accept
      """
      dataset_dict = copy.deepcopy(
          dataset_dict
      )  # it will be modified by code below
      # USER: Write your own image loading if it's not from a file
      try:
          image = read_image(
              dataset_dict["file_name"], format=self.image_format
          )
      except Exception as e:
          print(dataset_dict["file_name"])
          print(e)
          raise e
      try:
          check_image_size(dataset_dict, image)
      except SizeMismatchError as e:
          expected_wh = (dataset_dict["width"], dataset_dict["height"])
          image_wh = (image.shape[1], image.shape[0])
          if (image_wh[1], image_wh[0]) == expected_wh:
              print(
                  "transposing image {}".format(
                      dataset_dict["file_name"]
                  )
              )
              image = image.transpose(1, 0, 2)
          else:
              raise e
  
      # USER: Remove if you don't do semantic/panoptic segmentation.
      if "sem_seg_file_name" in dataset_dict:
          sem_seg_gt = read_image(
              dataset_dict.pop("sem_seg_file_name"), "L"
          ).squeeze(2)
      else:
          sem_seg_gt = None
  
      boxes = np.asarray(
          [
              BoxMode.convert(
                  instance["bbox"],
                  instance["bbox_mode"],
                  BoxMode.XYXY_ABS,
              )
              for instance in dataset_dict["annotations"]
          ]
      )
      aug_input = T.StandardAugInput(
          image, boxes=boxes, sem_seg=sem_seg_gt
      )
      transforms = aug_input.apply_augmentations(self.augmentation)
      image, sem_seg_gt = aug_input.image, aug_input.sem_seg
  
      image_shape = image.shape[:2]  # h, w
      # Pytorch's dataloader is efficient on torch.Tensor due to shared-memory,
      # but not efficient on large generic data structures due to the use of pickle & mp.Queue.
      # Therefore it's important to use torch.Tensor.
      dataset_dict["image"] = torch.as_tensor(
          np.ascontiguousarray(image.transpose(2, 0, 1))
      )
      if sem_seg_gt is not None:
          dataset_dict["sem_seg"] = torch.as_tensor(
              sem_seg_gt.astype("long")
          )
  
      # USER: Remove if you don't use pre-computed proposals.
      # Most users would not need this feature.
      if self.proposal_topk:
          utils.transform_proposals(
              dataset_dict,
              image_shape,
              transforms,
              proposal_topk=self.proposal_topk,
              min_box_size=self.proposal_min_box_size,
          )
  
      if not self.is_train:
          dataset_dict.pop("annotations", None)
          dataset_dict.pop("sem_seg_file_name", None)
          dataset_dict.pop("pano_seg_file_name", None)
          return dataset_dict
  
      if "annotations" in dataset_dict:
          # USER: Modify this if you want to keep them for some reason.
          for anno in dataset_dict["annotations"]:
              if not self.use_instance_mask:
                  anno.pop("segmentation", None)
              if not self.use_keypoint:
                  anno.pop("keypoints", None)
  
          # visualize_transformed_img(np.array(utils.read_image(dataset_dict["file_name"], format=self.image_format)),
          #                           dataset_dict["annotations"], bbox_fotmat="xywh", save_name="ori_img.png")
  
          # USER: Implement additional transformations if you have other types of data
          annos = [
              transform_instance_annotations(
                  obj,
                  transforms,
                  image_shape,
                  keypoint_hflip_indices=self.keypoint_hflip_indices,
              )
              for obj in dataset_dict.pop("annotations")
              if obj.get("iscrowd", 0) == 0
          ]
          # visualize_transformed_img(np.array(image), annos)
          instances = annotations_to_instances(
              annos, image_shape, mask_format=self.instance_mask_format
          )
  
          # After transforms such as cropping are applied, the bounding box may no longer
          # tightly bound the object. As an example, imagine a triangle object
          # [(0,0), (2,0), (0,2)] cropped by a box [(1,0),(2,2)] (XYXY format). The tight
          # bounding box of the cropped triangle should be [(1,0),(2,1)], which is not equal to
          if self.recompute_boxes:
              instances.gt_boxes = (
                  instances.gt_masks.get_bounding_boxes()
              )
          dataset_dict["instances"] = filter_empty_instances(instances)
  
      if self.basis_loss_on and self.is_train:
          # load basis supervisions
          if self.ann_set == "coco":
              basis_sem_path = (
                  dataset_dict["file_name"]
                  .replace("train2017", "thing_train2017")
                  .replace("image/train", "thing_train")
              )
          else:
              basis_sem_path = (
                  dataset_dict["file_name"]
                  .replace("coco", "lvis")
                  .replace("train2017", "thing_train")
              )
          # change extension to npz
          basis_sem_path = osp.splitext(basis_sem_path)[0] + ".npz"
          basis_sem_gt = np.load(basis_sem_path)["mask"]
          basis_sem_gt = transforms.apply_segmentation(basis_sem_gt)
          basis_sem_gt = torch.as_tensor(basis_sem_gt.astype("long"))
          dataset_dict["basis_sem"] = basis_sem_gt
      return dataset_dict
  
imports: import itertools
  import copy
  import logging
  import numpy
  import torch
  from ..registry.catalog import DatasetCatalog, MetadataCatalog
  from ..detection.detection_dataset import load_proposals_into_dataset, filter_images_with_few_keypoints, filter_images_with_only_crowd_annotations, get_detection_dataset_dicts
  from ..detection.detection_dataset import print_instances_class_histogram, build_batch_data_loader, trivial_batch_collator
  from ..detection.detection_utils import check_metadata_consistency, read_image, filter_empty_instances, annotations_to_instances
  from ..detection.detection_utils import check_image_size, build_augmentation_ranged_clip, transform_instance_annotations
  from ..detection.detection_dataset import DatasetFromList, MapDataset, DatasetMapper
  from ..detection.samplers import RepeatFactorTrainingSampler, TrainingSampler, InferenceSampler
  from ..transforms import instance_transforms
  from ..transforms.instance_transforms import RandomCropWithInstance
  from ..structures import BoxMode
label_desc: Use image node_id 2 for calling the DatasetMapperWithBasis obj's underlying member method code with example usage: obj.__call__(dataset_dict) and returns: dataset_dict, dataset_dict