def test_img_mask_vertical_horizontal_flip(img_3x4, mask_3x4): img, mask = img_3x4, mask_3x4 dc = slc.DataContainer((img, mask), "IM") stream = slc.Stream([slt.Flip(p=1, axis=0), slt.Flip(p=1, axis=1)]) dc = stream(dc, return_torch=False) 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 __init__(self, img_size=256): super(VHFlipRotateCrop, self).__init__(img_size) self.solt_pipeline = solt.Stream([ slt.Flip(p=self.probablity, axis=0), slt.Flip(p=self.probablity, axis=1), slt.Rotate(angle_range=(0, 20)), slt.Crop(224, crop_mode="r"), ]) self.albumentations_pipeline = albu.Compose([ albu.VerticalFlip(p=self.probablity), albu.HorizontalFlip(p=self.probablity), albu.Rotate(limit=(0, 20), p=self.probablity, border_mode=cv2.BORDER_CONSTANT, value=0), albu.RandomCrop(height=224, width=224), ToTensor(normalize={ "mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225] }), ]) self.torchvision_pipeline = tv_transforms.Compose([ tv_transforms.RandomHorizontalFlip(p=self.probablity), tv_transforms.RandomRotation(degrees=(0, 20)), tv_transforms.RandomCrop(224), tv_transforms.ToTensor(), tv_transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) _augm_ppl = augmentor.Pipeline() _augm_ppl.flip_top_bottom(probability=self.probablity) _augm_ppl.flip_left_right(probability=self.probablity) _augm_ppl.rotate(probability=self.probablity, max_left_rotation=0, max_right_rotation=20) _augm_ppl.crop_random(probability=1, percentage_area=224 / float(self.img_size)) self.augmentor_pipeline = tv_transforms.Compose([ _augm_ppl.torch_transform(), tv_transforms.transforms.ToTensor(), tv_transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ])
def test_fusion_rotate_360_flip_rotate_360(img_5x5): img = img_5x5 dc = slc.DataContainer((img, ), 'I') ppl = slc.Stream([ slc.Stream([ slt.Rotate((45, 45), padding='z', p=1), slt.Rotate((45, 45), padding='z', p=1), slt.Rotate((45, 45), padding='z', p=1), slt.Rotate((45, 45), padding='z', p=1), slt.Rotate((45, 45), padding='z', p=1), slt.Rotate((45, 45), padding='z', p=1), slt.Rotate((45, 45), padding='z', p=1), slt.Rotate((45, 45), padding='z', p=1), ], optimize_stack=True), slt.Flip(p=1, axis=1), slc.Stream([ slt.Rotate((45, 45), padding='z', p=1), slt.Rotate((45, 45), padding='z', p=1), slt.Rotate((45, 45), padding='z', p=1), slt.Rotate((45, 45), padding='z', p=1), slt.Rotate((45, 45), padding='z', p=1), slt.Rotate((45, 45), padding='z', p=1), slt.Rotate((45, 45), padding='z', p=1), slt.Rotate((45, 45), padding='z', p=1), ], optimize_stack=True) ]) img_res = ppl(dc, return_torch=False)[0][0] np.testing.assert_array_almost_equal( cv2.flip(img, 1).reshape(5, 5, 1), img_res)
def test_image_shape_equal_3_after_nested_flip(img): dc = slc.DataContainer((img, ), "I") stream = slc.Stream([ slt.Flip(p=1, axis=0), slt.Flip(p=1, axis=1), slc.Stream([ slt.Flip(p=1, axis=1), slt.Flip(p=1, axis=0), ]) ]) dc = stream(dc, return_torch=False) img_res, _, _ = dc[0] assert np.array_equal(len(img.shape), 3)
def __init__(self, img_size=256): super(VerticalFlip, self).__init__(img_size) self.solt_pipeline = slt.Flip(p=self.probablity, axis=0) self.albumentations_pipeline = albu.Compose([ albu.VerticalFlip(p=self.probablity), ToTensor(normalize={ "mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225] }), ]) self.torchvision_pipeline = tv_transforms.Compose([ tv_transforms.RandomVerticalFlip(p=self.probablity), tv_transforms.ToTensor(), tv_transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) _augm_ppl = augmentor.Pipeline() _augm_ppl.flip_top_bottom(probability=self.probablity) self.augmentor_pipeline = tv_transforms.Compose([ _augm_ppl.torch_transform(), tv_transforms.transforms.ToTensor(), tv_transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ])
def test_keypoints_vertical_flip_within_stream(): kpts_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]).reshape((4, 2)) kpts = slc.Keypoints(kpts_data, 2, 2) stream = slc.Stream([slt.Flip(p=1, axis=0)]) dc = slc.DataContainer((kpts,), "P") dc_res = stream(dc, return_torch=False) assert np.array_equal(dc_res[0][0].data, np.array([[0, 1], [0, 0], [1, 1], [1, 0]]).reshape((4, 2)))
def test_nested_stream(img, mask): dc = slc.DataContainer((img, mask), "IM") stream = slc.Stream([ slt.Flip(p=1, axis=0), slt.Flip(p=1, axis=1), slc.Stream([ slt.Flip(p=1, axis=1), slt.Flip(p=1, axis=0), ]) ]) dc = stream(dc, return_torch=False) 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_keypoints_vertical_flip(): kpts_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]).reshape((4, 2)) kpts = slc.Keypoints(kpts_data, frame=(2, 2)) stream = slt.Flip(p=1, axis=0) dc = slc.DataContainer((kpts, ), "P") dc_res = stream(dc) assert np.array_equal( dc_res[0][0].data, np.array([[0, 1], [0, 0], [1, 1], [1, 0]]).reshape((4, 2)))
def my_transforms(): train_trf = solt.Stream([ slt.Pad(pad_to=(36, 36)), slt.Rotate(10), slt.Crop((32, 32)), slt.CutOut((8, 8)), slt.Flip(p=0.5) ]) test_trf = solt.Stream([]) return {'train': train_trf, 'eval': test_trf}
def test_img_mask_vertical_horizontal_flip_negative_axes(img_3x4, mask_3x4): img, mask = img_3x4, mask_3x4 dc = slc.DataContainer((img, mask), "IM") stream = slt.Flip(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 create_train_transforms(size): return solt.Stream([ slt.JPEGCompression(p=0.5,quality_range=(60,100)), slt.Noise(p=0.25), slt.Brightness(), slt.Contrast(), slt.Flip(), slt.Rotate90(), solt.SelectiveStream([ slt.GammaCorrection(gamma_range=0.5, p=1), slt.Noise(gain_range=0.1, p=1), slt.SaltAndPepper(), slt.Blur(), ], n=3), slt.Rotate(angle_range=(-10, 10), p=0.5), slt.Resize((size,size)), ])
def test_complex_transform_serialization(): stream = slc.Stream([ slt.Flip(axis=1, p=0.5), slc.SelectiveStream([ slt.Rotate(angle_range=(-45, -45), p=1, padding="r"), slt.Rotate90(1, p=1), slt.Rotate(angle_range=(45, 45), p=1, padding="r"), ]), slt.Crop((350, 350)), slc.SelectiveStream([ slt.GammaCorrection(gamma_range=0.5, p=1), slt.Noise(gain_range=0.1, p=1), slt.Blur() ], n=3), slt.Projection( affine_transforms=slc.Stream([ slt.Rotate(angle_range=(-45, 45), p=1), slt.Scale(range_x=(0.8, 1.5), range_y=(0.8, 1.5), p=1, same=False), ]), v_range=(1e-4, 1e-3), p=1, ), slc.SelectiveStream( [ slt.CutOut(40, p=1), slt.CutOut(30, p=1), slt.CutOut(20, p=1), slt.CutOut(40, p=1), slc.Stream(), slc.Stream(), slc.Stream(), ], n=3, ), ]) assert slu.from_yaml(stream.to_yaml()).to_yaml() == slu.from_yaml( stream.to_yaml()).to_yaml()
def test_img_mask__kptsvertical_horizontal_flip_negative_axes(img, mask): kpts_data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]]).reshape((4, 2)) kpts = slc.Keypoints(kpts_data.copy(), frame=(3, 4)) dc = slc.DataContainer((img, mask, kpts), "IMP") stream = slt.Flip(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)
def __init__(self, img_size=256): super(HFlipCrop, self).__init__(img_size) self.solt_pipeline = solt.Stream([ slt.Flip(p=self.probablity, axis=1), slt.Crop(224, crop_mode="r") ]) self.albumentations_pipeline = albu.Compose([ albu.HorizontalFlip(p=self.probablity), albu.RandomCrop(height=224, width=224), ToTensor(normalize={ "mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225] }), ]) self.torchvision_pipeline = tv_transforms.Compose([ tv_transforms.RandomHorizontalFlip(p=self.probablity), tv_transforms.RandomCrop(224), tv_transforms.ToTensor(), tv_transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) _augm_ppl = augmentor.Pipeline() _augm_ppl.flip_left_right(probability=self.probablity) _augm_ppl.crop_random(probability=1, percentage_area=224 / float(self.img_size)) self.augmentor_pipeline = tv_transforms.Compose([ _augm_ppl.torch_transform(), tv_transforms.transforms.ToTensor(), tv_transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ])
"translate_x, translate_y, expected", [(None, (2, 2), (0, 2)), ((2, 2), None, (2, 0)), (None, None, (0, 0)),], ) def test_translate_when_range_x_is_none(translate_x, translate_y, expected, img_6x6_rgb): dc = slc.DataContainer(img_6x6_rgb, "I") trf = slt.Translate(range_x=translate_x, range_y=translate_y, p=1) trf.sample_transform(dc) assert (trf.state_dict["translate_x"], trf.state_dict["translate_y"]) == expected @pytest.mark.parametrize( "param_set", [ {"affine_transforms": "123"}, {"affine_transforms": 123}, {"affine_transforms": []}, {"affine_transforms": slc.Stream([slt.Flip(),])}, {"affine_transforms": slc.Stream([slt.Flip(),])}, {"v_range": "123"}, {"v_range": 123}, {"v_range": ("123", "456")}, {"v_range": ((2,), (4,))}, ], ) def test_random_projection_raises_type_errors(param_set): with pytest.raises(TypeError): slt.Projection(**param_set) @pytest.mark.parametrize( "value_range,to_catch", [
def test_transform_returns_original_data_when_not_used_and_applied(img_2x2): trf = slt.Flip(p=0) dc = slc.DataContainer(img_2x2, "I") dc_res = trf(dc) assert dc_res == dc
def test_flip_invalid_axis(): with pytest.raises(ValueError): slt.Flip(p=1, axis=100)
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.Flip(p=1, axis=1)])
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.Flip(p=1, axis=0)])
@pytest.mark.parametrize( "param_set", [ { "affine_transforms": "123" }, { "affine_transforms": 123 }, { "affine_transforms": [] }, { "affine_transforms": slc.Stream([ slt.Flip(), ]) }, { "affine_transforms": slc.Stream([ slt.Flip(), ]) }, { "v_range": "123" }, { "v_range": 123 }, { "v_range": ("123", "456")