def test_fusion_rotate_360_flip_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),
slt.RandomFlip(p=1, axis=1),
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(
cv2.flip(img, 1).reshape(5, 5, 1), img_res)
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 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_img_mask_vertical_horizontal_flip(img_3x4, mask_3x4):
img, mask = img_3x4, mask_3x4
dc = sld.DataContainer((img, mask), 'IM')
stream = slc.Stream(
[slt.RandomFlip(p=1, axis=0),
slt.RandomFlip(p=1, axis=1)])
dc = stream(dc)
img_res, _ = dc[0]
mask_res, _ = dc[1]
h, w = mask.shape
assert np.array_equal(
cv2.flip(cv2.flip(img, 0), 1).reshape(h, w, 1), img_res)
assert np.array_equal(cv2.flip(cv2.flip(mask, 0), 1), mask_res)
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_image_shape_equal_3_after_nested_flip(img_3x4):
img = img_3x4
dc = sld.DataContainer((img, ), 'I')
stream = slc.Stream([
slt.RandomFlip(p=1, axis=0),
slt.RandomFlip(p=1, axis=1),
slc.Stream([
slt.RandomFlip(p=1, axis=1),
slt.RandomFlip(p=1, axis=0),
])
])
dc = stream(dc)
img_res, _, _ = dc[0]
assert np.array_equal(len(img.shape), 3)
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 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_nested_stream(img_3x4, mask_3x4):
img, mask = img_3x4, mask_3x4
dc = sld.DataContainer((img, mask), 'IM')
stream = slc.Stream([
slt.RandomFlip(p=1, axis=0),
slt.RandomFlip(p=1, axis=1),
slc.Stream([
slt.RandomFlip(p=1, axis=1),
slt.RandomFlip(p=1, axis=0),
])
])
dc = stream(dc)
img_res, t0, _ = dc[0]
mask_res, t1, _ = dc[1]
assert np.array_equal(img, img_res)
assert np.array_equal(mask, mask_res)
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_keypoints_horizontal_flip_within_stream():
kpts_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]).reshape((4, 2))
kpts = sld.KeyPoints(kpts_data, 2, 2)
stream = slc.Stream([slt.RandomFlip(p=1, axis=1)])
dc = sld.DataContainer((kpts, ), 'P')
dc_res = stream(dc)
assert np.array_equal(
dc_res[0][0].data,
np.array([[1, 0], [1, 1], [0, 0], [0, 1]]).reshape((4, 2)))
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 test_transform_returns_original_data_if_not_in_specified_indices(img_2x2, img_3x3, img_3x4, img_5x5):
kpts_data = np.array([[0, 0], [0, 2], [2, 2], [2, 0]]).reshape((4, 2))
kpts = sld.KeyPoints(kpts_data, 3, 3)
dc = sld.DataContainer((img_2x2, img_3x3, img_3x4, img_5x5, 1, kpts, 2), 'IIIILPL')
trf = slt.RandomFlip(p=1, data_indices=(0, 1, 4))
res = trf(dc)
assert np.linalg.norm(res.data[0]-img_2x2) > 0
assert np.linalg.norm(res.data[1]-img_3x3) > 0
np.testing.assert_array_equal(res.data[2], img_3x4)
np.testing.assert_array_equal(res.data[3], img_5x5)
assert res.data[-1] == 2
np.testing.assert_array_equal(res.data[5].data, kpts_data)
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 init_train_augs(crop_mode='r', pad_mode='r'):
trf = transforms.Compose([
img_labels2solt,
slc.Stream(
[
slt.PadTransform(pad_to=(PAD_TO, PAD_TO)),
slt.RandomFlip(p=0.5, axis=1), # horizontal flip
slt.CropTransform(crop_size=(CROP_SIZE, CROP_SIZE),
crop_mode=crop_mode),
],
padding=pad_mode),
unpack_solt_data,
partial(apply_by_index, transform=transforms.ToTensor(), idx=0),
])
return trf
def init_train_augmentation_pipeline():
kvs = GlobalKVS()
ppl = transforms.Compose([
img_mask2solt,
slc.Stream([
slt.RandomFlip(axis=1, p=0.5),
slt.ImageGammaCorrection(gamma_range=(0.5, 2), p=0.5),
slt.PadTransform(pad_to=(kvs['args'].crop_x + 1,
kvs['args'].crop_y + 1)),
slt.CropTransform(crop_size=(kvs['args'].crop_x,
kvs['args'].crop_y),
crop_mode='r')
]),
solt2img_mask,
partial(apply_by_index, transform=gs2tens, idx=[0, 1]),
])
return ppl
def init_binary_segmentation_augs():
kvs = GlobalKVS()
ppl = tvt.Compose([
img_binary_mask2solt,
slc.Stream([
slt.PadTransform(pad_to=(kvs['args'].pad_x, kvs['args'].pad_y)),
slt.RandomFlip(axis=1, p=0.5),
slt.CropTransform(crop_size=(kvs['args'].crop_x,
kvs['args'].crop_y),
crop_mode='r'),
slt.ImageGammaCorrection(gamma_range=(kvs['args'].gamma_min,
kvs['args'].gamma_max),
p=0.5),
]),
solt2img_binary_mask,
partial(apply_by_index, transform=numpy2tens, idx=[0, 1]),
])
kvs.update('train_trf', ppl)
return ppl
def test_img_mask__kptsvertical_horizontal_flip_negative_axes(
img_3x4, mask_3x4):
img, mask = img_3x4, mask_3x4
kpts_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]).reshape((4, 2))
kpts = sld.KeyPoints(kpts_data.copy(), 3, 4)
dc = sld.DataContainer((img, mask, kpts), 'IMP')
stream = slt.RandomFlip(p=1, axis=-1)
dc = stream(dc)
img_res, _, _ = dc[0]
mask_res, _, _ = dc[1]
kpts_res, _, _ = dc[2]
h, w = mask.shape
assert np.array_equal(
cv2.flip(cv2.flip(img, 0), 1).reshape(h, w, 1), img_res)
assert np.array_equal(cv2.flip(cv2.flip(mask, 0), 1), mask_res)
kpts_data[:, 0] = 4 - 1 - kpts_data[:, 0]
kpts_data[:, 1] = 3 - 1 - kpts_data[:, 1]
assert np.array_equal(kpts_data, kpts_res.data)
trf.state_dict['translate_y']) == expected
@pytest.mark.parametrize('param_set', [
{
'affine_transforms': '123'
},
{
'affine_transforms': 123
},
{
'affine_transforms': []
},
{
'affine_transforms': slc.Stream([
slt.RandomFlip(),
])
},
{
'affine_transforms': slc.Stream([
slt.RandomFlip(),
])
},
{
'v_range': '123'
},
{
'v_range': 123
},
{
'v_range': [0, 0]
def test_transform_returns_original_data_when_not_used_and_applied(img_2x2):
trf = slt.RandomFlip(p=0)
dc = sld.DataContainer(img_2x2, 'I')
dc_res = trf(dc)
assert dc_res == dc
def test_base_transform_can_take_none_prop_and_it_becomes_0_5():
trf = slt.RandomFlip(p=None)
assert 0.5 == trf.p
def test_flip_invalid_axis():
with pytest.raises(ValueError):
slt.RandomFlip(p=1, axis=100)
def __init__(self):
self.imgaug_transform = iaa.Flipud(p=1)
self.augmentor_op = Operations.Flip(probability=1,
top_bottom_left_right="TOP_BOTTOM")
self.solt_stream = slc.Stream([slt.RandomFlip(p=1, axis=0)])
def train_test_transforms(conf, mean=None, std=None, crop_size=(512, 1024)):
"""
Compiles the different image augmentations that are used for input images.
:param conf: Transformation parameters
:param mean: Dataset image mean
:param std: Dataset image std
:param crop_size: Image size for the segmentation model
:return: Compiled transformation objects, and lists of the used transforms
"""
trf = conf['training']
prob = trf['transform_probability']
# Training transforms
# 3D transforms
if trf['experiment'] == '3D':
train_transforms = [
slc.SelectiveStream([
slc.Stream([
slt.RandomProjection(
slc.Stream([
slt.RandomRotate(rotation_range=tuple(
trf['rotation_range']),
p=prob),
slt.RandomScale(range_x=tuple(trf['scale_range']),
range_y=tuple(trf['scale_range']),
same=False,
p=prob),
#slt.RandomShear(range_x=tuple(trf['shear_range']),
# range_y=tuple(trf['shear_range']), p=prob),
slt.RandomTranslate(
range_x=trf['translation_range'],
range_y=trf['translation_range'],
p=prob)
]),
v_range=None #tuple(trf['v_range'])
),
# Spatial
slt.RandomFlip(p=prob),
slt.PadTransform(pad_to=crop_size),
slt.CropTransform(crop_mode='r', crop_size=crop_size),
# Intensity
# Brightness/contrast
slc.SelectiveStream([
slt.ImageRandomBrightness(brightness_range=tuple(
trf['brightness_range']),
p=prob),
slt.ImageRandomContrast(
contrast_range=trf['contrast_range'], p=prob)
]),
# Noise
slc.SelectiveStream([
slt.ImageSaltAndPepper(
p=prob, gain_range=trf['gain_range_sp']),
slt.ImageAdditiveGaussianNoise(
p=prob, gain_range=trf['gain_range_gn']),
slc.SelectiveStream([
slt.ImageBlur(p=prob,
blur_type='g',
k_size=(3, 7, 11),
gaussian_sigma=tuple(trf['sigma'])),
slt.ImageBlur(p=prob,
blur_type='m',
k_size=(3, 7, 11),
gaussian_sigma=tuple(trf['sigma']))
])
])
]),
# Empty stream
slc.Stream([
slt.PadTransform(pad_to=crop_size),
slt.CropTransform(crop_mode='r', crop_size=crop_size)
])
])
]
# 2D transforms
else:
train_transforms = [
slc.SelectiveStream([
slc.Stream([
# Projection
slt.RandomProjection(
slc.Stream([
slt.RandomRotate(rotation_range=tuple(
trf['rotation_range']),
p=prob),
slt.RandomScale(range_x=tuple(trf['scale_range']),
range_y=tuple(trf['scale_range']),
same=False,
p=prob),
# slt.RandomShear(range_x=tuple(trf['shear_range']),
# range_y=tuple(trf['shear_range']), p=prob),
slt.RandomTranslate(
range_x=trf['translation_range'],
range_y=trf['translation_range'],
p=prob)
]),
v_range=tuple(trf['v_range'])),
# Spatial
slt.RandomFlip(p=prob),
slt.PadTransform(pad_to=crop_size),
slt.CropTransform(crop_mode='r', crop_size=crop_size),
# Intensity
slc.SelectiveStream([
slt.ImageGammaCorrection(gamma_range=tuple(
trf['gamma_range']),
p=prob),
slt.ImageRandomHSV(h_range=tuple(trf['hsv_range']),
s_range=tuple(trf['hsv_range']),
v_range=tuple(trf['hsv_range']),
p=prob)
]),
slc.SelectiveStream([
slt.ImageRandomBrightness(brightness_range=tuple(
trf['brightness_range']),
p=prob),
slt.ImageRandomContrast(
contrast_range=trf['contrast_range'], p=prob)
]),
slc.SelectiveStream([
slt.ImageSaltAndPepper(
p=prob, gain_range=trf['gain_range_sp']),
slt.ImageAdditiveGaussianNoise(
p=prob, gain_range=trf['gain_range_gn']),
slc.SelectiveStream([
slt.ImageBlur(p=prob,
blur_type='g',
k_size=(3, 7, 11),
gaussian_sigma=tuple(trf['sigma'])),
slt.ImageBlur(p=prob,
blur_type='m',
k_size=(3, 7, 11),
gaussian_sigma=tuple(trf['sigma']))
])
])
]),
# Empty stream
slc.Stream([
slt.PadTransform(pad_to=crop_size),
slt.CropTransform(crop_mode='r', crop_size=crop_size)
])
])
]
# Compile training transforms
train_trf = [
# Move to SOLT format
wrap_solt,
# Transforms
slc.Stream(train_transforms),
# Extract image
unwrap_solt,
# Move to tensor
ApplyTransform(numpy2tens, (0, 1, 2))
]
# Validation transforms
val_trf = [
wrap_solt,
slc.Stream([
slt.PadTransform(pad_to=crop_size[1]),
slt.CropTransform(crop_mode='r', crop_size=crop_size)
]), unwrap_solt,
ApplyTransform(numpy2tens, idx=(0, 1, 2))
]
# Test transforms
test_trf = [unwrap_solt, ApplyTransform(numpy2tens, idx=(0, 1, 2))]
# Normalize train and val images if mean and std are given
if mean is not None and std is not None:
train_trf.append(
ApplyTransform(partial(normalize_channel_wise, mean=mean,
std=std)))
if mean is not None and std is not None:
val_trf.append(
ApplyTransform(partial(normalize_channel_wise, mean=mean,
std=std)))
# Compose transforms
train_trf_cmp = Compose(train_trf)
val_trf_cmp = Compose(val_trf)
test_trf_cmp = Compose(test_trf)
return {
'train': train_trf_cmp,
'val': val_trf_cmp,
'test': test_trf_cmp,
'train_list': train_trf,
'val_list': val_trf,
'test_list': test_trf
}
def train_test_transforms(conf, mean=None, std=None):
trf = conf['training']
prob = trf['transform_probability']
crop_size = tuple(trf['crop_size'])
# Training transforms
if trf['uCT']:
train_transforms = [
slt.RandomProjection(slc.Stream([
slt.RandomRotate(rotation_range=tuple(trf['rotation_range']),
p=prob),
slt.RandomScale(range_x=tuple(trf['scale_range']),
range_y=tuple(trf['scale_range']),
same=False,
p=prob),
slt.RandomShear(range_x=tuple(trf['shear_range']),
range_y=tuple(trf['shear_range']),
p=prob),
slt.RandomTranslate(range_x=trf['translation_range'],
range_y=trf['translation_range'],
p=prob)
]),
v_range=tuple(trf['v_range'])),
# Spatial
slt.RandomFlip(p=prob),
slt.PadTransform(pad_to=crop_size),
slt.CropTransform(crop_mode='r', crop_size=crop_size),
# Intensity
#slt.ImageGammaCorrection(gamma_range=tuple(trf['gamma_range']), p=prob),
#slt.ImageRandomHSV(h_range=tuple(trf['hsv_range']),
# s_range=tuple(trf['hsv_range']),
# v_range=tuple(trf['hsv_range']), p=prob),
# Brightness/contrast
slc.SelectiveStream([
slt.ImageRandomBrightness(brightness_range=tuple(
trf['brightness_range']),
p=prob),
slt.ImageRandomContrast(contrast_range=trf['contrast_range'],
p=prob)
]),
# Noise
slc.SelectiveStream([
slt.ImageSaltAndPepper(p=prob,
gain_range=trf['gain_range_sp']),
slt.ImageAdditiveGaussianNoise(
p=prob, gain_range=trf['gain_range_gn']),
slc.SelectiveStream([
slt.ImageBlur(p=prob,
blur_type='g',
k_size=(3, 7, 11),
gaussian_sigma=tuple(trf['sigma'])),
slt.ImageBlur(p=prob,
blur_type='m',
k_size=(3, 7, 11),
gaussian_sigma=tuple(trf['sigma']))
])
])
]
else:
train_transforms = [
# Projection
slt.RandomProjection(
slc.Stream([
slt.RandomRotate(rotation_range=tuple(
trf['rotation_range']),
p=prob),
slt.RandomScale(range_x=tuple(trf['scale_range']),
range_y=tuple(trf['scale_range']),
same=False,
p=prob),
#slt.RandomShear(range_x=tuple(trf['shear_range']),
# range_y=tuple(trf['shear_range']), p=prob),
#slt.RandomTranslate(range_x=trf['translation_range'], range_y=trf['translation_range'], p=prob)
]),
v_range=tuple(trf['v_range'])),
# Spatial
slt.RandomFlip(p=prob),
slt.PadTransform(pad_to=crop_size[1]),
slt.CropTransform(crop_mode='r', crop_size=crop_size),
# Intensity
# Add an empty stream
#slc.SelectiveStream([]),
slc.SelectiveStream([
slt.ImageGammaCorrection(gamma_range=tuple(trf['gamma_range']),
p=prob),
slt.ImageRandomHSV(h_range=tuple(trf['hsv_range']),
s_range=tuple(trf['hsv_range']),
v_range=tuple(trf['hsv_range']),
p=prob)
]),
slc.SelectiveStream([
slt.ImageRandomBrightness(brightness_range=tuple(
trf['brightness_range']),
p=prob),
slt.ImageRandomContrast(contrast_range=trf['contrast_range'],
p=prob)
]),
slc.SelectiveStream([
slt.ImageSaltAndPepper(p=prob,
gain_range=trf['gain_range_sp']),
slt.ImageAdditiveGaussianNoise(
p=prob, gain_range=trf['gain_range_gn']),
slc.SelectiveStream([
slt.ImageBlur(p=prob,
blur_type='g',
k_size=(3, 7, 11),
gaussian_sigma=tuple(trf['sigma'])),
slt.ImageBlur(p=prob,
blur_type='m',
k_size=(3, 7, 11),
gaussian_sigma=tuple(trf['sigma']))
])
])
]
train_trf = [
wrap_solt,
#slc.Stream(train_transforms),
slc.Stream([
slt.PadTransform(pad_to=crop_size[1]),
slt.CropTransform(crop_mode='r', crop_size=crop_size)
]),
unwrap_solt,
ApplyTransform(numpy2tens, (0, 1, 2))
]
# Validation transforms
val_trf = [
wrap_solt,
slc.Stream([
slt.PadTransform(pad_to=crop_size[1]),
slt.CropTransform(crop_mode='r', crop_size=crop_size)
]), unwrap_solt,
ApplyTransform(numpy2tens, idx=(0, 1, 2))
]
# Test transforms
test_trf = [unwrap_solt, ApplyTransform(numpy2tens, idx=(0, 1, 2))]
# Use normalize_channel_wise if mean and std not calculated
if mean is not None and std is not None:
train_trf.append(
ApplyTransform(partial(normalize_channel_wise, mean=mean,
std=std)))
if mean is not None and std is not None:
val_trf.append(
ApplyTransform(partial(normalize_channel_wise, mean=mean,
std=std)))
# Compose transforms
train_trf_cmp = Compose(train_trf)
val_trf_cmp = Compose(val_trf)
test_trf_cmp = Compose(test_trf)
return {
'train': train_trf_cmp,
'val': val_trf_cmp,
'test': test_trf_cmp,
'train_list': train_trf,
'val_list': val_trf,
'test_list': test_trf
}
def __init__(self):
self.imgaug_transform = iaa.Fliplr(p=1)
self.augmentor_op = Operations.Flip(probability=1,
top_bottom_left_right='LEFT_RIGHT')
self.solt_stream = slc.Stream([slt.RandomFlip(p=1, axis=1)])
