def test_stream_serializes_correctly(): ppl = slc.Stream([ slt.RandomRotate(rotation_range=(-90, 90)), slt.RandomRotate(rotation_range=(-90, 90)), slt.RandomRotate(rotation_range=(-90, 90)), slt.RandomProjection( slc.Stream([ slt.RandomRotate(rotation_range=(-90, 90)), ])) ]) serialized = ppl.serialize() for i, el in enumerate(serialized): if i < len(serialized) - 1: assert el == 'RandomRotate' assert serialized[el]['p'] == 0.5 assert serialized[el]['interpolation'] == ('bilinear', 'inherit') assert serialized[el]['padding'] == ('z', 'inherit') assert serialized[el]['range'] == (-90, 90) else: assert el == 'RandomProjection' assert serialized[el]['transforms']['RandomRotate']['p'] == 0.5 assert serialized[el]['transforms']['RandomRotate'][ 'interpolation'] == ('bilinear', 'inherit') assert serialized[el]['transforms']['RandomRotate']['padding'] == ( 'z', 'inherit') assert serialized[el]['transforms']['RandomRotate']['range'] == ( -90, 90)
def get_landmark_transform(config): return transforms.Compose([ # WrapImageLandmarksSOLT(), slc.Stream([ slt.RandomFlip(p=0.5, axis=1), slt.RandomScale(range_x=(0.8, 1.2), p=1), slt.RandomRotate(rotation_range=(-180, 180), p=0.2), slt.RandomProjection(affine_transforms=slc.Stream([ slt.RandomScale(range_x=(0.8, 1.3), p=1), slt.RandomRotate(rotation_range=(-180, 180), p=1), slt.RandomShear(range_x=(-0.1, 0.1), range_y=(0, 0), p=0.5), slt.RandomShear(range_y=(-0.1, 0.1), range_x=(0, 0), p=0.5), ]), v_range=(1e-5, 2e-3), p=0.8), slt.PadTransform(int(config.dataset.crop_size * 1.4), padding='z'), slt.CropTransform(config.dataset.crop_size, crop_mode='r'), slc.SelectiveStream([ slt.ImageSaltAndPepper(p=1, gain_range=0.01), slt.ImageBlur(p=1, blur_type='g', k_size=(3, 5)), slt.ImageBlur(p=1, blur_type='m', k_size=(3, 5)), slt.ImageAdditiveGaussianNoise(p=1, gain_range=0.5), slc.Stream([ slt.ImageSaltAndPepper(p=1, gain_range=0.05), slt.ImageBlur(p=0.5, blur_type='m', k_size=(3, 5)), ]), slc.Stream([ slt.ImageBlur(p=0.5, blur_type='m', k_size=(3, 5)), slt.ImageSaltAndPepper(p=1, gain_range=0.01), ]), slc.Stream() ]), slt.ImageGammaCorrection(p=1, gamma_range=(0.5, 1.5)) ]), SOLTtoHourGlassGSinput(downsample=4, sigma=3), ApplyTransformByIndex(transform=dwutils.npg2tens, ids=[0, 1]), ])
def test_projection_empty_sampling_from_many_low_prob_trf(): trf = slt.RandomProjection(affine_transforms=slc.Stream( [slt.RandomRotate(p=0), slt.RandomRotate(p=0), slt.RandomRotate(p=0)]), p=1) trf.sample_transform() assert np.array_equal(trf.state_dict['transform_matrix'], np.eye(3))
def test_selective_stream_too_many_probs(): with pytest.raises(ValueError): slc.SelectiveStream([ slt.RandomRotate(rotation_range=(90, 90), p=1), slt.RandomRotate(rotation_range=(-90, -90), p=1), ], n=2, probs=[0.4, 0.3, 0.3])
def test_value_error_when_optimizeing_wrong_elements_transforms_list(): trfs = [ slt.RandomRotate(rotation_range=(90, 90), p=1), slt.RandomRotate(rotation_range=(-90, -90), p=1), lambda x: x**2 ] with pytest.raises(TypeError): slc.Stream.optimize_stack(trfs)
def test_nested_streams_are_not_fused_with_matrix_trf(): trfs = [ slt.RandomRotate(rotation_range=(90, 90), p=1), slt.RandomRotate(rotation_range=(-90, -90), p=1), slc.Stream([ slt.RandomRotate(rotation_range=(90, 90), p=1), ]), slt.RandomRotate(rotation_range=(-90, -90), p=1), ] trfs_optimized = slc.Stream.optimize_stack(trfs) assert trfs_optimized[-2] == trfs[-2]
def test_selective_stream_low_prob_transform_should_not_change_the_data( img_5x5): img = img_5x5 dc = sld.DataContainer((img, ), 'I') ppl = slc.SelectiveStream([ slt.RandomRotate(rotation_range=(90, 90), p=0), slt.RandomRotate(rotation_range=(-90, -90), p=0) ]) dc_res = ppl(dc) np.array_equal(dc.data, dc_res.data)
def test_stream_settings(): ppl = slc.Stream([ slt.RandomRotate((45, 45), interpolation='bicubic', padding='z', p=1), slt.RandomRotate((45, 45), padding='r', p=1), slt.RandomRotate((45, 45), interpolation='bicubic', padding='z', p=1), slt.RandomShear(0.1, 0.1, interpolation='bilinear', padding='z'), ], interpolation='nearest', padding='z') for trf in ppl.transforms: assert trf.interpolation[0] == 'nearest' assert trf.padding[0] == 'z'
def test_selective_pipeline_selects_transforms_and_does_the_fusion(): ppl = slc.SelectiveStream([ slt.RandomRotate(rotation_range=(90, 90), p=1), slt.RandomRotate(rotation_range=(-90, -90), p=1), ], n=2, probs=[0.5, 0.5]) kpts_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]).reshape((4, 2)) kpts = sld.KeyPoints(kpts_data, 3, 4) dc = sld.DataContainer(kpts, 'P') dc_res = ppl(dc) assert np.array_equal(np.eye(3), ppl.transforms[0].state_dict['transform_matrix'])
def init_mnist_cifar_transforms(n_channels=1, stage='train'): if n_channels == 1: norm_mean_std = Normalize((0.1307, ), (0.3081, )) elif n_channels == 3: norm_mean_std = Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261)) else: raise ValueError("Not support channels of {}".format(n_channels)) train_trf = Compose([ wrap2solt, slc.Stream([ slt.RandomScale(range_x=(0.9, 1.1), same=False, p=0.5), slt.RandomShear(range_x=(-0.05, 0.05), p=0.5), slt.RandomRotate(rotation_range=(-5, 5), p=0.5), slt.PadTransform(pad_to=34), slt.CropTransform(crop_size=32, crop_mode='r') ]), unpack_solt, ApplyTransform(norm_mean_std) ]) if stage == 'train': return train_trf test_trf = Compose([ wrap2solt, slt.PadTransform(pad_to=32), unpack_solt, ApplyTransform(norm_mean_std) ]) return test_trf
def custom_augment(img): tr = Compose([ wrap2solt, slc.Stream([ slt.ResizeTransform(resize_to=(32, 32), interpolation='bilinear'), slt.RandomScale(range_x=(0.9, 1.1), same=False, p=0.5), slt.RandomFlip(axis=1, p=0.5), # slt.RandomShear(range_x=(-0.05, 0.05), p=0.5), # slt.RandomRotate(rotation_range=(-10, 10), p=0.5), slt.RandomRotate(rotation_range=(-5, 5), p=0.5), slt.PadTransform(pad_to=36), slt.CropTransform(crop_size=32, crop_mode='r'), slt.ImageAdditiveGaussianNoise(p=1.0) ]), unpack_solt, ApplyTransform(norm_mean_std) ]) if len(img.shape) == 3: imgs = np.expand_dims(img, axis=0) elif len(img.shape) == 4: imgs = img else: raise ValueError('Expect num of dims 3 or 4, but got {}'.format( len(img.shape))) out_imgs = [] for b in range(imgs.shape[0]): _img = imgs[b, :].astype(np.uint8) _img, _ = tr((_img, 0)) out_imgs.append(_img) return torch.stack(out_imgs, dim=0)
def init_mnist_transforms(): train_trf = Compose([ wrap2solt, slc.Stream([ slt.ResizeTransform(resize_to=(64, 64), interpolation='bilinear'), slt.RandomScale(range_x=(0.9, 1.1), same=False, p=0.5), slt.RandomShear(range_x=(-0.05, 0.05), p=0.5), slt.RandomRotate(rotation_range=(-10, 10), p=0.5), # slt.RandomRotate(rotation_range=(-5, 5), p=0.5), slt.PadTransform(pad_to=70), slt.CropTransform(crop_size=64, crop_mode='r'), slt.ImageAdditiveGaussianNoise(p=1.0) ]), unpack_solt, ApplyTransform(Normalize((0.5, ), (0.5, ))) ]) test_trf = Compose([ wrap2solt, slt.ResizeTransform(resize_to=(64, 64), interpolation='bilinear'), # slt.PadTransform(pad_to=64), unpack_solt, ApplyTransform(Normalize((0.5, ), (0.5, ))), ]) return train_trf, test_trf
def get_wrist_fracture_transformation(crop_size): return transforms.Compose([ SplitDataToFunction(wrap_img_target_solt), slc.Stream([ slt.RandomFlip(p=1, axis=1), slt.RandomProjection(affine_transforms=slc.Stream([ slt.RandomScale(range_x=(0.8, 1.2), p=1), slt.RandomShear(range_x=(-0.1, 0.1), p=0.5), slt.RandomShear(range_y=(-0.1, 0.1), p=0.5), slt.RandomRotate(rotation_range=(-10, 10), p=1), ]), v_range=(1e-5, 5e-4), p=0.8), slt.PadTransform(pad_to=(256, 256), padding='z'), slt.CropTransform(crop_size, crop_mode='r'), slc.SelectiveStream([ slc.SelectiveStream([ slt.ImageSaltAndPepper(p=1, gain_range=0.01), slt.ImageBlur(p=0.5, blur_type='m', k_size=(11, )), ]), slt.ImageAdditiveGaussianNoise(p=1, gain_range=0.5), ]), slt.ImageGammaCorrection(p=1, gamma_range=(0.5, 1.5)), ]), DataToFunction(solt_to_img_target), ApplyByIndex(transforms.ToTensor(), 0) ])
def test_transforms_are_serialized_with_state_when_needed(): trf = slt.RandomRotate(rotation_range=(-90, 90)) serialized = trf.serialize(include_state=True) assert 'dict' in serialized np.testing.assert_array_equal(serialized['dict']['transform_matrix'], np.eye(3))
def test_rotate_90_img_mask_keypoints(img_3x3, mask_3x3): # Setting up the data kpts_data = np.array([[0, 0], [0, 2], [2, 2], [2, 0]]).reshape((4, 2)) kpts = sld.KeyPoints(kpts_data, 3, 3) img, mask = img_3x3, mask_3x3 H, W = mask.shape dc = sld.DataContainer((img, mask, kpts, 1), 'IMPL') # Defining the 90 degrees transform (clockwise) stream = slt.RandomRotate(rotation_range=(90, 90), p=1) dc_res = stream(dc) img_res, _ = dc_res[0] mask_res, _ = dc_res[1] kpts_res, _ = dc_res[2] label_res, _ = dc_res[3] M = cv2.getRotationMatrix2D((W // 2, H // 2), -90, 1) expected_img_res = cv2.warpAffine(img, M, (W, H)).reshape((H, W, 1)) expected_mask_res = cv2.warpAffine(mask, M, (W, H)) expected_kpts_res = np.array([[2, 0], [0, 0], [0, 2], [2, 2]]).reshape( (4, 2)) assert np.array_equal(expected_img_res, img_res) assert np.array_equal(expected_mask_res, mask_res) np.testing.assert_array_almost_equal(expected_kpts_res, kpts_res.data) assert label_res == 1
def custom_augment(img): if len(img.shape) == 3: imgs = img.expand_dims(img, axis=0) else: imgs = img out_imgs = [] for b in range(img.shape[0]): img1 = imgs[b, :, :, 0:1].astype(np.uint8) img2 = imgs[b, :, :, 1:2].astype(np.uint8) tr = Compose([ wrap2solt, slc.Stream([ slt.ImageAdditiveGaussianNoise(p=0.5, gain_range=0.3), slt.RandomRotate(p=1, rotation_range=(-10, 10)), slt.PadTransform(pad_to=int(STD_SZ[0] * 1.05)), slt.CropTransform(crop_size=STD_SZ[0], crop_mode='r'), slt.ImageGammaCorrection(p=0.5, gamma_range=(0.5, 1.5)), ]), unpack_solt, ApplyTransform(Normalize((0.5, ), (0.5, ))) ]) img1, _ = tr((img1, 0)) img2, _ = tr((img2, 0)) out_img = torch.cat((img1, img2), dim=0) out_imgs.append(out_img) out_imgs = torch.stack(out_imgs, dim=0) return out_imgs
def test_matrix_transforms_state_reset(img_5x5, ignore_state, pipeline): n_iter = 50 if pipeline: ppl = slc.Stream([ slt.RandomRotate(rotation_range=(-180, 180), p=1, ignore_state=ignore_state), slt.PadTransform(pad_to=(10, 10)), ]) else: ppl = slt.RandomRotate(rotation_range=(-180, 180), p=1, ignore_state=ignore_state) img_test = img_5x5.copy() img_test[0, 0] = 1 random.seed(42) trf_not_eq = 0 imgs_not_eq = 0 for i in range(n_iter): dc1 = sld.DataContainer((img_test.copy(), ), 'I') dc2 = sld.DataContainer((img_test.copy(), ), 'I') dc1_res = ppl(dc1).data[0].squeeze() if pipeline: trf_state1 = ppl.transforms[0].state_dict[ 'transform_matrix_corrected'] else: trf_state1 = ppl.state_dict['transform_matrix_corrected'] dc2_res = ppl(dc2).data[0].squeeze() if pipeline: trf_state2 = ppl.transforms[0].state_dict[ 'transform_matrix_corrected'] else: trf_state2 = ppl.state_dict['transform_matrix_corrected'] if not np.array_equal(trf_state1, trf_state2): trf_not_eq += 1 if not np.array_equal(dc1_res, dc2_res): imgs_not_eq += 1 random.seed(None) assert trf_not_eq > n_iter // 2 assert imgs_not_eq > n_iter // 2
def test_matrix_transforms_use_cache_for_different_dc_items_raises_error( img_5x5, mask_3x4, pipeline): dc = sld.DataContainer((img_5x5, mask_3x4), 'IM') if pipeline: ppl = slc.Stream([ slt.RandomRotate(rotation_range=(-180, 180), p=1, ignore_state=False), slt.PadTransform(pad_to=(10, 10)), ]) else: ppl = slt.RandomRotate(rotation_range=(-180, 180), p=1, ignore_state=False) with pytest.raises(ValueError): ppl(dc)
def get_landmark_transform_kneel(config): cutout = slt.ImageCutOut( cutout_size=(int(config.dataset.cutout * config.dataset.augs.crop.crop_x), int(config.dataset.cutout * config.dataset.augs.crop.crop_y)), p=0.5) ppl = transforms.Compose([ slc.Stream(), slc.SelectiveStream( [ slc.Stream([ slt.RandomFlip(p=0.5, axis=1), slt.RandomProjection(affine_transforms=slc.Stream([ slt.RandomScale(range_x=(0.9, 1.1), p=1), slt.RandomRotate(rotation_range=(-90, 90), p=1), slt.RandomShear( range_x=(-0.1, 0.1), range_y=(-0.1, 0.1), p=0.5), slt.RandomShear( range_x=(-0.1, 0.1), range_y=(-0.1, 0.1), p=0.5), ]), v_range=(1e-5, 2e-3), p=0.5), # slt.RandomScale(range_x=(0.5, 2.5), p=0.5), ]), slc.Stream() ], probs=[0.7, 0.3]), slc.Stream([ slt.PadTransform( (config.dataset.augs.pad.pad_x, config.dataset.augs.pad.pad_y), padding='z'), slt.CropTransform((config.dataset.augs.crop.crop_x, config.dataset.augs.crop.crop_y), crop_mode='r'), ]), slc.SelectiveStream([ slt.ImageSaltAndPepper(p=1, gain_range=0.01), slt.ImageBlur(p=1, blur_type='g', k_size=(3, 5)), slt.ImageBlur(p=1, blur_type='m', k_size=(3, 5)), slt.ImageAdditiveGaussianNoise(p=1, gain_range=0.5), slc.Stream([ slt.ImageSaltAndPepper(p=1, gain_range=0.05), slt.ImageBlur(p=0.5, blur_type='m', k_size=(3, 5)), ]), slc.Stream([ slt.ImageBlur(p=0.5, blur_type='m', k_size=(3, 5)), slt.ImageSaltAndPepper(p=1, gain_range=0.01), ]), slc.Stream() ], n=1), slt.ImageGammaCorrection(p=0.5, gamma_range=(0.5, 1.5)), cutout if config.dataset.use_cutout else slc.Stream(), DataToFunction(solt_to_img_target), ApplyByIndex(transforms.ToTensor(), 0) ]) return ppl
def test_rotate_90_trnsforms_have_same_bahaviour(k): trf_1 = slt.RandomRotate(rotation_range=(k * 90, k * 90), p=1) trf_1.sample_transform() trf_2 = slt.RandomRotate90(k=k, p=1) trf_2.sample_transform() assert np.array_equal(trf_1.state_dict['transform_matrix'], trf_2.state_dict['transform_matrix'])
def __init__(self): self.imgaug_transform = iaa.Affine(rotate=(45, 45), order=1, mode="reflect") self.augmentor_op = Operations.RotateStandard(probability=1, max_left_rotation=45, max_right_rotation=45) self.solt_stream = slc.Stream( [slt.RandomRotate(p=1, rotation_range=(45, 45))], padding="r")
def init_transforms(nc=1): if nc == 1: norm_mean_std = Normalize((0.1307, ), (0.3081, )) elif nc == 3: norm_mean_std = Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261)) else: raise ValueError("Not support channels of {}".format(nc)) train_trf = Compose([ wrap2solt, slc.Stream([ # slt.ResizeTransform(resize_to=(32, 32), interpolation='bilinear'), slt.RandomScale(range_x=(0.95, 1.05), same=False, p=0.5), # slt.RandomShear(range_x=(-0.05, 0.05), p=0.5), slt.RandomRotate(rotation_range=(-10, 10), p=0.5), slt.RandomFlip(p=0.5, axis=1), # slt.RandomRotate(rotation_range=(-5, 5), p=0.5), slt.RandomTranslate(range_x=3, range_y=3), # slt.PadTransform(pad_to=34), # slt.CropTransform(crop_size=32, crop_mode='r'), # slt.ImageAdditiveGaussianNoise(p=1.0) ]), unpack_solt, ApplyTransform(norm_mean_std) ]) test_trf = Compose([ wrap2solt, slt.ResizeTransform(resize_to=(32, 32), interpolation='bilinear'), unpack_solt, ApplyTransform(norm_mean_std) ]) def custom_augment(img): tr = Compose([ wrap2solt, slc.Stream([ slt.ResizeTransform(resize_to=(32, 32), interpolation='bilinear'), slt.RandomScale(range_x=(0.9, 1.1), same=False, p=0.5), slt.RandomShear(range_x=(-0.05, 0.05), p=0.5), slt.RandomRotate(rotation_range=(-10, 10), p=0.5), # slt.RandomRotate(rotation_range=(-5, 5), p=0.5), slt.PadTransform(pad_to=36), slt.CropTransform(crop_size=32, crop_mode='r'), slt.ImageAdditiveGaussianNoise(p=1.0) ]), unpack_solt, ApplyTransform(norm_mean_std) ]) img_tr, _ = tr((img, 0)) return img_tr return train_trf, test_trf, custom_augment
def test_fusion_happens(): ppl = slc.Stream([ slt.RandomScale((0.5, 1.5), (0.5, 1.5), p=1), slt.RandomRotate((-50, 50), padding='z', p=1), slt.RandomShear((-0.5, 0.5), (-0.5, 0.5), padding='z', p=1), slt.RandomFlip(p=1, axis=1), ]) st = ppl.optimize_stack(ppl.transforms) assert len(st) == 2
def test_stream_settings_strict(): ppl = slc.Stream([ slt.RandomRotate((45, 45), interpolation='bicubic', padding='z', p=1), slt.RandomRotate((45, 45), padding='r', p=1), slt.RandomRotate((45, 45), interpolation=('bicubic', 'strict'), padding=('r', 'strict'), p=1), slt.RandomShear(0.1, 0.1, interpolation='bilinear', padding='z'), ], interpolation='nearest', padding='z') for idx, trf in enumerate(ppl.transforms): if idx == 2: assert trf.interpolation[0] == 'bicubic' assert trf.padding[0] == 'r' else: assert trf.interpolation[0] == 'nearest' assert trf.padding[0] == 'z'
def test_stream_nested_settings(): ppl = slc.Stream([ slt.RandomRotate((45, 45), interpolation='bicubic', padding='z', p=1), slt.RandomRotate((45, 45), padding='r', p=1), slc.Stream([ slt.RandomRotate( (45, 45), interpolation='bicubic', padding='z', p=1), slt.RandomRotate((45, 45), padding='r', p=1), ], interpolation='bicubic', padding='r') ], interpolation='nearest', padding='z') trfs = ppl.transforms[:2] + ppl.transforms[-1].transforms for idx, trf in enumerate(trfs): assert trf.interpolation[0] == 'nearest' assert trf.padding[0] == 'z'
def init_augs(): kvs = GlobalKVS() args = kvs['args'] cutout = slt.ImageCutOut(cutout_size=(int(args.cutout * args.crop_x), int(args.cutout * args.crop_y)), p=0.5) # plus-minus 1.3 pixels jitter = slt.KeypointsJitter(dx_range=(-0.003, 0.003), dy_range=(-0.003, 0.003)) ppl = tvt.Compose([ jitter if args.use_target_jitter else slc.Stream(), slc.SelectiveStream([ slc.Stream([ slt.RandomFlip(p=0.5, axis=1), slt.RandomProjection(affine_transforms=slc.Stream([ slt.RandomScale(range_x=(0.8, 1.3), p=1), slt.RandomRotate(rotation_range=(-90, 90), p=1), slt.RandomShear( range_x=(-0.1, 0.1), range_y=(-0.1, 0.1), p=0.5), ]), v_range=(1e-5, 2e-3), p=0.5), slt.RandomScale(range_x=(0.5, 2.5), p=0.5), ]), slc.Stream() ], probs=[0.7, 0.3]), slc.Stream([ slt.PadTransform((args.pad_x, args.pad_y), padding='z'), slt.CropTransform((args.crop_x, args.crop_y), crop_mode='r'), ]), slc.SelectiveStream([ slt.ImageSaltAndPepper(p=1, gain_range=0.01), slt.ImageBlur(p=1, blur_type='g', k_size=(3, 5)), slt.ImageBlur(p=1, blur_type='m', k_size=(3, 5)), slt.ImageAdditiveGaussianNoise(p=1, gain_range=0.5), slc.Stream([ slt.ImageSaltAndPepper(p=1, gain_range=0.05), slt.ImageBlur(p=0.5, blur_type='m', k_size=(3, 5)), ]), slc.Stream([ slt.ImageBlur(p=0.5, blur_type='m', k_size=(3, 5)), slt.ImageSaltAndPepper(p=1, gain_range=0.01), ]), slc.Stream() ], n=1), slt.ImageGammaCorrection(p=0.5, gamma_range=(0.5, 1.5)), cutout if args.use_cutout else slc.Stream(), partial(solt2torchhm, downsample=None, sigma=None), ]) kvs.update('train_trf', ppl)
def get_landmark_transform_kneel(config): cutout = slt.ImageCutOut(cutout_size=(int(config.dataset.cutout * config.dataset.augs.crop.crop_x), int(config.dataset.cutout * config.dataset.augs.crop.crop_y)), p=0.5) # plus-minus 1.3 pixels jitter = slt.KeypointsJitter(dx_range=(-0.003, 0.003), dy_range=(-0.003, 0.003)) ppl = transforms.Compose([ ColorPaddingWithSide(p=0.05, pad_size=10, side=SIDES.RANDOM, color=(50,100)), TriangularMask(p=0.025, arm_lengths=(100, 50), side=SIDES.RANDOM, color=(50,100)), TriangularMask(p=0.025, arm_lengths=(50, 100), side=SIDES.RANDOM, color=(50,100)), LowVisibilityTransform(p=0.05, alpha=0.15, bgcolor=(50,100)), SubSampleUpScale(p=0.01), jitter if config.dataset.augs.use_target_jitter else slc.Stream(), slc.SelectiveStream([ slc.Stream([ slt.RandomFlip(p=0.5, axis=1), slt.RandomProjection(affine_transforms=slc.Stream([ slt.RandomScale(range_x=(0.9, 1.1), p=1), slt.RandomRotate(rotation_range=(-90, 90), p=1), slt.RandomShear(range_x=(-0.1, 0.1), range_y=(-0.1, 0.1), p=0.5), ]), v_range=(1e-5, 2e-3), p=0.5), # slt.RandomScale(range_x=(0.5, 2.5), p=0.5), ]), slc.Stream() ], probs=[0.7, 0.3]), slc.Stream([ slt.PadTransform((config.dataset.augs.pad.pad_x, config.dataset.augs.pad.pad_y), padding='z'), slt.CropTransform((config.dataset.augs.crop.crop_x, config.dataset.augs.crop.crop_y), crop_mode='r'), ]), slc.SelectiveStream([ slt.ImageSaltAndPepper(p=1, gain_range=0.01), slt.ImageBlur(p=1, blur_type='g', k_size=(3, 5)), slt.ImageBlur(p=1, blur_type='m', k_size=(3, 5)), slt.ImageAdditiveGaussianNoise(p=1, gain_range=0.5), slc.Stream([ slt.ImageSaltAndPepper(p=1, gain_range=0.05), slt.ImageBlur(p=0.5, blur_type='m', k_size=(3, 5)), ]), slc.Stream([ slt.ImageBlur(p=0.5, blur_type='m', k_size=(3, 5)), slt.ImageSaltAndPepper(p=1, gain_range=0.01), ]), slc.Stream() ], n=1), slt.ImageGammaCorrection(p=0.5, gamma_range=(0.5, 1.5)), cutout if config.dataset.use_cutout else slc.Stream(), partial(solt2torchhm, downsample=None, sigma=None), ]) return ppl
def test_keypoints_assert_reflective(img_3x3, mask_3x3): # Setting up the data kpts_data = np.array([[0, 0], [0, 2], [2, 2], [2, 0]]).reshape((4, 2)) kpts = sld.KeyPoints(kpts_data, 3, 3) img, mask = img_3x3, mask_3x3 dc = sld.DataContainer(( img, mask, kpts, ), 'IMP') # Defining the 90 degrees transform (clockwise) stream = slt.RandomRotate(rotation_range=(20, 20), p=1, padding='r') with pytest.raises(ValueError): stream(dc)
def test_random_proj_and_selective_stream(img_5x5): img = img_5x5 dc = sld.DataContainer((img, ), 'I') ppl = slt.RandomProjection(slc.SelectiveStream([ slt.RandomRotate(rotation_range=(90, 90), p=0), slt.RandomScale(range_y=(0, 0.1), same=True, p=0), slt.RandomShear(range_y=(-0.1, 0.1), p=0), ], n=3), v_range=(0, 0)) dc_res = ppl(dc) assert np.array_equal(dc.data, dc_res.data)
def test_fusion_rotate_360(img_5x5): img = img_5x5 dc = sld.DataContainer((img, ), 'I') ppl = slc.Stream([ slt.RandomRotate((45, 45), padding='z', p=1), slt.RandomRotate((45, 45), padding='z', p=1), slt.RandomRotate((45, 45), padding='z', p=1), slt.RandomRotate((45, 45), padding='z', p=1), slt.RandomRotate((45, 45), padding='z', p=1), slt.RandomRotate((45, 45), padding='z', p=1), slt.RandomRotate((45, 45), padding='z', p=1), slt.RandomRotate((45, 45), padding='z', p=1), ]) img_res = ppl(dc)[0][0] np.testing.assert_array_almost_equal(img, img_res)