def test_MaximumDeterministicTracker():
"""This tests that the Maximum Deterministic Direction Getter plays nice
LocalTracking and produces reasonable streamlines in a simple example.
"""
sphere = HemiSphere.from_sphere(unit_octahedron)
# A simple image with three possible configurations, a vertical tract,
# a horizontal tract and a crossing
pmf_lookup = np.array([[0., 0., 1.],
[1., 0., 0.],
[0., 1., 0.],
[.4, .6, 0.]])
simple_image = np.array([[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 3, 2, 2, 2, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
])
simple_image = simple_image[..., None]
pmf = pmf_lookup[simple_image]
seeds = [np.array([1., 1., 0.])] * 30
mask = (simple_image > 0).astype(float)
tc = ThresholdTissueClassifier(mask, .5)
dg = DeterministicMaximumDirectionGetter.from_pmf(pmf, 90, sphere)
streamlines = LocalTracking(dg, tc, seeds, np.eye(4), 1.)
expected = [np.array([[ 0., 1., 0.],
[ 1., 1., 0.],
[ 2., 1., 0.],
[ 2., 2., 0.],
[ 2., 3., 0.],
[ 2., 4., 0.],
[ 2., 5., 0.]]),
np.array([[ 0., 1., 0.],
[ 1., 1., 0.],
[ 2., 1., 0.],
[ 3., 1., 0.],
[ 4., 1., 0.]])
]
def allclose(x, y):
return x.shape == y.shape and np.allclose(x, y)
for sl in streamlines:
dir = ( -sphere.vertices[0] ).copy()
if not allclose(sl, expected[0]):
raise AssertionError()
# The first path is not possible if 90 degree turns are excluded
dg = DeterministicMaximumDirectionGetter.from_pmf(pmf, 80, sphere)
streamlines = LocalTracking(dg, tc, seeds, np.eye(4), 1.)
for sl in streamlines:
npt.assert_(np.allclose(sl, expected[1]))
def test_DeterministicMaximumDirectionGetter():
# Test the DeterministicMaximumDirectionGetter
dir = unit_octahedron.vertices[-1].copy()
point = np.zeros(3)
N = unit_octahedron.theta.shape[0]
# No valid direction
pmf = np.zeros((3, 3, 3, N))
dg = DeterministicMaximumDirectionGetter.from_pmf(pmf, 90,
unit_octahedron)
state = dg.get_direction(point, dir)
npt.assert_equal(state, 1)
# Test BF #1566 - bad condition in DeterministicMaximumDirectionGetter
pmf = np.zeros((3, 3, 3, N))
pmf[0, 0, 0, 0] = 1
dg = DeterministicMaximumDirectionGetter.from_pmf(pmf, 0,
unit_octahedron)
state = dg.get_direction(point, dir)
npt.assert_equal(state, 1)
def test_affine_transformations():
"""This tests that the input affine is properly handled by
LocalTracking and produces reasonable streamlines in a simple example.
"""
sphere = HemiSphere.from_sphere(unit_octahedron)
# A simple image with three possible configurations, a vertical tract,
# a horizontal tract and a crossing
pmf_lookup = np.array([[0., 0., 1.],
[1., 0., 0.],
[0., 1., 0.],
[.4, .6, 0.]])
simple_image = np.array([[0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 3, 2, 2, 2, 0],
[0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
])
simple_image = simple_image[..., None]
pmf = pmf_lookup[simple_image]
seeds = [np.array([1., 1., 0.]),
np.array([2., 4., 0.])]
expected = [np.array([[0., 1., 0.],
[1., 1., 0.],
[2., 1., 0.],
[3., 1., 0.],
[4., 1., 0.]]),
np.array([[2., 0., 0.],
[2., 1., 0.],
[2., 2., 0.],
[2., 3., 0.],
[2., 4., 0.],
[2., 5., 0.]])]
mask = (simple_image > 0).astype(float)
tc = BinaryTissueClassifier(mask)
dg = DeterministicMaximumDirectionGetter.from_pmf(pmf, 60, sphere,
pmf_threshold=0.1)
# TST- bad affine wrong shape
bad_affine = np.eye(3)
npt.assert_raises(ValueError, LocalTracking, dg, tc, seeds, bad_affine, 1.)
# TST - bad affine with shearing
bad_affine = np.eye(4)
bad_affine[0, 1] = 1.
npt.assert_raises(ValueError, LocalTracking, dg, tc, seeds, bad_affine, 1.)
# TST - identity
a0 = np.eye(4)
# TST - affines with positive/negative offsets
a1 = np.eye(4)
a1[:3, 3] = [1, 2, 3]
a2 = np.eye(4)
a2[:3, 3] = [-2, 0, -1]
# TST - affine with scaling
a3 = np.eye(4)
a3[0, 0] = a3[1, 1] = a3[2, 2] = 8
# TST - affine with axes inverting (negative value)
a4 = np.eye(4)
a4[1, 1] = a4[2, 2] = -1
# TST - combined affines
a5 = a1 + a2 + a3
a5[3, 3] = 1
# TST - in vivo affine exemple
# Sometimes data have affines with tiny shear components.
# For example, the small_101D data-set has some of that:
fdata, _, _ = get_data('small_101D')
a6 = nib.load(fdata).affine
for affine in [a0, a1, a2, a3, a4, a5, a6]:
lin = affine[:3, :3]
offset = affine[:3, 3]
seeds_trans = [np.dot(lin, s) + offset for s in seeds]
# We compute the voxel size to ajust the step size to one voxel
voxel_size = np.mean(np.sqrt(np.dot(lin, lin).diagonal()))
streamlines = LocalTracking(direction_getter=dg,
tissue_classifier=tc,
seeds=seeds_trans,
affine=affine,
step_size=voxel_size,
return_all=True)
# We apply the inverse affine transformation to the generated
# streamlines. It should be equals to the expected streamlines
# (generated with the identity affine matrix).
affine_inv = np.linalg.inv(affine)
lin = affine_inv[:3, :3]
offset = affine_inv[:3, 3]
streamlines_inv = []
for line in streamlines:
streamlines_inv.append([np.dot(pts, lin) + offset for pts in line])
npt.assert_equal(len(streamlines_inv[0]), len(expected[0]))
npt.assert_(np.allclose(streamlines_inv[0], expected[0], atol=0.3))
npt.assert_equal(len(streamlines_inv[1]), len(expected[1]))
npt.assert_(np.allclose(streamlines_inv[1], expected[1], atol=0.3))
def test_maximum_deterministic_tracker():
"""This tests that the Maximum Deterministic Direction Getter plays nice
LocalTracking and produces reasonable streamlines in a simple example.
"""
sphere = HemiSphere.from_sphere(unit_octahedron)
# A simple image with three possible configurations, a vertical tract,
# a horizontal tract and a crossing
pmf_lookup = np.array([[0., 0., 1.], [1., 0., 0.], [0., 1., 0.],
[.4, .6, 0.]])
simple_image = np.array([
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 3, 2, 2, 2, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
])
simple_image = simple_image[..., None]
pmf = pmf_lookup[simple_image]
seeds = [np.array([1., 1., 0.])] * 30
mask = (simple_image > 0).astype(float)
sc = ThresholdStoppingCriterion(mask, .5)
dg = DeterministicMaximumDirectionGetter.from_pmf(pmf,
90,
sphere,
pmf_threshold=0.1)
streamlines = LocalTracking(dg, sc, seeds, np.eye(4), 1.)
expected = [
np.array([[0., 1., 0.], [1., 1., 0.], [2., 1., 0.], [2., 2., 0.],
[2., 3., 0.], [2., 4., 0.]]),
np.array([[0., 1., 0.], [1., 1., 0.], [2., 1., 0.], [3., 1., 0.],
[4., 1., 0.]]),
np.array([[0., 1., 0.], [1., 1., 0.], [2., 1., 0.]])
]
def allclose(x, y):
return x.shape == y.shape and np.allclose(x, y)
for sl in streamlines:
if not allclose(sl, expected[0]):
raise AssertionError()
# The first path is not possible if 90 degree turns are excluded
dg = DeterministicMaximumDirectionGetter.from_pmf(pmf,
80,
sphere,
pmf_threshold=0.1)
streamlines = LocalTracking(dg, sc, seeds, np.eye(4), 1.)
for sl in streamlines:
npt.assert_(np.allclose(sl, expected[1]))
# Both path are not possible if 90 degree turns are exclude and
# if pmf_threshold is larger than 0.67. Streamlines should stop at
# the crossing.
# 0.4/0.6 < 2/3, multiplying the pmf should not change the ratio
dg = DeterministicMaximumDirectionGetter.from_pmf(10 * pmf,
80,
sphere,
pmf_threshold=0.67)
streamlines = LocalTracking(dg, sc, seeds, np.eye(4), 1.)
for sl in streamlines:
npt.assert_(np.allclose(sl, expected[2]))
def test_affine_transformations():
"""This tests that the input affine is properly handled by
LocalTracking and produces reasonable streamlines in a simple example.
"""
sphere = HemiSphere.from_sphere(unit_octahedron)
# A simple image with three possible configurations, a vertical tract,
# a horizontal tract and a crossing
pmf_lookup = np.array([[0., 0., 1.],
[1., 0., 0.],
[0., 1., 0.],
[.4, .6, 0.]])
simple_image = np.array([[0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 3, 2, 2, 2, 0],
[0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
])
simple_image = simple_image[..., None]
pmf = pmf_lookup[simple_image]
seeds = [np.array([1., 1., 0.]),
np.array([2., 4., 0.])]
expected = [np.array([[1., 1., 0.],
[2., 1., 0.],
[3., 1., 0.]]),
np.array([[2., 1., 0.],
[2., 2., 0.],
[2., 3., 0.],
[2., 4., 0.]])]
mask = (simple_image > 0).astype(float)
sc = BinaryStoppingCriterion(mask)
dg = DeterministicMaximumDirectionGetter.from_pmf(pmf, 60, sphere,
pmf_threshold=0.1)
# TST- bad affine wrong shape
bad_affine = np.eye(3)
npt.assert_raises(ValueError, LocalTracking, dg, sc, seeds, bad_affine, 1.)
# TST - bad affine with shearing
bad_affine = np.eye(4)
bad_affine[0, 1] = 1.
npt.assert_raises(ValueError, LocalTracking, dg, sc, seeds, bad_affine, 1.)
# TST - bad seeds
bad_seeds = 1000
npt.assert_raises(ValueError, LocalTracking, dg, sc, bad_seeds,
np.eye(4), 1.)
# TST - identity
a0 = np.eye(4)
# TST - affines with positive/negative offsets
a1 = np.eye(4)
a1[:3, 3] = [1, 2, 3]
a2 = np.eye(4)
a2[:3, 3] = [-2, 0, -1]
# TST - affine with scaling
a3 = np.eye(4)
a3[0, 0] = a3[1, 1] = a3[2, 2] = 8
# TST - affine with axes inverting (negative value)
a4 = np.eye(4)
a4[1, 1] = a4[2, 2] = -1
# TST - combined affines
a5 = a1 + a2 + a3
a5[3, 3] = 1
# TST - in vivo affine example
# Sometimes data have affines with tiny shear components.
# For example, the small_101D data-set has some of that:
fdata, _, _ = get_fnames('small_101D')
a6 = nib.load(fdata).affine
for affine in [a0, a1, a2, a3, a4, a5, a6]:
lin = affine[:3, :3]
offset = affine[:3, 3]
seeds_trans = [np.dot(lin, s) + offset for s in seeds]
# We compute the voxel size to adjust the step size to one voxel
voxel_size = np.mean(np.sqrt(np.dot(lin, lin).diagonal()))
streamlines = LocalTracking(direction_getter=dg,
stopping_criterion=sc,
seeds=seeds_trans,
affine=affine,
step_size=voxel_size,
return_all=True)
# We apply the inverse affine transformation to the generated
# streamlines. It should be equals to the expected streamlines
# (generated with the identity affine matrix).
affine_inv = np.linalg.inv(affine)
lin = affine_inv[:3, :3]
offset = affine_inv[:3, 3]
streamlines_inv = []
for line in streamlines:
streamlines_inv.append([np.dot(pts, lin) + offset for pts in line])
npt.assert_equal(len(streamlines_inv[0]), len(expected[0]))
npt.assert_(np.allclose(streamlines_inv[0], expected[0], atol=0.3))
npt.assert_equal(len(streamlines_inv[1]), len(expected[1]))
npt.assert_(np.allclose(streamlines_inv[1], expected[1], atol=0.3))
def test_maximum_deterministic_tracker():
"""This tests that the Maximum Deterministic Direction Getter plays nice
LocalTracking and produces reasonable streamlines in a simple example.
"""
sphere = HemiSphere.from_sphere(unit_octahedron)
# A simple image with three possible configurations, a vertical tract,
# a horizontal tract and a crossing
pmf_lookup = np.array([[0., 0., 1.],
[1., 0., 0.],
[0., 1., 0.],
[.4, .6, 0.]])
simple_image = np.array([[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 3, 2, 2, 2, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
])
simple_image = simple_image[..., None]
pmf = pmf_lookup[simple_image]
seeds = [np.array([1., 1., 0.])] * 30
mask = (simple_image > 0).astype(float)
tc = ThresholdTissueClassifier(mask, .5)
dg = DeterministicMaximumDirectionGetter.from_pmf(pmf, 90, sphere,
pmf_threshold=0.1)
streamlines = LocalTracking(dg, tc, seeds, np.eye(4), 1.)
expected = [np.array([[0., 1., 0.],
[1., 1., 0.],
[2., 1., 0.],
[2., 2., 0.],
[2., 3., 0.],
[2., 4., 0.]]),
np.array([[0., 1., 0.],
[1., 1., 0.],
[2., 1., 0.],
[3., 1., 0.],
[4., 1., 0.]]),
np.array([[0., 1., 0.],
[1., 1., 0.],
[2., 1., 0.]])]
def allclose(x, y):
return x.shape == y.shape and np.allclose(x, y)
for sl in streamlines:
if not allclose(sl, expected[0]):
raise AssertionError()
# The first path is not possible if 90 degree turns are excluded
dg = DeterministicMaximumDirectionGetter.from_pmf(pmf, 80, sphere,
pmf_threshold=0.1)
streamlines = LocalTracking(dg, tc, seeds, np.eye(4), 1.)
for sl in streamlines:
npt.assert_(np.allclose(sl, expected[1]))
# Both path are not possible if 90 degree turns are exclude and
# if pmf_threshold is larger than 0.67. Streamlines should stop at
# the crossing.
# 0.4/0.6 < 2/3, multiplying the pmf should not change the ratio
dg = DeterministicMaximumDirectionGetter.from_pmf(10*pmf, 80, sphere,
pmf_threshold=0.67)
streamlines = LocalTracking(dg, tc, seeds, np.eye(4), 1.)
for sl in streamlines:
npt.assert_(np.allclose(sl, expected[2]))
