def __call__(self, img_group, is_flow=False):
image_h = img_group[0].shape[0]
image_w = img_group[0].shape[1]
crop_w, crop_h = self.crop_size
offsets = GroupMultiScaleCrop.fill_fix_offset(
False, image_w, image_h, crop_w, crop_h)
oversample_group = list()
for o_w, o_h in offsets:
normal_group = list()
flip_group = list()
for i, img in enumerate(img_group):
crop = mmcv.imcrop(img, np.array(
[o_w, o_h, o_w + crop_w-1, o_h + crop_h-1]))
normal_group.append(crop)
flip_crop = mmcv.imflip(crop)
if is_flow and i % 2 == 0:
flip_group.append(mmcv.iminvert(flip_crop))
else:
flip_group.append(flip_crop)
oversample_group.extend(normal_group)
oversample_group.extend(flip_group)
return oversample_group, None
def __call__(self, results):
img_group = results['img_group']
img_h, img_w = img_group[0].shape[:2]
crop_w, crop_h = self.crop_size
offsets = MultiScaleCrop.fill_fix_offset(False, img_w, img_h, crop_w,
crop_h)
oversample_group = list()
for o_w, o_h in offsets:
normal_group = list()
flip_group = list()
for i, img in enumerate(img_group):
crop = mmcv.imcrop(
img,
np.array([o_w, o_h, o_w + crop_w - 1, o_h + crop_h - 1]))
normal_group.append(crop)
flip_crop = mmcv.imflip(crop)
if results['modality'] == 'Flow' and i % 2 == 0:
flip_group.append(mmcv.iminvert(flip_crop))
else:
flip_group.append(flip_crop)
oversample_group.extend(normal_group)
oversample_group.extend(flip_group)
results['img_group'] = oversample_group
results['crop_bbox'] = None
results['img_shape'] = results['img_group'][0].shape
return results
def __call__(self, results):
if np.random.rand() > self.prob:
return results
for key in results.get('img_fields', ['img']):
img = results[key]
img_inverted = mmcv.iminvert(img)
results[key] = img_inverted.astype(img.dtype)
return results
def __call__(self, img_group, scale, crop_history=None, flip=False,
keep_ratio=True, div_255=False, is_flow=False):
# 1. rescale
if keep_ratio:
tuple_list = [mmcv.imrescale(
img, scale, return_scale=True) for img in img_group]
img_group, scale_factors = list(zip(*tuple_list))
scale_factor = scale_factors[0]
else:
tuple_list = [mmcv.imresize(
img, scale, return_scale=True) for img in img_group]
img_group, w_scales, h_scales = list(zip(*tuple_list))
scale_factor = np.array([w_scales[0], h_scales[0],
w_scales[0], h_scales[0]],
dtype=np.float32)
# 2. crop (if necessary)
if crop_history is not None:
self.op_crop = GroupCrop(crop_history)
if self.op_crop is not None:
img_group, crop_quadruple = self.op_crop(
img_group, is_flow=is_flow)
else:
crop_quadruple = None
img_shape = img_group[0].shape
# 3. flip
if flip:
img_group = [mmcv.imflip(img) for img in img_group]
if is_flow:
for i in range(0, len(img_group), 2):
img_group[i] = mmcv.iminvert(img_group[i])
# 4a. div_255
if div_255:
img_group = [mmcv.imnormalize(img, 0, 255, False)
for img in img_group]
# 4. normalize
img_group = [mmcv.imnormalize(
img, self.mean, self.std, self.to_rgb) for img in img_group]
# 5. pad
if self.size_divisor is not None:
img_group = [mmcv.impad_to_multiple(
img, self.size_divisor) for img in img_group]
pad_shape = img_group[0].shape
else:
pad_shape = img_shape
if is_flow:
assert len(img_group[0].shape) == 2
img_group = [np.stack((flow_x, flow_y), axis=2)
for flow_x, flow_y in zip(
img_group[0::2], img_group[1::2])]
# 6. transpose
img_group = [img.transpose(2, 0, 1) for img in img_group]
# Stack into numpy.array
img_group = np.stack(img_group, axis=0)
return img_group, img_shape, pad_shape, scale_factor, crop_quadruple
def __call__(self, results):
img_group = results['img_group']
img_h, img_w = img_group[0].shape[:2]
crop_w, crop_h = self.crop_size
# assert crop_h == img_h or crop_w == img_w
if crop_h == img_h:
w_step = (img_w - crop_w) // 2
offsets = [
(0, 0), # left
(2 * w_step, 0), # right
(w_step, 0), # middle
]
elif crop_w == img_w:
h_step = (img_h - crop_h) // 2
offsets = [
(0, 0), # top
(0, 2 * h_step), # down
(0, h_step), # middle
]
else:
w_step = (img_w - crop_w) // 4
h_step = (img_h - crop_h) // 4
offsets = list()
offsets.append((0 * w_step, 2 * h_step)) # left
offsets.append((4 * w_step, 2 * h_step)) # right
offsets.append((2 * w_step, 2 * h_step)) # center
oversample_group = list()
for o_w, o_h in offsets:
normal_group = list()
flip_group = list()
for i, img in enumerate(img_group):
crop = mmcv.imcrop(
img,
np.array([o_w, o_h, o_w + crop_w - 1, o_h + crop_h - 1]))
normal_group.append(crop)
flip_crop = mmcv.imflip(crop)
if results['modality'] == 'Flow' and i % 2 == 0:
flip_group.append(mmcv.iminvert(flip_crop))
else:
flip_group.append(flip_crop)
oversample_group.extend(normal_group)
results['img_group'] = oversample_group
results['crop_bbox'] = None
results['img_shape'] = results['img_group'][0].shape
return results
def __call__(self, results):
img_group = results['img_group']
flip = True if np.random.rand() < self.flip_ratio else False
if flip:
img_group = [mmcv.imflip(img, self.direction) for img in img_group]
if results['modality'] == 'Flow':
for i in range(0, len(img_group), 2):
img_group[i] = mmcv.iminvert(img_group[i])
results['flip'] = flip
results['flip_direction'] = self.direction
results['img_group'] = img_group
return results
def __call__(self, results):
"""Performs the Flip augmentation.
Args:
results (dict): The resulting dict to be modified and passed
to the next transform in pipeline.
"""
_init_lazy_if_proper(results, self.lazy)
modality = results['modality']
if modality == 'Flow':
assert self.direction == 'horizontal'
if np.random.rand() < self.flip_ratio:
flip = True
else:
flip = False
results['flip'] = flip
results['flip_direction'] = self.direction
if not self.lazy:
if flip:
for i, img in enumerate(results['imgs']):
mmcv.imflip_(img, self.direction)
lt = len(results['imgs'])
for i in range(0, lt, 2):
# flow with even indexes are x_flow, which need to be
# inverted when doing horizontal flip
if modality == 'Flow':
results['imgs'][i] = mmcv.iminvert(results['imgs'][i])
else:
results['imgs'] = list(results['imgs'])
else:
lazyop = results['lazy']
if lazyop['flip']:
raise NotImplementedError('Use one Flip please')
lazyop['flip'] = flip
lazyop['flip_direction'] = self.direction
return results
def __call__(self, img_group, is_flow=False):
image_h = img_group[0].shape[0]
image_w = img_group[0].shape[1]
crop_w, crop_h = self.crop_size
assert crop_h == image_h or crop_w == image_w
if crop_h == image_h:
w_step = (image_w - crop_w) // 2
offsets = list()
offsets.append((0, 0)) # left
offsets.append((2 * w_step, 0)) # right
offsets.append((w_step, 0)) # middle
elif crop_w == image_w:
h_step = (image_h - crop_h) // 2
offsets = list()
offsets.append((0, 0)) # top
offsets.append((0, 2 * h_step)) # down
offsets.append((0, h_step)) # middle
oversample_group = list()
for o_w, o_h in offsets:
normal_group = list()
flip_group = list()
for i, img in enumerate(img_group):
crop = mmcv.imcrop(
img,
np.array([o_w, o_h, o_w + crop_w - 1, o_h + crop_h - 1]))
normal_group.append(crop)
flip_crop = mmcv.imflip(crop)
if is_flow and i % 2 == 0:
flip_group.append(mmcv.iminvert(flip_crop))
else:
flip_group.append(flip_crop)
oversample_group.extend(normal_group)
# oversample_group.extend(flip_group)
return oversample_group, None
def test_iminvert(self):
img = np.array([[0, 128, 255], [1, 127, 254], [2, 129, 253]],
dtype=np.uint8)
img_r = np.array([[255, 127, 0], [254, 128, 1], [253, 126, 2]],
dtype=np.uint8)
assert_array_equal(mmcv.iminvert(img), img_r)
def test_flip(self):
with pytest.raises(ValueError):
# direction must be in ['horizontal', 'vertical']
Flip(direction='vertically')
target_keys = ['imgs', 'flip_direction', 'modality']
# do not flip imgs.
imgs = list(np.random.rand(2, 64, 64, 3))
results = dict(imgs=copy.deepcopy(imgs), modality='RGB')
flip = Flip(flip_ratio=0, direction='horizontal')
flip_results = flip(results)
assert assert_dict_has_keys(flip_results, target_keys)
assert np.array_equal(imgs, results['imgs'])
assert id(flip_results['imgs']) == id(results['imgs'])
assert np.shape(flip_results['imgs']) == np.shape(imgs)
# always flip imgs horizontally.
imgs = list(np.random.rand(2, 64, 64, 3))
results = dict(imgs=copy.deepcopy(imgs), modality='RGB')
results['gt_bboxes'] = np.array([[0, 0, 60, 60]])
results['proposals'] = np.array([[0, 0, 60, 60]])
flip = Flip(flip_ratio=1, direction='horizontal')
flip_results = flip(results)
assert assert_dict_has_keys(flip_results, target_keys)
if flip_results['flip'] is True:
assert check_flip(imgs, flip_results['imgs'],
flip_results['flip_direction'])
assert id(flip_results['imgs']) == id(results['imgs'])
assert np.shape(flip_results['imgs']) == np.shape(imgs)
# flip flow images horizontally
imgs = [
np.arange(16).reshape(4, 4).astype(np.float32),
np.arange(16, 32).reshape(4, 4).astype(np.float32)
]
results = dict(imgs=copy.deepcopy(imgs), modality='Flow')
flip = Flip(flip_ratio=1, direction='horizontal')
flip_results = flip(results)
assert assert_dict_has_keys(flip_results, target_keys)
imgs = [x.reshape(4, 4, 1) for x in imgs]
flip_results['imgs'] = [
x.reshape(4, 4, 1) for x in flip_results['imgs']
]
if flip_results['flip'] is True:
assert check_flip([imgs[0]],
[mmcv.iminvert(flip_results['imgs'][0])],
flip_results['flip_direction'])
assert check_flip([imgs[1]], [flip_results['imgs'][1]],
flip_results['flip_direction'])
assert id(flip_results['imgs']) == id(results['imgs'])
assert np.shape(flip_results['imgs']) == np.shape(imgs)
# always flip imgs vertivally.
imgs = list(np.random.rand(2, 64, 64, 3))
results = dict(imgs=copy.deepcopy(imgs), modality='RGB')
flip = Flip(flip_ratio=1, direction='vertical')
flip_results = flip(results)
assert assert_dict_has_keys(flip_results, target_keys)
if flip_results['flip'] is True:
assert check_flip(imgs, flip_results['imgs'],
flip_results['flip_direction'])
assert id(flip_results['imgs']) == id(results['imgs'])
assert np.shape(flip_results['imgs']) == np.shape(imgs)
assert repr(flip) == (f'{flip.__class__.__name__}'
f'(flip_ratio={1}, direction=vertical, '
f'flip_label_map={None}, lazy={False})')
# transform label for the flipped image with the specific label.
_flip_label_map = {4: 6}
imgs = list(np.random.rand(2, 64, 64, 3))
# the label should be mapped.
results = dict(imgs=copy.deepcopy(imgs), modality='RGB', label=4)
flip = Flip(flip_ratio=1,
direction='horizontal',
flip_label_map=_flip_label_map)
flip_results = flip(results)
assert results['label'] == 6
# the label should not be mapped.
results = dict(imgs=copy.deepcopy(imgs), modality='RGB', label=3)
flip = Flip(flip_ratio=1,
direction='horizontal',
flip_label_map=_flip_label_map)
flip_results = flip(results)
assert results['label'] == 3
def __call__(self,
img_group,
scale,
crop_history=None,
flip=False,
keep_ratio=True,
div_255=False,
is_flow=False,
interpolation='bilinear',
normalize=True,
more_aug=False):
# 1. rescale
if keep_ratio:
tuple_list = [
mmcv.imrescale(img,
scale,
return_scale=True,
interpolation=interpolation)
for img in img_group
]
img_group, scale_factors = list(zip(*tuple_list))
scale_factor = scale_factors[0]
else:
tuple_list = [
mmcv.imresize(img,
scale,
return_scale=True,
interpolation=interpolation) for img in img_group
]
img_group, w_scales, h_scales = list(zip(*tuple_list))
scale_factor = np.array(
[w_scales[0], h_scales[0], w_scales[0], h_scales[0]],
dtype=np.float32)
# 2. crop (if necessary)
if crop_history is not None:
self.op_crop = GroupCrop(crop_history,
input_size=self.crop_size,
resize=True)
if self.op_crop is not None and isinstance(
self.op_crop, (GroupCrop, GroupMultiScaleCrop)):
img_group, crop_quadruple = self.op_crop(
img_group, is_flow=is_flow, interpolation=interpolation)
elif self.op_crop is not None:
img_group, crop_quadruple = self.op_crop(img_group,
is_flow=is_flow)
else:
crop_quadruple = None
img_shape = img_group[0].shape
if more_aug:
seq = iaa.Sequential([
iaa.GaussianBlur(sigma=np.random.uniform(0, 5)),
iaa.AdditiveGaussianNoise(loc=0,
scale=(0.0, 0.05 * 255),
per_channel=0.5),
])
img_group = seq(images=np.array(img_group))
# 3. flip
if flip:
img_group = [mmcv.imflip(img) for img in img_group]
if is_flow:
for i in range(0, len(img_group), 2):
img_group[i] = mmcv.iminvert(img_group[i])
# 4a. div_255
if div_255:
img_group = [
mmcv.imnormalize(img, 0, 255, False) for img in img_group
]
# 4. normalize
if normalize:
img_group = [
mmcv.imnormalize(img, self.mean, self.std, self.to_rgb)
for img in img_group
]
# 5. pad
if self.size_divisor is not None:
img_group = [
mmcv.impad_to_multiple(img, self.size_divisor)
for img in img_group
]
pad_shape = img_group[0].shape
else:
pad_shape = img_shape
if is_flow:
assert len(img_group[0].shape) == 2
img_group = [
np.stack((flow_x, flow_y), axis=2)
for flow_x, flow_y in zip(img_group[0::2], img_group[1::2])
]
# 6. transpose
if len(img_shape) == 2:
img_group = [img[:, :, np.newaxis] for img in img_group]
img_group = [img.transpose(2, 0, 1) for img in img_group]
# Stack into numpy.array
img_group = np.stack(img_group, axis=0)
return img_group, img_shape, pad_shape, scale_factor, crop_quadruple
def __call__(self,
img_group,
scale,
crop_history=None,
flip=False,
keep_ratio=True,
div_255=False,
is_flow=False,
image_name=None):
if self.resize_crop or self.rescale_crop:
if self.afterdetect_resize:
img_group = [
cv2.resize(img, self.afterdetect_resize)
for img in img_group
]
img_group, crop_quadruple = self.op_crop(img_group)
img_shape = img_group[0].shape
scale_factor = None
else:
# 1. rescale
if keep_ratio:
tuple_list = [
mmcv.imrescale(img, scale, return_scale=True)
for img in img_group
]
img_group, scale_factors = list(zip(*tuple_list))
scale_factor = scale_factors[0]
else:
tuple_list = [
mmcv.imresize(img, scale, return_scale=True)
for img in img_group
]
img_group, w_scales, h_scales = list(zip(*tuple_list))
scale_factor = np.array(
[w_scales[0], h_scales[0], w_scales[0], h_scales[0]],
dtype=np.float32)
if self.pre_mean_volume is not None:
volume_len = self.pre_mean_volume.shape[0]
img_group = [
img - self.pre_mean_volume[i % volume_len, ...]
for i, img in enumerate(img_group)
]
# 2. crop (if necessary)
if crop_history is not None:
self.op_crop = GroupCrop(crop_history)
if self.op_crop is not None:
img_group, crop_quadruple = self.op_crop(img_group,
is_flow=is_flow)
else:
crop_quadruple = None
img_shape = img_group[0].shape
# import matplotlib.pyplot as plt
# import os
# for i in range(len(img_group)):
# plt.imshow(img_group[i])
# save_dir = os.path.join("show_fig",image_name.split("/")[-1])
# if not os.path.exists(save_dir):
# os.mkdir(save_dir)
# plt.savefig(os.path.join(save_dir,"{}".format(i)))
# 3. flip
if flip:
img_group = [mmcv.imflip(img) for img in img_group]
if is_flow:
for i in range(0, len(img_group), 2):
img_group[i] = mmcv.iminvert(img_group[i])
# 4a. div_255
if div_255:
img_group = [
mmcv.imnormalize(img, 0, 255, False) for img in img_group
]
# 4. normalize
img_group = [
mmcv.imnormalize(img, self.mean, self.std, self.to_rgb)
for img in img_group
]
# 5. pad
if self.size_divisor is not None:
img_group = [
mmcv.impad_to_multiple(img, self.size_divisor)
for img in img_group
]
pad_shape = img_group[0].shape
else:
pad_shape = img_shape
if is_flow:
assert len(img_group[0].shape) == 2
img_group = [
np.stack((flow_x, flow_y), axis=2)
for flow_x, flow_y in zip(img_group[0::2], img_group[1::2])
]
# 6. transpose
img_group = [img.transpose(2, 0, 1) for img in img_group]
# Stack into numpy.array
img_group = np.stack(img_group, axis=0)
return img_group, img_shape, pad_shape, scale_factor, crop_quadruple
def test_flip(self):
with pytest.raises(ValueError):
# direction must be in ['horizontal', 'vertical']
Flip(direction='vertically')
target_keys = ['imgs', 'flip_direction', 'modality']
# do not flip imgs.
imgs = list(np.random.rand(2, 64, 64, 3))
results = dict(imgs=copy.deepcopy(imgs), modality='RGB')
flip = Flip(flip_ratio=0, direction='horizontal')
flip_results = flip(results)
assert self.check_keys_contain(flip_results.keys(), target_keys)
assert np.array_equal(imgs, results['imgs'])
assert id(flip_results['imgs']) == id(results['imgs'])
assert np.shape(flip_results['imgs']) == np.shape(imgs)
# always flip imgs horizontally.
imgs = list(np.random.rand(2, 64, 64, 3))
results = dict(imgs=copy.deepcopy(imgs), modality='RGB')
flip = Flip(flip_ratio=1, direction='horizontal')
flip_results = flip(results)
assert self.check_keys_contain(flip_results.keys(), target_keys)
if flip_results['flip'] is True:
assert self.check_flip(imgs, flip_results['imgs'],
flip_results['flip_direction'])
assert id(flip_results['imgs']) == id(results['imgs'])
assert np.shape(flip_results['imgs']) == np.shape(imgs)
# flip flow images horizontally
imgs = [
np.arange(16).reshape(4, 4).astype(np.float32),
np.arange(16, 32).reshape(4, 4).astype(np.float32)
]
results = dict(imgs=copy.deepcopy(imgs), modality='Flow')
flip = Flip(flip_ratio=1, direction='horizontal')
flip_results = flip(results)
assert self.check_keys_contain(flip_results.keys(), target_keys)
imgs = [x.reshape(4, 4, 1) for x in imgs]
flip_results['imgs'] = [
x.reshape(4, 4, 1) for x in flip_results['imgs']
]
if flip_results['flip'] is True:
assert self.check_flip([imgs[0]],
[mmcv.iminvert(flip_results['imgs'][0])],
flip_results['flip_direction'])
assert self.check_flip([imgs[1]], [flip_results['imgs'][1]],
flip_results['flip_direction'])
assert id(flip_results['imgs']) == id(results['imgs'])
assert np.shape(flip_results['imgs']) == np.shape(imgs)
# always flip imgs vertivally.
imgs = list(np.random.rand(2, 64, 64, 3))
results = dict(imgs=copy.deepcopy(imgs), modality='RGB')
flip = Flip(flip_ratio=1, direction='vertical')
flip_results = flip(results)
assert self.check_keys_contain(flip_results.keys(), target_keys)
if flip_results['flip'] is True:
assert self.check_flip(imgs, flip_results['imgs'],
flip_results['flip_direction'])
assert id(flip_results['imgs']) == id(results['imgs'])
assert np.shape(flip_results['imgs']) == np.shape(imgs)
assert repr(flip) == (f'{flip.__class__.__name__}'
f'(flip_ratio={1}, direction=vertical, '
f'lazy={False})')
