def test_scale_translate_rotate_compose():
coord = [10, 13]
transform_a = Affine(scale=[2, 3], translate=[8, -5], rotate=25)
transform_b = Affine(scale=[0.3, 1.4], translate=[-2.2, 3], rotate=65)
transform_c = transform_b.compose(transform_a)
new_coord_1 = transform_c(coord)
new_coord_2 = transform_b(transform_a(coord))
npt.assert_allclose(new_coord_1, new_coord_2)
def test_scale_translate_rotate_inverse():
coord = [10, 13]
transform = Affine(scale=[2, 3], translate=[8, -5], rotate=90)
new_coord = transform(coord)
post_scale = np.multiply(coord, [2, 3])
# As rotate by 90 degrees, can use [-y, x]
post_rotate = [-post_scale[1], post_scale[0]]
target_coord = np.add(post_rotate, [8, -5])
npt.assert_allclose(new_coord, target_coord)
inverted_new_coord = transform.inverse(new_coord)
npt.assert_allclose(inverted_new_coord, coord)
def test_transform_coupling(make_napari_viewer):
viewer = make_napari_viewer()
data = np.random.random((2, 6, 30, 40))
layer = viewer.add_image(data)
layer.mode = 'transform'
layer.affine = Affine(scale=[0.5, 0.5, 0.5, 0.5])
np.testing.assert_almost_equal(
viewer.overlays.interaction_box.transform.scale, [0.5, 0.5])
viewer.overlays.interaction_box.transform_drag = Affine(scale=[2.0, 2.0])
np.testing.assert_almost_equal(layer.affine.scale, [0.5, 0.5, 2.0, 2.0])
def test_rotate():
coord = [10, 13]
transform = Affine(rotate=90)
new_coord = transform(coord)
# As rotate by 90 degrees, can use [-y, x]
target_coord = [-coord[1], coord[0]]
npt.assert_allclose(new_coord, target_coord)
def test_replace_slice_independence():
affine = Affine(ndim=6)
a = Affine(translate=(3, 8), rotate=33, scale=(0.75, 1.2), shear=[-0.5])
b = Affine(translate=(2, 5), rotate=-10, scale=(1.0, 2.3), shear=[-0.0])
c = Affine(translate=(0, 0), rotate=45, scale=(3.33, 0.9), shear=[1.5])
affine = affine.replace_slice([1, 2], a)
affine = affine.replace_slice([3, 4], b)
affine = affine.replace_slice([0, 5], c)
np.testing.assert_almost_equal(a.affine_matrix,
affine.set_slice([1, 2]).affine_matrix)
np.testing.assert_almost_equal(b.affine_matrix,
affine.set_slice([3, 4]).affine_matrix)
np.testing.assert_almost_equal(c.affine_matrix,
affine.set_slice([0, 5]).affine_matrix)
def test_split_channels_multi_affine_napari(kwargs):
kwargs['affine'] = [
Affine(scale=[1, 1]),
Affine(scale=[2, 2]),
Affine(scale=[3, 3]),
]
data = np.random.randint(0, 200, (3, 128, 128))
result_list = split_channels(data, 0, **kwargs)
assert len(result_list) == 3
for idx, result_data in enumerate(result_list):
d, meta, _ = result_data
assert d.shape == (128, 128)
assert np.array_equal(
meta['affine'].affine_matrix,
Affine(scale=[idx + 1, idx + 1]).affine_matrix,
)
def test_split_channels_affine_napari(kwargs):
kwargs['affine'] = Affine(affine_matrix=np.eye(3))
data = np.random.randint(0, 200, (3, 128, 128))
result_list = split_channels(data, 0, **kwargs)
assert len(result_list) == 3
for d, meta, _ in result_list:
assert d.shape == (128, 128)
assert np.array_equal(meta['affine'].affine_matrix, np.eye(3))
def test_repeat_shear_setting():
"""Test repeatedly setting shear with a lower triangular matrix."""
# Note this test is needed to check lower triangular
# decomposition of shear is working
mat = np.eye(3)
mat[2, 0] = 0.5
transform = Affine(shear=mat.copy())
# Check shear decomposed into lower triangular
np.testing.assert_almost_equal(mat, transform.shear)
# Set shear to same value
transform.shear = mat.copy()
# Check shear still decomposed into lower triangular
np.testing.assert_almost_equal(mat, transform.shear)
# Set shear to same value
transform.shear = mat.copy()
# Check shear still decomposed into lower triangular
np.testing.assert_almost_equal(mat, transform.shear)
def test_numpy_array_protocol(dimensionality):
N = dimensionality
A = np.eye(N + 1)
A[:-1] = np.random.random((N, N + 1))
transform = Affine(affine_matrix=A)
np.testing.assert_almost_equal(transform.affine_matrix, A)
np.testing.assert_almost_equal(np.asarray(transform), A)
coords = np.random.random((20, N + 1)) * 20
coords[:, -1] = 1
np.testing.assert_almost_equal((transform @ coords.T).T[:, :-1],
transform(coords[:, :-1]))
def test_affine_matrix_compose(dimensionality):
np.random.seed(0)
N = dimensionality
A = np.eye(N + 1)
A[:-1, :-1] = np.random.random((N, N))
A[:-1, -1] = np.random.random(N)
B = np.eye(N + 1)
B[:-1, :-1] = np.random.random((N, N))
B[:-1, -1] = np.random.random(N)
# Create transform
transform_A = Affine(affine_matrix=A)
transform_B = Affine(affine_matrix=B)
# Check affine was passed correctly
np.testing.assert_almost_equal(transform_A.affine_matrix, A)
np.testing.assert_almost_equal(transform_B.affine_matrix, B)
# Compose tranform and directly matrix multiply
transform_C = transform_B.compose(transform_A)
C = B @ A
np.testing.assert_almost_equal(transform_C.affine_matrix, C)
def test_affine_properties_setters():
transform = Affine()
transform.translate = [8, -5]
npt.assert_allclose(transform.translate, [8, -5])
transform.scale = [2, 3]
npt.assert_allclose(transform.scale, [2, 3])
transform.rotate = 90
npt.assert_almost_equal(transform.rotate, [[0, -1], [1, 0]])
transform.shear = [1]
npt.assert_almost_equal(transform.shear, [1])
def test_affine_matrix_inverse(dimensionality):
np.random.seed(0)
N = dimensionality
A = np.eye(N + 1)
A[:-1, :-1] = np.random.random((N, N))
A[:-1, -1] = np.random.random(N)
# Create transform
transform = Affine(affine_matrix=A)
# Check affine was passed correctly
np.testing.assert_almost_equal(transform.affine_matrix, A)
# Check inverse is create correctly
np.testing.assert_almost_equal(transform.inverse.affine_matrix,
np.linalg.inv(A))
def test_composite_affine_equiv_to_affine(dimensionality):
np.random.seed(0)
translate = np.random.randn(dimensionality)
scale = np.random.randn(dimensionality)
rotate = special_ortho_group.rvs(dimensionality)
shear = np.random.randn((dimensionality * (dimensionality - 1)) // 2)
composite = CompositeAffine(
translate=translate, scale=scale, rotate=rotate, shear=shear
)
affine = Affine(
translate=translate, scale=scale, rotate=rotate, shear=shear
)
np.testing.assert_almost_equal(
composite.affine_matrix, affine.affine_matrix
)
def test_affine_matrix(dimensionality):
np.random.seed(0)
N = dimensionality
A = np.eye(N + 1)
A[:-1, :-1] = np.random.random((N, N))
A[:-1, -1] = np.random.random(N)
# Create transform
transform = Affine(affine_matrix=A)
# Check affine was passed correctly
np.testing.assert_almost_equal(transform.affine_matrix, A)
# Create input vector
x = np.ones(N + 1)
x[:-1] = np.random.random(N)
# Apply transform and direct matrix multiplication
result_transform = transform(x[:-1])
result_mat_multiply = (A @ x)[:-1]
np.testing.assert_almost_equal(result_transform, result_mat_multiply)
def test_affine_properties():
transform = Affine(scale=[2, 3], translate=[8, -5], rotate=90, shear=[1])
npt.assert_allclose(transform.translate, [8, -5])
npt.assert_allclose(transform.scale, [2, 3])
npt.assert_almost_equal(transform.rotate, [[0, -1], [1, 0]])
npt.assert_almost_equal(transform.shear, [1])
def test_diagonal_scale_setter():
diag_transform = Affine(scale=[2, 3], name='st')
assert diag_transform._is_diagonal
diag_transform.scale = [1]
npt.assert_allclose(diag_transform.scale, [1.0, 1.0])
def test_replace_slice_num_dimensions():
with pytest.raises(ValueError):
Affine().replace_slice([0], Affine())
