def test_hemisphere_subdivide():
def flip(vertices):
x, y, z = vertices.T
f = (z < 0) | ((z == 0) & (y < 0)) | ((z == 0) & (y == 0) & (x < 0))
return 1 - 2*f[:, None]
decimals = 6
# Test HemiSphere.subdivide
# Create a hemisphere by dividing a hemi-icosahedron
hemi1 = HemiSphere.from_sphere(unit_icosahedron).subdivide(4)
vertices1 = np.round(hemi1.vertices, decimals)
vertices1 *= flip(vertices1)
order = np.lexsort(vertices1.T)
vertices1 = vertices1[order]
# Create a hemisphere from a subdivided sphere
sphere = unit_icosahedron.subdivide(4)
hemi2 = HemiSphere.from_sphere(sphere)
vertices2 = np.round(hemi2.vertices, decimals)
vertices2 *= flip(vertices2)
order = np.lexsort(vertices2.T)
vertices2 = vertices2[order]
# The two hemispheres should have the same vertices up to their order
nt.assert_array_equal(vertices1, vertices2)
# Create a hemisphere from vertices
hemi3 = HemiSphere(xyz=hemi1.vertices)
nt.assert_array_equal(hemi1.faces, hemi3.faces)
nt.assert_array_equal(hemi1.edges, hemi3.edges)
def test_hemisphere_subdivide():
def flip(vertices):
x, y, z = vertices.T
f = (z < 0) | ((z == 0) & (y < 0)) | ((z == 0) & (y == 0) & (x < 0))
return 1 - 2 * f[:, None]
decimals = 6
# Test HemiSphere.subdivide
# Create a hemisphere by dividing a hemi-icosahedron
hemi1 = HemiSphere.from_sphere(unit_icosahedron).subdivide(4)
vertices1 = np.round(hemi1.vertices, decimals)
vertices1 *= flip(vertices1)
order = np.lexsort(vertices1.T)
vertices1 = vertices1[order]
# Create a hemisphere from a subdivided sphere
sphere = unit_icosahedron.subdivide(4)
hemi2 = HemiSphere.from_sphere(sphere)
vertices2 = np.round(hemi2.vertices, decimals)
vertices2 *= flip(vertices2)
order = np.lexsort(vertices2.T)
vertices2 = vertices2[order]
# The two hemispheres should have the same vertices up to their order
nt.assert_array_equal(vertices1, vertices2)
# Create a hemisphere from vertices
hemi3 = HemiSphere(xyz=hemi1.vertices)
nt.assert_array_equal(hemi1.faces, hemi3.faces)
nt.assert_array_equal(hemi1.edges, hemi3.edges)
def test_peak_direction_tracker():
"""This tests that the Peaks And Metrics 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
peaks_values_lookup = np.array([[0., 0.],
[1., 0.],
[1., 0.],
[0.5, 0.5]])
peaks_indices_lookup = np.array([[-1, -1],
[0, -1],
[1, -1],
[0, 1]])
# PeaksAndMetricsDirectionGetter needs at 3 slices on each axis to work
simple_image = np.zeros([5, 6, 3], dtype=int)
simple_image[:, :, 1] = np.array([[0, 1, 0, 1, 0, 0],
[0, 1, 0, 1, 0, 0],
[0, 3, 2, 2, 2, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
])
dg = PeaksAndMetrics()
dg.sphere = sphere
dg.peak_values = peaks_values_lookup[simple_image]
dg.peak_indices = peaks_indices_lookup[simple_image]
dg.ang_thr = 90
mask = (simple_image >= 0).astype(float)
tc = ThresholdTissueClassifier(mask, 0.5)
seeds = [np.array([1., 1., 1.]),
np.array([2., 4., 1.]),
np.array([1., 3., 1.]),
np.array([4., 4., 1.])]
streamlines = LocalTracking(dg, tc, seeds, np.eye(4), 1.)
expected = [np.array([[0., 1., 1.],
[1., 1., 1.],
[2., 1., 1.],
[3., 1., 1.],
[4., 1., 1.]]),
np.array([[2., 0., 1.],
[2., 1., 1.],
[2., 2., 1.],
[2., 3., 1.],
[2., 4., 1.],
[2., 5., 1.]]),
np.array([[0., 3., 1.],
[1., 3., 1.],
[2., 3., 1.],
[2., 4., 1.],
[2., 5., 1.]]),
np.array([[4., 4., 1.]])]
for i, sl in enumerate(streamlines):
npt.assert_(np.allclose(sl, expected[i]))
def test_bdg_initial_direction():
"""This test the number of inital direction."
"""
hsph_updated = HemiSphere.from_sphere(unit_icosahedron).subdivide(2)
vertices = hsph_updated.vertices
bvecs = vertices
bvals = np.ones(len(vertices)) * 1000
bvecs = np.insert(bvecs, 0, np.array([0, 0, 0]), axis=0)
bvals = np.insert(bvals, 0, 0)
gtab = gradient_table(bvals, bvecs)
# test that we get one direction when we have a single tensor
voxel = single_tensor(gtab).reshape([1, 1, 1, -1])
dti_model = dti.TensorModel(gtab)
boot_dg = BootDirectionGetter.from_data(voxel, dti_model, 30, sh_order=6)
initial_direction = boot_dg.initial_direction(np.zeros(3))
npt.assert_equal(len(initial_direction), 1)
npt.assert_allclose(initial_direction[0], [1, 0, 0], atol=0.1)
# test that we get multiple directions when we have a multi-tensor
mevals = np.array([[1.5, 0.4, 0.4], [1.5, 0.4, 0.4]]) * 1e-3
fracs = [60, 40]
voxel, primary_evecs = multi_tensor(gtab, mevals, fractions=fracs,
snr=None)
voxel = voxel.reshape([1, 1, 1, -1])
response = (np.array([0.0015, 0.0004, 0.0004]), 1)
csd_model = ConstrainedSphericalDeconvModel(gtab, response=response,
sh_order=4)
boot_dg = BootDirectionGetter.from_data(voxel, csd_model, 30)
initial_direction = boot_dg.initial_direction(np.zeros(3))
npt.assert_equal(len(initial_direction), 2)
npt.assert_allclose(initial_direction, primary_evecs, atol=0.1)
def test_csd_superres():
""" Check the quality of csdfit with high SH order. """
_, fbvals, fbvecs = get_fnames('small_64D')
bvals, bvecs = read_bvals_bvecs(fbvals, fbvecs)
gtab = gradient_table(bvals, bvecs)
# img, gtab = read_stanford_hardi()
evals = np.array([[1.5, .3, .3]]) * [[1.], [1.]] / 1000.
S, sticks = multi_tensor(gtab, evals, snr=None, fractions=[55., 45.])
with warnings.catch_warnings(record=True) as w:
warnings.filterwarnings(action="always",
message="Number of parameters required.*",
category=UserWarning)
model16 = ConstrainedSphericalDeconvModel(gtab, (evals[0], 3.),
sh_order=16)
assert_greater_equal(len(w), 1)
npt.assert_(issubclass(w[-1].category, UserWarning))
fit16 = model16.fit(S)
sphere = HemiSphere.from_sphere(get_sphere('symmetric724'))
# print local_maxima(fit16.odf(default_sphere), default_sphere.edges)
d, v, ind = peak_directions(fit16.odf(sphere), sphere,
relative_peak_threshold=.2,
min_separation_angle=0)
# Check that there are two peaks
assert_equal(len(d), 2)
# Check that peaks line up with sticks
cos_sim = abs((d * sticks).sum(1)) ** .5
assert_(all(cos_sim > .99))
def _create_mt_sim(mevals, angles, fractions, S0, SNR, half_sphere=False):
_, fbvals, fbvecs = get_fnames('small_64D')
bvals, bvecs = read_bvals_bvecs(fbvals, fbvecs)
gtab = gradient_table(bvals, bvecs)
S, sticks = multi_tensor(gtab,
mevals,
S0,
angles=angles,
fractions=fractions,
snr=SNR)
sphere = get_sphere('symmetric724').subdivide(2)
if half_sphere:
sphere = HemiSphere.from_sphere(sphere)
odf_gt = multi_tensor_odf(sphere.vertices,
mevals,
angles=angles,
fractions=fractions)
return odf_gt, sticks, sphere
def test_sphere_scaling_csdmodel():
"""Check that mirroring regulization sphere does not change the result of
csddeconv model"""
_, fbvals, fbvecs = get_data('small_64D')
bvals = np.load(fbvals)
bvecs = np.load(fbvecs)
gtab = gradient_table(bvals, bvecs)
mevals = np.array(([0.0015, 0.0003, 0.0003],
[0.0015, 0.0003, 0.0003]))
angles = [(0, 0), (60, 0)]
S, sticks = multi_tensor(gtab, mevals, 100., angles=angles,
fractions=[50, 50], snr=None)
sphere = get_sphere('symmetric362')
hemi = HemiSphere.from_sphere(sphere)
response = (np.array([0.0015, 0.0003, 0.0003]), 100)
model_full = ConstrainedSphericalDeconvModel(gtab, response,
reg_sphere=sphere)
model_hemi = ConstrainedSphericalDeconvModel(gtab, response,
reg_sphere=hemi)
csd_fit_full = model_full.fit(S)
csd_fit_hemi = model_hemi.fit(S)
assert_array_almost_equal(csd_fit_full.shm_coeff, csd_fit_hemi.shm_coeff)
def test_bdg_residual():
"""This tests the bootstrapping residual.
"""
hsph_updated = HemiSphere.from_sphere(unit_icosahedron).subdivide(2)
vertices = hsph_updated.vertices
bvecs = vertices
bvals = np.ones(len(vertices)) * 1000
bvecs = np.insert(bvecs, 0, np.array([0, 0, 0]), axis=0)
bvals = np.insert(bvals, 0, 0)
gtab = gradient_table(bvals, bvecs)
r, theta, phi = cart2sphere(*vertices.T)
with warnings.catch_warnings():
warnings.filterwarnings(
"ignore", message=shm.descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
B, m, n = shm.real_sh_descoteaux(6, theta, phi)
shm_coeff = np.random.random(B.shape[1])
# sphere_func is sampled of the spherical function for each point of
# the sphere
sphere_func = np.dot(shm_coeff, B.T)
voxel = np.concatenate((np.zeros(1), sphere_func))
data = np.tile(voxel, (3, 3, 3, 1))
with warnings.catch_warnings():
warnings.filterwarnings(
"ignore", message=shm.descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
csd_model = ConstrainedSphericalDeconvModel(gtab, response, sh_order=6)
boot_pmf_gen = BootPmfGen(data, model=csd_model, sphere=hsph_updated,
sh_order=6)
# Two boot samples should be the same
odf1 = boot_pmf_gen.get_pmf(np.array([1.5, 1.5, 1.5]))
odf2 = boot_pmf_gen.get_pmf(np.array([1.5, 1.5, 1.5]))
npt.assert_array_almost_equal(odf1, odf2)
# A boot sample with less sh coeffs should have residuals, thus the two
# should be different
with warnings.catch_warnings():
warnings.filterwarnings(
"ignore", message=shm.descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
boot_pmf_gen2 = BootPmfGen(data, model=csd_model, sphere=hsph_updated,
sh_order=4)
odf1 = boot_pmf_gen2.get_pmf(np.array([1.5, 1.5, 1.5]))
odf2 = boot_pmf_gen2.get_pmf(np.array([1.5, 1.5, 1.5]))
npt.assert_(np.any(odf1 != odf2))
# test with a gtab with two shells and assert you get an error
bvals[-1] = 2000
gtab = gradient_table(bvals, bvecs)
with warnings.catch_warnings():
warnings.filterwarnings(
"ignore", message=shm.descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
csd_model = ConstrainedSphericalDeconvModel(gtab, response, sh_order=6)
npt.assert_raises(ValueError, BootPmfGen, data, csd_model, hsph_updated, 6)
def test_peak_direction_tracker():
"""This tests that the Peaks And Metrics 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
peaks_values_lookup = np.array([[0., 0.],
[1., 0.],
[1., 0.],
[0.5, 0.5]])
peaks_indices_lookup = np.array([[-1, -1],
[0, -1],
[1, -1],
[0, 1]])
# PeaksAndMetricsDirectionGetter needs at 3 slices on each axis to work
simple_image = np.zeros([5, 6, 3], dtype=int)
simple_image[:, :, 1] = np.array([[0, 1, 0, 1, 0, 0],
[0, 1, 0, 1, 0, 0],
[0, 3, 2, 2, 2, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
])
dg = PeaksAndMetrics()
dg.sphere = sphere
dg.peak_values = peaks_values_lookup[simple_image]
dg.peak_indices = peaks_indices_lookup[simple_image]
dg.ang_thr = 90
mask = (simple_image >= 0).astype(float)
tc = ThresholdTissueClassifier(mask, 0.5)
seeds = [np.array([1., 1., 1.]),
np.array([2., 4., 1.]),
np.array([1., 3., 1.]),
np.array([4., 4., 1.])]
streamlines = LocalTracking(dg, tc, seeds, np.eye(4), 1.)
expected = [np.array([[0., 1., 1.],
[1., 1., 1.],
[2., 1., 1.],
[3., 1., 1.],
[4., 1., 1.]]),
np.array([[2., 0., 1.],
[2., 1., 1.],
[2., 2., 1.],
[2., 3., 1.],
[2., 4., 1.],
[2., 5., 1.]]),
np.array([[0., 3., 1.],
[1., 3., 1.],
[2., 3., 1.],
[2., 4., 1.],
[2., 5., 1.]]),
np.array([[4., 4., 1.]])]
for i, sl in enumerate(streamlines):
npt.assert_(np.allclose(sl, expected[i]))
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_save_seeds():
tissue = np.array([[2, 1, 1, 2, 1],
[2, 2, 1, 1, 2],
[1, 1, 1, 1, 1],
[1, 1, 1, 2, 2],
[0, 1, 1, 1, 2],
[0, 1, 1, 0, 2],
[1, 0, 1, 1, 1]])
tissue = tissue[None]
sphere = HemiSphere.from_sphere(unit_octahedron)
pmf_lookup = np.array([[0., 0., 0., ],
[0., 0., 1.]])
pmf = pmf_lookup[(tissue > 0).astype("int")]
# Create a seeds along
x = np.array([0., 0, 0, 0, 0, 0, 0])
y = np.array([0., 1, 2, 3, 4, 5, 6])
z = np.array([1., 1, 1, 0, 1, 1, 1])
seeds = np.column_stack([x, y, z])
# Set up tracking
endpoint_mask = tissue == TissueTypes.ENDPOINT
invalidpoint_mask = tissue == TissueTypes.INVALIDPOINT
tc = ActTissueClassifier(endpoint_mask, invalidpoint_mask)
dg = ProbabilisticDirectionGetter.from_pmf(pmf, 60, sphere)
# valid streamlines only
streamlines_generator = LocalTracking(direction_getter=dg,
tissue_classifier=tc,
seeds=seeds,
affine=np.eye(4),
step_size=1.,
return_all=False,
save_seeds=True)
streamlines_not_all = iter(streamlines_generator)
# Verifiy that seeds are returned by the LocalTracker
_, seed = next(streamlines_not_all)
npt.assert_equal(seed, seeds[0])
_, seed = next(streamlines_not_all)
npt.assert_equal(seed, seeds[1])
# Verifiy that seeds are returned by the PFTTracker also
pft_streamlines = ParticleFilteringTracking(direction_getter=dg,
tissue_classifier=tc,
seeds=seeds,
affine=np.eye(4),
step_size=1.,
max_cross=1,
return_all=False,
save_seeds=True)
streamlines = iter(pft_streamlines)
_, seed = next(streamlines)
npt.assert_equal(seed, seeds[0])
_, seed = next(streamlines)
npt.assert_equal(seed, seeds[1])
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:
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 send_targets_to_half_sphere(t, sphere):
# toDo. See how to include this to use classification on the half sphere.
half_sphere = HemiSphere.from_sphere(sphere)
peak = half_sphere.find_closest(t)
# Checking cosine similarity:
if abs(np.dot(peak, t)) > abs(np.dot(peak, -t)):
t = -t
return t
def test_pmf_from_sh():
sphere = HemiSphere.from_sphere(unit_octahedron)
pmfgen = SHCoeffPmfGen(np.ones([2, 2, 2, 28]), sphere, None)
# Test that the pmf is greater than 0 for a valid point
pmf = pmfgen.get_pmf(np.array([0, 0, 0], dtype='float'))
npt.assert_equal(np.sum(pmf) > 0, True)
# Test that the pmf is 0 for invalid Points
npt.assert_array_equal(pmfgen.get_pmf(np.array([-1, 0, 0], dtype='float')),
np.zeros(len(sphere.vertices)))
npt.assert_array_equal(pmfgen.get_pmf(np.array([0, 0, 10], dtype='float')),
np.zeros(len(sphere.vertices)))
def test_pmf_from_sh():
sphere = HemiSphere.from_sphere(unit_octahedron)
pmfgen = SHCoeffPmfGen(np.ones([2, 2, 2, 28]), sphere, None)
# Test that the pmf is greater than 0 for a valid point
pmf = pmfgen.get_pmf(np.array([0, 0, 0], dtype='float'))
npt.assert_equal(np.sum(pmf) > 0, True)
# Test that the pmf is 0 for invalid Points
npt.assert_array_equal(pmfgen.get_pmf(np.array([-1, 0, 0], dtype='float')),
np.zeros(len(sphere.vertices)))
npt.assert_array_equal(pmfgen.get_pmf(np.array([0, 0, 10], dtype='float')),
np.zeros(len(sphere.vertices)))
def test_closest_peak_tracker():
"""This tests that the Closest Peak 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.],
[.5, .5, 0.]])
simple_image = np.array([[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[2, 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.]), np.array([2., 4., 0.])]
mask = (simple_image > 0).astype(float)
tc = BinaryTissueClassifier(mask)
dg = ClosestPeakDirectionGetter.from_pmf(pmf, 90, sphere,
pmf_threshold=0.1)
streamlines = Streamlines(LocalTracking(dg, tc, seeds, np.eye(4), 1.))
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.]])]
def allclose(x, y):
return x.shape == y.shape and np.allclose(x, y)
if not allclose(streamlines[0], expected[0]):
raise AssertionError()
if not allclose(streamlines[1], expected[1]):
raise AssertionError()
def test_closest_peak_tracker():
"""This tests that the Closest Peak 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.],
[.5, .5, 0.]])
simple_image = np.array([[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[2, 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.]), np.array([2., 4., 0.])]
mask = (simple_image > 0).astype(float)
tc = BinaryTissueClassifier(mask)
dg = ClosestPeakDirectionGetter.from_pmf(pmf, 90, sphere,
pmf_threshold=0.1)
streamlines = Streamlines(LocalTracking(dg, tc, seeds, np.eye(4), 1.))
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.]])]
def allclose(x, y):
return x.shape == y.shape and np.allclose(x, y)
if not allclose(streamlines[0], expected[0]):
raise AssertionError()
if not allclose(streamlines[1], expected[1]):
raise AssertionError()
def test_boot_pmf():
# This tests the local model used for the bootstrapping.
hsph_updated = HemiSphere.from_sphere(unit_octahedron)
vertices = hsph_updated.vertices
bvecs = vertices
bvals = np.ones(len(vertices)) * 1000
bvecs = np.insert(bvecs, 0, np.array([0, 0, 0]), axis=0)
bvals = np.insert(bvals, 0, 0)
gtab = gradient_table(bvals, bvecs)
voxel = single_tensor(gtab)
data = np.tile(voxel, (3, 3, 3, 1))
point = np.array([1., 1., 1.])
tensor_model = TensorModel(gtab)
boot_pmf_gen = BootPmfGen(data, model=tensor_model, sphere=hsph_updated)
no_boot_pmf = boot_pmf_gen.get_pmf_no_boot(point)
model_pmf = tensor_model.fit(voxel).odf(hsph_updated)
npt.assert_equal(len(hsph_updated.vertices), no_boot_pmf.shape[0])
npt.assert_array_almost_equal(no_boot_pmf, model_pmf)
# test model spherical harmonic order different than bootstrap order
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always", category=UserWarning)
csd_model = ConstrainedSphericalDeconvModel(gtab, response, sh_order=6)
# Tests that the first catched warning comes from
# the CSD model constructor
npt.assert_(issubclass(w[0].category, UserWarning))
npt.assert_("Number of parameters required " in str(w[0].message))
# Tests that additionnal warnings are raised for outdated SH basis
npt.assert_(len(w) > 1)
boot_pmf_gen_sh4 = BootPmfGen(data,
model=csd_model,
sphere=hsph_updated,
sh_order=4)
pmf_sh4 = boot_pmf_gen_sh4.get_pmf(point)
npt.assert_equal(len(hsph_updated.vertices), pmf_sh4.shape[0])
npt.assert_(np.sum(pmf_sh4.shape) > 0)
boot_pmf_gen_sh8 = BootPmfGen(data,
model=csd_model,
sphere=hsph_updated,
sh_order=8)
pmf_sh8 = boot_pmf_gen_sh8.get_pmf(point)
npt.assert_equal(len(hsph_updated.vertices), pmf_sh8.shape[0])
npt.assert_(np.sum(pmf_sh8.shape) > 0)
def _get_direction_getter(args, mask_data):
sh_data = nib.load(args.sh_file).get_data().astype('float64')
sphere = HemiSphere.from_sphere(get_sphere(args.sphere))
theta = get_theta(args.theta, args.algo)
if args.algo in ['det', 'prob']:
if args.algo == 'det':
dg_class = DeterministicMaximumDirectionGetter
else:
dg_class = ProbabilisticDirectionGetter
return dg_class.from_shcoeff(shcoeff=sh_data,
max_angle=theta,
sphere=sphere,
basis_type=args.sh_basis,
relative_peak_threshold=args.sf_threshold)
# Code for type EUDX. We don't use peaks_from_model
# because we want the peaks from the provided sh.
sh_shape_3d = sh_data.shape[:-1]
npeaks = 5
peak_dirs = np.zeros((sh_shape_3d + (npeaks, 3)))
peak_values = np.zeros((sh_shape_3d + (npeaks, )))
peak_indices = np.full((sh_shape_3d + (npeaks, )), -1, dtype='int')
b_matrix = get_b_matrix(find_order_from_nb_coeff(sh_data), sphere,
args.sh_basis)
for idx in np.ndindex(sh_shape_3d):
if not mask_data[idx]:
continue
directions, values, indices = get_maximas(sh_data[idx], sphere,
b_matrix, args.sf_threshold,
0)
if values.shape[0] != 0:
n = min(npeaks, values.shape[0])
peak_dirs[idx][:n] = directions[:n]
peak_values[idx][:n] = values[:n]
peak_indices[idx][:n] = indices[:n]
dg = PeaksAndMetrics()
dg.sphere = sphere
dg.peak_dirs = peak_dirs
dg.peak_values = peak_values
dg.peak_indices = peak_indices
dg.ang_thr = theta
dg.qa_thr = args.sf_threshold
return dg
def test_pmf_from_sh():
sphere = HemiSphere.from_sphere(unit_octahedron)
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
message=descoteaux07_legacy_msg,
category=PendingDeprecationWarning)
pmfgen = SHCoeffPmfGen(np.ones([2, 2, 2, 28]), sphere, None)
# Test that the pmf is greater than 0 for a valid point
pmf = pmfgen.get_pmf(np.array([0, 0, 0], dtype='float'))
npt.assert_equal(np.sum(pmf) > 0, True)
# Test that the pmf is 0 for invalid Points
npt.assert_array_equal(pmfgen.get_pmf(np.array([-1, 0, 0], dtype='float')),
np.zeros(len(sphere.vertices)))
npt.assert_array_equal(pmfgen.get_pmf(np.array([0, 0, 10], dtype='float')),
np.zeros(len(sphere.vertices)))
def test_pmf_from_array():
sphere = HemiSphere.from_sphere(unit_octahedron)
pmfgen = SimplePmfGen(np.ones([2, 2, 2, len(sphere.vertices)]))
# Test that the pmf is greater than 0 for a valid point
pmf = pmfgen.get_pmf(np.array([0, 0, 0], dtype='float'))
npt.assert_equal(np.sum(pmf) > 0, True)
# Test that the pmf is 0 for invalid Points
npt.assert_array_equal(pmfgen.get_pmf(np.array([-1, 0, 0], dtype='float')),
np.zeros(len(sphere.vertices)))
npt.assert_array_equal(pmfgen.get_pmf(np.array([0, 0, 10], dtype='float')),
np.zeros(len(sphere.vertices)))
npt.assert_raises(
ValueError,
lambda: SimplePmfGen(np.ones([2, 2, 2, len(sphere.vertices)])*-1))
def test_pmf_from_array():
sphere = HemiSphere.from_sphere(unit_octahedron)
pmfgen = SimplePmfGen(np.ones([2, 2, 2, len(sphere.vertices)]))
# Test that the pmf is greater than 0 for a valid point
pmf = pmfgen.get_pmf(np.array([0, 0, 0], dtype='float'))
npt.assert_equal(np.sum(pmf) > 0, True)
# Test that the pmf is 0 for invalid Points
npt.assert_array_equal(pmfgen.get_pmf(np.array([-1, 0, 0], dtype='float')),
np.zeros(len(sphere.vertices)))
npt.assert_array_equal(pmfgen.get_pmf(np.array([0, 0, 10], dtype='float')),
np.zeros(len(sphere.vertices)))
npt.assert_raises(
ValueError,
lambda: SimplePmfGen(np.ones([2, 2, 2, len(sphere.vertices)]) * -1))
def test_boot_pmf():
"""This tests the local model used for the bootstrapping.
"""
hsph_updated = HemiSphere.from_sphere(unit_octahedron)
vertices = hsph_updated.vertices
bvecs = vertices
bvals = np.ones(len(vertices)) * 1000
bvecs = np.insert(bvecs, 0, np.array([0, 0, 0]), axis=0)
bvals = np.insert(bvals, 0, 0)
gtab = gradient_table(bvals, bvecs)
voxel = single_tensor(gtab)
data = np.tile(voxel, (3, 3, 3, 1))
point = np.array([1., 1., 1.])
tensor_model = TensorModel(gtab)
boot_pmf_gen = BootPmfGen(data, model=tensor_model, sphere=hsph_updated)
no_boot_pmf = boot_pmf_gen.get_pmf_no_boot(point)
model_pmf = tensor_model.fit(voxel).odf(hsph_updated)
npt.assert_equal(len(hsph_updated.vertices), no_boot_pmf.shape[0])
npt.assert_array_almost_equal(no_boot_pmf, model_pmf)
# test model spherical harmonic order different than bootstrap order
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always", category=UserWarning)
csd_model = ConstrainedSphericalDeconvModel(gtab, None, sh_order=6)
assert_greater(
len([lw for lw in w if issubclass(lw.category, UserWarning)]), 0)
boot_pmf_gen_sh4 = BootPmfGen(data,
model=csd_model,
sphere=hsph_updated,
sh_order=4)
pmf_sh4 = boot_pmf_gen_sh4.get_pmf(point)
npt.assert_equal(len(hsph_updated.vertices), pmf_sh4.shape[0])
npt.assert_(np.sum(pmf_sh4.shape) > 0)
boot_pmf_gen_sh8 = BootPmfGen(data,
model=csd_model,
sphere=hsph_updated,
sh_order=8)
pmf_sh8 = boot_pmf_gen_sh8.get_pmf(point)
npt.assert_equal(len(hsph_updated.vertices), pmf_sh8.shape[0])
npt.assert_(np.sum(pmf_sh8.shape) > 0)
def test_bdg_residual():
"""This tests the bootstrapping residual.
"""
hsph_updated = HemiSphere.from_sphere(unit_icosahedron).subdivide(2)
vertices = hsph_updated.vertices
bvecs = vertices
bvals = np.ones(len(vertices)) * 1000
bvecs = np.insert(bvecs, 0, np.array([0, 0, 0]), axis=0)
bvals = np.insert(bvals, 0, 0)
gtab = gradient_table(bvals, bvecs)
r, theta, phi = cart2sphere(*vertices.T)
B, m, n = shm.real_sym_sh_basis(6, theta, phi)
shm_coeff = np.random.random(B.shape[1])
# sphere_func is sampled of the spherical function for each point of
# the sphere
sphere_func = np.dot(shm_coeff, B.T)
voxel = np.concatenate((np.zeros(1), sphere_func))
data = np.tile(voxel, (3, 3, 3, 1))
csd_model = ConstrainedSphericalDeconvModel(gtab, None, sh_order=6)
boot_pmf_gen = BootPmfGen(data, model=csd_model, sphere=hsph_updated,
sh_order=6)
# Two boot samples should be the same
odf1 = boot_pmf_gen.get_pmf(np.array([1.5, 1.5, 1.5]))
odf2 = boot_pmf_gen.get_pmf(np.array([1.5, 1.5, 1.5]))
npt.assert_array_almost_equal(odf1, odf2)
# A boot sample with less sh coeffs should have residuals, thus the two
# should be different
boot_pmf_gen2 = BootPmfGen(data, model=csd_model, sphere=hsph_updated,
sh_order=4)
odf1 = boot_pmf_gen2.get_pmf(np.array([1.5, 1.5, 1.5]))
odf2 = boot_pmf_gen2.get_pmf(np.array([1.5, 1.5, 1.5]))
npt.assert_(np.any(odf1 != odf2))
# test with a gtab with two shells and assert you get an error
bvals[-1] = 2000
gtab = gradient_table(bvals, bvecs)
csd_model = ConstrainedSphericalDeconvModel(gtab, None, sh_order=6)
npt.assert_raises(ValueError, BootPmfGen, data, csd_model, hsph_updated, 6)
def test_boot_pmf():
"""This tests the local model used for the bootstrapping.
"""
hsph_updated = HemiSphere.from_sphere(unit_octahedron)
vertices = hsph_updated.vertices
bvecs = vertices
bvals = np.ones(len(vertices)) * 1000
bvecs = np.insert(bvecs, 0, np.array([0, 0, 0]), axis=0)
bvals = np.insert(bvals, 0, 0)
gtab = gradient_table(bvals, bvecs)
voxel = single_tensor(gtab)
data = np.tile(voxel, (3, 3, 3, 1))
point = np.array([1., 1., 1.])
tensor_model = TensorModel(gtab)
boot_pmf_gen = BootPmfGen(data, model=tensor_model, sphere=hsph_updated)
no_boot_pmf = boot_pmf_gen.get_pmf_no_boot(point)
model_pmf = tensor_model.fit(voxel).odf(hsph_updated)
npt.assert_equal(len(hsph_updated.vertices), no_boot_pmf.shape[0])
npt.assert_array_almost_equal(no_boot_pmf, model_pmf)
# test model sherical harminic order different than bootstrap order
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always", category=UserWarning)
csd_model = ConstrainedSphericalDeconvModel(gtab, None, sh_order=6)
assert_greater(len([lw for lw in w if issubclass(lw.category,
UserWarning)]), 0)
boot_pmf_gen_sh4 = BootPmfGen(data, model=csd_model, sphere=hsph_updated,
sh_order=4)
pmf_sh4 = boot_pmf_gen_sh4.get_pmf(point)
npt.assert_equal(len(hsph_updated.vertices), pmf_sh4.shape[0])
npt.assert_(np.sum(pmf_sh4.shape) > 0)
boot_pmf_gen_sh8 = BootPmfGen(data, model=csd_model, sphere=hsph_updated,
sh_order=8)
pmf_sh8 = boot_pmf_gen_sh8.get_pmf(point)
npt.assert_equal(len(hsph_updated.vertices), pmf_sh8.shape[0])
npt.assert_(np.sum(pmf_sh8.shape) > 0)
def test_bdg_get_direction():
"""This tests the direction found by the bootstrap direction getter.
"""
sphere = HemiSphere.from_sphere(unit_icosahedron.subdivide())
two_neighbors = sphere.edges[0]
direction1 = sphere.vertices[two_neighbors[0]]
direction2 = sphere.vertices[two_neighbors[1]]
angle = np.rad2deg(direction1.dot(direction2))
point = np.zeros(3)
prev_direction = direction2.copy()
pmf = np.zeros([1, 1, 1, len(sphere.vertices)])
pmf[:, :, :, two_neighbors[0]] = 1
pmf_gen = SimplePmfGen(pmf)
# test case in which no valid direction is found with default maxdir
boot_dg = BootDirectionGetter(pmf_gen, angle / 2., sphere=sphere)
npt.assert_equal(boot_dg.get_direction(point, prev_direction), 1)
npt.assert_equal(direction2, prev_direction)
# test case in which no valid direction is found with new max attempts
boot_dg = BootDirectionGetter(pmf_gen,
angle / 2.,
sphere=sphere,
max_attempts=3)
npt.assert_equal(boot_dg.get_direction(point, prev_direction), 1)
npt.assert_equal(direction2, prev_direction)
# test case in which a valid direction is found
boot_dg = BootDirectionGetter(pmf_gen,
angle * 2.,
sphere=sphere,
max_attempts=1)
npt.assert_equal(boot_dg.get_direction(point, prev_direction), 0)
npt.assert_equal(direction1, prev_direction)
# test invalid max_attempts parameters
npt.assert_raises(
ValueError, lambda: BootDirectionGetter(
pmf_gen, angle * 2., sphere=sphere, max_attempts=0))
def create_unit_hemisphere(recursion_level=2):
"""Creates a unit sphere by subdividing a unit octahedron, returns half
the sphere.
Parameters
-------------
recursion_level : int
Level of subdivision, recursion_level=1 will return an octahedron,
anything bigger will return a more subdivided sphere. The sphere will
have $(4^recursion_level+2)/2$ vertices.
Returns
---------
HemiSphere :
Half of a unit sphere.
See Also
----------
create_unit_sphere, Sphere, HemiSphere
"""
sphere = create_unit_sphere(recursion_level)
return HemiSphere.from_sphere(sphere)
def _create_mt_sim(mevals, angles, fractions, S0, SNR, half_sphere=False):
_, fbvals, fbvecs = get_data('small_64D')
bvals = np.load(fbvals)
bvecs = np.load(fbvecs)
gtab = gradient_table(bvals, bvecs)
S, sticks = multi_tensor(gtab, mevals, S0, angles=angles,
fractions=fractions, snr=SNR)
sphere = get_sphere('symmetric724').subdivide(2)
if half_sphere:
sphere = HemiSphere.from_sphere(sphere)
odf_gt = multi_tensor_odf(sphere.vertices, mevals,
angles=angles, fractions=fractions)
return odf_gt, sticks, sphere
def test_bdg_get_direction():
"""This tests the direction found by the bootstrap direction getter.
"""
sphere = HemiSphere.from_sphere(unit_icosahedron.subdivide())
two_neighbors = sphere.edges[0]
direction1 = sphere.vertices[two_neighbors[0]]
direction2 = sphere.vertices[two_neighbors[1]]
angle = np.rad2deg(direction1.dot(direction2))
point = np.zeros(3)
prev_direction = direction2.copy()
pmf = np.zeros([1, 1, 1, len(sphere.vertices)])
pmf[:, :, :, two_neighbors[0]] = 1
pmf_gen = SimplePmfGen(pmf)
# test case in which no valid direction is found with default maxdir
boot_dg = BootDirectionGetter(pmf_gen, angle / 2., sphere=sphere)
npt.assert_equal(boot_dg.get_direction(point, prev_direction), 1)
npt.assert_equal(direction2, prev_direction)
# test case in which no valid direction is found with new max attempts
boot_dg = BootDirectionGetter(pmf_gen, angle / 2., sphere=sphere,
max_attempts=3)
npt.assert_equal(boot_dg.get_direction(point, prev_direction), 1)
npt.assert_equal(direction2, prev_direction)
# test case in which a valid direction is found
boot_dg = BootDirectionGetter(pmf_gen, angle * 2., sphere=sphere,
max_attempts=1)
npt.assert_equal(boot_dg.get_direction(point, prev_direction), 0)
npt.assert_equal(direction1, prev_direction)
# test invalid max_attempts parameters
npt.assert_raises(
ValueError,
lambda: BootDirectionGetter(pmf_gen, angle * 2., sphere=sphere,
max_attempts=0))
from __future__ import division
from warnings import warn
import numpy as np
from .recspeed import local_maxima, remove_similar_vertices
from ..core.onetime import auto_attr
from dipy.core.sphere import unique_edges, unit_icosahedron, HemiSphere
#Classes OdfModel and OdfFit are using API ReconstModel and ReconstFit from .base
default_sphere = HemiSphere.from_sphere(unit_icosahedron.subdivide(3))
class DirectionFinder(object):
"""Abstract class for direction finding"""
def __init__(self):
self._config = {}
def __call__(self, sphere_eval):
"""To be impemented by subclasses"""
raise NotImplementedError()
def config(self, **kwargs):
"""Update direction finding parameters"""
for i in kwargs:
if i not in self._config:
warn("{} is not a known parameter".format(i))
self._config.update(kwargs)
class DiscreteDirectionFinder(DirectionFinder):
"""Discrete Direction Finder
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_bootstap_peak_tracker():
"""This tests that the Bootstrat Peak Direction Getter plays nice
LocalTracking and produces reasonable streamlines in a simple example.
"""
sphere = get_sphere('repulsion100')
# A simple image with three possible configurations, a vertical tract,
# a horizontal tract and a crossing
simple_image = np.array([
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[2, 3, 2, 2, 2, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
])
simple_image = simple_image[..., None]
bvecs = sphere.vertices
bvals = np.ones(len(bvecs)) * 1000
bvecs = np.insert(bvecs, 0, np.array([0, 0, 0]), axis=0)
bvals = np.insert(bvals, 0, 0)
gtab = gradient_table(bvals, bvecs)
angles = [(90, 90), (90, 0)]
fracs = [50, 50]
mevals = np.array([[1.5, 0.4, 0.4], [1.5, 0.4, 0.4]]) * 1e-3
mevecs = [
np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]),
np.array([[0, 1, 0], [1, 0, 0], [0, 0, 1]])
]
voxel1 = single_tensor(gtab, 1, mevals[0], mevecs[0], snr=None)
voxel2 = single_tensor(gtab, 1, mevals[0], mevecs[1], snr=None)
voxel3, _ = multi_tensor(gtab,
mevals,
fractions=fracs,
angles=angles,
snr=None)
data = np.tile(voxel3, [5, 6, 1, 1])
data[simple_image == 1] = voxel1
data[simple_image == 2] = voxel2
response = (np.array(mevals[1]), 1)
csd_model = ConstrainedSphericalDeconvModel(gtab, response, sh_order=6)
seeds = [np.array([0., 1., 0.]), np.array([2., 4., 0.])]
sc = BinaryStoppingCriterion((simple_image > 0).astype(float))
sphere = HemiSphere.from_sphere(get_sphere('symmetric724'))
boot_dg = BootDirectionGetter.from_data(data, csd_model, 60, sphere=sphere)
streamlines_generator = LocalTracking(boot_dg, sc, seeds, np.eye(4), 1.)
streamlines = Streamlines(streamlines_generator)
expected = [
np.array([[0., 1., 0.], [1., 1., 0.], [2., 1., 0.], [3., 1., 0.],
[4., 1., 0.]]),
np.array([
[2., 4., 0.],
[2., 3., 0.],
[2., 2., 0.],
[2., 1., 0.],
[2., 0., 0.],
])
]
def allclose(x, y):
return x.shape == y.shape and np.allclose(x, y, atol=0.5)
if not allclose(streamlines[0], expected[0]):
raise AssertionError()
if not allclose(streamlines[1], expected[1]):
raise AssertionError()
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_stop_conditions():
"""This tests that the Local Tracker behaves as expected for the
following tissue types.
"""
# StreamlineStatus.TRACKPOINT = 1
# StreamlineStatus.ENDPOINT = 2
# StreamlineStatus.INVALIDPOINT = 0
tissue = np.array([[2, 1, 1, 2, 1], [2, 2, 1, 1, 2], [1, 1, 1, 1, 1],
[1, 1, 1, 2, 2], [0, 1, 1, 1, 2], [0, 1, 1, 0, 2],
[1, 0, 1, 1, 1], [2, 1, 2, 0, 0]])
tissue = tissue[None]
sphere = HemiSphere.from_sphere(unit_octahedron)
pmf_lookup = np.array([[
0.,
0.,
0.,
], [0., 0., 1.]])
pmf = pmf_lookup[(tissue > 0).astype("int")]
# Create a seeds along
x = np.array([0., 0, 0, 0, 0, 0, 0, 0])
y = np.array([0., 1, 2, 3, 4, 5, 6, 7])
z = np.array([1., 1, 1, 0, 1, 1, 1, 1])
seeds = np.column_stack([x, y, z])
# Set up tracking
endpoint_mask = tissue == StreamlineStatus.ENDPOINT
invalidpoint_mask = tissue == StreamlineStatus.INVALIDPOINT
sc = ActStoppingCriterion(endpoint_mask, invalidpoint_mask)
dg = ProbabilisticDirectionGetter.from_pmf(pmf, 60, sphere)
# valid streamlines only
streamlines_generator = LocalTracking(direction_getter=dg,
stopping_criterion=sc,
seeds=seeds,
affine=np.eye(4),
step_size=1.,
return_all=False)
streamlines_not_all = iter(streamlines_generator)
# all streamlines
streamlines_all_generator = LocalTracking(direction_getter=dg,
stopping_criterion=sc,
seeds=seeds,
affine=np.eye(4),
step_size=1.,
return_all=True)
streamlines_all = iter(streamlines_all_generator)
# Check that the first streamline stops at 1 and 2 (ENDPOINT)
y = 0
sl = next(streamlines_not_all)
npt.assert_equal(sl[0], [0, y, 1])
npt.assert_equal(sl[-1], [0, y, 2])
npt.assert_equal(len(sl), 2)
sl = next(streamlines_all)
npt.assert_equal(sl[0], [0, y, 1])
npt.assert_equal(sl[-1], [0, y, 2])
npt.assert_equal(len(sl), 2)
# Check that the next streamline stops at 1 and 3 (ENDPOINT)
y = 1
sl = next(streamlines_not_all)
npt.assert_equal(sl[0], [0, y, 1])
npt.assert_equal(sl[-1], [0, y, 3])
npt.assert_equal(len(sl), 3)
sl = next(streamlines_all)
npt.assert_equal(sl[0], [0, y, 1])
npt.assert_equal(sl[-1], [0, y, 3])
npt.assert_equal(len(sl), 3)
# This streamline should be the same as above. This row does not have
# ENDPOINTs, but the streamline should stop at the edge and not include
# OUTSIDEIMAGE points.
y = 2
sl = next(streamlines_not_all)
npt.assert_equal(sl[0], [0, y, 0])
npt.assert_equal(sl[-1], [0, y, 4])
npt.assert_equal(len(sl), 5)
sl = next(streamlines_all)
npt.assert_equal(sl[0], [0, y, 0])
npt.assert_equal(sl[-1], [0, y, 4])
npt.assert_equal(len(sl), 5)
# If we seed on the edge, the first (or last) point in the streamline
# should be the seed.
y = 3
sl = next(streamlines_not_all)
npt.assert_equal(sl[0], seeds[y])
sl = next(streamlines_all)
npt.assert_equal(sl[0], seeds[y])
# The last 3 seeds should not produce streamlines,
# INVALIDPOINT streamlines are rejected (return_all=False).
npt.assert_equal(len(list(streamlines_not_all)), 0)
# The last 3 seeds should produce invalid streamlines,
# INVALIDPOINT streamlines are kept (return_all=True).
# The streamline stops at 1 (INVALIDPOINT) and 3 (ENDPOINT)
y = 4
sl = next(streamlines_all)
npt.assert_equal(sl[0], [0, y, 1])
npt.assert_equal(sl[-1], [0, y, 3])
npt.assert_equal(len(sl), 3)
# The streamline stops at 0 (INVALIDPOINT) and 2 (INVALIDPOINT)
y = 5
sl = next(streamlines_all)
npt.assert_equal(sl[0], [0, y, 1])
npt.assert_equal(sl[-1], [0, y, 2])
npt.assert_equal(len(sl), 2)
# The streamline should contain only one point, the seed point,
# because no valid inital direction was returned.
y = 6
sl = next(streamlines_all)
npt.assert_equal(sl[0], seeds[y])
npt.assert_equal(sl[-1], seeds[y])
npt.assert_equal(len(sl), 1)
# The streamline should contain only one point, the seed point,
# because no valid neighboring voxel (ENDPOINT)
y = 7
sl = next(streamlines_all)
npt.assert_equal(sl[0], seeds[y])
npt.assert_equal(sl[-1], seeds[y])
npt.assert_equal(len(sl), 1)
def test_probabilistic_odf_weighted_tracker():
"""This tests that the Probabalistic 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.],
[.6, .4, 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 = ProbabilisticDirectionGetter.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.]])
]
def allclose(x, y):
return x.shape == y.shape and np.allclose(x, y)
path = [False, False]
for sl in streamlines:
if allclose(sl, expected[0]):
path[0] = True
elif allclose(sl, expected[1]):
path[1] = True
else:
raise AssertionError()
npt.assert_(all(path))
# The first path is not possible if 90 degree turns are excluded
dg = ProbabilisticDirectionGetter.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]))
# The first path is not possible if pmf_threshold > 0.67
# 0.4/0.6 < 2/3, multiplying the pmf should not change the ratio
dg = ProbabilisticDirectionGetter.from_pmf(10 * pmf,
90,
sphere,
pmf_threshold=0.67)
streamlines = LocalTracking(dg, sc, seeds, np.eye(4), 1.)
for sl in streamlines:
npt.assert_(np.allclose(sl, expected[1]))
# Test non WM seed position
seeds = [[0, 0, 0], [5, 5, 5]]
streamlines = LocalTracking(dg,
sc,
seeds,
np.eye(4),
0.2,
max_cross=1,
return_all=True)
streamlines = Streamlines(streamlines)
npt.assert_(len(streamlines[0]) == 1) # INVALIDPOINT
npt.assert_(len(streamlines[1]) == 1) # OUTSIDEIMAGE
# Test that all points are within the image volume
seeds = seeds_from_mask(np.ones(mask.shape), np.eye(4), density=2)
streamline_generator = LocalTracking(dg,
sc,
seeds,
np.eye(4),
0.5,
return_all=True)
streamlines = Streamlines(streamline_generator)
for s in streamlines:
npt.assert_(np.all((s + 0.5).astype(int) >= 0))
npt.assert_(np.all((s + 0.5).astype(int) < mask.shape))
# Test that the number of streamline return with return_all=True equal the
# number of seeds places
npt.assert_(np.array([len(streamlines) == len(seeds)]))
# Test reproducibility
tracking_1 = Streamlines(
LocalTracking(dg, sc, seeds, np.eye(4), 0.5, random_seed=0))._data
tracking_2 = Streamlines(
LocalTracking(dg, sc, seeds, np.eye(4), 0.5, random_seed=0))._data
npt.assert_equal(tracking_1, tracking_2)
def test_ProbabilisticOdfWeightedTracker():
"""This tests that the Probabalistic 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.],
[.6, .4, 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 = ProbabilisticDirectionGetter.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.],
[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)
path = [False, False]
for sl in streamlines:
if allclose(sl, expected[0]):
path[0] = True
elif allclose(sl, expected[1]):
path[1] = True
else:
raise AssertionError()
npt.assert_(all(path))
# The first path is not possible if 90 degree turns are excluded
dg = ProbabilisticDirectionGetter.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]))
# The first path is not possible if pmf_threshold > 0.4
dg = ProbabilisticDirectionGetter.from_pmf(pmf, 90, sphere,
pmf_threshold=0.5)
streamlines = LocalTracking(dg, tc, seeds, np.eye(4), 1.)
for sl in streamlines:
npt.assert_(np.allclose(sl, expected[1]))
>>> verts, faces = get_sphere('not a sphere name') #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
DataError: No sphere called "not a sphere name"
'''
fname = SPHERE_FILES.get(name)
if fname is None:
raise DataError('No sphere called "%s"' % name)
res = np.load(fname)
# Set to native byte order to avoid errors in compiled routines for
# big-endian platforms, when using these spheres.
return Sphere(xyz=as_native_array(res['vertices']),
faces=as_native_array(res['faces']))
default_sphere = HemiSphere.from_sphere(get_sphere('symmetric724'))
small_sphere = HemiSphere.from_sphere(get_sphere('symmetric362'))
def get_data(name='small_64D'):
""" provides filenames of some test datasets or other useful parametrisations
Parameters
----------
name : str
the filename/s of which dataset to return, one of:
'small_64D' small region of interest nifti,bvecs,bvals 64 directions
'small_101D' small region of interest nifti,bvecs,bvals 101 directions
'aniso_vox' volume with anisotropic voxel size as Nifti
'fornix' 300 tracks in Trackvis format (from Pittsburgh Brain Competition)
'gqi_vectors' the scanner wave vectors needed for a GQI acquisitions of 101 directions tested on Siemens 3T Trio
(720, 3)
>>> verts, faces = get_sphere('not a sphere name') #doctest: +IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
DataError: No sphere called "not a sphere name"
"""
fname = SPHERE_FILES.get(name)
if fname is None:
raise DataError('No sphere called "%s"' % name)
res = np.load(fname)
# Set to native byte order to avoid errors in compiled routines for
# big-endian platforms, when using these spheres.
return Sphere(xyz=as_native_array(res["vertices"]), faces=as_native_array(res["faces"]))
default_sphere = HemiSphere.from_sphere(get_sphere("symmetric724"))
small_sphere = HemiSphere.from_sphere(get_sphere("symmetric362"))
def get_data(name="small_64D"):
""" provides filenames of some test datasets or other useful parametrisations
Parameters
----------
name : str
the filename/s of which dataset to return, one of:
'small_64D' small region of interest nifti,bvecs,bvals 64 directions
'small_101D' small region of interest nifti,bvecs,bvals 101 directions
'aniso_vox' volume with anisotropic voxel size as Nifti
'fornix' 300 tracks in Trackvis format (from Pittsburgh Brain Competition)
'gqi_vectors' the scanner wave vectors needed for a GQI acquisitions of 101 directions tested on Siemens 3T Trio
def _get_direction_getter(args):
odf_data = nib.load(args.in_odf).get_fdata(dtype=np.float32)
sphere = HemiSphere.from_sphere(get_sphere(args.sphere))
theta = get_theta(args.theta, args.algo)
non_zeros_count = np.count_nonzero(np.sum(odf_data, axis=-1))
non_first_val_count = np.count_nonzero(np.argmax(odf_data, axis=-1))
if args.algo in ['det', 'prob']:
if non_first_val_count / non_zeros_count > 0.5:
logging.warning('Input detected as peaks. Input should be'
'fodf for det/prob, verify input just in case.')
if args.algo == 'det':
dg_class = DeterministicMaximumDirectionGetter
else:
dg_class = ProbabilisticDirectionGetter
return dg_class.from_shcoeff(
shcoeff=odf_data, max_angle=theta, sphere=sphere,
basis_type=args.sh_basis,
relative_peak_threshold=args.sf_threshold)
elif args.algo == 'eudx':
# Code for type EUDX. We don't use peaks_from_model
# because we want the peaks from the provided sh.
odf_shape_3d = odf_data.shape[:-1]
dg = PeaksAndMetrics()
dg.sphere = sphere
dg.ang_thr = theta
dg.qa_thr = args.sf_threshold
# Heuristic to find out if the input are peaks or fodf
# fodf are always around 0.15 and peaks around 0.75
if non_first_val_count / non_zeros_count > 0.5:
logging.info('Input detected as peaks.')
nb_peaks = odf_data.shape[-1] // 3
slices = np.arange(0, 15+1, 3)
peak_values = np.zeros(odf_shape_3d+(nb_peaks,))
peak_indices = np.zeros(odf_shape_3d+(nb_peaks,))
for idx in np.argwhere(np.sum(odf_data, axis=-1)):
idx = tuple(idx)
for i in range(nb_peaks):
peak_values[idx][i] = np.linalg.norm(
odf_data[idx][slices[i]:slices[i+1]], axis=-1)
peak_indices[idx][i] = sphere.find_closest(
odf_data[idx][slices[i]:slices[i+1]])
dg.peak_dirs = odf_data
else:
logging.info('Input detected as fodf.')
npeaks = 5
peak_dirs = np.zeros((odf_shape_3d + (npeaks, 3)))
peak_values = np.zeros((odf_shape_3d + (npeaks, )))
peak_indices = np.full((odf_shape_3d + (npeaks, )), -1, dtype='int')
b_matrix = get_b_matrix(
find_order_from_nb_coeff(odf_data), sphere, args.sh_basis)
for idx in np.argwhere(np.sum(odf_data, axis=-1)):
idx = tuple(idx)
directions, values, indices = get_maximas(odf_data[idx],
sphere, b_matrix,
args.sf_threshold, 0)
if values.shape[0] != 0:
n = min(npeaks, values.shape[0])
peak_dirs[idx][:n] = directions[:n]
peak_values[idx][:n] = values[:n]
peak_indices[idx][:n] = indices[:n]
dg.peak_dirs = peak_dirs
dg.peak_values = peak_values
dg.peak_indices = peak_indices
return dg
def test_probabilistic_odf_weighted_tracker():
"""This tests that the Probabalistic 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.],
[.6, .4, 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 = ProbabilisticDirectionGetter.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.],
[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)
path = [False, False]
for sl in streamlines:
if allclose(sl, expected[0]):
path[0] = True
elif allclose(sl, expected[1]):
path[1] = True
else:
raise AssertionError()
npt.assert_(all(path))
# The first path is not possible if 90 degree turns are excluded
dg = ProbabilisticDirectionGetter.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]))
# The first path is not possible if pmf_threshold > 0.67
# 0.4/0.6 < 2/3, multiplying the pmf should not change the ratio
dg = ProbabilisticDirectionGetter.from_pmf(10*pmf, 90, sphere,
pmf_threshold=0.67)
streamlines = LocalTracking(dg, tc, seeds, np.eye(4), 1.)
for sl in streamlines:
npt.assert_(np.allclose(sl, expected[1]))
# Test non WM seed position
seeds = [[0, 0, 0], [5, 5, 5]]
streamlines = LocalTracking(dg, tc, seeds, np.eye(4), 0.2, max_cross=1,
return_all=True)
streamlines = Streamlines(streamlines)
npt.assert_(len(streamlines[0]) == 3) # INVALIDPOINT
npt.assert_(len(streamlines[1]) == 1) # OUTSIDEIMAGE
# Test that all points are within the image volume
seeds = seeds_from_mask(np.ones(mask.shape), density=2)
streamline_generator = LocalTracking(dg, tc, seeds, np.eye(4), 0.5,
return_all=True)
streamlines = Streamlines(streamline_generator)
for s in streamlines:
npt.assert_(np.all((s + 0.5).astype(int) >= 0))
npt.assert_(np.all((s + 0.5).astype(int) < mask.shape))
# Test that the number of streamline return with return_all=True equal the
# number of seeds places
npt.assert_(np.array([len(streamlines) == len(seeds)]))
# Test reproducibility
tracking_1 = Streamlines(LocalTracking(dg, tc, seeds, np.eye(4),
0.5,
random_seed=0)).data
tracking_2 = Streamlines(LocalTracking(dg, tc, seeds, np.eye(4),
0.5,
random_seed=0)).data
npt.assert_equal(tracking_1, tracking_2)
def test_stop_conditions():
"""This tests that the Local Tracker behaves as expected for the
following tissue types.
"""
# TissueTypes.TRACKPOINT = 1
# TissueTypes.ENDPOINT = 2
# TissueTypes.INVALIDPOINT = 0
tissue = np.array([[2, 1, 1, 2, 1],
[2, 2, 1, 1, 2],
[1, 1, 1, 1, 1],
[1, 1, 1, 2, 2],
[0, 1, 1, 1, 2],
[0, 1, 1, 0, 2],
[1, 0, 1, 1, 1]])
tissue = tissue[None]
sphere = HemiSphere.from_sphere(unit_octahedron)
pmf_lookup = np.array([[0., 0., 0., ],
[0., 0., 1.]])
pmf = pmf_lookup[(tissue > 0).astype("int")]
# Create a seeds along
x = np.array([0., 0, 0, 0, 0, 0, 0])
y = np.array([0., 1, 2, 3, 4, 5, 6])
z = np.array([1., 1, 1, 0, 1, 1, 1])
seeds = np.column_stack([x, y, z])
# Set up tracking
endpoint_mask = tissue == TissueTypes.ENDPOINT
invalidpoint_mask = tissue == TissueTypes.INVALIDPOINT
tc = ActTissueClassifier(endpoint_mask, invalidpoint_mask)
dg = ProbabilisticDirectionGetter.from_pmf(pmf, 60, sphere)
# valid streamlines only
streamlines_generator = LocalTracking(direction_getter=dg,
tissue_classifier=tc,
seeds=seeds,
affine=np.eye(4),
step_size=1.,
return_all=False)
streamlines_not_all = iter(streamlines_generator)
# all streamlines
streamlines_all_generator = LocalTracking(direction_getter=dg,
tissue_classifier=tc,
seeds=seeds,
affine=np.eye(4),
step_size=1.,
return_all=True)
streamlines_all = iter(streamlines_all_generator)
# Check that the first streamline stops at 0 and 3 (ENDPOINT)
y = 0
sl = next(streamlines_not_all)
npt.assert_equal(sl[0], [0, y, 0])
npt.assert_equal(sl[-1], [0, y, 3])
npt.assert_equal(len(sl), 4)
sl = next(streamlines_all)
npt.assert_equal(sl[0], [0, y, 0])
npt.assert_equal(sl[-1], [0, y, 3])
npt.assert_equal(len(sl), 4)
# Check that the first streamline stops at 0 and 4 (ENDPOINT)
y = 1
sl = next(streamlines_not_all)
npt.assert_equal(sl[0], [0, y, 0])
npt.assert_equal(sl[-1], [0, y, 4])
npt.assert_equal(len(sl), 5)
sl = next(streamlines_all)
npt.assert_equal(sl[0], [0, y, 0])
npt.assert_equal(sl[-1], [0, y, 4])
npt.assert_equal(len(sl), 5)
# This streamline should be the same as above. This row does not have
# ENDPOINTs, but the streamline should stop at the edge and not include
# OUTSIDEIMAGE points.
y = 2
sl = next(streamlines_not_all)
npt.assert_equal(sl[0], [0, y, 0])
npt.assert_equal(sl[-1], [0, y, 4])
npt.assert_equal(len(sl), 5)
sl = next(streamlines_all)
npt.assert_equal(sl[0], [0, y, 0])
npt.assert_equal(sl[-1], [0, y, 4])
npt.assert_equal(len(sl), 5)
# If we seed on the edge, the first (or last) point in the streamline
# should be the seed.
y = 3
sl = next(streamlines_not_all)
npt.assert_equal(sl[0], seeds[y])
sl = next(streamlines_all)
npt.assert_equal(sl[0], seeds[y])
# The last 3 seeds should not produce streamlines,
# INVALIDPOINT streamlines are rejected (return_all=False).
npt.assert_equal(len(list(streamlines_not_all)), 0)
# The last 3 seeds should produce invalid streamlines,
# INVALIDPOINT streamlines are kept (return_all=True).
# The streamline stops at 0 (INVALIDPOINT) and 4 (ENDPOINT)
y = 4
sl = next(streamlines_all)
npt.assert_equal(sl[0], [0, y, 0])
npt.assert_equal(sl[-1], [0, y, 4])
npt.assert_equal(len(sl), 5)
# The streamline stops at 0 (INVALIDPOINT) and 4 (INVALIDPOINT)
y = 5
sl = next(streamlines_all)
npt.assert_equal(sl[0], [0, y, 0])
npt.assert_equal(sl[-1], [0, y, 3])
npt.assert_equal(len(sl), 4)
# The last streamline should contain only one point, the seed point,
# because no valid inital direction was returned.
y = 6
sl = next(streamlines_all)
npt.assert_equal(sl[0], seeds[y])
npt.assert_equal(sl[-1], seeds[y])
npt.assert_equal(len(sl), 1)
def test_ProbabilisticOdfWeightedTracker():
sphere = HemiSphere.from_sphere(unit_octahedron)
# A simple image with three possible configurations, a vertical tract,
# a horizontal tract and a crossing
odf_list = [np.array([0., 0., 0.]),
np.array([1., 0., 0.]),
np.array([0., 1., 0.]),
np.array([1., 1., 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],
])
# Make the image 4d
simple_image = simple_image[..., None, None]
# Simple model and fit for this image
class MyModel():
def fit(self, data):
return MyFit(data)
class MyFit(object):
def __init__(self, n):
self.n = n
def odf(self, sphere):
return odf_list[self.n]
seeds = [np.array([1.5, 1.5, .5])] * 30
model = MyModel()
mask = np.ones([5, 6, 1], dtype="bool")
stepper = FixedSizeStepper(1.)
interpolator = NearestNeighborInterpolator(simple_image, (1, 1, 1))
# These are the only two possible paths though the simple_image
pwt = ProbabilisticOdfWeightedTracker(model, interpolator, mask,
stepper, 90, seeds, sphere)
expected = [np.array([[0.5, 1.5, 0.5],
[1.5, 1.5, 0.5],
[2.5, 1.5, 0.5],
[2.5, 2.5, 0.5],
[2.5, 3.5, 0.5],
[2.5, 4.5, 0.5],
[2.5, 5.5, 0.5]]),
np.array([[0.5, 1.5, 0.5],
[1.5, 1.5, 0.5],
[2.5, 1.5, 0.5],
[3.5, 1.5, 0.5],
[4.5, 1.5, 0.5]])
]
def allclose(x, y):
return x.shape == y.shape and np.allclose(x, y)
path = [False, False]
for streamline in pwt:
if allclose(streamline, expected[0]):
path[0] = True
elif allclose(streamline, expected[1]):
path[1] = True
else:
raise AssertionError()
assert_(all(path))
# The first path is not possible if 90 degree turns are excluded
pwt = ProbabilisticOdfWeightedTracker(model, interpolator, mask,
stepper, 80, seeds, sphere)
for streamline in pwt:
assert_(np.allclose(streamline, expected[1]))
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]))
def test_ProbabilisticOdfWeightedTracker():
sphere = HemiSphere.from_sphere(unit_octahedron)
# A simple image with three possible configurations, a vertical tract,
# a horizontal tract and a crossing
odf_list = [
np.array([0., 0., 0.]),
np.array([1., 0., 0.]),
np.array([0., 1., 0.]),
np.array([1., 1., 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],
])
# Make the image 4d
simple_image = simple_image[..., None, None]
# Simple model and fit for this image
class MyModel():
def fit(self, data):
return MyFit(data)
class MyFit(object):
def __init__(self, n):
self.n = int(n)
def odf(self, sphere):
return odf_list[self.n]
seeds = [np.array([1.5, 1.5, .5])] * 30
model = MyModel()
mask = np.ones([5, 6, 1], dtype="bool")
stepper = FixedSizeStepper(1.)
interpolator = NearestNeighborInterpolator(simple_image, (1, 1, 1))
# These are the only two possible paths though the simple_image
pwt = ProbabilisticOdfWeightedTracker(model, interpolator, mask, stepper,
90, seeds, sphere)
expected = [
np.array([[0.5, 1.5, 0.5], [1.5, 1.5, 0.5], [2.5, 1.5, 0.5],
[2.5, 2.5, 0.5], [2.5, 3.5, 0.5], [2.5, 4.5, 0.5],
[2.5, 5.5, 0.5]]),
np.array([[0.5, 1.5, 0.5], [1.5, 1.5, 0.5], [2.5, 1.5, 0.5],
[3.5, 1.5, 0.5], [4.5, 1.5, 0.5]])
]
def allclose(x, y):
return x.shape == y.shape and np.allclose(x, y)
path = [False, False]
for streamline in pwt:
if allclose(streamline, expected[0]):
path[0] = True
elif allclose(streamline, expected[1]):
path[1] = True
else:
raise AssertionError()
assert_(all(path))
# The first path is not possible if 90 degree turns are excluded
pwt = ProbabilisticOdfWeightedTracker(model, interpolator, mask, stepper,
80, seeds, sphere)
for streamline in pwt:
assert_(np.allclose(streamline, expected[1]))
from ..utils.six.moves import xrange
import numpy as np
import scipy.optimize as opt
from .recspeed import local_maxima, remove_similar_vertices, search_descending
from ..core.onetime import auto_attr
from dipy.core.sphere import HemiSphere, Sphere
from dipy.data import get_sphere
#from dipy.reconst.shm import sph_harm_ind_list, smooth_pinv
# Classes OdfModel and OdfFit are using API ReconstModel and ReconstFit from
# .base
default_sphere = HemiSphere.from_sphere(get_sphere('symmetric724'))
def peak_directions_nl(sphere_eval, relative_peak_threshold=.25,
min_separation_angle=45, sphere=default_sphere,
xtol=1e-7):
"""Non Linear Direction Finder
Parameters
----------
sphere_eval : callable
A function which can be evaluated on a sphere.
relative_peak_threshold : float
Only return peaks greater than ``relative_peak_threshold * m`` where m
is the largest peak.
min_separation_angle : float in [0, 90]
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))
