code: def merge_semantic_and_instance(
      semantic,
      instance,
      label_divisor,
      thing_list,
      stuff_area,
      ignore_index,
  ):
      """
      Post-processing for panoptic segmentation, by merging semantic segmentation label and class agnostic
          instance segmentation label.
  
      Args:
          semantic (Tensor): A Tensor of shape [1, H, W], predicted semantic label.
          instance (Tensor): A Tensor of shape [1, H, W], predicted instance label.
          label_divisor (int): An Integer, used to convert panoptic id = semantic id * label_divisor + instance_id.
          thing_list (list): A List of thing class id.
          stuff_area (int): An Integer, remove stuff whose area is less tan stuff_area.
          ignore_index (int): Specifies a value that is ignored.
  
      Returns:
          Tensor: A Tensor of shape [1, H, W] . The pixels whose value equaling ignore_index is ignored.
              The stuff class is represented as format like class_id, while
              thing class as class_id * label_divisor + ins_id and ins_id begin from 1.
      """
      # In case thing mask does not align with semantic prediction
      pan_seg = paddle.zeros_like(semantic) + ignore_index
      thing_seg = instance > 0
      semantic_thing_seg = paddle.zeros_like(semantic)
      for thing_class in thing_list:
          semantic_thing_seg += semantic == thing_class
  
      # keep track of instance id for each class
      class_id_tracker = {}
  
      # paste thing by majority voting
      ins_ids = paddle.unique(instance)
      for ins_id in ins_ids:
          if ins_id == 0:
              continue
          # Make sure only do majority voting within semantic_thing_seg
          thing_mask = paddle.logical_and(
              instance == ins_id, semantic_thing_seg == 1
          )
          if paddle.all(paddle.logical_not(thing_mask)):
              continue
          # get class id for instance of ins_id
          sem_ins_id = paddle.gather(
              semantic.reshape((-1,)),
              paddle.nonzero(thing_mask.reshape((-1,))),
          )  # equal to semantic[thing_mask]
          v, c = paddle.unique(sem_ins_id, return_counts=True)
          class_id = paddle.gather(v, c.argmax())
          class_id = int(class_id)
          if class_id in class_id_tracker:
              new_ins_id = class_id_tracker[class_id]
          else:
              class_id_tracker[class_id] = 1
              new_ins_id = 1
          class_id_tracker[class_id] += 1
  
          # pan_seg[thing_mask] = class_id * label_divisor + new_ins_id
          pan_seg = pan_seg * (paddle.logical_not(thing_mask)) + (
              class_id * label_divisor + new_ins_id
          ) * thing_mask.astype("int64")
  
      # paste stuff to unoccupied area
      class_ids = paddle.unique(semantic)
      for class_id in class_ids:
          if class_id.numpy() in thing_list:
              # thing class
              continue
          # calculate stuff area
          stuff_mask = paddle.logical_and(
              semantic == class_id, paddle.logical_not(thing_seg)
          )
          area = paddle.sum(stuff_mask.astype("int64"))
          if area >= stuff_area:
              # pan_seg[stuff_mask] = class_id
              pan_seg = (
                  pan_seg * (paddle.logical_not(stuff_mask))
                  + stuff_mask.astype("int64") * class_id
              )
  
      return pan_seg
  
file_path: PaddleSeg/contrib/PanopticDeepLab/core/infer.py
imports: import collections.abc
  from itertools import combinations
  from functools import partial
  import numpy
  import paddle
  import paddle.nn.functional
label_desc: Use image node_id 6 for calling a global function with example usage: merge_semantic_and_instance(semantic, instance, label_divisor, thing_list, stuff_area, ignore_index) and returns: pan_seg