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)
