def transform(images):
input, answer = copy.deepcopy(images)
# rotate
deg = np.random.choice(DEG_RANGE)
input = rotate_image(input, deg)
answer = rotate_image(answer, deg)
# resize
H, W = input.shape[1:]
h_resize = int(np.random.uniform(240, H * 2.0))
w_resize = int(np.random.uniform(320, W * 2.0))
input = chainercv.transforms.resize(input, (h_resize, w_resize))
answer = chainercv.transforms.resize(answer, (h_resize, w_resize))
# crop
input, slice = transforms.random_crop(input, (240, 320), return_param=True)
answer = answer[:, slice["y_slice"], slice['x_slice']]
# flip
input, param = transforms.random_flip(input,
x_random=True,
return_param=True)
if param['x_flip']:
transforms.flip(answer, x_flip=True)
# pca_lighting:
input = transforms.pca_lighting(input, sigma=5)
return resize((input, answer))
def __call__(self, in_data):
if len(in_data) == 6:
img, bbox, label, mask, crowd, area = in_data
elif len(in_data) == 4:
img, bbox, label, mask = in_data
else:
raise ValueError
img = img.transpose(2, 0, 1) # H, W, C -> C, H, W
if not self.train:
if len(in_data) == 6:
return img, bbox, label, mask, crowd, area
elif len(in_data) == 4:
return img, bbox, label, mask
else:
raise ValueError
imgs, sizes, scales = self.mask_rcnn.prepare([img])
# print(type(imgs))
# print(type(sizes))
# print(type(scales))
img = imgs[0]
H, W = sizes[0]
scale = scales[0]
_, o_H, o_W = img.shape
if len(bbox) > 0:
bbox = transforms.resize_bbox(bbox, (H, W), (o_H, o_W))
if len(mask) > 0:
mask = transforms.resize(
mask, size=(o_H, o_W), interpolation=0)
# # horizontally flip
# img, params = transforms.random_flip(
# img, x_random=True, return_param=True)
# bbox = transforms.flip_bbox(
# bbox, (o_H, o_W), x_flip=params['x_flip'])
# if mask.ndim == 2:
# mask = transforms.flip(
# mask[None, :, :], x_flip=params['x_flip'])[0]
# else:
# mask = transforms.flip(mask, x_flip=params['x_flip'])
# horizontally and vartically flip
img, params = transforms.random_flip(
img, y_random=True, x_random=True, return_param=True)
bbox = transforms.flip_bbox(
bbox, (o_H, o_W), y_flip=params['y_flip'], x_flip=params['x_flip'])
if mask.ndim == 2:
mask = transforms.flip(
mask[None, :, :], y_flip=params['y_flip'], x_flip=params['x_flip'])[0]
else:
mask = transforms.flip(mask, y_flip=params['y_flip'], x_flip=params['x_flip'])
return img, bbox, label, mask, scale, sizes
def test_rotate(self):
img = np.random.uniform(size=(3, 32, 24))
angle = random.uniform(0, 180)
out = rotate(img, angle)
expected = flip(img, x_flip=True)
expected = rotate(expected, -1 * angle)
expected = flip(expected, x_flip=True)
np.testing.assert_almost_equal(out, expected, decimal=6)
def __call__(self, in_data):
img, label = in_data
_, height, width = img.shape
scale = np.random.uniform(self.scale_range[0], self.scale_range[1])
# Scale
scaled_height = int(scale * height)
scaled_width = int(scale * width)
img = transforms.resize(img, (scaled_height, scaled_width),
PIL.Image.BICUBIC)
label = transforms.resize(label[None], (scaled_height, scaled_width),
PIL.Image.NEAREST)[0]
# Crop
if (scaled_height < self.crop_size[0]) or (scaled_width <
self.crop_size[1]):
shorter_side = min(img.shape[1:])
img, param = transforms.random_crop(img,
(shorter_side, shorter_side),
True)
else:
img, param = transforms.random_crop(img, self.crop_size, True)
label = label[param['y_slice'], param['x_slice']]
# Rotate
angle = np.random.uniform(-10, 10)
img = transforms.rotate(img, angle, expand=False)
label = transforms.rotate(label[None],
angle,
expand=False,
interpolation=PIL.Image.NEAREST,
fill=-1)[0]
# Resize
if ((img.shape[1] < self.crop_size[0])
or (img.shape[2] < self.crop_size[1])):
img = transforms.resize(img, self.crop_size, PIL.Image.BICUBIC)
if ((label.shape[0] < self.crop_size[0])
or (label.shape[1] < self.crop_size[1])):
label = transforms.resize(label[None].astype(np.float32),
self.crop_size, PIL.Image.NEAREST)
label = label.astype(np.int32)[0]
# heightorizontal flip
if self.horizontal_flip and np.random.rand() > 0.5:
img = transforms.flip(img, x_flip=True)
label = transforms.flip(label[None], x_flip=True)[0]
# Mean subtraction
img = img - self.mean
return img, label
def get_example(self, i):
imgpath, lblpath, polypath = self.pairs[i]
img = self.get_image(imgpath)
lbl = self.get_label(lblpath)
if random.random() < 0.5:
lbl = flip(lbl, x_flip=True)
img = flip(img, x_flip=True)
if self.labels_only:
return lbl
else:
return lbl, img
def transform(data):
x_img, y_img = data
x_flip, y_flip, rot = np.random.choice([True, False], 3)
# random flip
x_img = transforms.flip(x_img, y_flip=y_flip, x_flip=x_flip)
y_img = transforms.flip(y_img, y_flip=y_flip, x_flip=x_flip)
# # random rot
if rot:
x_img = np.rot90(x_img, axes=(-2, -1))
y_img = np.rot90(y_img, axes=(-2, -1))
return x_img, y_img
def get_example(self, i):
imgpath, lblpath, edgepath = self.pairs[i]
img = self.get_image(imgpath)
lbl = self.get_label(lblpath)
edg = self.get_edge(edgepath)
if random.random() < 0.5:
lbl = flip(lbl, x_flip=True)
img = flip(img, x_flip=True)
edg = flip(edg, x_flip=True)
if self.use_edge:
lbl = np.concatenate([lbl, edg], axis=0)
return lbl, img
def __call__(self, in_data):
if len(in_data) == 4:
img, mask, label, bbox = in_data
else:
img, bbox, label = in_data
# Flipping
img, params = transforms.random_flip(img,
x_random=True,
return_param=True)
x_flip = params['x_flip']
bbox = transforms.flip_bbox(bbox, img.shape[1:], x_flip=x_flip)
# Scaling and mean subtraction
img, scale = scale_img(img, self.min_size, self.max_size)
img -= self.mean
bbox = bbox * scale
if len(in_data) == 4:
mask = transforms.flip(mask, x_flip=x_flip)
mask = transforms.resize(mask.astype(np.float32),
img.shape[1:],
interpolation=PIL.Image.NEAREST).astype(
np.bool)
return img, bbox, label, mask
else:
return img, bbox, label
def test_random_flip_vertical(self):
img = np.random.uniform(size=(3, 24, 24))
out = flip(img, x_flip=False, y_flip=True)
expected = img
expected = expected[:, ::-1, :]
np.testing.assert_equal(out, expected)
def test_random_flip_vertical(self):
img = np.random.uniform(size=(3, 24, 24))
out = flip(img, y_flip=True, x_flip=False)
expected = img
expected = expected[:, ::-1, :]
np.testing.assert_equal(out, expected)
def test_random_flip(self):
img = np.random.uniform(size=(3, 24, 24))
out = flip(img, horizontal=True, vertical=True)
expected = img
expected = expected[:, :, ::-1]
expected = expected[:, ::-1, :]
np.testing.assert_equal(out, expected)
def test_rotate(self):
img = np.random.uniform(size=(3, 32, 24))
angle = random.uniform(-180, 180)
out = rotate(img,
angle,
fill=self.fill,
interpolation=self.interpolation)
expected = flip(img, x_flip=True)
expected = rotate(expected,
-1 * angle,
fill=self.fill,
interpolation=self.interpolation)
expected = flip(expected, x_flip=True)
if self.interpolation == PIL.Image.NEAREST:
assert np.mean(out == expected) > 0.99
else:
np.testing.assert_almost_equal(out, expected, decimal=6)
def test_rotate_pil(self):
chainer.global_config.cv_rotate_backend = 'PIL'
img = np.random.uniform(0, 256, size=self.size).astype(np.float32)
angle = random.uniform(-180, 180)
out = rotate(img,
angle,
fill=self.fill,
interpolation=self.interpolation)
expected = flip(img, x_flip=True)
expected = rotate(expected,
-1 * angle,
fill=self.fill,
interpolation=self.interpolation)
expected = flip(expected, x_flip=True)
if self.interpolation == PIL.Image.NEAREST:
assert np.mean(out == expected) > 0.99
else:
np.testing.assert_almost_equal(out, expected, decimal=3)
def __call__(self, in_data):
if len(in_data) == 6:
img, bbox, label, mask, crowd, area = in_data
elif len(in_data) == 4:
img, bbox, label, mask = in_data
else:
raise ValueError
img = img.transpose(2, 0, 1) # H, W, C -> C, H, W
if not self.train:
if len(in_data) == 6:
return img, bbox, label, mask, crowd, area
elif len(in_data) == 4:
return img, bbox, label, mask
else:
raise ValueError
_, H, W = img.shape
img = self.mask_rcnn.prepare(img)
_, o_H, o_W = img.shape
scale = o_H / H
if len(bbox) > 0:
bbox = transforms.resize_bbox(bbox, (H, W), (o_H, o_W))
if len(mask) > 0:
mask = transforms.resize(
mask, size=(o_H, o_W), interpolation=0)
# horizontally flip
img, params = transforms.random_flip(
img, x_random=True, return_param=True)
bbox = transforms.flip_bbox(
bbox, (o_H, o_W), x_flip=params['x_flip'])
if mask.ndim == 2:
mask = transforms.flip(
mask[None, :, :], x_flip=params['x_flip'])[0]
else:
mask = transforms.flip(mask, x_flip=params['x_flip'])
return img, bbox, label, mask, scale
def __call__(self, in_data):
img, label = in_data
# img = transforms.resize(img, self.size)
img = transforms.random_crop(img, self.size)
img = transforms.flip(img, y_flip=self.y_flip, x_flip=self.x_flip)
img = transforms.random_rotate(img)
######################## perimage normalize #############
ms_im = img.reshape((img.shape[0], -1))
mean = np.mean(ms_im, axis=1)[:, np.newaxis, np.newaxis]
std = np.std(ms_im, axis=1)[:, np.newaxis, np.newaxis]
img = (img - mean) / (std + 0.0000001)
####################################################
return img, label
def flip(image, zyx, vu, camera, x_flip=False, y_flip=False):
C, H, W = image.shape
zyx_flipped = flip_point_zyx(camera,
zyx, (H, W),
x_flip=x_flip,
y_flip=y_flip)
image_flipped = transforms.flip(image, x_flip=x_flip, y_flip=y_flip)
vu_flipped = transforms.flip_point(
vu,
(H, W),
x_flip=x_flip,
y_flip=y_flip,
)
return image_flipped, zyx_flipped, vu_flipped
def __call__(self, in_data):
img, mask, label = in_data
bbox = mask_to_bbox(mask)
_, orig_H, orig_W = img.shape
img = self.fcis.prepare(img)
_, H, W = img.shape
scale = H / orig_H
mask = transforms.resize(mask.astype(np.float32), (H, W))
bbox = transforms.resize_bbox(bbox, (orig_H, orig_W), (H, W))
img, params = transforms.random_flip(img,
x_random=True,
return_param=True)
mask = transforms.flip(mask, x_flip=params['x_flip'])
bbox = transforms.flip_bbox(bbox, (H, W), x_flip=params['x_flip'])
return img, mask, label, bbox, scale
def __call__(self, in_data):
if len(in_data) == 5:
img, label, bbox, mask, i = in_data
elif len(in_data) == 4:
img, bbox, label, i = in_data
_, H, W = img.shape
img = self.net.prepare(img)
_, o_H, o_W = img.shape
scale = o_H / H
if len(bbox) == 0:
return img, [], [], 1
bbox = resize_bbox(bbox, (H, W), (o_H, o_W))
mask = resize(mask, (o_H, o_W))
#horizontal flip
img, params = transforms.random_flip(img,
x_random=True,
return_param=True)
bbox = transforms.flip_bbox(bbox, (o_H, o_W), x_flip=params['x_flip'])
mask = transforms.flip(mask, x_flip=params['x_flip'])
cv2.imwrite("gt_roi.png", mask[0] * 255)
return img, bbox, label, scale, mask
def __call__(self, in_data):
if len(in_data)==5:
img, label, bbox, mask, i = in_data
elif len(in_data)==4:
img, bbox, label, i= in_data
label = [self.labelids.index(l) + 1 for l in label]
_, H, W = img.shape
if chainer.config.train:
img = self.net.prepare(img)
_, o_H, o_W = img.shape
scale = o_H / H
if len(bbox)==0:
return img, [],[],1
bbox = resize_bbox(bbox, (H, W), (o_H, o_W))
mask = resize(mask,(o_H, o_W))
if chainer.config.train:
#horizontal flip
img, params = transforms.random_flip(
img, x_random=True, return_param=True)
bbox = transforms.flip_bbox(
bbox, (o_H, o_W), x_flip=params['x_flip'])
mask = transforms.flip(mask, x_flip=params['x_flip'])
return img, bbox, label, scale, mask, i
def __call__(self, in_data):
image, label, bbox, mask = in_data
_, H, W = image.shape
cell_size = 32 * self.downscale
# Horizontal flip
if self.options['x_flip']:
if np.random.randint(2) == 0:
image = transforms.flip(image, x_flip=True)
bbox = transforms.flip_bbox(bbox, (H, W), x_flip=True)
mask = transforms.flip(mask, x_flip=True)
# Random rotation (90 or 270 degrees)
if self.options['rotate90']:
assert H == W, 'Height and width must match when `rotate90` is set.'
if np.random.randint(2) == 0: # Rotate?
if np.random.randint(2) == 0: # Counter-clockwise?
bbox = rotate_bbox(bbox, 1, (H, W))
image = np.rot90(image, 1, axes=(1, 2))
mask = np.rot90(mask, 1, axes=(1, 2))
else:
bbox = rotate_bbox(bbox, 3, (H, W))
image = np.rot90(image, 3, axes=(1, 2))
mask = np.rot90(mask, 3, axes=(1, 2))
_, H, W = image.shape
# Zoom in / zoom out
if self.options['zoom'] > 1:
assert self.options[
'scale'] <= 1.0, "`scale` shouldn't be set if `zoom` is set."
max_log_zoom = np.log(self.options['zoom'])
log_zoom = np.random.random() * 2 * max_log_zoom - max_log_zoom
zoom = np.exp(log_zoom)
if zoom > 1:
# Zoom in
y_size, x_size = int(H / zoom), int(W / zoom)
y_offset = np.random.randint(H - y_size + 1)
x_offset = np.random.randint(W - x_size + 1)
y_slice = slice(y_offset, y_offset + y_size)
x_slice = slice(x_offset, x_offset + x_size)
bbox = transforms.crop_bbox(bbox, y_slice, x_slice)
bbox *= zoom
image = transforms.resize(image[:, y_slice, x_slice], (H, W))
mask = transforms.resize(mask[:, y_slice, x_slice], (H, W),
interpolation=Image.NEAREST)
elif zoom < 1:
# Zoom out
y_size, x_size = int(H / zoom), int(W / zoom)
y_offset = np.random.randint(y_size - H + 1)
x_offset = np.random.randint(x_size - W + 1)
bbox = transforms.translate_bbox(bbox, y_offset, x_offset)
new_image = np.zeros((1, y_size, x_size), dtype=np.float32)
new_image[:, y_offset:y_offset + H,
x_offset:x_offset + W] = image
new_mask = np.zeros((1, y_size, x_size), dtype=np.float32)
new_mask[:, y_offset:y_offset + H,
x_offset:x_offset + W] = mask
bbox *= zoom
image = transforms.resize(new_image, (H, W))
mask = transforms.resize(new_mask, (H, W),
interpolation=Image.NEAREST)
# Random scale
if self.options['scale'] > 1.0:
assert self.options[
'crop'], '`crop` must be set if `scale` is set.'
max_log_scale = np.log(self.options['scale'])
log_scale = np.random.random() * 2 * max_log_scale - max_log_scale
scale = np.exp(log_scale)
image = transforms.resize(image, (int(H * scale), int(W * scale)))
mask = transforms.resize(mask, (int(H * scale), int(W * scale)),
interpolation=Image.NEAREST)
_, H, W = image.shape
bbox *= scale
# Random crop
if self.options['crop']:
y_margin = (H - 1) % cell_size + 1
x_margin = (W - 1) % cell_size + 1
y_offset = np.random.randint(y_margin)
x_offset = np.random.randint(x_margin)
y_size = H - y_margin
x_size = W - x_margin
y_slice = slice(y_offset, y_offset + y_size)
x_slice = slice(x_offset, x_offset + x_size)
image = image[:, y_slice, x_slice]
bbox = transforms.crop_bbox(bbox, y_slice, x_slice)
mask = mask[:, y_slice, x_slice]
# Change window width
if self.options['window_width'] > 1.0:
image = (image - 128) * self.options['window_width'] + 128
# Change contrast
if self.options['contrast']:
image += np.random.randint(self.options['contrast'] * 2 +
1) - self.options['contrast']
image = np.clip(image, 0, 255)
# save_data(image, bbox, mask)
return image, label, bbox, mask
def _transform(inputs,
mean=None,
crop_size=(512, 512),
color_sigma=25.5,
scale=[0.5, 2.0],
rotate=False,
fliplr=False,
n_class=20):
img, label = inputs
# Scaling
if scale:
if isinstance(scale, (list, tuple)):
scale = np.random.uniform(scale[0], scale[1])
scaled_h = int(img.shape[1] * scale)
scaled_w = int(img.shape[2] * scale)
img = transforms.resize(img, (scaled_h, scaled_w), Image.BICUBIC)
label = transforms.resize(label[None, ...], (scaled_h, scaled_w),
Image.NEAREST)[0]
# Crop
if crop_size is not None:
if (img.shape[1] < crop_size[0]) or (img.shape[2] < crop_size[1]):
shorter_side = min(img.shape[1:])
_crop_size = (shorter_side, shorter_side)
img, param = transforms.random_crop(img, _crop_size, True)
else:
img, param = transforms.random_crop(img, crop_size, True)
label = label[param['y_slice'], param['x_slice']]
# Rotate
if rotate:
angle = np.random.uniform(-10, 10)
rows, cols = img.shape[1:]
img = img.transpose(1, 2, 0)
r = cv.getRotationMatrix2D((cols // 2, rows // 2), angle, 1)
img = cv.warpAffine(img, r, (cols, rows)).transpose(2, 0, 1)
r = cv.getRotationMatrix2D((cols // 2, rows // 2), angle, 1)
label = cv.warpAffine(label,
r, (cols, rows),
flags=cv.INTER_NEAREST,
borderValue=-1)
# Resize
if crop_size is not None:
if (img.shape[1] < crop_size[0]) or (img.shape[2] < crop_size[1]):
img = transforms.resize(img, crop_size, Image.BICUBIC)
if (label.shape[0] < crop_size[0]) or (label.shape[1] < crop_size[1]):
label = transforms.resize(label[None, ...].astype(np.float32),
crop_size, Image.NEAREST)
label = label.astype(np.int32)[0]
# Mean subtraction
if mean is not None:
img -= mean[:, None, None]
# LR-flipping
if fliplr:
if np.random.rand() > 0.5:
img = transforms.flip(img, x_flip=True)
label = transforms.flip(label[None, ...], x_flip=True)[0]
# Color augmentation
if color_sigma is not None:
img = transforms.pca_lighting(img, color_sigma)
assert label.max() < n_class, '{}'.format(label.max())
if crop_size is not None:
assert img.shape == (3, crop_size[0], crop_size[1]), \
'{} != {}'.format(img.shape, crop_size)
assert label.shape == (crop_size[0], crop_size[1]), \
'{} != {}'.format(label.shape, crop_size)
return img, label
