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