def test_5d_grid_range(self):
a_grid = gryds.Grid((10, 10, 10, 10, 10))
self.assertEqual(a_grid.grid[0, 9, 0, 0, 0, 0],
np.array(0.9, dtype=DTYPE))
self.assertEqual(a_grid.grid[4, 0, 0, 0, 0, 9],
np.array(0.9, dtype=DTYPE))
def test_5d_downscaling(self):
matrix = np.zeros((5, 6))
for i in range(5):
matrix[i, i] = 1
matrix[2, 2] = 1.5
trf = gryds.LinearTransformation(
matrix) # scale grid by 150$ isotropically
grid = gryds.Grid((2, 3, 4, 5, 6))
new_grid = grid.transform(trf)
# The original grid runs from 0 to 0.9
# The transformed grid should run from 0 to 1.35
np.testing.assert_equal(new_grid.grid[0, 0], np.array(0, DTYPE))
np.testing.assert_almost_equal(
new_grid.grid[2, :, :, 3],
np.array(1.125, DTYPE), # 1.5 * 0.75
decimal=6)
# The jacobian of this transformation should be 1 everywhere, i.e. no
# scaling should have happened
np.testing.assert_almost_equal(
grid.jacobian_det(trf),
np.array(1.5, DTYPE), # i.e. 1.5^5
decimal=4)
def test_2d_grid_scaling(self):
a_grid = gryds.Grid((10, 20))
new_grid = a_grid.scaled_to((3, 4))
self.assertAlmostEqual(new_grid.grid[0, 9, 0],
np.array(2.7, dtype=DTYPE),
places=6)
self.assertAlmostEqual(new_grid.grid[1, 0, 19],
np.array(3.8, dtype=DTYPE),
places=6)
def test_bspline_2d_folding(self):
bspline_grid = np.array([
# Folds the top half of the image slightly over the bottom half.
[[0.51, 0.51], [-0.5, -0.5]],
[[0, 0], [0, 0]]
])
trf = gryds.BSplineTransformationCuda(bspline_grid, order=1)
grid = gryds.Grid((100, 20))
# The jacobian of this transformation should be below 0 everywhere
self.assertTrue(np.all(grid.jacobian_det(trf) < 0))
def test_3d_45_deg_rotation_with_center(self):
trf = gryds.AffineTransformation(
ndim=3,
angles=[0, 0.25 * np.pi, 0],
center_of=np.zeros((10, 20, 20))) # rotate grid 45° anticlockwise
grid = gryds.Grid((10, 20, 20))
# The jacobian of this transformation should be 1 everywhere, i.e. no
# scaling should have happened
np.testing.assert_almost_equal(grid.jacobian_det(trf),
np.array(1, DTYPE),
decimal=5)
def test_5d_grid_scaling(self):
a_grid = gryds.Grid((10, 10, 10, 10, 10))
new_grid = a_grid.scaled_to((3, 4, 5, 6, 7))
self.assertAlmostEqual(
new_grid.grid[0, 9, 0, 0, 0, 0],
np.array(2.7, dtype=DTYPE), # 3 x 9 / 10
places=6)
self.assertAlmostEqual(
new_grid.grid[4, 0, 0, 0, 0, 9],
np.array(6.3, dtype=DTYPE), # 7 x 9 / 10
places=6)
def test_bspline_2d(self):
bspline_grid = np.array([[[0.1, 0], [0, 0]], [[0, 0], [0, 0]]])
trf = gryds.BSplineTransformation(bspline_grid)
grid = gryds.Grid((10, 20))
new_grid = grid.transform(trf)
# The top left has been displaced by 10% or 0.1 pixels in the i-direction
np.testing.assert_almost_equal(new_grid.grid[0, 0, 0],
np.array(0.1, DTYPE))
# The jacobian of this transformation should NOT be 1 everywhere, i.e.
# scaling should have happened, and the new volume should be smaller
# as the top left has been folded in
self.assertTrue(np.all(grid.jacobian_det(trf) < np.array(1, DTYPE)))
def test_2d_90_deg_rotation(self):
trf = gryds.AffineTransformation(ndim=2, angles=[0.5 * np.pi]) # rotate grid 90 degrees clockwise
grid = gryds.Grid((10, 20))
new_grid = grid.transform(trf)
# The grid runs from 0 to 0.95 on the j-axis
# 90 deg rot means the i-axis will run from 0 to -0.95
np.testing.assert_equal(new_grid.grid[0, 0, 0], np.array(0, DTYPE))
np.testing.assert_equal(new_grid.grid[0, 0, -1], np.array(-0.95, DTYPE))
# The jacobian of this transformation should be 1 everywhere, i.e. no
# scaling should have happened
np.testing.assert_almost_equal(
grid.jacobian_det(trf),
np.array(1, DTYPE),
decimal=4)
def test_translation_bspline_2d(self):
bspline_grid = np.ones((2, 2, 2))
trf = gryds.BSplineTransformation(bspline_grid)
grid = gryds.Grid((10, 20))
new_grid = grid.transform(trf)
# The grid runs from 0 to 0.9 on the i-axis
# Translation by 100% will mean that the i-axis will now run from 1 to 1.9
np.testing.assert_equal(new_grid.grid[0, 0, 0], np.array(1, DTYPE))
np.testing.assert_equal(new_grid.grid[0, -1, 0], np.array(1.9, DTYPE))
# The jacobian of this transformation should be 1 everywhere, i.e. no
# scaling should have happened
np.testing.assert_almost_equal(grid.jacobian_det(trf),
np.array(1, DTYPE),
decimal=4)
def test_2d_translation(self):
trf = gryds.TranslationTransformation(
[0.1, 0]) # move grid 10% downwards (moves image 10% upwards)
grid = gryds.Grid((10, 20))
new_grid = grid.transform(trf)
# The original grid runs from 0 to 0.9 for the i-coordinates
# The transformed grid should run from 0.1 to 1
np.testing.assert_equal(new_grid.grid[0, 0], np.array(0.1, DTYPE))
np.testing.assert_equal(new_grid.grid[0, 9], np.array(1.0, DTYPE))
# The jacobian of this transformation should be 1 everywhere, i.e. no
# scaling should have happened
np.testing.assert_almost_equal(grid.jacobian_det(trf),
np.array(1, DTYPE),
decimal=4)
def test_5d_translation(self):
trf = gryds.TranslationTransformation([0, 0, 0.1, 0, 0])
grid = gryds.Grid((10, 10, 10, 10, 10))
new_grid = grid.transform(trf)
# The original grid runs from 0 to 0.9
# The transformed grid should run from 0.1 to 1
self.assertTrue(np.all(new_grid.grid[2, :, :, 0] == np.array(0.1, DTYPE)))
self.assertTrue(np.all(new_grid.grid[2, :, :, 9] == np.array(1.0, DTYPE)))
# The jacobian of this transformation should be 1 everywhere, i.e. no
# scaling should have happened
np.testing.assert_almost_equal(
grid.jacobian_det(trf),
np.array(1, DTYPE),
decimal=4)
def random_deformation_gen(image, bspline_shape=(3, 3), std=0.15):
assert image.shape[0] == image.shape[1]
bspline_grid_shape = (len(image.shape), ) + bspline_shape
bspline_grid = np.random.rand(*bspline_grid_shape) * std
a_bspline_transformation = gryds.BSplineTransformation(bspline_grid)
an_image_interpolator = gryds.Interpolator(image, order=1)
an_image_grid = gryds.Grid(
image.shape) # makes a Grid the size of the image
a_deformed_image_grid = an_image_grid.transform(a_bspline_transformation)
a_deformed_image = an_image_interpolator.resample(a_deformed_image_grid)
f = (a_deformed_image_grid.grid - an_image_grid.grid) * image.shape[0]
flow = np.ndarray(image.shape + (len(image.shape), ))
for i in range(len(image.shape)):
flow[..., i] = f[i, ...]
return a_deformed_image, flow
def test_2d_downscaling(self):
trf = gryds.AffineTransformation(
ndim=2, scaling=[1.5, 1]) # scale grid by 150% isotropically
grid = gryds.Grid((10, 20))
new_grid = grid.transform(trf)
# The original grid runs from 0 to 0.9 for the i-coordinates
# The transformed grid should run from 0 to 1.35
np.testing.assert_equal(new_grid.grid[0, 0], np.array(0, DTYPE))
np.testing.assert_almost_equal(new_grid.grid[0, 9],
np.array(1.35, DTYPE),
decimal=6)
# The jacobian of this transformation should be 1 everywhere, i.e. no
# scaling should have happened
np.testing.assert_almost_equal(
grid.jacobian_det(trf),
np.array(1.5, DTYPE), # i.e. 1.5*1.5
decimal=4)
def test_grid_wrong_scale_shape(self):
a_grid = gryds.Grid((2, 2))
self.assertRaises(ValueError, a_grid.scaled_to, [1, 2, 3])
def test_grid_init(self):
gryds.Grid(grid=np.zeros((2, 10, 10)))
def test_grid_repr(self):
a_grid = gryds.Grid((2, 2))
self.assertEqual(str(a_grid), 'Grid(2D, 2x2)')
def test_grid_repr(self):
a_grid = gryds.Grid((2, 2))
self.assertEqual(
str(a_grid),
'gryds.interpolators.grid.Grid(\n\t[[[0. 0. ]\n\t [0.5 0.5]]\n\t\n\t [[0. 0.5]\n\t [0. 0.5]]]\n)'
)
def test_2d_grid_ranges(self):
a_grid = gryds.Grid((10, 20))
self.assertEqual(a_grid.grid[0, 9, 0], np.array(0.9, dtype=DTYPE))
self.assertEqual(a_grid.grid[1, 0, 19], np.array(0.95, dtype=DTYPE))
