| 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, |
|
|
