mirror of https://github.com/open-mmlab/mmcv.git
854 lines
35 KiB
Python
854 lines
35 KiB
Python
# Copyright (c) OpenMMLab. All rights reserved.
|
|
import copy
|
|
import os.path as osp
|
|
|
|
import numpy as np
|
|
import pytest
|
|
|
|
import mmcv
|
|
from mmcv.transforms import (TRANSFORMS, Normalize, Pad, RandomFlip,
|
|
RandomResize, Resize)
|
|
|
|
try:
|
|
import torch
|
|
except ModuleNotFoundError:
|
|
torch = None
|
|
else:
|
|
import torchvision
|
|
|
|
from numpy.testing import assert_array_almost_equal, assert_array_equal
|
|
from PIL import Image
|
|
|
|
|
|
class TestNormalize:
|
|
|
|
def test_normalize(self):
|
|
img_norm_cfg = dict(
|
|
mean=[123.675, 116.28, 103.53],
|
|
std=[58.395, 57.12, 57.375],
|
|
to_rgb=True)
|
|
transform = Normalize(**img_norm_cfg)
|
|
results = dict()
|
|
img = mmcv.imread(
|
|
osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
|
|
original_img = copy.deepcopy(img)
|
|
results['img'] = img
|
|
results = transform(results)
|
|
mean = np.array(img_norm_cfg['mean'])
|
|
std = np.array(img_norm_cfg['std'])
|
|
converted_img = (original_img[..., ::-1] - mean) / std
|
|
assert np.allclose(results['img'], converted_img)
|
|
|
|
def test_repr(self):
|
|
img_norm_cfg = dict(
|
|
mean=[123.675, 116.28, 103.53],
|
|
std=[58.395, 57.12, 57.375],
|
|
to_rgb=True)
|
|
transform = Normalize(**img_norm_cfg)
|
|
assert repr(transform) == ('Normalize(mean=[123.675 116.28 103.53 ], '
|
|
'std=[58.395 57.12 57.375], to_rgb=True)')
|
|
|
|
|
|
class TestResize:
|
|
|
|
def test_resize(self):
|
|
data_info = dict(
|
|
img=np.random.random((1333, 800, 3)),
|
|
gt_semantic_seg=np.random.random((1333, 800, 3)),
|
|
gt_bboxes=np.array([[0, 0, 112, 112]]),
|
|
gt_keypoints=np.array([[[20, 50, 1]]]))
|
|
|
|
with pytest.raises(AssertionError):
|
|
transform = Resize(scale=None, scale_factor=None)
|
|
with pytest.raises(TypeError):
|
|
transform = Resize(scale_factor=[])
|
|
# test scale is int
|
|
transform = Resize(scale=2000)
|
|
results = transform(copy.deepcopy(data_info))
|
|
assert results['img'].shape[:2] == (2000, 2000)
|
|
assert results['scale_factor'] == (2000 / 800, 2000 / 1333)
|
|
|
|
# test scale is tuple
|
|
transform = Resize(scale=(2000, 2000))
|
|
results = transform(copy.deepcopy(data_info))
|
|
assert results['img'].shape[:2] == (2000, 2000)
|
|
assert results['scale_factor'] == (2000 / 800, 2000 / 1333)
|
|
|
|
# test scale_factor is float
|
|
transform = Resize(scale_factor=2.0)
|
|
results = transform(copy.deepcopy(data_info))
|
|
assert results['img'].shape[:2] == (2666, 1600)
|
|
assert results['scale_factor'] == (2.0, 2.0)
|
|
|
|
# test scale_factor is tuple
|
|
transform = Resize(scale_factor=(1.5, 2))
|
|
results = transform(copy.deepcopy(data_info))
|
|
assert results['img'].shape[:2] == (2666, 1200)
|
|
assert results['scale_factor'] == (1.5, 2)
|
|
|
|
# test keep_ratio is True
|
|
transform = Resize(scale=(2000, 2000), keep_ratio=True)
|
|
results = transform(copy.deepcopy(data_info))
|
|
assert results['img'].shape[:2] == (2000, 1200)
|
|
assert results['scale'] == (1200, 2000)
|
|
assert results['scale_factor'] == (1200 / 800, 2000 / 1333)
|
|
|
|
# test resize_bboxes/seg/kps
|
|
transform = Resize(scale_factor=(1.5, 2))
|
|
results = transform(copy.deepcopy(data_info))
|
|
assert (results['gt_bboxes'] == np.array([[0, 0, 168, 224]])).all()
|
|
assert (results['gt_keypoints'] == np.array([[[30, 100, 1]]])).all()
|
|
assert results['gt_semantic_seg'].shape[:2] == (2666, 1200)
|
|
|
|
# test clip_object_border = False
|
|
data_info = dict(
|
|
img=np.random.random((300, 400, 3)),
|
|
gt_bboxes=np.array([[200, 150, 600, 450]]))
|
|
transform = Resize(scale=(200, 150), clip_object_border=False)
|
|
results = transform(data_info)
|
|
assert (results['gt_bboxes'] == np.array([100, 75, 300, 225])).all()
|
|
|
|
def test_repr(self):
|
|
transform = Resize(scale=(2000, 2000), keep_ratio=True)
|
|
assert repr(transform) == ('Resize(scale=(2000, 2000), '
|
|
'scale_factor=None, keep_ratio=True, '
|
|
'clip_object_border=True), backend=cv2), '
|
|
'interpolation=bilinear)')
|
|
|
|
|
|
class TestPad:
|
|
|
|
def test_pad(self):
|
|
# test size and size_divisor are both set
|
|
with pytest.raises(AssertionError):
|
|
Pad(size=(10, 10), size_divisor=2)
|
|
|
|
# test size and size_divisor are both None
|
|
with pytest.raises(AssertionError):
|
|
Pad(size=None, size_divisor=None)
|
|
|
|
# test size and pad_to_square are both None
|
|
with pytest.raises(AssertionError):
|
|
Pad(size=(10, 10), pad_to_square=True)
|
|
|
|
# test pad_val is not int or tuple
|
|
with pytest.raises(AssertionError):
|
|
Pad(size=(10, 10), pad_val=[])
|
|
|
|
# test padding_mode is not 'constant', 'edge', 'reflect' or 'symmetric'
|
|
with pytest.raises(AssertionError):
|
|
Pad(size=(10, 10), padding_mode='edg')
|
|
|
|
data_info = dict(
|
|
img=np.random.random((1333, 800, 3)),
|
|
gt_semantic_seg=np.random.random((1333, 800, 3)),
|
|
gt_bboxes=np.array([[0, 0, 112, 112]]),
|
|
gt_keypoints=np.array([[[20, 50, 1]]]))
|
|
|
|
# test pad img / gt_semantic_seg with size
|
|
trans = Pad(size=(1200, 2000))
|
|
results = trans(copy.deepcopy(data_info))
|
|
assert results['img'].shape[:2] == (2000, 1200)
|
|
assert results['gt_semantic_seg'].shape[:2] == (2000, 1200)
|
|
|
|
# test pad img/gt_semantic_seg with size_divisor
|
|
trans = Pad(size_divisor=11)
|
|
results = trans(copy.deepcopy(data_info))
|
|
assert results['img'].shape[:2] == (1342, 803)
|
|
assert results['gt_semantic_seg'].shape[:2] == (1342, 803)
|
|
|
|
# test pad img/gt_semantic_seg with pad_to_square
|
|
trans = Pad(pad_to_square=True)
|
|
results = trans(copy.deepcopy(data_info))
|
|
assert results['img'].shape[:2] == (1333, 1333)
|
|
assert results['gt_semantic_seg'].shape[:2] == (1333, 1333)
|
|
|
|
# test pad img/gt_semantic_seg with pad_to_square and size_divisor
|
|
trans = Pad(pad_to_square=True, size_divisor=11)
|
|
results = trans(copy.deepcopy(data_info))
|
|
assert results['img'].shape[:2] == (1342, 1342)
|
|
assert results['gt_semantic_seg'].shape[:2] == (1342, 1342)
|
|
|
|
# test pad img/gt_semantic_seg with pad_to_square and size_divisor
|
|
trans = Pad(pad_to_square=True, size_divisor=11)
|
|
results = trans(copy.deepcopy(data_info))
|
|
assert results['img'].shape[:2] == (1342, 1342)
|
|
assert results['gt_semantic_seg'].shape[:2] == (1342, 1342)
|
|
|
|
# test padding_mode
|
|
new_img = np.ones((1333, 800, 3))
|
|
data_info['img'] = new_img
|
|
trans = Pad(pad_to_square=True, padding_mode='edge')
|
|
results = trans(copy.deepcopy(data_info))
|
|
assert (results['img'] == np.ones((1333, 1333, 3))).all()
|
|
|
|
# test pad_val is dict
|
|
# test rgb image, size=(2000, 2000)
|
|
trans = Pad(
|
|
size=(2000, 2000),
|
|
pad_val=dict(img=(12, 12, 12), seg=(10, 10, 10)))
|
|
results = trans(copy.deepcopy(data_info))
|
|
assert (results['img'][1333:2000, 800:2000, :] == 12).all()
|
|
assert (results['gt_semantic_seg'][1333:2000, 800:2000, :] == 10).all()
|
|
|
|
trans = Pad(size=(2000, 2000), pad_val=dict(img=(12, 12, 12)))
|
|
results = trans(copy.deepcopy(data_info))
|
|
assert (results['img'][1333:2000, 800:2000, :] == 12).all()
|
|
assert (results['gt_semantic_seg'][1333:2000,
|
|
800:2000, :] == 255).all()
|
|
|
|
# test rgb image, pad_to_square=True
|
|
trans = Pad(
|
|
pad_to_square=True,
|
|
pad_val=dict(img=(12, 12, 12), seg=(10, 10, 10)))
|
|
results = trans(copy.deepcopy(data_info))
|
|
assert (results['img'][:, 800:1333, :] == 12).all()
|
|
assert (results['gt_semantic_seg'][:, 800:1333, :] == 10).all()
|
|
|
|
trans = Pad(pad_to_square=True, pad_val=dict(img=(12, 12, 12)))
|
|
results = trans(copy.deepcopy(data_info))
|
|
assert (results['img'][:, 800:1333, :] == 12).all()
|
|
assert (results['gt_semantic_seg'][:, 800:1333, :] == 255).all()
|
|
|
|
# test pad_val is int
|
|
# test rgb image
|
|
trans = Pad(size=(2000, 2000), pad_val=12)
|
|
results = trans(copy.deepcopy(data_info))
|
|
assert (results['img'][1333:2000, 800:2000, :] == 12).all()
|
|
assert (results['gt_semantic_seg'][1333:2000,
|
|
800:2000, :] == 255).all()
|
|
# test gray image
|
|
new_img = np.random.random((1333, 800))
|
|
data_info['img'] = new_img
|
|
new_semantic_seg = np.random.random((1333, 800))
|
|
data_info['gt_semantic_seg'] = new_semantic_seg
|
|
trans = Pad(size=(2000, 2000), pad_val=12)
|
|
results = trans(copy.deepcopy(data_info))
|
|
assert (results['img'][1333:2000, 800:2000] == 12).all()
|
|
assert (results['gt_semantic_seg'][1333:2000, 800:2000] == 255).all()
|
|
|
|
def test_repr(self):
|
|
trans = Pad(pad_to_square=True, size_divisor=11, padding_mode='edge')
|
|
assert repr(trans) == (
|
|
'Pad(size=None, size_divisor=11, pad_to_square=True, '
|
|
"pad_val={'img': 0, 'seg': 255}), padding_mode=edge)")
|
|
|
|
|
|
class TestCenterCrop:
|
|
|
|
@classmethod
|
|
def setup_class(cls):
|
|
img = mmcv.imread(
|
|
osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
|
|
cls.original_img = copy.deepcopy(img)
|
|
seg = np.random.randint(0, 19, (300, 400)).astype(np.uint8)
|
|
cls.gt_semantic_map = copy.deepcopy(seg)
|
|
|
|
@staticmethod
|
|
def reset_results(results, original_img, gt_semantic_map):
|
|
results['img'] = copy.deepcopy(original_img)
|
|
results['gt_semantic_seg'] = copy.deepcopy(gt_semantic_map)
|
|
results['gt_bboxes'] = np.array([[0, 0, 210, 160],
|
|
[200, 150, 400, 300]])
|
|
results['gt_keypoints'] = np.array([[[20, 50, 1]], [[200, 150, 1]],
|
|
[[300, 225, 1]]])
|
|
return results
|
|
|
|
@pytest.mark.skipif(
|
|
condition=torch is None, reason='No torch in current env')
|
|
def test_error(self):
|
|
# test assertion if size is smaller than 0
|
|
with pytest.raises(AssertionError):
|
|
transform = dict(type='CenterCrop', crop_size=-1)
|
|
TRANSFORMS.build(transform)
|
|
|
|
# test assertion if size is tuple but one value is smaller than 0
|
|
with pytest.raises(AssertionError):
|
|
transform = dict(type='CenterCrop', crop_size=(224, -1))
|
|
TRANSFORMS.build(transform)
|
|
|
|
# test assertion if size is tuple and len(size) < 2
|
|
with pytest.raises(AssertionError):
|
|
transform = dict(type='CenterCrop', crop_size=(224, ))
|
|
TRANSFORMS.build(transform)
|
|
|
|
# test assertion if size is tuple len(size) > 2
|
|
with pytest.raises(AssertionError):
|
|
transform = dict(type='CenterCrop', crop_size=(224, 224, 3))
|
|
TRANSFORMS.build(transform)
|
|
|
|
def test_repr(self):
|
|
# test repr
|
|
transform = dict(type='CenterCrop', crop_size=224)
|
|
center_crop_module = TRANSFORMS.build(transform)
|
|
assert isinstance(repr(center_crop_module), str)
|
|
|
|
def test_transform(self):
|
|
results = {}
|
|
self.reset_results(results, self.original_img, self.gt_semantic_map)
|
|
|
|
# test CenterCrop when size is int
|
|
transform = dict(type='CenterCrop', crop_size=224)
|
|
center_crop_module = TRANSFORMS.build(transform)
|
|
results = center_crop_module(results)
|
|
assert results['height'] == 224
|
|
assert results['width'] == 224
|
|
assert (results['img'] == self.original_img[38:262, 88:312, ...]).all()
|
|
assert (
|
|
results['gt_semantic_seg'] == self.gt_semantic_map[38:262,
|
|
88:312]).all()
|
|
assert np.equal(results['gt_bboxes'],
|
|
np.array([[0, 0, 122, 122], [112, 112, 224,
|
|
224]])).all()
|
|
assert np.equal(
|
|
results['gt_keypoints'],
|
|
np.array([[[0, 12, 1]], [[112, 112, 1]], [[212, 187, 1]]])).all()
|
|
|
|
# test CenterCrop when size is tuple
|
|
transform = dict(type='CenterCrop', crop_size=(224, 224))
|
|
center_crop_module = TRANSFORMS.build(transform)
|
|
results = self.reset_results(results, self.original_img,
|
|
self.gt_semantic_map)
|
|
results = center_crop_module(results)
|
|
assert results['height'] == 224
|
|
assert results['width'] == 224
|
|
assert (results['img'] == self.original_img[38:262, 88:312, ...]).all()
|
|
assert (
|
|
results['gt_semantic_seg'] == self.gt_semantic_map[38:262,
|
|
88:312]).all()
|
|
assert np.equal(results['gt_bboxes'],
|
|
np.array([[0, 0, 122, 122], [112, 112, 224,
|
|
224]])).all()
|
|
assert np.equal(
|
|
results['gt_keypoints'],
|
|
np.array([[[0, 12, 1]], [[112, 112, 1]], [[212, 187, 1]]])).all()
|
|
|
|
# test CenterCrop when crop_height != crop_width
|
|
transform = dict(type='CenterCrop', crop_size=(224, 256))
|
|
center_crop_module = TRANSFORMS.build(transform)
|
|
results = self.reset_results(results, self.original_img,
|
|
self.gt_semantic_map)
|
|
results = center_crop_module(results)
|
|
assert results['height'] == 256
|
|
assert results['width'] == 224
|
|
assert (results['img'] == self.original_img[22:278, 88:312, ...]).all()
|
|
assert (
|
|
results['gt_semantic_seg'] == self.gt_semantic_map[22:278,
|
|
88:312]).all()
|
|
assert np.equal(results['gt_bboxes'],
|
|
np.array([[0, 0, 122, 138], [112, 128, 224,
|
|
256]])).all()
|
|
assert np.equal(
|
|
results['gt_keypoints'],
|
|
np.array([[[0, 28, 1]], [[112, 128, 1]], [[212, 203, 1]]])).all()
|
|
|
|
# test CenterCrop when crop_size is equal to img.shape
|
|
img_height, img_width, _ = self.original_img.shape
|
|
transform = dict(type='CenterCrop', crop_size=(img_width, img_height))
|
|
center_crop_module = TRANSFORMS.build(transform)
|
|
results = self.reset_results(results, self.original_img,
|
|
self.gt_semantic_map)
|
|
results = center_crop_module(results)
|
|
assert results['height'] == 300
|
|
assert results['width'] == 400
|
|
assert (results['img'] == self.original_img).all()
|
|
assert (results['gt_semantic_seg'] == self.gt_semantic_map).all()
|
|
assert np.equal(results['gt_bboxes'],
|
|
np.array([[0, 0, 210, 160], [200, 150, 400,
|
|
300]])).all()
|
|
assert np.equal(
|
|
results['gt_keypoints'],
|
|
np.array([[[20, 50, 1]], [[200, 150, 1]], [[300, 225, 1]]])).all()
|
|
|
|
# test CenterCrop when crop_size is larger than img.shape
|
|
transform = dict(
|
|
type='CenterCrop', crop_size=(img_width * 2, img_height * 2))
|
|
center_crop_module = TRANSFORMS.build(transform)
|
|
results = self.reset_results(results, self.original_img,
|
|
self.gt_semantic_map)
|
|
results = center_crop_module(results)
|
|
assert results['height'] == 300
|
|
assert results['width'] == 400
|
|
assert (results['img'] == self.original_img).all()
|
|
assert (results['gt_semantic_seg'] == self.gt_semantic_map).all()
|
|
assert np.equal(results['gt_bboxes'],
|
|
np.array([[0, 0, 210, 160], [200, 150, 400,
|
|
300]])).all()
|
|
assert np.equal(
|
|
results['gt_keypoints'],
|
|
np.array([[[20, 50, 1]], [[200, 150, 1]], [[300, 225, 1]]])).all()
|
|
|
|
# test with padding
|
|
transform = dict(
|
|
type='CenterCrop',
|
|
crop_size=(img_width // 2, img_height * 2),
|
|
pad_mode='constant',
|
|
pad_val=12)
|
|
center_crop_module = TRANSFORMS.build(transform)
|
|
results = self.reset_results(results, self.original_img,
|
|
self.gt_semantic_map)
|
|
results = center_crop_module(results)
|
|
assert results['height'] == 600
|
|
assert results['width'] == 200
|
|
assert results['img'].shape[:2] == results['gt_semantic_seg'].shape
|
|
assert (results['img'][300:600, 100:300, ...] == 12).all()
|
|
assert (results['gt_semantic_seg'][300:600, 100:300] == 255).all()
|
|
assert np.equal(results['gt_bboxes'],
|
|
np.array([[0, 0, 110, 160], [100, 150, 200,
|
|
300]])).all()
|
|
assert np.equal(
|
|
results['gt_keypoints'],
|
|
np.array([[[0, 50, 1]], [[100, 150, 1]], [[200, 225, 1]]])).all()
|
|
|
|
transform = dict(
|
|
type='CenterCrop',
|
|
crop_size=(img_width // 2, img_height * 2),
|
|
pad_mode='constant',
|
|
pad_val=dict(img=13, seg=33))
|
|
center_crop_module = TRANSFORMS.build(transform)
|
|
results = self.reset_results(results, self.original_img,
|
|
self.gt_semantic_map)
|
|
results = center_crop_module(results)
|
|
assert results['height'] == 600
|
|
assert results['width'] == 200
|
|
assert (results['img'][300:600, 100:300, ...] == 13).all()
|
|
assert (results['gt_semantic_seg'][300:600, 100:300] == 33).all()
|
|
assert np.equal(results['gt_bboxes'],
|
|
np.array([[0, 0, 110, 160], [100, 150, 200,
|
|
300]])).all()
|
|
assert np.equal(
|
|
results['gt_keypoints'],
|
|
np.array([[[0, 50, 1]], [[100, 150, 1]], [[200, 225, 1]]])).all()
|
|
|
|
# test CenterCrop when crop_width is smaller than img_width
|
|
transform = dict(
|
|
type='CenterCrop', crop_size=(img_width // 2, img_height))
|
|
center_crop_module = TRANSFORMS.build(transform)
|
|
results = self.reset_results(results, self.original_img,
|
|
self.gt_semantic_map)
|
|
results = center_crop_module(results)
|
|
assert results['height'] == img_height
|
|
assert results['width'] == img_width // 2
|
|
assert (results['img'] == self.original_img[:, 100:300, ...]).all()
|
|
assert (
|
|
results['gt_semantic_seg'] == self.gt_semantic_map[:,
|
|
100:300]).all()
|
|
assert np.equal(results['gt_bboxes'],
|
|
np.array([[0, 0, 110, 160], [100, 150, 200,
|
|
300]])).all()
|
|
assert np.equal(
|
|
results['gt_keypoints'],
|
|
np.array([[[0, 50, 1]], [[100, 150, 1]], [[200, 225, 1]]])).all()
|
|
|
|
# test CenterCrop when crop_height is smaller than img_height
|
|
transform = dict(
|
|
type='CenterCrop', crop_size=(img_width, img_height // 2))
|
|
center_crop_module = TRANSFORMS.build(transform)
|
|
results = self.reset_results(results, self.original_img,
|
|
self.gt_semantic_map)
|
|
results = center_crop_module(results)
|
|
assert results['height'] == img_height // 2
|
|
assert results['width'] == img_width
|
|
assert (results['img'] == self.original_img[75:225, ...]).all()
|
|
assert (results['gt_semantic_seg'] == self.gt_semantic_map[75:225,
|
|
...]).all()
|
|
assert np.equal(results['gt_bboxes'],
|
|
np.array([[0, 0, 210, 85], [200, 75, 400,
|
|
150]])).all()
|
|
assert np.equal(
|
|
results['gt_keypoints'],
|
|
np.array([[[20, 0, 1]], [[200, 75, 1]], [[300, 150, 1]]])).all()
|
|
|
|
@pytest.mark.skipif(
|
|
condition=torch is None, reason='No torch in current env')
|
|
def test_torchvision_compare(self):
|
|
# compare results with torchvision
|
|
results = {}
|
|
transform = dict(type='CenterCrop', crop_size=224)
|
|
center_crop_module = TRANSFORMS.build(transform)
|
|
results = self.reset_results(results, self.original_img,
|
|
self.gt_semantic_map)
|
|
results = center_crop_module(results)
|
|
center_crop_module = torchvision.transforms.CenterCrop(size=224)
|
|
pil_img = Image.fromarray(self.original_img)
|
|
pil_seg = Image.fromarray(self.gt_semantic_map)
|
|
cropped_img = center_crop_module(pil_img)
|
|
cropped_img = np.array(cropped_img)
|
|
cropped_seg = center_crop_module(pil_seg)
|
|
cropped_seg = np.array(cropped_seg)
|
|
assert np.equal(results['img'], cropped_img).all()
|
|
assert np.equal(results['gt_semantic_seg'], cropped_seg).all()
|
|
|
|
|
|
class TestRandomGrayscale:
|
|
|
|
@classmethod
|
|
def setup_class(cls):
|
|
cls.img = np.random.rand(10, 10, 3).astype(np.float32)
|
|
|
|
def test_repr(self):
|
|
# test repr
|
|
transform = dict(
|
|
type='RandomGrayscale',
|
|
prob=1.,
|
|
channel_weights=(0.299, 0.587, 0.114),
|
|
keep_channel=True)
|
|
random_gray_scale_module = TRANSFORMS.build(transform)
|
|
assert isinstance(repr(random_gray_scale_module), str)
|
|
|
|
def test_error(self):
|
|
# test invalid argument
|
|
transform = dict(type='RandomGrayscale', prob=2)
|
|
with pytest.raises(AssertionError):
|
|
TRANSFORMS.build(transform)
|
|
|
|
def test_transform(self):
|
|
results = dict()
|
|
# test rgb2gray, return the grayscale image with prob = 1.
|
|
transform = dict(
|
|
type='RandomGrayscale',
|
|
prob=1.,
|
|
channel_weights=(0.299, 0.587, 0.114),
|
|
keep_channel=True)
|
|
|
|
random_gray_scale_module = TRANSFORMS.build(transform)
|
|
results['img'] = copy.deepcopy(self.img)
|
|
img = random_gray_scale_module(results)['img']
|
|
computed_gray = (
|
|
self.img[:, :, 0] * 0.299 + self.img[:, :, 1] * 0.587 +
|
|
self.img[:, :, 2] * 0.114)
|
|
for i in range(img.shape[2]):
|
|
assert_array_almost_equal(img[:, :, i], computed_gray, decimal=4)
|
|
assert img.shape == (10, 10, 3)
|
|
|
|
# test rgb2gray, return the original image with p=0.
|
|
transform = dict(type='RandomGrayscale', prob=0.)
|
|
random_gray_scale_module = TRANSFORMS.build(transform)
|
|
results['img'] = copy.deepcopy(self.img)
|
|
img = random_gray_scale_module(results)['img']
|
|
assert_array_equal(img, self.img)
|
|
assert img.shape == (10, 10, 3)
|
|
|
|
# test image with one channel
|
|
transform = dict(type='RandomGrayscale', prob=1.)
|
|
results['img'] = self.img[:, :, 0:1]
|
|
random_gray_scale_module = TRANSFORMS.build(transform)
|
|
img = random_gray_scale_module(results)['img']
|
|
assert_array_equal(img, self.img[:, :, 0:1])
|
|
assert img.shape == (10, 10, 1)
|
|
|
|
|
|
class TestMultiScaleFlipAug:
|
|
|
|
@classmethod
|
|
def setup_class(cls):
|
|
cls.img = mmcv.imread(
|
|
osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
|
|
cls.original_img = copy.deepcopy(cls.img)
|
|
|
|
def test_error(self):
|
|
# test assertion if img_scale is None
|
|
with pytest.raises(AssertionError):
|
|
transform = dict(
|
|
type='MultiScaleFlipAug', img_scale=None, transforms=[])
|
|
TRANSFORMS.build(transform)
|
|
|
|
# test assertion if img_scale is not tuple or list of tuple
|
|
with pytest.raises(AssertionError):
|
|
transform = dict(
|
|
type='MultiScaleFlipAug', img_scale=[1333, 800], transforms=[])
|
|
TRANSFORMS.build(transform)
|
|
|
|
# test assertion if flip_direction is not str or list of str
|
|
with pytest.raises(AssertionError):
|
|
transform = dict(
|
|
type='MultiScaleFlipAug',
|
|
img_scale=[(1333, 800)],
|
|
flip_direction=1,
|
|
transforms=[])
|
|
TRANSFORMS.build(transform)
|
|
|
|
@pytest.mark.skipif(
|
|
condition=torch is None, reason='No torch in current env')
|
|
def test_multi_scale_flip_aug(self):
|
|
# test with empty transforms
|
|
transform = dict(
|
|
type='MultiScaleFlipAug',
|
|
transforms=[],
|
|
img_scale=[(1333, 800), (800, 600), (640, 480)],
|
|
flip=True,
|
|
flip_direction=['horizontal', 'vertical', 'diagonal'])
|
|
multi_scale_flip_aug_module = TRANSFORMS.build(transform)
|
|
results = dict()
|
|
results['img'] = copy.deepcopy(self.original_img)
|
|
results = multi_scale_flip_aug_module(results)
|
|
assert len(results['img']) == 12
|
|
|
|
# test with flip=False
|
|
transform = dict(
|
|
type='MultiScaleFlipAug',
|
|
transforms=[],
|
|
img_scale=[(1333, 800), (800, 600), (640, 480)],
|
|
flip=False,
|
|
flip_direction=['horizontal', 'vertical', 'diagonal'])
|
|
multi_scale_flip_aug_module = TRANSFORMS.build(transform)
|
|
results = dict()
|
|
results['img'] = copy.deepcopy(self.original_img)
|
|
results = multi_scale_flip_aug_module(results)
|
|
assert len(results['img']) == 3
|
|
|
|
# test with transforms
|
|
img_norm_cfg = dict(
|
|
mean=[123.675, 116.28, 103.53],
|
|
std=[58.395, 57.12, 57.375],
|
|
to_rgb=True)
|
|
transforms_cfg = [
|
|
dict(type='Normalize', **img_norm_cfg),
|
|
dict(type='Pad', size_divisor=32),
|
|
dict(type='ImageToTensor', keys=['img']),
|
|
]
|
|
transform = dict(
|
|
type='MultiScaleFlipAug',
|
|
transforms=transforms_cfg,
|
|
img_scale=[(1333, 800), (800, 600), (640, 480)],
|
|
flip=True,
|
|
flip_direction=['horizontal', 'vertical', 'diagonal'])
|
|
multi_scale_flip_aug_module = TRANSFORMS.build(transform)
|
|
results = dict()
|
|
results['img'] = copy.deepcopy(self.original_img)
|
|
results = multi_scale_flip_aug_module(results)
|
|
assert len(results['img']) == 12
|
|
|
|
|
|
class TestRandomMultiscaleResize:
|
|
|
|
@classmethod
|
|
def setup_class(cls):
|
|
cls.img = mmcv.imread(
|
|
osp.join(osp.dirname(__file__), '../data/color.jpg'), 'color')
|
|
cls.original_img = copy.deepcopy(cls.img)
|
|
|
|
def reset_results(self, results):
|
|
results['img'] = copy.deepcopy(self.original_img)
|
|
results['gt_semantic_seg'] = copy.deepcopy(self.original_img)
|
|
|
|
def test_repr(self):
|
|
# test repr
|
|
transform = dict(
|
|
type='RandomMultiscaleResize', scales=[(1333, 800), (1333, 600)])
|
|
random_multiscale_resize = TRANSFORMS.build(transform)
|
|
assert isinstance(repr(random_multiscale_resize), str)
|
|
|
|
def test_error(self):
|
|
# test assertion if size is smaller than 0
|
|
with pytest.raises(AssertionError):
|
|
transform = dict(type='RandomMultiscaleResize', scales=[0.5, 1, 2])
|
|
TRANSFORMS.build(transform)
|
|
|
|
def test_random_multiscale_resize(self):
|
|
results = dict()
|
|
# test with one scale
|
|
transform = dict(type='RandomMultiscaleResize', scales=[(1333, 800)])
|
|
random_multiscale_resize = TRANSFORMS.build(transform)
|
|
self.reset_results(results)
|
|
results = random_multiscale_resize(results)
|
|
assert results['img'].shape == (800, 1333, 3)
|
|
|
|
# test with multi scales
|
|
_scale_choice = [(1333, 800), (1333, 600)]
|
|
transform = dict(type='RandomMultiscaleResize', scales=_scale_choice)
|
|
random_multiscale_resize = TRANSFORMS.build(transform)
|
|
self.reset_results(results)
|
|
results = random_multiscale_resize(results)
|
|
assert (results['img'].shape[1],
|
|
results['img'].shape[0]) in _scale_choice
|
|
|
|
# test keep_ratio
|
|
transform = dict(
|
|
type='RandomMultiscaleResize',
|
|
scales=[(900, 600)],
|
|
keep_ratio=True)
|
|
random_multiscale_resize = TRANSFORMS.build(transform)
|
|
self.reset_results(results)
|
|
_input_ratio = results['img'].shape[0] / results['img'].shape[1]
|
|
results = random_multiscale_resize(results)
|
|
_output_ratio = results['img'].shape[0] / results['img'].shape[1]
|
|
assert_array_almost_equal(_input_ratio, _output_ratio)
|
|
|
|
# test clip_object_border
|
|
gt_bboxes = [[200, 150, 600, 450]]
|
|
transform = dict(
|
|
type='RandomMultiscaleResize',
|
|
scales=[(200, 150)],
|
|
clip_object_border=True)
|
|
random_multiscale_resize = TRANSFORMS.build(transform)
|
|
self.reset_results(results)
|
|
results['gt_bboxes'] = np.array(gt_bboxes)
|
|
results = random_multiscale_resize(results)
|
|
assert results['img'].shape == (150, 200, 3)
|
|
assert np.equal(results['gt_bboxes'], np.array([[100, 75, 200,
|
|
150]])).all()
|
|
|
|
transform = dict(
|
|
type='RandomMultiscaleResize',
|
|
scales=[(200, 150)],
|
|
clip_object_border=False)
|
|
random_multiscale_resize = TRANSFORMS.build(transform)
|
|
self.reset_results(results)
|
|
results['gt_bboxes'] = np.array(gt_bboxes)
|
|
results = random_multiscale_resize(results)
|
|
assert results['img'].shape == (150, 200, 3)
|
|
assert np.equal(results['gt_bboxes'], np.array([[100, 75, 300,
|
|
225]])).all()
|
|
|
|
|
|
class TestRandomFlip:
|
|
|
|
def test_init(self):
|
|
|
|
# prob is float
|
|
TRANSFORMS = RandomFlip(0.1)
|
|
assert TRANSFORMS.prob == 0.1
|
|
|
|
# prob is None
|
|
with pytest.raises(ValueError):
|
|
TRANSFORMS = RandomFlip(None)
|
|
assert TRANSFORMS.prob is None
|
|
|
|
# prob is a list
|
|
TRANSFORMS = RandomFlip([0.1, 0.2], ['horizontal', 'vertical'])
|
|
assert len(TRANSFORMS.prob) == 2
|
|
assert len(TRANSFORMS.direction) == 2
|
|
|
|
# direction is an invalid type
|
|
with pytest.raises(ValueError):
|
|
TRANSFORMS = RandomFlip(0.1, 1)
|
|
|
|
# prob is an invalid type
|
|
with pytest.raises(ValueError):
|
|
TRANSFORMS = RandomFlip('0.1')
|
|
|
|
def test_transform(self):
|
|
|
|
results = {
|
|
'img': np.random.random((224, 224, 3)),
|
|
'gt_bboxes': np.array([[0, 1, 100, 101]]),
|
|
'gt_keypoints': np.array([[[100, 100, 1.0]]]),
|
|
'gt_semantic_seg': np.random.random((224, 224, 3))
|
|
}
|
|
|
|
# horizontal flip
|
|
TRANSFORMS = RandomFlip([1.0], ['horizontal'])
|
|
results_update = TRANSFORMS.transform(copy.deepcopy(results))
|
|
assert (results_update['gt_bboxes'] == np.array([[124, 1, 224,
|
|
101]])).all()
|
|
|
|
# diagnal flip
|
|
TRANSFORMS = RandomFlip([1.0], ['diagonal'])
|
|
results_update = TRANSFORMS.transform(copy.deepcopy(results))
|
|
assert (results_update['gt_bboxes'] == np.array([[124, 123, 224,
|
|
223]])).all()
|
|
|
|
# vertical flip
|
|
TRANSFORMS = RandomFlip([1.0], ['vertical'])
|
|
results_update = TRANSFORMS.transform(copy.deepcopy(results))
|
|
assert (results_update['gt_bboxes'] == np.array([[0, 123, 100,
|
|
223]])).all()
|
|
|
|
# horizontal flip when direction is None
|
|
TRANSFORMS = RandomFlip(1.0)
|
|
results_update = TRANSFORMS.transform(copy.deepcopy(results))
|
|
assert (results_update['gt_bboxes'] == np.array([[124, 1, 224,
|
|
101]])).all()
|
|
|
|
TRANSFORMS = RandomFlip(0.0)
|
|
results_update = TRANSFORMS.transform(copy.deepcopy(results))
|
|
assert (results_update['gt_bboxes'] == np.array([[0, 1, 100,
|
|
101]])).all()
|
|
|
|
# flip direction is invalid in bbox flip
|
|
with pytest.raises(ValueError):
|
|
TRANSFORMS = RandomFlip(1.0)
|
|
results_update = TRANSFORMS.flip_bbox(results['gt_bboxes'],
|
|
(224, 224), 'invalid')
|
|
|
|
# flip direction is invalid in keypoints flip
|
|
with pytest.raises(ValueError):
|
|
TRANSFORMS = RandomFlip(1.0)
|
|
results_update = TRANSFORMS.flip_keypoints(results['gt_keypoints'],
|
|
(224, 224), 'invalid')
|
|
|
|
def test_repr(self):
|
|
TRANSFORMS = RandomFlip(0.1)
|
|
TRANSFORMS_str = str(TRANSFORMS)
|
|
assert isinstance(TRANSFORMS_str, str)
|
|
|
|
|
|
class TestRandomResize:
|
|
|
|
def test_init(self):
|
|
TRANSFORMS = RandomResize(
|
|
(224, 224),
|
|
(1.0, 2.0),
|
|
)
|
|
assert TRANSFORMS.scale == (224, 224)
|
|
|
|
def test_repr(self):
|
|
TRANSFORMS = RandomResize(
|
|
(224, 224),
|
|
(1.0, 2.0),
|
|
)
|
|
TRANSFORMS_str = str(TRANSFORMS)
|
|
assert isinstance(TRANSFORMS_str, str)
|
|
|
|
def test_transform(self):
|
|
|
|
# choose target scale from init when override is True
|
|
results = {}
|
|
TRANSFORMS = RandomResize((224, 224), (1.0, 2.0))
|
|
results_update = TRANSFORMS.transform(copy.deepcopy(results))
|
|
assert results_update['scale'][0] >= 224 and results_update['scale'][
|
|
0] <= 448
|
|
assert results_update['scale'][1] >= 224 and results_update['scale'][
|
|
1] <= 448
|
|
|
|
# keep ratio is True
|
|
results = {
|
|
'img': np.random.random((224, 224, 3)),
|
|
'gt_semantic_seg': np.random.random((224, 224, 3)),
|
|
'gt_bboxes': np.array([[0, 0, 112, 112]]),
|
|
'gt_keypoints': np.array([[[112, 112]]])
|
|
}
|
|
# import pdb
|
|
# pdb.set_trace()
|
|
TRANSFORMS = RandomResize((224, 224), (1.0, 2.0), keep_ratio=True)
|
|
results_update = TRANSFORMS.transform(copy.deepcopy(results))
|
|
assert 224 <= results_update['height']
|
|
assert 448 >= results_update['height']
|
|
assert 224 <= results_update['width']
|
|
assert 448 >= results_update['width']
|
|
assert results_update['keep_ratio']
|
|
assert results['gt_bboxes'][0][2] >= 112
|
|
assert results['gt_bboxes'][0][2] <= 112
|
|
|
|
# keep ratio is False
|
|
TRANSFORMS = RandomResize((224, 224), (1.0, 2.0), keep_ratio=False)
|
|
results_update = TRANSFORMS.transform(copy.deepcopy(results))
|
|
|
|
# choose target scale from init when override is False and scale is a
|
|
# list of tuples
|
|
results = {}
|
|
TRANSFORMS = RandomResize([(224, 448), (112, 224)], keep_ratio=True)
|
|
results_update = TRANSFORMS.transform(copy.deepcopy(results))
|
|
assert results_update['scale'][0] >= 224 and results_update['scale'][
|
|
0] <= 448
|
|
assert results_update['scale'][1] >= 112 and results_update['scale'][
|
|
1] <= 224
|
|
|
|
# the type of scale is invalid in init
|
|
with pytest.raises(NotImplementedError):
|
|
results = {}
|
|
TRANSFORMS = RandomResize([(224, 448), [112, 224]],
|
|
keep_ratio=True)
|
|
results_update = TRANSFORMS.transform(copy.deepcopy(results))
|