patch

diff --git a/configs/cbnet/cascade_rcnn_cbv2d1_r2_101_mdconv_fpn_20e_fp16_ms400-1400_giou_4conv1f_coco.py b/configs/cbnet/cascade_rcnn_cbv2d1_r2_101_mdconv_fpn_20e_fp16_ms400-1400_giou_4conv1f_coco.py
index 167d4379..7c0bd239 100644
--- a/configs/cbnet/cascade_rcnn_cbv2d1_r2_101_mdconv_fpn_20e_fp16_ms400-1400_giou_4conv1f_coco.py
+++ b/configs/cbnet/cascade_rcnn_cbv2d1_r2_101_mdconv_fpn_20e_fp16_ms400-1400_giou_4conv1f_coco.py
@@ -2,9 +2,9 @@ _base_ = '../res2net/cascade_rcnn_r2_101_fpn_20e_coco.py'
 
 model = dict(
     backbone=dict(
-        type='CBRes2Net', 
+        type='CBRes2Net',
         cb_del_stages=1,
-        cb_inplanes=[64, 256, 512, 1024, 2048], 
+        cb_inplanes=[64, 256, 512, 1024, 2048],
         dcn=dict(type='DCNv2', deform_groups=1, fallback_on_stride=False),
         stage_with_dcn=(False, True, True, True)
     ),
@@ -28,7 +28,7 @@ model = dict(
                     target_stds=[0.1, 0.1, 0.2, 0.2]),
                 reg_class_agnostic=False,
                 reg_decoded_bbox=True,
-                norm_cfg=dict(type='SyncBN', requires_grad=True),
+                norm_cfg=dict(type='BN', requires_grad=True),
                 loss_cls=dict(
                     type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
                 loss_bbox=dict(type='GIoULoss', loss_weight=10.0)),
@@ -47,7 +47,7 @@ model = dict(
                     target_stds=[0.05, 0.05, 0.1, 0.1]),
                 reg_class_agnostic=False,
                 reg_decoded_bbox=True,
-                norm_cfg=dict(type='SyncBN', requires_grad=True),
+                norm_cfg=dict(type='BN', requires_grad=True),
                 loss_cls=dict(
                     type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
                 loss_bbox=dict(type='GIoULoss', loss_weight=10.0)),
@@ -66,7 +66,7 @@ model = dict(
                     target_stds=[0.033, 0.033, 0.067, 0.067]),
                 reg_class_agnostic=False,
                 reg_decoded_bbox=True,
-                norm_cfg=dict(type='SyncBN', requires_grad=True),
+                norm_cfg=dict(type='BN', requires_grad=True),
                 loss_cls=dict(
                     type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
                 loss_bbox=dict(type='GIoULoss', loss_weight=10.0))
diff --git a/configs/cbnet/htc_cbv2_swin_base_patch4_window7_mstrain_400-1400_giou_4conv1f_adamw_20e_coco.py b/configs/cbnet/htc_cbv2_swin_base_patch4_window7_mstrain_400-1400_giou_4conv1f_adamw_20e_coco.py
index 51edfd62..a7434c5d 100644
--- a/configs/cbnet/htc_cbv2_swin_base_patch4_window7_mstrain_400-1400_giou_4conv1f_adamw_20e_coco.py
+++ b/configs/cbnet/htc_cbv2_swin_base_patch4_window7_mstrain_400-1400_giou_4conv1f_adamw_20e_coco.py
@@ -18,7 +18,7 @@ model = dict(
                     target_stds=[0.1, 0.1, 0.2, 0.2]),
                 reg_class_agnostic=True,
                 reg_decoded_bbox=True,
-                norm_cfg=dict(type='SyncBN', requires_grad=True),
+                norm_cfg=dict(type='BN', requires_grad=True),
                 loss_cls=dict(
                     type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
                 loss_bbox=dict(type='GIoULoss', loss_weight=10.0)),
@@ -37,7 +37,7 @@ model = dict(
                     target_stds=[0.05, 0.05, 0.1, 0.1]),
                 reg_class_agnostic=True,
                 reg_decoded_bbox=True,
-                norm_cfg=dict(type='SyncBN', requires_grad=True),
+                norm_cfg=dict(type='BN', requires_grad=True),
                 loss_cls=dict(
                     type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
                 loss_bbox=dict(type='GIoULoss', loss_weight=10.0)),
@@ -56,7 +56,7 @@ model = dict(
                     target_stds=[0.033, 0.033, 0.067, 0.067]),
                 reg_class_agnostic=True,
                 reg_decoded_bbox=True,
-                norm_cfg=dict(type='SyncBN', requires_grad=True),
+                norm_cfg=dict(type='BN', requires_grad=True),
                 loss_cls=dict(
                     type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
                 loss_bbox=dict(type='GIoULoss', loss_weight=10.0))
diff --git a/mmdet/__init__.py b/mmdet/__init__.py
index 646ee84e..9e846286 100644
--- a/mmdet/__init__.py
+++ b/mmdet/__init__.py
@@ -20,9 +20,9 @@ mmcv_maximum_version = '1.4.0'
 mmcv_version = digit_version(mmcv.__version__)
 
 
-assert (mmcv_version >= digit_version(mmcv_minimum_version)
-        and mmcv_version <= digit_version(mmcv_maximum_version)), \
-    f'MMCV=={mmcv.__version__} is used but incompatible. ' \
-    f'Please install mmcv>={mmcv_minimum_version}, <={mmcv_maximum_version}.'
+#assert (mmcv_version >= digit_version(mmcv_minimum_version)
+#        and mmcv_version <= digit_version(mmcv_maximum_version)), \
+#    f'MMCV=={mmcv.__version__} is used but incompatible. ' \
+#    f'Please install mmcv>={mmcv_minimum_version}, <={mmcv_maximum_version}.'
 
 __all__ = ['__version__', 'short_version']
diff --git a/mmdet/core/mask/structures.py b/mmdet/core/mask/structures.py
index 6f5a62ae..a9d0ebb4 100644
--- a/mmdet/core/mask/structures.py
+++ b/mmdet/core/mask/structures.py
@@ -1,3 +1,4 @@
+# Copyright (c) OpenMMLab. All rights reserved.
 from abc import ABCMeta, abstractmethod
 
 import cv2
@@ -528,6 +529,21 @@ class BitmapMasks(BaseInstanceMasks):
         self = cls(masks, height=height, width=width)
         return self
 
+    def get_bboxes(self):
+        num_masks = len(self)
+        boxes = np.zeros((num_masks, 4), dtype=np.float32)
+        x_any = self.masks.any(axis=1)
+        y_any = self.masks.any(axis=2)
+        for idx in range(num_masks):
+            x = np.where(x_any[idx, :])[0]
+            y = np.where(y_any[idx, :])[0]
+            if len(x) > 0 and len(y) > 0:
+                # use +1 for x_max and y_max so that the right and bottom
+                # boundary of instance masks are fully included by the box
+                boxes[idx, :] = np.array([x[0], y[0], x[-1] + 1, y[-1] + 1],
+                                         dtype=np.float32)
+        return boxes
+
 
 class PolygonMasks(BaseInstanceMasks):
     """This class represents masks in the form of polygons.
@@ -637,8 +653,8 @@ class PolygonMasks(BaseInstanceMasks):
                 resized_poly = []
                 for p in poly_per_obj:
                     p = p.copy()
-                    p[0::2] *= w_scale
-                    p[1::2] *= h_scale
+                    p[0::2] = p[0::2] * w_scale
+                    p[1::2] = p[1::2] * h_scale
                     resized_poly.append(p)
                 resized_masks.append(resized_poly)
             resized_masks = PolygonMasks(resized_masks, *out_shape)
@@ -690,8 +706,8 @@ class PolygonMasks(BaseInstanceMasks):
                 for p in poly_per_obj:
                     # pycocotools will clip the boundary
                     p = p.copy()
-                    p[0::2] -= bbox[0]
-                    p[1::2] -= bbox[1]
+                    p[0::2] = p[0::2] - bbox[0]
+                    p[1::2] = p[1::2] - bbox[1]
                     cropped_poly_per_obj.append(p)
                 cropped_masks.append(cropped_poly_per_obj)
             cropped_masks = PolygonMasks(cropped_masks, h, w)
@@ -736,12 +752,12 @@ class PolygonMasks(BaseInstanceMasks):
                 p = p.copy()
                 # crop
                 # pycocotools will clip the boundary
-                p[0::2] -= bbox[0]
-                p[1::2] -= bbox[1]
+                p[0::2] = p[0::2] - bbox[0]
+                p[1::2] = p[1::2] - bbox[1]
 
                 # resize
-                p[0::2] *= w_scale
-                p[1::2] *= h_scale
+                p[0::2] = p[0::2] * w_scale
+                p[1::2] = p[1::2] * h_scale
                 resized_mask.append(p)
             resized_masks.append(resized_mask)
         return PolygonMasks(resized_masks, *out_shape)
@@ -944,6 +960,7 @@ class PolygonMasks(BaseInstanceMasks):
                 a list of vertices, in CCW order.
             """
             from scipy.stats import truncnorm
+
             # Generate around the unit circle
             cx, cy = (0.0, 0.0)
             radius = 1
@@ -1019,6 +1036,24 @@ class PolygonMasks(BaseInstanceMasks):
         self = cls(masks, height, width)
         return self
 
+    def get_bboxes(self):
+        num_masks = len(self)
+        boxes = np.zeros((num_masks, 4), dtype=np.float32)
+        for idx, poly_per_obj in enumerate(self.masks):
+            # simply use a number that is big enough for comparison with
+            # coordinates
+            xy_min = np.array([self.width * 2, self.height * 2],
+                              dtype=np.float32)
+            xy_max = np.zeros(2, dtype=np.float32)
+            for p in poly_per_obj:
+                xy = np.array(p).reshape(-1, 2).astype(np.float32)
+                xy_min = np.minimum(xy_min, np.min(xy, axis=0))
+                xy_max = np.maximum(xy_max, np.max(xy, axis=0))
+            boxes[idx, :2] = xy_min
+            boxes[idx, 2:] = xy_max
+
+        return boxes
+
 
 def polygon_to_bitmap(polygons, height, width):
     """Convert masks from the form of polygons to bitmaps.
@@ -1035,3 +1070,33 @@ def polygon_to_bitmap(polygons, height, width):
     rle = maskUtils.merge(rles)
     bitmap_mask = maskUtils.decode(rle).astype(np.bool)
     return bitmap_mask
+
+
+def bitmap_to_polygon(bitmap):
+    """Convert masks from the form of bitmaps to polygons.
+
+    Args:
+        bitmap (ndarray): masks in bitmap representation.
+
+    Return:
+        list[ndarray]: the converted mask in polygon representation.
+        bool: whether the mask has holes.
+    """
+    bitmap = np.ascontiguousarray(bitmap).astype(np.uint8)
+    # cv2.RETR_CCOMP: retrieves all of the contours and organizes them
+    #   into a two-level hierarchy. At the top level, there are external
+    #   boundaries of the components. At the second level, there are
+    #   boundaries of the holes. If there is another contour inside a hole
+    #   of a connected component, it is still put at the top level.
+    # cv2.CHAIN_APPROX_NONE: stores absolutely all the contour points.
+    outs = cv2.findContours(bitmap, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
+    contours = outs[-2]
+    hierarchy = outs[-1]
+    if hierarchy is None:
+        return [], False
+    # hierarchy[i]: 4 elements, for the indexes of next, previous,
+    # parent, or nested contours. If there is no corresponding contour,
+    # it will be -1.
+    with_hole = (hierarchy.reshape(-1, 4)[:, 3] >= 0).any()
+    contours = [c.reshape(-1, 2) for c in contours]
+    return contours, with_hole
diff --git a/mmdet/core/visualization/image.py b/mmdet/core/visualization/image.py
index 5a148384..66f82a38 100644
--- a/mmdet/core/visualization/image.py
+++ b/mmdet/core/visualization/image.py
@@ -1,3 +1,5 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import cv2
 import matplotlib.pyplot as plt
 import mmcv
 import numpy as np
@@ -5,17 +7,25 @@ import pycocotools.mask as mask_util
 from matplotlib.collections import PatchCollection
 from matplotlib.patches import Polygon
 
+#from mmdet.core.evaluation.panoptic_utils import INSTANCE_OFFSET
+from ..mask.structures import bitmap_to_polygon
 from ..utils import mask2ndarray
+from .palette import get_palette, palette_val
+
+__all__ = [
+    'color_val_matplotlib', 'draw_masks', 'draw_bboxes', 'draw_labels',
+    'imshow_det_bboxes', 'imshow_gt_det_bboxes'
+]
 
 EPS = 1e-2
 
 
 def color_val_matplotlib(color):
     """Convert various input in BGR order to normalized RGB matplotlib color
-    tuples,
+    tuples.
 
     Args:
-        color (:obj:`Color`/str/tuple/int/ndarray): Color inputs
+        color (:obj`Color` | str | tuple | int | ndarray): Color inputs.
 
     Returns:
         tuple[float]: A tuple of 3 normalized floats indicating RGB channels.
@@ -25,9 +35,177 @@ def color_val_matplotlib(color):
     return tuple(color)
 
 
+def _get_adaptive_scales(areas, min_area=800, max_area=30000):
+    """Get adaptive scales according to areas.
+
+    The scale range is [0.5, 1.0]. When the area is less than
+    ``'min_area'``, the scale is 0.5 while the area is larger than
+    ``'max_area'``, the scale is 1.0.
+
+    Args:
+        areas (ndarray): The areas of bboxes or masks with the
+            shape of (n, ).
+        min_area (int): Lower bound areas for adaptive scales.
+            Default: 800.
+        max_area (int): Upper bound areas for adaptive scales.
+            Default: 30000.
+
+    Returns:
+        ndarray: The adaotive scales with the shape of (n, ).
+    """
+    scales = 0.5 + (areas - min_area) / (max_area - min_area)
+    scales = np.clip(scales, 0.5, 1.0)
+    return scales
+
+
+def _get_bias_color(base, max_dist=30):
+    """Get different colors for each masks.
+
+    Get different colors for each masks by adding a bias
+    color to the base category color.
+    Args:
+        base (ndarray): The base category color with the shape
+            of (3, ).
+        max_dist (int): The max distance of bias. Default: 30.
+
+    Returns:
+        ndarray: The new color for a mask with the shape of (3, ).
+    """
+    new_color = base + np.random.randint(
+        low=-max_dist, high=max_dist + 1, size=3)
+    return np.clip(new_color, 0, 255, new_color)
+
+
+def draw_bboxes(ax, bboxes, color='g', alpha=0.8, thickness=2):
+    """Draw bounding boxes on the axes.
+
+    Args:
+        ax (matplotlib.Axes): The input axes.
+        bboxes (ndarray): The input bounding boxes with the shape
+            of (n, 4).
+        color (list[tuple] | matplotlib.color): the colors for each
+            bounding boxes.
+        alpha (float): Transparency of bounding boxes. Default: 0.8.
+        thickness (int): Thickness of lines. Default: 2.
+
+    Returns:
+        matplotlib.Axes: The result axes.
+    """
+    polygons = []
+    for i, bbox in enumerate(bboxes):
+        bbox_int = bbox.astype(np.int32)
+        poly = [[bbox_int[0], bbox_int[1]], [bbox_int[0], bbox_int[3]],
+                [bbox_int[2], bbox_int[3]], [bbox_int[2], bbox_int[1]]]
+        np_poly = np.array(poly).reshape((4, 2))
+        polygons.append(Polygon(np_poly))
+    p = PatchCollection(
+        polygons,
+        facecolor='none',
+        edgecolors=color,
+        linewidths=thickness,
+        alpha=alpha)
+    ax.add_collection(p)
+
+    return ax
+
+
+def draw_labels(ax,
+                labels,
+                positions,
+                scores=None,
+                class_names=None,
+                color='w',
+                font_size=8,
+                scales=None,
+                horizontal_alignment='left'):
+    """Draw labels on the axes.
+
+    Args:
+        ax (matplotlib.Axes): The input axes.
+        labels (ndarray): The labels with the shape of (n, ).
+        positions (ndarray): The positions to draw each labels.
+        scores (ndarray): The scores for each labels.
+        class_names (list[str]): The class names.
+        color (list[tuple] | matplotlib.color): The colors for labels.
+        font_size (int): Font size of texts. Default: 8.
+        scales (list[float]): Scales of texts. Default: None.
+        horizontal_alignment (str): The horizontal alignment method of
+            texts. Default: 'left'.
+
+    Returns:
+        matplotlib.Axes: The result axes.
+    """
+    for i, (pos, label) in enumerate(zip(positions, labels)):
+        label_text = class_names[
+            label] if class_names is not None else f'class {label}'
+        if scores is not None:
+            label_text += f'|{scores[i]:.02f}'
+        text_color = color[i] if isinstance(color, list) else color
+
+        font_size_mask = font_size if scales is None else font_size * scales[i]
+        ax.text(
+            pos[0],
+            pos[1],
+            f'{label_text}',
+            bbox={
+                'facecolor': 'black',
+                'alpha': 0.8,
+                'pad': 0.7,
+                'edgecolor': 'none'
+            },
+            color=text_color,
+            fontsize=font_size_mask,
+            verticalalignment='top',
+            horizontalalignment=horizontal_alignment)
+
+    return ax
+
+
+def draw_masks(ax, img, masks, color=None, with_edge=True, alpha=0.8):
+    """Draw masks on the image and their edges on the axes.
+
+    Args:
+        ax (matplotlib.Axes): The input axes.
+        img (ndarray): The image with the shape of (3, h, w).
+        masks (ndarray): The masks with the shape of (n, h, w).
+        color (ndarray): The colors for each masks with the shape
+            of (n, 3).
+        with_edge (bool): Whether to draw edges. Default: True.
+        alpha (float): Transparency of bounding boxes. Default: 0.8.
+
+    Returns:
+        matplotlib.Axes: The result axes.
+        ndarray: The result image.
+    """
+    taken_colors = set([0, 0, 0])
+    if color is None:
+        random_colors = np.random.randint(0, 255, (masks.size(0), 3))
+        color = [tuple(c) for c in random_colors]
+        color = np.array(color, dtype=np.uint8)
+    polygons = []
+    for i, mask in enumerate(masks):
+        if with_edge:
+            contours, _ = bitmap_to_polygon(mask)
+            polygons += [Polygon(c) for c in contours]
+
+        color_mask = color[i]
+        while tuple(color_mask) in taken_colors:
+            color_mask = _get_bias_color(color_mask)
+        taken_colors.add(tuple(color_mask))
+
+        mask = mask.astype(bool)
+        img[mask] = img[mask] * (1 - alpha) + color_mask * alpha
+
+    p = PatchCollection(
+        polygons, facecolor='none', edgecolors='w', linewidths=1, alpha=0.8)
+    ax.add_collection(p)
+
+    return ax, img
+
+
 def imshow_det_bboxes(img,
-                      bboxes,
-                      labels,
+                      bboxes=None,
+                      labels=None,
                       segms=None,
                       class_names=None,
                       score_thr=0,
@@ -35,7 +213,7 @@ def imshow_det_bboxes(img,
                       text_color='green',
                       mask_color=None,
                       thickness=2,
-                      font_size=13,
+                      font_size=8,
                       win_name='',
                       show=True,
                       wait_time=0,
@@ -43,43 +221,51 @@ def imshow_det_bboxes(img,
     """Draw bboxes and class labels (with scores) on an image.
 
     Args:
-        img (str or ndarray): The image to be displayed.
+        img (str | ndarray): The image to be displayed.
         bboxes (ndarray): Bounding boxes (with scores), shaped (n, 4) or
             (n, 5).
         labels (ndarray): Labels of bboxes.
-        segms (ndarray or None): Masks, shaped (n,h,w) or None
+        segms (ndarray | None): Masks, shaped (n,h,w) or None.
         class_names (list[str]): Names of each classes.
-        score_thr (float): Minimum score of bboxes to be shown.  Default: 0
-        bbox_color (str or tuple(int) or :obj:`Color`):Color of bbox lines.
-           The tuple of color should be in BGR order. Default: 'green'
-        text_color (str or tuple(int) or :obj:`Color`):Color of texts.
-           The tuple of color should be in BGR order. Default: 'green'
-        mask_color (str or tuple(int) or :obj:`Color`, optional):
-           Color of masks. The tuple of color should be in BGR order.
-           Default: None
-        thickness (int): Thickness of lines. Default: 2
-        font_size (int): Font size of texts. Default: 13
-        show (bool): Whether to show the image. Default: True
-        win_name (str): The window name. Default: ''
+        score_thr (float): Minimum score of bboxes to be shown. Default: 0.
+        bbox_color (list[tuple] | tuple | str | None): Colors of bbox lines.
+           If a single color is given, it will be applied to all classes.
+           The tuple of color should be in RGB order. Default: 'green'.
+        text_color (list[tuple] | tuple | str | None): Colors of texts.
+           If a single color is given, it will be applied to all classes.
+           The tuple of color should be in RGB order. Default: 'green'.
+        mask_color (list[tuple] | tuple | str | None, optional): Colors of
+           masks. If a single color is given, it will be applied to all
+           classes. The tuple of color should be in RGB order.
+           Default: None.
+        thickness (int): Thickness of lines. Default: 2.
+        font_size (int): Font size of texts. Default: 13.
+        show (bool): Whether to show the image. Default: True.
+        win_name (str): The window name. Default: ''.
         wait_time (float): Value of waitKey param. Default: 0.
         out_file (str, optional): The filename to write the image.
-            Default: None
+            Default: None.
 
     Returns:
         ndarray: The image with bboxes drawn on it.
     """
-    assert bboxes.ndim == 2, \
+    assert bboxes is None or bboxes.ndim == 2, \
         f' bboxes ndim should be 2, but its ndim is {bboxes.ndim}.'
     assert labels.ndim == 1, \
         f' labels ndim should be 1, but its ndim is {labels.ndim}.'
-    assert bboxes.shape[0] == labels.shape[0], \
-        'bboxes.shape[0] and labels.shape[0] should have the same length.'
-    assert bboxes.shape[1] == 4 or bboxes.shape[1] == 5, \
+    assert bboxes is None or bboxes.shape[1] == 4 or bboxes.shape[1] == 5, \
         f' bboxes.shape[1] should be 4 or 5, but its {bboxes.shape[1]}.'
+    assert bboxes is None or bboxes.shape[0] <= labels.shape[0], \
+        'labels.shape[0] should not be less than bboxes.shape[0].'
+    assert segms is None or segms.shape[0] == labels.shape[0], \
+        'segms.shape[0] and labels.shape[0] should have the same length.'
+    assert segms is not None or bboxes is not None, \
+        'segms and bboxes should not be None at the same time.'
+
     img = mmcv.imread(img).astype(np.uint8)
 
     if score_thr > 0:
-        assert bboxes.shape[1] == 5
+        assert bboxes is not None and bboxes.shape[1] == 5
         scores = bboxes[:, -1]
         inds = scores > score_thr
         bboxes = bboxes[inds, :]
@@ -87,25 +273,6 @@ def imshow_det_bboxes(img,
         if segms is not None:
             segms = segms[inds, ...]
 
-    mask_colors = []
-    if labels.shape[0] > 0:
-        if mask_color is None:
-            # random color
-            np.random.seed(42)
-            mask_colors = [
-                np.random.randint(0, 256, (1, 3), dtype=np.uint8)
-                for _ in range(max(labels) + 1)
-            ]
-        else:
-            # specify  color
-            mask_colors = [
-                np.array(mmcv.color_val(mask_color)[::-1], dtype=np.uint8)
-            ] * (
-                max(labels) + 1)
-
-    bbox_color = color_val_matplotlib(bbox_color)
-    text_color = color_val_matplotlib(text_color)
-
     img = mmcv.bgr2rgb(img)
     width, height = img.shape[1], img.shape[0]
     img = np.ascontiguousarray(img)
@@ -123,44 +290,64 @@ def imshow_det_bboxes(img,
     ax = plt.gca()
     ax.axis('off')
 
-    polygons = []
-    color = []
-    for i, (bbox, label) in enumerate(zip(bboxes, labels)):
-        bbox_int = bbox.astype(np.int32)
-        poly = [[bbox_int[0], bbox_int[1]], [bbox_int[0], bbox_int[3]],
-                [bbox_int[2], bbox_int[3]], [bbox_int[2], bbox_int[1]]]
-        np_poly = np.array(poly).reshape((4, 2))
-        polygons.append(Polygon(np_poly))
-        color.append(bbox_color)
-        label_text = class_names[
-            label] if class_names is not None else f'class {label}'
-        if len(bbox) > 4:
-            label_text += f'|{bbox[-1]:.02f}'
-        ax.text(
-            bbox_int[0],
-            bbox_int[1],
-            f'{label_text}',
-            bbox={
-                'facecolor': 'black',
-                'alpha': 0.8,
-                'pad': 0.7,
-                'edgecolor': 'none'
-            },
-            color=text_color,
-            fontsize=font_size,
-            verticalalignment='top',
-            horizontalalignment='left')
-        if segms is not None:
-            color_mask = mask_colors[labels[i]]
-            mask = segms[i].astype(bool)
-            img[mask] = img[mask] * 0.5 + color_mask * 0.5
+    max_label = int(max(labels) if len(labels) > 0 else 0)
+    text_palette = palette_val(get_palette(text_color, max_label + 1))
+    text_colors = [text_palette[label] for label in labels]
+
+    num_bboxes = 0
+    if bboxes is not None:
+        num_bboxes = bboxes.shape[0]
+        bbox_palette = palette_val(get_palette(bbox_color, max_label + 1))
+        colors = [bbox_palette[label] for label in labels[:num_bboxes]]
+        draw_bboxes(ax, bboxes, colors, alpha=0.8, thickness=thickness)
+
+        horizontal_alignment = 'left'
+        positions = bboxes[:, :2].astype(np.int32) + thickness
+        areas = (bboxes[:, 3] - bboxes[:, 1]) * (bboxes[:, 2] - bboxes[:, 0])
+        scales = _get_adaptive_scales(areas)
+        scores = bboxes[:, 4] if bboxes.shape[1] == 5 else None
+        draw_labels(
+            ax,
+            labels[:num_bboxes],
+            positions,
+            scores=scores,
+            class_names=class_names,
+            color=text_colors,
+            font_size=font_size,
+            scales=scales,
+            horizontal_alignment=horizontal_alignment)
+
+    if segms is not None:
+        mask_palette = get_palette(mask_color, max_label + 1)
+        colors = [mask_palette[label] for label in labels]
+        colors = np.array(colors, dtype=np.uint8)
+        draw_masks(ax, img, segms, colors, with_edge=True)
+
+        if num_bboxes < segms.shape[0]:
+            segms = segms[num_bboxes:]
+            horizontal_alignment = 'center'
+            areas = []
+            positions = []
+            for mask in segms:
+                _, _, stats, centroids = cv2.connectedComponentsWithStats(
+                    mask.astype(np.uint8), connectivity=8)
+                largest_id = np.argmax(stats[1:, -1]) + 1
+                positions.append(centroids[largest_id])
+                areas.append(stats[largest_id, -1])
+            areas = np.stack(areas, axis=0)
+            scales = _get_adaptive_scales(areas)
+            draw_labels(
+                ax,
+                labels[num_bboxes:],
+                positions,
+                class_names=class_names,
+                color=text_colors,
+                font_size=font_size,
+                scales=scales,
+                horizontal_alignment=horizontal_alignment)
 
     plt.imshow(img)
 
-    p = PatchCollection(
-        polygons, facecolor='none', edgecolors=color, linewidths=thickness)
-    ax.add_collection(p)
-
     stream, _ = canvas.print_to_buffer()
     buffer = np.frombuffer(stream, dtype='uint8')
     img_rgba = buffer.reshape(height, width, 4)
@@ -191,12 +378,12 @@ def imshow_gt_det_bboxes(img,
                          result,
                          class_names=None,
                          score_thr=0,
-                         gt_bbox_color=(255, 102, 61),
-                         gt_text_color=(255, 102, 61),
-                         gt_mask_color=(255, 102, 61),
-                         det_bbox_color=(72, 101, 241),
-                         det_text_color=(72, 101, 241),
-                         det_mask_color=(72, 101, 241),
+                         gt_bbox_color=(61, 102, 255),
+                         gt_text_color=(200, 200, 200),
+                         gt_mask_color=(61, 102, 255),
+                         det_bbox_color=(241, 101, 72),
+                         det_text_color=(200, 200, 200),
+                         det_mask_color=(241, 101, 72),
                          thickness=2,
                          font_size=13,
                          win_name='',
@@ -206,54 +393,75 @@ def imshow_gt_det_bboxes(img,
     """General visualization GT and result function.
 
     Args:
-      img (str or ndarray): The image to be displayed.)
+      img (str | ndarray): The image to be displayed.
       annotation (dict): Ground truth annotations where contain keys of
-          'gt_bboxes' and 'gt_labels' or 'gt_masks'
-      result (tuple[list] or list): The detection result, can be either
+          'gt_bboxes' and 'gt_labels' or 'gt_masks'.
+      result (tuple[list] | list): The detection result, can be either
           (bbox, segm) or just bbox.
       class_names (list[str]): Names of each classes.
-      score_thr (float): Minimum score of bboxes to be shown.  Default: 0
-      gt_bbox_color (str or tuple(int) or :obj:`Color`):Color of bbox lines.
-           The tuple of color should be in BGR order. Default: (255, 102, 61)
-      gt_text_color (str or tuple(int) or :obj:`Color`):Color of texts.
-           The tuple of color should be in BGR order. Default: (255, 102, 61)
-      gt_mask_color (str or tuple(int) or :obj:`Color`, optional):
-           Color of masks. The tuple of color should be in BGR order.
-           Default: (255, 102, 61)
-      det_bbox_color (str or tuple(int) or :obj:`Color`):Color of bbox lines.
-           The tuple of color should be in BGR order. Default: (72, 101, 241)
-      det_text_color (str or tuple(int) or :obj:`Color`):Color of texts.
-           The tuple of color should be in BGR order. Default: (72, 101, 241)
-      det_mask_color (str or tuple(int) or :obj:`Color`, optional):
-           Color of masks. The tuple of color should be in BGR order.
-           Default: (72, 101, 241)
-      thickness (int): Thickness of lines. Default: 2
-      font_size (int): Font size of texts. Default: 13
-      win_name (str): The window name. Default: ''
-      show (bool): Whether to show the image. Default: True
+      score_thr (float): Minimum score of bboxes to be shown. Default: 0.
+      gt_bbox_color (list[tuple] | tuple | str | None): Colors of bbox lines.
+          If a single color is given, it will be applied to all classes.
+          The tuple of color should be in RGB order. Default: (61, 102, 255).
+      gt_text_color (list[tuple] | tuple | str | None): Colors of texts.
+          If a single color is given, it will be applied to all classes.
+          The tuple of color should be in RGB order. Default: (200, 200, 200).
+      gt_mask_color (list[tuple] | tuple | str | None, optional): Colors of
+          masks. If a single color is given, it will be applied to all classes.
+          The tuple of color should be in RGB order. Default: (61, 102, 255).
+      det_bbox_color (list[tuple] | tuple | str | None):Colors of bbox lines.
+          If a single color is given, it will be applied to all classes.
+          The tuple of color should be in RGB order. Default: (241, 101, 72).
+      det_text_color (list[tuple] | tuple | str | None):Colors of texts.
+          If a single color is given, it will be applied to all classes.
+          The tuple of color should be in RGB order. Default: (200, 200, 200).
+      det_mask_color (list[tuple] | tuple | str | None, optional): Color of
+          masks. If a single color is given, it will be applied to all classes.
+          The tuple of color should be in RGB order. Default: (241, 101, 72).
+      thickness (int): Thickness of lines. Default: 2.
+      font_size (int): Font size of texts. Default: 13.
+      win_name (str): The window name. Default: ''.
+      show (bool): Whether to show the image. Default: True.
       wait_time (float): Value of waitKey param. Default: 0.
       out_file (str, optional): The filename to write the image.
-         Default: None
+          Default: None.
 
     Returns:
         ndarray: The image with bboxes or masks drawn on it.
     """
     assert 'gt_bboxes' in annotation
     assert 'gt_labels' in annotation
-    assert isinstance(
-        result,
-        (tuple, list)), f'Expected tuple or list, but get {type(result)}'
+    assert isinstance(result, (tuple, list, dict)), 'Expected ' \
+        f'tuple or list or dict, but get {type(result)}'
 
+    gt_bboxes = annotation['gt_bboxes']
+    gt_labels = annotation['gt_labels']
     gt_masks = annotation.get('gt_masks', None)
     if gt_masks is not None:
         gt_masks = mask2ndarray(gt_masks)
 
+    gt_seg = annotation.get('gt_semantic_seg', None)
+    if gt_seg is not None:
+        pad_value = 255  # the padding value of gt_seg
+        sem_labels = np.unique(gt_seg)
+        all_labels = np.concatenate((gt_labels, sem_labels), axis=0)
+        all_labels, counts = np.unique(all_labels, return_counts=True)
+        stuff_labels = all_labels[np.logical_and(counts < 2,
+                                                 all_labels != pad_value)]
+        stuff_masks = gt_seg[None] == stuff_labels[:, None, None]
+        gt_labels = np.concatenate((gt_labels, stuff_labels), axis=0)
+        gt_masks = np.concatenate((gt_masks, stuff_masks.astype(np.uint8)),
+                                  axis=0)
+        # If you need to show the bounding boxes,
+        # please comment the following line
+        # gt_bboxes = None
+
     img = mmcv.imread(img)
 
     img = imshow_det_bboxes(
         img,
-        annotation['gt_bboxes'],
-        annotation['gt_labels'],
+        gt_bboxes,
+        gt_labels,
         gt_masks,
         class_names=class_names,
         bbox_color=gt_bbox_color,
@@ -264,25 +472,38 @@ def imshow_gt_det_bboxes(img,
         win_name=win_name,
         show=False)
 
-    if isinstance(result, tuple):
-        bbox_result, segm_result = result
-        if isinstance(segm_result, tuple):
-            segm_result = segm_result[0]  # ms rcnn
+    if not isinstance(result, dict):
+        if isinstance(result, tuple):
+            bbox_result, segm_result = result
+            if isinstance(segm_result, tuple):
+                segm_result = segm_result[0]  # ms rcnn
+        else:
+            bbox_result, segm_result = result, None
+
+        bboxes = np.vstack(bbox_result)
+        labels = [
+            np.full(bbox.shape[0], i, dtype=np.int32)
+            for i, bbox in enumerate(bbox_result)
+        ]
+        labels = np.concatenate(labels)
+
+        segms = None
+        if segm_result is not None and len(labels) > 0:  # non empty
+            segms = mmcv.concat_list(segm_result)
+            segms = mask_util.decode(segms)
+            segms = segms.transpose(2, 0, 1)
     else:
-        bbox_result, segm_result = result, None
-
-    bboxes = np.vstack(bbox_result)
-    labels = [
-        np.full(bbox.shape[0], i, dtype=np.int32)
-        for i, bbox in enumerate(bbox_result)
-    ]
-    labels = np.concatenate(labels)
-
-    segms = None
-    if segm_result is not None and len(labels) > 0:  # non empty
-        segms = mmcv.concat_list(segm_result)
-        segms = mask_util.decode(segms)
-        segms = segms.transpose(2, 0, 1)
+        assert class_names is not None, 'We need to know the number ' \
+                                        'of classes.'
+        VOID = len(class_names)
+        bboxes = None
+        pan_results = result['pan_results']
+        # keep objects ahead
+        ids = np.unique(pan_results)[::-1]
+        legal_indices = ids != VOID
+        ids = ids[legal_indices]
+        labels = np.array([id % INSTANCE_OFFSET for id in ids], dtype=np.int64)
+        segms = (pan_results[None] == ids[:, None, None])
 
     img = imshow_det_bboxes(
         img,