def my_transforms(): train_trf = solt.Stream([ slt.Scale(range_x=(0.9, 1.1), same=False, p=0.5), slt.Shear(range_x=(-0.05, 0.05), p=0.5), slt.Rotate((-5, 5), p=0.5), slt.Pad(pad_to=(32, 32)) ]) test_trf = solt.Stream([slt.Pad(pad_to=(32, 32))]) return {'train': train_trf, 'eval': test_trf}
def test_padding_img_mask_3x4_5x5(img_3x4, mask_3x4): img, mask = img_3x4, mask_3x4 dc = slc.DataContainer((img, mask), "IM") transf = slt.Pad((5, 5)) res = transf(dc) assert (res[0][0].shape[0] == 5) and (res[0][0].shape[1] == 5) assert (res[1][0].shape[0] == 5) and (res[1][0].shape[1] == 5)
def test_2x2_pad_to_20x20_center_crop_2x2(pad_size, crop_size, img_2x2, mask_2x2): # Setting up the data kpts_data = np.array([[0, 0], [0, 1], [1, 1], [1, 0]]).reshape((4, 2)) kpts = slc.Keypoints(kpts_data, 2, 2) img, mask = img_2x2, mask_2x2 dc = slc.DataContainer(( img, mask, kpts, ), "IMP") stream = slc.Stream( [slt.Pad(pad_to=pad_size), slt.Crop(crop_to=crop_size)]) res = stream(dc, return_torch=False) assert (res[0][0].shape[0] == 2) and (res[0][0].shape[1] == 2) assert (res[1][0].shape[0] == 2) and (res[1][0].shape[1] == 2) assert (res[2][0].height == 2) and (res[2][0].width == 2) assert np.array_equal(res[0][0], img) assert np.array_equal(res[1][0], mask) assert np.array_equal(res[2][0].data, kpts_data)
def test_reflective_padding_cant_be_applied_to_kpts(): kpts_data = np.array([[0, 0], [0, 1], [1, 0], [2, 0]]).reshape((4, 2)) kpts = slc.Keypoints(kpts_data, 3, 4) dc = slc.DataContainer((1, kpts), "LP") trf = slt.Pad(pad_to=(10, 10), padding="r") with pytest.raises(ValueError): trf(dc)
def test_padding_img_mask_2x2_3x3(img_2x2, mask_2x2): img, mask = img_2x2, mask_2x2 dc = slc.DataContainer((img, mask), "IM") transf = slt.Pad((3, 3)) res = transf(dc) assert (res[0][0].shape[0] == 3) and (res[0][0].shape[1] == 3) assert (res[1][0].shape[0] == 3) and (res[1][0].shape[1] == 3)
def test_pad_does_not_change_the_data_when_the_image_and_the_mask_are_big(pad_size, pad_type, img_3x3, mask_3x3): dc = slc.DataContainer((img_3x3, mask_3x3), "IM") trf = slt.Pad(pad_to=pad_size, padding=pad_type) dc_res = trf(dc) np.testing.assert_array_equal(dc_res.data[0], img_3x3) np.testing.assert_array_equal(dc_res.data[1], mask_3x3)
def test_deserialize_from_dict(serialized): trfs = slc.Stream([slt.Pad(34), slt.Crop(32, "r"), slt.CutOut(2)]) serialized_trfs = json.dumps(trfs.to_dict()) serialized_from_deserialized = json.dumps( slu.from_dict(serialized).to_dict()) assert serialized_trfs == serialized_from_deserialized
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_different_crop_modes(crop_mode, img_2x2, mask_2x2): if crop_mode == "d": with pytest.raises(ValueError): slt.Crop(crop_to=2, crop_mode=crop_mode) else: stream = slc.Stream([slt.Pad(pad_to=20), slt.Crop(crop_to=2, crop_mode=crop_mode),]) img, mask = img_2x2, mask_2x2 dc = slc.DataContainer((img, mask,), "IM") dc_res = stream(dc, return_torch=False) for el in dc_res.data: assert el.shape[0] == 2 assert el.shape[1] == 2
def test_matrix_transforms_state_reset(img_5x5, ignore_state, pipeline): n_iter = 50 if pipeline: ppl = slc.Stream([ slt.Rotate(angle_range=(-180, 180), p=1, ignore_state=ignore_state), slt.Pad(pad_to=(10, 10)), ]) else: ppl = slt.Rotate(angle_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 = slc.DataContainer((img_test.copy(), ), 'I') dc2 = slc.DataContainer((img_test.copy(), ), 'I') if pipeline: dc1_res = ppl(dc1, return_torch=False).data[0].squeeze() else: 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'] if pipeline: dc2_res = ppl(dc2, return_torch=False).data[0].squeeze() else: 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 my_transforms(): train_trf = solt.Stream([ # slt.Scale(range_x=(0.9, 1.1), range_y=(0.9, 1.1), same=True, p=0.5), # slt.Translate(range_x=(-0.05, 0.05), range_y=(-0.05, 0.05), p=0.5), # slt.GammaCorrection(gamma_range=0.1, p=0.5), slt.Pad(pad_to=(36, 36)), slt.Rotate((-5, 5), p=0.5), slt.Crop((32, 32)), # slt.Noise(gain_range=0.1, p=0.8), slt.CutOut((8, 8)) ]) test_trf = solt.Stream([]) custom_trf = solt.Stream([ slt.Pad(pad_to=(36, 36)), slt.Rotate((-5, 5), p=0.5), slt.Crop((32, 32)), # slt.Noise(gain_range=0.1, p=0.8), slt.CutOut((8, 8)) ]) return {'train': train_trf, 'eval': test_trf, 'transforms': custom_trf}
def test_3x3_pad_to_20x20_center_crop_3x3_shape_stayes_unchanged(img_3x3, mask_3x3): # Setting up the data kpts_data = np.array([[0, 0], [0, 2], [2, 2], [2, 0]]).reshape((4, 2)) kpts = slc.Keypoints(kpts_data, 3, 3) img, mask = img_3x3, mask_3x3 dc = slc.DataContainer((img, mask, kpts,), "IMP") stream = slc.Stream([slt.Pad((20, 20)), slt.Crop((3, 3))]) res = stream(dc, return_torch=False) assert (res[0][0].shape[0] == 3) and (res[0][0].shape[1] == 3) assert (res[1][0].shape[0] == 3) and (res[1][0].shape[1] == 3) assert (res[2][0].height == 3) and (res[2][0].width == 3)
def test_6x6_pad_to_20x20_center_crop_6x6_kpts_img(img): # Setting up the data kpts_data = np.array([[0, 0], [0, 5], [1, 3], [2, 0]]).reshape((4, 2)) kpts = slc.Keypoints(kpts_data, frame=(6, 6)) dc = slc.DataContainer((kpts, img), "PI") stream = slc.Stream([slt.Pad((20, 20)), slt.Crop((6, 6))]) res = stream(dc, return_torch=False) assert (res[1][0].shape[0] == 6) and (res[1][0].shape[1] == 6) assert (res[0][0].frame[0] == 6) and (res[0][0].frame[1] == 6) assert np.array_equal(res[1][0], img) assert np.array_equal(res[0][0].data, kpts_data)
def test_pad_to_20x20_img_mask_keypoints_3x3_kpts_first(img_3x3, mask_3x3): # Setting up the data kpts_data = np.array([[0, 0], [0, 2], [2, 2], [2, 0]]).reshape((4, 2)) kpts = slc.Keypoints(kpts_data, 3, 3) img, mask = img_3x3, mask_3x3 dc = slc.DataContainer((kpts, img, mask), "PIM") transf = slt.Pad((20, 20)) res = transf(dc) assert (res[2][0].shape[0] == 20) and (res[2][0].shape[1] == 20) assert (res[1][0].shape[0] == 20) and (res[1][0].shape[1] == 20) assert (res[0][0].height == 20) and (res[0][0].width == 20) assert np.array_equal(res[0][0].data, np.array([[8, 8], [8, 10], [10, 10], [10, 8]]).reshape((4, 2)))
def test_matrix_transforms_use_cache_for_different_dc_items_raises_error( img_5x5, mask_3x4, pipeline): dc = slc.DataContainer((img_5x5, mask_3x4), 'IM') if pipeline: ppl = slc.Stream([ slt.Rotate(angle_range=(-180, 180), p=1, ignore_state=False), slt.Pad(pad_to=(10, 10)), ]) else: ppl = slt.Rotate(angle_range=(-180, 180), p=1, ignore_state=False) with pytest.raises(ValueError): if pipeline: ppl(dc, return_torch=False) else: ppl(dc)
def test_pad_to_20x20_img_mask_keypoints_3x3(img, mask): # Setting up the data kpts_data = np.array([[0, 0], [0, 2], [2, 2], [2, 0]]).reshape((4, 2)) kpts = slc.Keypoints(kpts_data, frame=(3, 3)) dc = slc.DataContainer(( img, mask, kpts, ), "IMP") transf = slt.Pad((20, 20)) res = transf(dc) assert (res[0][0].shape[0] == 20) and (res[0][0].shape[1] == 20) assert (res[1][0].shape[0] == 20) and (res[1][0].shape[1] == 20) assert (res[2][0].frame[0] == 20) and (res[2][0].frame[1] == 20) assert np.array_equal( res[2][0].data, np.array([[8, 8], [8, 10], [10, 10], [10, 8]]).reshape((4, 2)))
def __init__(self, pad, img_size=256): super(Pad, self).__init__(img_size) self.pad = pad self.solt_pipeline = slt.Pad(pad) self.albumentations_pipeline = albu.Compose([ albu.PadIfNeeded(min_height=pad, min_width=pad, border_mode=cv2.BORDER_CONSTANT, value=0), ToTensor(normalize={ "mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225] }), ]) self.torchvision_pipeline = tv_transforms.Compose([ tv_transforms.Pad(pad), tv_transforms.ToTensor(), tv_transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ])
def test_padding_for_item(inp, transform_settings, expected): dc = slc.DataContainer((inp, ), "I", transform_settings) dc_res = slt.Pad(pad_to=(7, 7))(dc) assert np.array_equal(expected, dc_res.data[0])
} }, { "cutout": { "cutout_size": 2, "p": 0.5 } }, ], }, }, ] } }, slc.Stream([ slt.Pad(34), slt.Crop(32, "r"), slt.CutOut(2), slc.Stream([slt.Pad(34), slt.Crop(32, "r"), slt.CutOut(2)]), ]), ], [ { "stream": { "transforms": [ { "stream": { "interpolation": None,
def test_padding_cant_be_float(): with pytest.raises(TypeError): slt.Pad(pad_to=2.5)
def test_wrong_transform_type_in_a_stream(img_2x2): dc = slc.DataContainer(img_2x2, 'I') with pytest.raises(TypeError): slc.Stream.exec_stream([slt.Pad(4), lambda x: x**2], dc, False)
def test_padding_img_mask(img, mask, pad_to, shape_out): dc = slc.DataContainer((img, mask), "IM") transf = slt.Pad(pad_to) res = transf(dc) np.testing.assert_array_equal(res[0][0].shape[:-1], shape_out) np.testing.assert_array_equal(res[1][0].shape, shape_out)
def init_mnist_transforms(): return Stream([slt.Pad(pad_to=(32, 32))])
def test_padding_img_2x2_2x2(img_2x2): img = img_2x2 dc = slc.DataContainer((img, ), "I") transf = slt.Pad((2, 2)) res = transf(dc) assert (res[0][0].shape[0] == 2) and (res[0][0].shape[1] == 2)
def __init__(self): self.solt_stream = slc.Stream( [slt.Pad(pad_to=(512, 512), padding="r")])
def test_padding_img(img, pad_to): dc = slc.DataContainer((img, ), "I") transf = slt.Pad(pad_to) res = transf(dc) np.testing.assert_array_equal(res[0][0].shape[:-1], pad_to)