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 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_manually_specified_padding_and_interpolation(img, mask): dc = slc.DataContainer( (img.copy(), img.copy(), mask.copy(), mask.copy(), 1), "IIMML", { 0: { "interpolation": "bicubic", "padding": "z" }, 2: { "interpolation": "bilinear" }, 3: { "padding": "r" } }, ) assert dc.transform_settings[0]["interpolation"] == ("bicubic", "strict") assert dc.transform_settings[1]["interpolation"] == ("bilinear", "inherit") assert dc.transform_settings[2]["interpolation"] == ("bilinear", "strict") assert dc.transform_settings[3]["interpolation"] == ("nearest", "strict") assert dc.transform_settings[0]["padding"] == ("z", "strict") assert dc.transform_settings[1]["padding"] == ("z", "inherit") assert dc.transform_settings[2]["padding"] == ("z", "inherit") assert dc.transform_settings[3]["padding"] == ("r", "strict")
def test_transform_returns_original_data_if_not_in_specified_indices( trf, img_3x3_rgb): img_3x3 = img_3x3_rgb * 128 kpts_data = np.array([[0, 0], [0, 2], [2, 2], [2, 0]]).reshape((4, 2)) kpts = slc.Keypoints(kpts_data.copy(), 3, 3) dc = slc.DataContainer((img_3x3.copy(), img_3x3.copy(), img_3x3.copy(), img_3x3.copy(), 1, kpts, 2), "IIIILPL") kwargs = {"p": 1, "data_indices": (0, 1, 4)} if class_accepts(trf, "gain_range"): kwargs["gain_range"] = (0.7, 0.9) if class_accepts(trf, "brightness_range"): kwargs["brightness_range"] = (10, 20) if class_accepts(trf, "h_range"): kwargs["h_range"] = (50, 50) kwargs["s_range"] = (50, 50) if class_accepts(trf, "h_range"): kwargs["h_range"] = (50, 50) kwargs["s_range"] = (50, 50) trf = trf(**kwargs) res = trf(dc) assert np.linalg.norm(res.data[0] - img_3x3) > 0 assert np.linalg.norm(res.data[1] - img_3x3) > 0 np.testing.assert_array_equal(res.data[2], img_3x3) np.testing.assert_array_equal(res.data[3], img_3x3) assert res.data[-1] == 2 np.testing.assert_array_equal(res.data[5].data, kpts_data)
def test_random_contrast_multiplies_the_data(img): dc = slc.DataContainer((img, ), "I") ppl = slt.Contrast(p=1, contrast_range=(2, 2)) dc_res = ppl(dc) assert np.array_equal(dc.data[0] * 2, dc_res.data[0])
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_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_cutout_blacks_out_image(img, expected, cut_size): dc = slc.DataContainer((img, ), "I") trf = slc.Stream([slt.CutOut(p=1, cutout_size=cut_size)]) dc_res = trf(dc, return_torch=False) assert np.array_equal(expected, dc_res.data[0])
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_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
def test_hsv_trying_use_not_uint8(dtype, img_6x6): trf = slt.HSV(p=1) img_rgb = np.dstack((img_6x6, img_6x6, img_6x6)).astype(dtype) dc = slc.DataContainer(img_rgb, "I") with pytest.raises(TypeError): trf(dc)
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_resize_img_to_arbitrary_size(img, mask, resize_to): # Setting up the data kpts_data = np.array([[0, 0], [0, 2], [2, 2], [2, 0]]).reshape( (4, 2)) # Top left corner kpts = slc.Keypoints(kpts_data.copy(), img.shape[0], img.shape[1]) dc = slc.DataContainer(( img, mask, kpts, ), "IMP") transf = slt.Resize(resize_to=resize_to) res = transf(dc).data if isinstance(resize_to, int): resize_to = (resize_to, resize_to) scale_x = resize_to[0] / img.shape[1] scale_y = resize_to[1] / img.shape[0] assert transf.resize_to == resize_to assert (res[0].shape[0] == resize_to[1]) and (res[0].shape[1] == resize_to[0]) assert (res[1].shape[0] == resize_to[1]) and (res[1].shape[1] == resize_to[0]) assert (res[2].height == resize_to[1]) and (res[2].width == resize_to[0]) kpts_data = kpts_data.astype(float) kpts_data[:, 0] *= scale_x kpts_data[:, 1] *= scale_y kpts_data = kpts_data.astype(int) assert np.array_equal(res[2].data, kpts_data)
def test_resize_img_to_arbitrary_size(img, mask, resize_to): # Setting up the data kpts_data = np.array([[0, 0], [0, 2], [2, 2], [2, 0]]).reshape( (4, 2)) # Top left corner kpts = slc.Keypoints(kpts_data.copy(), frame=(img.shape[:2])) dc = slc.DataContainer(( img, mask, kpts, ), "IMP") transf = slt.Resize(resize_to=resize_to) res = transf(dc).data if isinstance(resize_to, int): resize_to = (resize_to, resize_to) scales = tuple(resize_to[i] / img.shape[i] for i in range(img.ndim - 1)) assert transf.resize_to == resize_to np.testing.assert_array_equal(res[0].shape[:-1], resize_to) np.testing.assert_array_equal(res[1].shape, resize_to) np.testing.assert_array_equal(res[2].frame, resize_to) kpts_data = kpts_data.astype(float) kpts_data = (kpts_data * np.asarray(scales)[None, ]) kpts_data = kpts_data.astype(int) assert np.array_equal(res[2].data, kpts_data)
def test_scale_xy_axis_even(img_6x6): stream = slt.Scale((0.5, 0.5), (2, 2), same=False, p=1, ignore_fast_mode=True) dc = slc.DataContainer((img_6x6,), "I") H, W = img_6x6.shape[0], img_6x6.shape[1] img_res = stream(dc)[0][0] assert H * 2 == img_res.shape[0] assert W // 2 == img_res.shape[1]
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_scale_xy_axis_odd(img_5x5): stream = slt.Scale((0.5, 0.5), (3, 3), same=False, p=1, ignore_fast_mode=True) dc = slc.DataContainer((img_5x5,), "I") H, W = img_5x5.shape[0], img_5x5.shape[1] img_res = stream(dc)[0][0] assert H * 3 == img_res.shape[0] assert W // 2 == img_res.shape[1]
def test_zoom_x_axis_odd(img_5x5): stream = slt.Scale(range_x=(0.5, 0.5), range_y=(1, 1), same=False, p=1, ignore_fast_mode=True) dc = slc.DataContainer((img_5x5,), "I") H, W = img_5x5.shape[0], img_5x5.shape[1] img_res = stream(dc)[0][0] assert H == img_res.shape[0] assert W // 2 == img_res.shape[1]
def test_data_dep_trf_raises_value_error_when_imgs_are_of_different_size( img_1, img_2): trf = slt.SaltAndPepper(gain_range=0.0, p=1) with pytest.raises(ValueError): trf( slc.DataContainer( (1, img_1.astype(np.uint8), img_2.astype(np.uint8)), "LII"))
def test_rotate_90_img_mask_keypoints_destructive(img_3x3, mask_3x3, transform_settings, ignore_state): # 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 H, W = mask.shape dc = slc.DataContainer((img, mask, kpts, 1), "IMPL", transform_settings=copy.deepcopy(transform_settings),) # Defining the 90 degrees transform (clockwise) stream = slt.Rotate(angle_range=(90, 90), p=1, ignore_state=ignore_state) 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) img_inter = ALLOWED_INTERPOLATIONS["bicubic"] img_pad = ALLOWED_PADDINGS["z"] if transform_settings is not None: img_inter = ALLOWED_INTERPOLATIONS[transform_settings[0]["interpolation"]] img_pad = ALLOWED_PADDINGS[transform_settings[0]["padding"]] expected_img_res = cv2.warpAffine(img, M, (W, H), flags=img_inter, borderMode=img_pad).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 __getitem__(self, index): subject_id, side, kl, t_lnd, f_lnd, _, center = self.split.iloc[index] kl = int(kl) if self.ann_type == 'hc': fname = os.path.join(self.data_root, f'{subject_id}_{kl}_{side}.png') else: fname = os.path.join(self.data_root, f'{subject_id}.png') img = cv2.imread(fname) if self.ann_type == 'hc': lndms = np.vstack((parse_landmarks(t_lnd), parse_landmarks(f_lnd))) kpts = slt.KeyPoints(lndms, img.shape[0], img.shape[1]) dc = slc.DataContainer((img, kpts, kl), 'IPL') else: row, col, _ = img.shape center = np.array(list(map(int, center.split( ',')))) * self.hc_lc_scale - self.hc_lc_scale * self.img_pad if side == 'L': img = img[:, col // 2:] center[0] -= col // 2 else: img = img[:, :col // 2] center = slt.KeyPoints(np.expand_dims(center, 0), img.shape[0], img.shape[1]) dc = slc.DataContainer((img, center, -1), 'IPL') transform_result = self.transform(dc) img, target_hm, target_kp, kl = transform_result res = { 'img': img, 'subject_id': subject_id, 'kl': kl, 'side': side, 'kp_gt': target_kp } if target_hm is not None: res['target_hm'] = target_hm return res
def test_interpolation_or_padding_settings_for_labels_or_keypoints(setting): kpts = slc.Keypoints(pts=np.array([[0, 0], [0, 2], [2, 2], [2, 0]]).reshape((4, 2)), frame=(3, 3)) with pytest.raises(TypeError): slc.DataContainer(data=(kpts, ), fmt="P", transform_settings={0: setting})
def test_different_interpolations_per_item_per_transform(img_6x6, transform_settings): dc = slc.DataContainer((img_6x6,), "I", transform_settings=transform_settings) dc_res = slt.Resize(resize_to=(10, 15), interpolation="bilinear")(dc) interp = ALLOWED_INTERPOLATIONS["bilinear"] if transform_settings is not None: interp = ALLOWED_INTERPOLATIONS[transform_settings[0]["interpolation"][0]] assert np.array_equal(cv2.resize(img_6x6, (10, 15), interpolation=interp).reshape(15, 10, 1), dc_res.data[0],)
def test_transform_settings_wrong_length(img_5x5): with pytest.raises(ValueError): slc.DataContainer((img_5x5, img_5x5, 1), 'IIL', { 1: {}, 2: {}, 3: {}, 4: {} })
def test_translate_forward_backward_sampling(img_6x6_rgb): stream = slc.Stream( [slt.Translate(range_x=(1, 1), range_y=(1, 1), p=1), slt.Translate(range_x=(-1, -1), range_y=(-1, -1), p=1),] ) dc = slc.DataContainer(img_6x6_rgb, "I") trf = stream.optimize_transforms_stack(stream.transforms, dc)[0] assert 1 == trf.state_dict["translate_x"] # The settings will be overrided by the first transform assert 1 == trf.state_dict["translate_y"] # The settings will be overrided by the first transform assert np.array_equal(trf.state_dict["transform_matrix"], np.eye(3))
def test_rotate_90_transforms_have_same_behaviour(k, img_6x6_rgb): dc = slc.DataContainer(img_6x6_rgb, "I") trf_1 = slt.Rotate(angle_range=(k * 90, k * 90), p=1) trf_1.sample_transform(dc) trf_2 = slt.Rotate90(k=k, p=1) trf_2.sample_transform(dc) assert np.array_equal(trf_1.state_dict["transform_matrix"], trf_2.state_dict["transform_matrix"])
def test_crop_or_cutout_size_are_too_big(img_2x2, cutout_crop_size): dc = slc.DataContainer((img_2x2, ), "I") trf = slt.Crop(crop_to=cutout_crop_size) with pytest.raises(ValueError): trf(dc) trf = slt.CutOut(p=1, cutout_size=cutout_crop_size) with pytest.raises(ValueError): trf(dc)
def test_scale_img_mask(img_3x4, mask_3x4): img_mask_3x4 = img_3x4, mask_3x4 stream = slt.Scale((0.5, 0.5), (2, 2), same=False, p=1, ignore_fast_mode=True) dc = slc.DataContainer(img_mask_3x4, "IM") H, W = img_mask_3x4[0].shape[0], img_mask_3x4[0].shape[1] img_res = stream(dc)[0][0] mask_res = stream(dc)[1][0] assert H * 2 == img_res.shape[0], W // 2 == img_res.shape[1] assert H * 2 == mask_res.shape[0], W // 2 == mask_res.shape[1]
def test_gaussian_noise_no_image_throws_value_error(): trf = slt.Noise(p=1) # Setting up the data kpts_data = np.array([[0, 0], [0, 5], [1, 3], [2, 0]]).reshape((4, 2)) kpts = slc.Keypoints(kpts_data, 6, 6) dc = slc.DataContainer((kpts, ), "P") with pytest.raises(ValueError): trf(dc)
def test_pad_crop_resize_dont_change_data_when_parameters_are_not_set(img_3x3, mask_3x3, trf): # 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") res = trf()(dc, return_torch=False) assert dc == res