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