def test_phantom():
# generate a gradient table for phantom data
directions8 = generate_bvecs(8)
directions30 = generate_bvecs(20)
directions60 = generate_bvecs(30)
# Create full dataset parameters
# (6 b-values = 0, 8 directions for b-value 300, 30 directions for b-value
# 1000 and 60 directions for b-value 2000)
bvals = np.hstack((np.zeros(6), 300 * np.ones(8), 1000 * np.ones(20),
2000 * np.ones(30)))
bvecs = np.vstack((np.zeros(
(6, 3)), directions8, directions30, directions60))
gtab = gradient_table(bvals, bvecs)
dwi, sigma = rfiw_phantom(gtab, snr=10)
dwi_den1 = p2s.patch2self(dwi, model='ridge', bvals=bvals, alpha=1.0)
assert_less(np.max(dwi_den1) / sigma, np.max(dwi) / sigma)
dwi_den2 = p2s.patch2self(dwi, model='ridge', bvals=bvals, alpha=0.7)
assert_less(np.max(dwi_den2) / sigma, np.max(dwi) / sigma)
assert_array_almost_equal(dwi_den1, dwi_den2, decimal=0)
assert_raises(ValueError, p2s.patch2self, dwi, model='empty', bvals=bvals)
# Try this with a sigma volume, instead of a scalar
dwi_den = p2s.patch2self(dwi, bvals=bvals, model='ols')
assert_less(np.max(dwi_den) / sigma, np.max(dwi) / sigma)
def test_generate_bvecs():
"""Tests whether we have properly generated bvecs.
"""
# Test if the generated bvectors are unit vectors
bvecs = generate_bvecs(100)
norm = [np.linalg.norm(v) for v in bvecs]
npt.assert_almost_equal(norm, np.ones(100))
# Test if two generated vectors are almost orthogonal
bvecs_2 = generate_bvecs(2)
cos_theta = np.dot(bvecs_2[0], bvecs_2[1])
npt.assert_almost_equal(cos_theta, 0., decimal=6)
def test_generate_bvecs():
"""Tests whether we have properly generated bvecs.
"""
# Test if the generated bvectors are unit vectors
bvecs = generate_bvecs(100)
norm = [np.linalg.norm(v) for v in bvecs]
npt.assert_almost_equal(norm, np.ones(100))
# Test if two generated vectors are almost orthogonal
bvecs_2 = generate_bvecs(2)
cos_theta = np.dot(bvecs_2[0], bvecs_2[1])
npt.assert_almost_equal(cos_theta, 0.)
def gen_gtab():
# generate a gradient table for phantom data
directions8 = generate_bvecs(8)
directions30 = generate_bvecs(30)
directions60 = generate_bvecs(60)
# Create full dataset parameters
# (6 b-values = 0, 8 directions for b-value 300, 30 directions for b-value
# 1000 and 60 directions for b-value 2000)
bvals = np.hstack((np.zeros(6), 300 * np.ones(8), 1000 * np.ones(30),
2000 * np.ones(60)))
bvecs = np.vstack((np.zeros(
(6, 3)), directions8, directions30, directions60))
gtab = gradient_table(bvals, bvecs)
return gtab
def test_reconst_ivim():
with TemporaryDirectory() as out_dir:
bvals = np.array([
0., 10., 20., 30., 40., 60., 80., 100., 120., 140., 160., 180.,
200., 300., 400., 500., 600., 700., 800., 900., 1000.
])
N = len(bvals)
bvecs = generate_bvecs(N)
temp_bval_path = pjoin(out_dir, "temp.bval")
np.savetxt(temp_bval_path, bvals)
temp_bvec_path = pjoin(out_dir, "temp.bvec")
np.savetxt(temp_bvec_path, bvecs)
gtab = gradient_table(bvals, bvecs)
S0, f, D_star, D = 1000.0, 0.132, 0.00885, 0.000921
mevals = np.array(([D_star, D_star, D_star], [D, D, D]))
# This gives an isotropic signal.
data = multi_tensor(gtab,
mevals,
snr=None,
S0=S0,
fractions=[f * 100, 100 * (1 - f)])
# Single voxel data
data_single = data[0]
temp_affine = np.eye(4)
data_multi = np.zeros((2, 2, 1, len(gtab.bvals)), dtype=int)
data_multi[0, 0, 0] = data_multi[0, 1, 0] = data_multi[
1, 0, 0] = data_multi[1, 1, 0] = data_single
data_path = pjoin(out_dir, 'tmp_data.nii.gz')
save_nifti(data_path, data_multi, temp_affine)
mask = np.ones_like(data_multi[..., 0], dtype=np.uint8)
mask_path = pjoin(out_dir, 'tmp_mask.nii.gz')
save_nifti(mask_path, mask, temp_affine)
ivim_flow = ReconstIvimFlow()
args = [data_path, temp_bval_path, temp_bvec_path, mask_path]
ivim_flow.run(*args, out_dir=out_dir)
S0_path = ivim_flow.last_generated_outputs['out_S0_predicted']
S0_data = load_nifti_data(S0_path)
assert_equal(S0_data.shape, data_multi.shape[:-1])
f_path = ivim_flow.last_generated_outputs['out_perfusion_fraction']
f_data = load_nifti_data(f_path)
assert_equal(f_data.shape, data_multi.shape[:-1])
D_star_path = ivim_flow.last_generated_outputs['out_D_star']
D_star_data = load_nifti_data(D_star_path)
assert_equal(D_star_data.shape, data_multi.shape[:-1])
D_path = ivim_flow.last_generated_outputs['out_D']
D_data = load_nifti_data(D_path)
assert_equal(D_data.shape, data_multi.shape[:-1])
def gen_gtab():
# generate a gradient table for phantom data
directions8 = generate_bvecs(8)
directions30 = generate_bvecs(30)
directions60 = generate_bvecs(60)
# Create full dataset parameters
# (6 b-values = 0, 8 directions for b-value 300, 30 directions for b-value
# 1000 and 60 directions for b-value 2000)
bvals = np.hstack((np.zeros(6),
300 * np.ones(8),
1000 * np.ones(30),
2000 * np.ones(60)))
bvecs = np.vstack((np.zeros((6, 3)),
directions8, directions30, directions60))
gtab = gradient_table(bvals, bvecs)
return gtab
def test_check_multi_b():
bvals = np.array([1000, 1000, 1000, 1000, 2000, 2000, 2000, 2000, 0])
bvecs = generate_bvecs(bvals.shape[-1])
gtab = gradient_table(bvals, bvecs)
npt.assert_(check_multi_b(gtab, 2, non_zero=False))
# We don't consider differences this small to be sufficient:
bvals = np.array([1995, 1995, 1995, 1995, 2005, 2005, 2005, 2005, 0])
bvecs = generate_bvecs(bvals.shape[-1])
gtab = gradient_table(bvals, bvecs)
npt.assert_(not check_multi_b(gtab, 2, non_zero=True))
# Unless you specify that you are interested in this magnitude of changes:
npt.assert_(check_multi_b(gtab, 2, non_zero=True, bmag=1))
# Or if you consider zero to be one of your b-values:
npt.assert_(check_multi_b(gtab, 2, non_zero=False))
def test_check_multi_b():
bvals = np.array([1000, 1000, 1000, 1000, 2000, 2000, 2000, 2000, 0])
bvecs = generate_bvecs(bvals.shape[-1])
gtab = gradient_table(bvals, bvecs)
npt.assert_(check_multi_b(gtab, 2, non_zero=False))
# We don't consider differences this small to be sufficient:
bvals = np.array([1995, 1995, 1995, 1995, 2005, 2005, 2005, 2005, 0])
bvecs = generate_bvecs(bvals.shape[-1])
gtab = gradient_table(bvals, bvecs)
npt.assert_(not check_multi_b(gtab, 2, non_zero=True))
# Unless you specify that you are interested in this magnitude of changes:
npt.assert_(check_multi_b(gtab, 2, non_zero=True, bmag=1))
# Or if you consider zero to be one of your b-values:
npt.assert_(check_multi_b(gtab, 2, non_zero=False))
def test_reconst_ivim():
with TemporaryDirectory() as out_dir:
bvals = np.array([0., 10., 20., 30., 40., 60., 80., 100.,
120., 140., 160., 180., 200., 300., 400.,
500., 600., 700., 800., 900., 1000.])
N = len(bvals)
bvecs = generate_bvecs(N)
temp_bval_path = pjoin(out_dir, "temp.bval")
np.savetxt(temp_bval_path, bvals)
temp_bvec_path = pjoin(out_dir, "temp.bvec")
np.savetxt(temp_bvec_path, bvecs)
gtab = gradient_table(bvals, bvecs)
S0, f, D_star, D = 1000.0, 0.132, 0.00885, 0.000921
mevals = np.array(([D_star, D_star, D_star], [D, D, D]))
# This gives an isotropic signal.
data = multi_tensor(gtab, mevals, snr=None, S0=S0,
fractions=[f * 100, 100 * (1 - f)])
# Single voxel data
data_single = data[0]
temp_affine = np.eye(4)
data_multi = np.zeros((2, 2, 1, len(gtab.bvals)))
data_multi[0, 0, 0] = data_multi[0, 1, 0] = data_multi[
1, 0, 0] = data_multi[1, 1, 0] = data_single
data_img = nib.Nifti1Image(data_multi.astype(int), temp_affine)
data_path = pjoin(out_dir, 'tmp_data.nii.gz')
nib.save(data_img, data_path)
mask = np.ones_like(data_multi[..., 0])
mask_img = nib.Nifti1Image(mask.astype(np.uint8), data_img.affine)
mask_path = pjoin(out_dir, 'tmp_mask.nii.gz')
nib.save(mask_img, mask_path)
ivim_flow = ReconstIvimFlow()
args = [data_path, temp_bval_path, temp_bvec_path, mask_path]
ivim_flow.run(*args, out_dir=out_dir)
S0_path = ivim_flow.last_generated_outputs['out_S0_predicted']
S0_data = nib.load(S0_path).get_data()
assert_equal(S0_data.shape, data_img.shape[:-1])
f_path = ivim_flow.last_generated_outputs['out_perfusion_fraction']
f_data = nib.load(f_path).get_data()
assert_equal(f_data.shape, data_img.shape[:-1])
D_star_path = ivim_flow.last_generated_outputs['out_D_star']
D_star_data = nib.load(D_star_path).get_data()
assert_equal(D_star_data.shape, data_img.shape[:-1])
D_path = ivim_flow.last_generated_outputs['out_D']
D_data = nib.load(D_path).get_data()
assert_equal(D_data.shape, data_img.shape[:-1])
def test_b0_threshold_greater_than0():
"""
Added test case for default b0_threshold set to 50.
Checks if error is thrown correctly.
"""
bvals_b0t = np.array([50., 10., 20., 30., 40., 60., 80., 100.,
120., 140., 160., 180., 200., 300., 400.,
500., 600., 700., 800., 900., 1000.])
N = len(bvals_b0t)
bvecs = generate_bvecs(N)
gtab = gradient_table(bvals_b0t, bvecs.T)
with assert_raises(ValueError) as vae:
_ = IvimModel(gtab, fit_method='LM')
b0_s = "The IVIM model requires a measurement at b==0. As of "
assert b0_s in vae.exception
def test_b0_threshold_greater_than0():
"""
Added test case for default b0_threshold set to 50.
Checks if error is thrown correctly.
"""
bvals_b0t = np.array([50., 10., 20., 30., 40., 60., 80., 100.,
120., 140., 160., 180., 200., 300., 400.,
500., 600., 700., 800., 900., 1000.])
N = len(bvals_b0t)
bvecs = generate_bvecs(N)
gtab = gradient_table(bvals_b0t, bvecs.T)
with assert_raises(ValueError) as vae:
_ = IvimModel(gtab)
b0_s = "The IVIM model requires a measurement at b==0. As of "
assert b0_s in vae.exception
def reconst_mmri_core(flow, lap, pos):
with TemporaryDirectory() as out_dir:
data_path, bval_path, bvec_path = get_fnames('small_25')
volume = load_nifti_data(data_path)
mmri_flow = flow()
mmri_flow.run(data_files=data_path,
bvals_files=bval_path,
bvecs_files=bvec_path,
small_delta=0.0129,
big_delta=0.0218,
laplacian=lap,
positivity=pos,
out_dir=out_dir)
for out_name in [
'out_rtop', 'out_lapnorm', 'out_msd', 'out_qiv', 'out_rtap',
'out_rtpp', 'out_ng', 'out_parng', 'out_perng'
]:
out_path = mmri_flow.last_generated_outputs[out_name]
out_data = load_nifti_data(out_path)
npt.assert_equal(out_data.shape, volume.shape[:-1])
bvals, bvecs = read_bvals_bvecs(bval_path, bvec_path)
bvals[0] = 5.
bvecs = generate_bvecs(len(bvals))
tmp_bval_path = pjoin(out_dir, "tmp.bval")
tmp_bvec_path = pjoin(out_dir, "tmp.bvec")
np.savetxt(tmp_bval_path, bvals)
np.savetxt(tmp_bvec_path, bvecs.T)
mmri_flow._force_overwrite = True
with npt.assert_raises(BaseException):
npt.assert_warns(UserWarning,
mmri_flow.run,
data_path,
tmp_bval_path,
tmp_bvec_path,
small_delta=0.0129,
big_delta=0.0218,
laplacian=lap,
positivity=pos,
out_dir=out_dir)
def reconst_flow_core(flow):
with TemporaryDirectory() as out_dir:
data_path, bval_path, bvec_path = get_fnames('small_64D')
vol_img = nib.load(data_path)
volume = vol_img.get_data()
mask = np.ones_like(volume[:, :, :, 0])
mask_img = nib.Nifti1Image(mask.astype(np.uint8), vol_img.affine)
mask_path = pjoin(out_dir, 'tmp_mask.nii.gz')
nib.save(mask_img, mask_path)
reconst_flow = flow()
for sh_order in [4, 6, 8]:
if flow.get_short_name() == 'csd':
reconst_flow.run(data_path, bval_path, bvec_path, mask_path,
sh_order=sh_order,
out_dir=out_dir, extract_pam_values=True)
elif flow.get_short_name() == 'csa':
reconst_flow.run(data_path, bval_path, bvec_path, mask_path,
sh_order=sh_order,
odf_to_sh_order=sh_order,
out_dir=out_dir, extract_pam_values=True)
gfa_path = reconst_flow.last_generated_outputs['out_gfa']
gfa_data = nib.load(gfa_path).get_data()
npt.assert_equal(gfa_data.shape, volume.shape[:-1])
peaks_dir_path =\
reconst_flow.last_generated_outputs['out_peaks_dir']
peaks_dir_data = nib.load(peaks_dir_path).get_data()
npt.assert_equal(peaks_dir_data.shape[-1], 15)
npt.assert_equal(peaks_dir_data.shape[:-1], volume.shape[:-1])
peaks_idx_path = \
reconst_flow.last_generated_outputs['out_peaks_indices']
peaks_idx_data = nib.load(peaks_idx_path).get_data()
npt.assert_equal(peaks_idx_data.shape[-1], 5)
npt.assert_equal(peaks_idx_data.shape[:-1], volume.shape[:-1])
peaks_vals_path = \
reconst_flow.last_generated_outputs['out_peaks_values']
peaks_vals_data = nib.load(peaks_vals_path).get_data()
npt.assert_equal(peaks_vals_data.shape[-1], 5)
npt.assert_equal(peaks_vals_data.shape[:-1], volume.shape[:-1])
shm_path = reconst_flow.last_generated_outputs['out_shm']
shm_data = nib.load(shm_path).get_data()
# Test that the number of coefficients is what you would expect
# given the order of the sh basis:
npt.assert_equal(shm_data.shape[-1],
sph_harm_ind_list(sh_order)[0].shape[0])
npt.assert_equal(shm_data.shape[:-1], volume.shape[:-1])
pam = load_peaks(reconst_flow.last_generated_outputs['out_pam'])
npt.assert_allclose(pam.peak_dirs.reshape(peaks_dir_data.shape),
peaks_dir_data)
npt.assert_allclose(pam.peak_values, peaks_vals_data)
npt.assert_allclose(pam.peak_indices, peaks_idx_data)
npt.assert_allclose(pam.shm_coeff, shm_data)
npt.assert_allclose(pam.gfa, gfa_data)
bvals, bvecs = read_bvals_bvecs(bval_path, bvec_path)
bvals[0] = 5.
bvecs = generate_bvecs(len(bvals))
tmp_bval_path = pjoin(out_dir, "tmp.bval")
tmp_bvec_path = pjoin(out_dir, "tmp.bvec")
np.savetxt(tmp_bval_path, bvals)
np.savetxt(tmp_bvec_path, bvecs.T)
reconst_flow._force_overwrite = True
with npt.assert_raises(BaseException):
npt.assert_warns(UserWarning, reconst_flow.run, data_path,
tmp_bval_path, tmp_bvec_path, mask_path,
out_dir=out_dir, extract_pam_values=True)
if flow.get_short_name() == 'csd':
reconst_flow = flow()
reconst_flow._force_overwrite = True
reconst_flow.run(data_path, bval_path, bvec_path, mask_path,
out_dir=out_dir, frf=[15, 5, 5])
reconst_flow = flow()
reconst_flow._force_overwrite = True
reconst_flow.run(data_path, bval_path, bvec_path, mask_path,
out_dir=out_dir, frf='15, 5, 5')
reconst_flow = flow()
reconst_flow._force_overwrite = True
reconst_flow.run(data_path, bval_path, bvec_path, mask_path,
out_dir=out_dir, frf=None)
reconst_flow2 = flow()
reconst_flow2._force_overwrite = True
reconst_flow2.run(data_path, bval_path, bvec_path, mask_path,
out_dir=out_dir, frf=None,
roi_center=[10, 10, 10])
def test_reconst_dki():
with TemporaryDirectory() as out_dir:
data_path, bval_path, bvec_path = get_fnames('small_101D')
volume, affine = load_nifti(data_path)
mask = np.ones_like(volume[:, :, :, 0])
mask_path = pjoin(out_dir, 'tmp_mask.nii.gz')
save_nifti(mask_path, mask.astype(np.uint8), affine)
dki_flow = ReconstDkiFlow()
args = [data_path, bval_path, bvec_path, mask_path]
dki_flow.run(*args, out_dir=out_dir)
fa_path = dki_flow.last_generated_outputs['out_fa']
fa_data = load_nifti_data(fa_path)
assert_equal(fa_data.shape, volume.shape[:-1])
tensor_path = dki_flow.last_generated_outputs['out_dt_tensor']
tensor_data = load_nifti_data(tensor_path)
assert_equal(tensor_data.shape[-1], 6)
assert_equal(tensor_data.shape[:-1], volume.shape[:-1])
ga_path = dki_flow.last_generated_outputs['out_ga']
ga_data = load_nifti_data(ga_path)
assert_equal(ga_data.shape, volume.shape[:-1])
rgb_path = dki_flow.last_generated_outputs['out_rgb']
rgb_data = load_nifti_data(rgb_path)
assert_equal(rgb_data.shape[-1], 3)
assert_equal(rgb_data.shape[:-1], volume.shape[:-1])
md_path = dki_flow.last_generated_outputs['out_md']
md_data = load_nifti_data(md_path)
assert_equal(md_data.shape, volume.shape[:-1])
ad_path = dki_flow.last_generated_outputs['out_ad']
ad_data = load_nifti_data(ad_path)
assert_equal(ad_data.shape, volume.shape[:-1])
rd_path = dki_flow.last_generated_outputs['out_rd']
rd_data = load_nifti_data(rd_path)
assert_equal(rd_data.shape, volume.shape[:-1])
mk_path = dki_flow.last_generated_outputs['out_mk']
mk_data = load_nifti_data(mk_path)
assert_equal(mk_data.shape, volume.shape[:-1])
ak_path = dki_flow.last_generated_outputs['out_ak']
ak_data = load_nifti_data(ak_path)
assert_equal(ak_data.shape, volume.shape[:-1])
rk_path = dki_flow.last_generated_outputs['out_rk']
rk_data = load_nifti_data(rk_path)
assert_equal(rk_data.shape, volume.shape[:-1])
kt_path = dki_flow.last_generated_outputs['out_dk_tensor']
kt_data = load_nifti_data(kt_path)
assert_equal(kt_data.shape[-1], 15)
assert_equal(kt_data.shape[:-1], volume.shape[:-1])
mode_path = dki_flow.last_generated_outputs['out_mode']
mode_data = load_nifti_data(mode_path)
assert_equal(mode_data.shape, volume.shape[:-1])
evecs_path = dki_flow.last_generated_outputs['out_evec']
evecs_data = load_nifti_data(evecs_path)
assert_equal(evecs_data.shape[-2:], tuple((3, 3)))
assert_equal(evecs_data.shape[:-2], volume.shape[:-1])
evals_path = dki_flow.last_generated_outputs['out_eval']
evals_data = load_nifti_data(evals_path)
assert_equal(evals_data.shape[-1], 3)
assert_equal(evals_data.shape[:-1], volume.shape[:-1])
bvals, bvecs = read_bvals_bvecs(bval_path, bvec_path)
bvals[0] = 5.
bvecs = generate_bvecs(len(bvals))
tmp_bval_path = pjoin(out_dir, "tmp.bval")
tmp_bvec_path = pjoin(out_dir, "tmp.bvec")
np.savetxt(tmp_bval_path, bvals)
np.savetxt(tmp_bvec_path, bvecs.T)
dki_flow._force_overwrite = True
npt.assert_warns(UserWarning, dki_flow.run, data_path,
tmp_bval_path, tmp_bvec_path, mask_path,
out_dir=out_dir, b0_threshold=0)
def reconst_flow_core(flow):
with TemporaryDirectory() as out_dir:
data_path, bval_path, bvec_path = get_fnames('small_64D')
volume, affine = load_nifti(data_path)
mask = np.ones_like(volume[:, :, :, 0])
mask_path = pjoin(out_dir, 'tmp_mask.nii.gz')
save_nifti(mask_path, mask.astype(np.uint8), affine)
reconst_flow = flow()
for sh_order in [4, 6, 8]:
if flow.get_short_name() == 'csd':
reconst_flow.run(data_path,
bval_path,
bvec_path,
mask_path,
sh_order=sh_order,
out_dir=out_dir,
extract_pam_values=True)
elif flow.get_short_name() == 'csa':
reconst_flow.run(data_path,
bval_path,
bvec_path,
mask_path,
sh_order=sh_order,
odf_to_sh_order=sh_order,
out_dir=out_dir,
extract_pam_values=True)
gfa_path = reconst_flow.last_generated_outputs['out_gfa']
gfa_data = load_nifti_data(gfa_path)
npt.assert_equal(gfa_data.shape, volume.shape[:-1])
peaks_dir_path =\
reconst_flow.last_generated_outputs['out_peaks_dir']
peaks_dir_data = load_nifti_data(peaks_dir_path)
npt.assert_equal(peaks_dir_data.shape[-1], 15)
npt.assert_equal(peaks_dir_data.shape[:-1], volume.shape[:-1])
peaks_idx_path = \
reconst_flow.last_generated_outputs['out_peaks_indices']
peaks_idx_data = load_nifti_data(peaks_idx_path)
npt.assert_equal(peaks_idx_data.shape[-1], 5)
npt.assert_equal(peaks_idx_data.shape[:-1], volume.shape[:-1])
peaks_vals_path = \
reconst_flow.last_generated_outputs['out_peaks_values']
peaks_vals_data = load_nifti_data(peaks_vals_path)
npt.assert_equal(peaks_vals_data.shape[-1], 5)
npt.assert_equal(peaks_vals_data.shape[:-1], volume.shape[:-1])
shm_path = reconst_flow.last_generated_outputs['out_shm']
shm_data = load_nifti_data(shm_path)
# Test that the number of coefficients is what you would expect
# given the order of the sh basis:
npt.assert_equal(shm_data.shape[-1],
sph_harm_ind_list(sh_order)[0].shape[0])
npt.assert_equal(shm_data.shape[:-1], volume.shape[:-1])
pam = load_peaks(reconst_flow.last_generated_outputs['out_pam'])
npt.assert_allclose(pam.peak_dirs.reshape(peaks_dir_data.shape),
peaks_dir_data)
npt.assert_allclose(pam.peak_values, peaks_vals_data)
npt.assert_allclose(pam.peak_indices, peaks_idx_data)
npt.assert_allclose(pam.shm_coeff, shm_data)
npt.assert_allclose(pam.gfa, gfa_data)
bvals, bvecs = read_bvals_bvecs(bval_path, bvec_path)
bvals[0] = 5.
bvecs = generate_bvecs(len(bvals))
tmp_bval_path = pjoin(out_dir, "tmp.bval")
tmp_bvec_path = pjoin(out_dir, "tmp.bvec")
np.savetxt(tmp_bval_path, bvals)
np.savetxt(tmp_bvec_path, bvecs.T)
reconst_flow._force_overwrite = True
if flow.get_short_name() == 'csd':
reconst_flow = flow()
reconst_flow._force_overwrite = True
reconst_flow.run(data_path,
bval_path,
bvec_path,
mask_path,
out_dir=out_dir,
frf=[15, 5, 5])
reconst_flow = flow()
reconst_flow._force_overwrite = True
reconst_flow.run(data_path,
bval_path,
bvec_path,
mask_path,
out_dir=out_dir,
frf='15, 5, 5')
reconst_flow = flow()
reconst_flow._force_overwrite = True
reconst_flow.run(data_path,
bval_path,
bvec_path,
mask_path,
out_dir=out_dir,
frf=None)
reconst_flow2 = flow()
reconst_flow2._force_overwrite = True
reconst_flow2.run(data_path,
bval_path,
bvec_path,
mask_path,
out_dir=out_dir,
frf=None,
roi_center=[5, 5, 5])
else:
with npt.assert_raises(BaseException):
npt.assert_warns(UserWarning,
reconst_flow.run,
data_path,
tmp_bval_path,
tmp_bvec_path,
mask_path,
out_dir=out_dir,
extract_pam_values=True)
# test parallel implementation
reconst_flow = flow()
reconst_flow._force_overwrite = True
reconst_flow.run(data_path,
bval_path,
bvec_path,
mask_path,
out_dir=out_dir,
parallel=True,
nbr_processes=None)
reconst_flow = flow()
reconst_flow._force_overwrite = True
reconst_flow.run(data_path,
bval_path,
bvec_path,
mask_path,
out_dir=out_dir,
parallel=True,
nbr_processes=2)
def setup_module():
global gtab, ivim_fit_single, ivim_model_LM, data_single, params_LM, \
data_multi, ivim_params_LM, D_star, D, f, S0, gtab_with_multiple_b0, \
noisy_single, mevals, gtab_no_b0, ivim_fit_multi, ivim_model_VP, \
f_VP, D_star_VP, D_VP, params_VP
# Let us generate some data for testing.
bvals = np.array([0., 10., 20., 30., 40., 60., 80., 100.,
120., 140., 160., 180., 200., 300., 400.,
500., 600., 700., 800., 900., 1000.])
N = len(bvals)
bvecs = generate_bvecs(N)
gtab = gradient_table(bvals, bvecs.T, b0_threshold=0)
S0, f, D_star, D = 1000.0, 0.132, 0.00885, 0.000921
# params for a single voxel
params_LM = np.array([S0, f, D_star, D])
mevals = np.array(([D_star, D_star, D_star], [D, D, D]))
# This gives an isotropic signal.
signal = multi_tensor(gtab, mevals, snr=None, S0=S0,
fractions=[f * 100, 100 * (1 - f)])
# Single voxel data
data_single = signal[0]
data_multi = np.zeros((2, 2, 1, len(gtab.bvals)))
data_multi[0, 0, 0] = data_multi[0, 1, 0] = data_multi[
1, 0, 0] = data_multi[1, 1, 0] = data_single
ivim_params_LM = np.zeros((2, 2, 1, 4))
ivim_params_LM[0, 0, 0] = ivim_params_LM[0, 1, 0] = params_LM
ivim_params_LM[1, 0, 0] = ivim_params_LM[1, 1, 0] = params_LM
ivim_model_LM = IvimModel(gtab, fit_method='LM')
ivim_model_one_stage = IvimModel(gtab, fit_method='LM')
ivim_fit_single = ivim_model_LM.fit(data_single)
ivim_fit_multi = ivim_model_LM.fit(data_multi)
ivim_model_one_stage.fit(data_single)
ivim_model_one_stage.fit(data_multi)
bvals_no_b0 = np.array([5., 10., 20., 30., 40., 60., 80., 100.,
120., 140., 160., 180., 200., 300., 400.,
500., 600., 700., 800., 900., 1000.])
_ = generate_bvecs(N) # bvecs_no_b0
gtab_no_b0 = gradient_table(bvals_no_b0, bvecs.T, b0_threshold=0)
bvals_with_multiple_b0 = np.array([0., 0., 0., 0., 40., 60., 80., 100.,
120., 140., 160., 180., 200., 300., 400.,
500., 600., 700., 800., 900., 1000.])
bvecs_with_multiple_b0 = generate_bvecs(N)
gtab_with_multiple_b0 = gradient_table(bvals_with_multiple_b0,
bvecs_with_multiple_b0.T,
b0_threshold=0)
noisy_single = np.array([4243.71728516, 4317.81298828, 4244.35693359,
4439.36816406, 4420.06201172, 4152.30078125,
4114.34912109, 4104.59375, 4151.61914062,
4003.58374023, 4013.68408203, 3906.39428711,
3909.06079102, 3495.27197266, 3402.57006836,
3163.10180664, 2896.04003906, 2663.7253418,
2614.87695312, 2316.55371094, 2267.7722168])
noisy_multi = np.zeros((2, 2, 1, len(gtab.bvals)))
noisy_multi[0, 1, 0] = noisy_multi[
1, 0, 0] = noisy_multi[1, 1, 0] = noisy_single
noisy_multi[0, 0, 0] = data_single
ivim_model_VP = IvimModel(gtab, fit_method='VarPro')
f_VP, D_star_VP, D_VP = 0.13, 0.0088, 0.000921
# params for a single voxel
params_VP = np.array([f, D_star, D])
ivim_params_VP = np.zeros((2, 2, 1, 3))
ivim_params_VP[0, 0, 0] = ivim_params_VP[0, 1, 0] = params_VP
ivim_params_VP[1, 0, 0] = ivim_params_VP[1, 1, 0] = params_VP
from dipy.reconst.ivim import ivim_prediction, IvimModel
from dipy.core.gradients import gradient_table, generate_bvecs
from dipy.sims.voxel import multi_tensor
from distutils.version import LooseVersion
import scipy
SCIPY_VERSION = LooseVersion(scipy.version.short_version)
# Let us generate some data for testing.
bvals = np.array([0., 10., 20., 30., 40., 60., 80., 100.,
120., 140., 160., 180., 200., 300., 400.,
500., 600., 700., 800., 900., 1000.])
N = len(bvals)
bvecs = generate_bvecs(N)
gtab = gradient_table(bvals, bvecs.T)
S0, f, D_star, D = 1000.0, 0.132, 0.00885, 0.000921
# params for a single voxel
params = np.array([S0, f, D_star, D])
mevals = np.array(([D_star, D_star, D_star], [D, D, D]))
# This gives an isotropic signal.
signal = multi_tensor(gtab, mevals, snr=None, S0=S0,
fractions=[f * 100, 100 * (1 - f)])
# Single voxel data
data_single = signal[0]
data_multi = np.zeros((2, 2, 1, len(gtab.bvals)))
data_multi[0, 0, 0] = data_multi[0, 1, 0] = data_multi[
def reconst_mmri_core(flow, lap, pos):
with TemporaryDirectory() as out_dir:
data_path, bval_path, bvec_path = get_fnames('small_25')
vol_img = nib.load(data_path)
volume = vol_img.get_data()
mmri_flow = flow()
mmri_flow.run(data_files=data_path, bvals_files=bval_path,
bvecs_files=bvec_path, small_delta=0.0129,
big_delta=0.0218, laplacian=lap,
positivity=pos, out_dir=out_dir)
rtop = mmri_flow.last_generated_outputs['out_rtop']
rtop_data = nib.load(rtop).get_data()
npt.assert_equal(rtop_data.shape, volume.shape[:-1])
lapnorm = mmri_flow.last_generated_outputs['out_lapnorm']
lapnorm_data = nib.load(lapnorm).get_data()
npt.assert_equal(lapnorm_data.shape, volume.shape[:-1])
msd = mmri_flow.last_generated_outputs['out_msd']
msd_data = nib.load(msd).get_data()
npt.assert_equal(msd_data.shape, volume.shape[:-1])
qiv = mmri_flow.last_generated_outputs['out_qiv']
qiv_data = nib.load(qiv).get_data()
npt.assert_equal(qiv_data.shape, volume.shape[:-1])
rtap = mmri_flow.last_generated_outputs['out_rtap']
rtap_data = nib.load(rtap).get_data()
npt.assert_equal(rtap_data.shape, volume.shape[:-1])
rtpp = mmri_flow.last_generated_outputs['out_rtpp']
rtpp_data = nib.load(rtpp).get_data()
npt.assert_equal(rtpp_data.shape, volume.shape[:-1])
ng = mmri_flow.last_generated_outputs['out_ng']
ng_data = nib.load(ng).get_data()
npt.assert_equal(ng_data.shape, volume.shape[:-1])
parng = mmri_flow.last_generated_outputs['out_parng']
parng_data = nib.load(parng).get_data()
npt.assert_equal(parng_data.shape, volume.shape[:-1])
perng = mmri_flow.last_generated_outputs['out_perng']
perng_data = nib.load(perng).get_data()
npt.assert_equal(perng_data.shape, volume.shape[:-1])
bvals, bvecs = read_bvals_bvecs(bval_path, bvec_path)
bvals[0] = 5.
bvecs = generate_bvecs(len(bvals))
tmp_bval_path = pjoin(out_dir, "tmp.bval")
tmp_bvec_path = pjoin(out_dir, "tmp.bvec")
np.savetxt(tmp_bval_path, bvals)
np.savetxt(tmp_bvec_path, bvecs.T)
mmri_flow._force_overwrite = True
with npt.assert_raises(BaseException):
npt.assert_warns(UserWarning, mmri_flow.run, data_path,
tmp_bval_path, tmp_bvec_path, small_delta=0.0129,
big_delta=0.0218, laplacian=lap,
positivity=pos, out_dir=out_dir)
def reconst_mmri_core(flow, lap, pos):
with TemporaryDirectory() as out_dir:
data_path, bval_path, bvec_path = get_fnames('small_25')
vol_img = nib.load(data_path)
volume = vol_img.get_data()
mmri_flow = flow()
mmri_flow.run(data_file=data_path,
data_bvals=bval_path,
data_bvecs=bvec_path,
small_delta=0.0129,
big_delta=0.0218,
laplacian=lap,
positivity=pos,
out_dir=out_dir)
rtop = mmri_flow.last_generated_outputs['out_rtop']
rtop_data = nib.load(rtop).get_data()
eq_(rtop_data.shape, volume.shape[:-1])
lapnorm = mmri_flow.last_generated_outputs['out_lapnorm']
lapnorm_data = nib.load(lapnorm).get_data()
eq_(lapnorm_data.shape, volume.shape[:-1])
msd = mmri_flow.last_generated_outputs['out_msd']
msd_data = nib.load(msd).get_data()
eq_(msd_data.shape, volume.shape[:-1])
qiv = mmri_flow.last_generated_outputs['out_qiv']
qiv_data = nib.load(qiv).get_data()
eq_(qiv_data.shape, volume.shape[:-1])
rtap = mmri_flow.last_generated_outputs['out_rtap']
rtap_data = nib.load(rtap).get_data()
eq_(rtap_data.shape, volume.shape[:-1])
rtpp = mmri_flow.last_generated_outputs['out_rtpp']
rtpp_data = nib.load(rtpp).get_data()
eq_(rtpp_data.shape, volume.shape[:-1])
ng = mmri_flow.last_generated_outputs['out_ng']
ng_data = nib.load(ng).get_data()
eq_(ng_data.shape, volume.shape[:-1])
parng = mmri_flow.last_generated_outputs['out_parng']
parng_data = nib.load(parng).get_data()
eq_(parng_data.shape, volume.shape[:-1])
perng = mmri_flow.last_generated_outputs['out_perng']
perng_data = nib.load(perng).get_data()
eq_(perng_data.shape, volume.shape[:-1])
bvals, bvecs = read_bvals_bvecs(bval_path, bvec_path)
bvals[0] = 5.
bvecs = generate_bvecs(len(bvals))
tmp_bval_path = pjoin(out_dir, "tmp.bval")
tmp_bvec_path = pjoin(out_dir, "tmp.bvec")
np.savetxt(tmp_bval_path, bvals)
np.savetxt(tmp_bvec_path, bvecs.T)
mmri_flow._force_overwrite = True
with npt.assert_raises(BaseException):
npt.assert_warns(UserWarning,
mmri_flow.run,
data_path,
tmp_bval_path,
tmp_bvec_path,
small_delta=0.0129,
big_delta=0.0218,
laplacian=lap,
positivity=pos,
out_dir=out_dir)
from dipy.reconst.ivim import ivim_prediction, IvimModel
from dipy.core.gradients import gradient_table, generate_bvecs
from dipy.sims.voxel import multi_tensor
from distutils.version import LooseVersion
import scipy
SCIPY_VERSION = LooseVersion(scipy.version.short_version)
# Let us generate some data for testing.
bvals = np.array([0., 10., 20., 30., 40., 60., 80., 100.,
120., 140., 160., 180., 200., 300., 400.,
500., 600., 700., 800., 900., 1000.])
N = len(bvals)
bvecs = generate_bvecs(N)
gtab = gradient_table(bvals, bvecs.T)
S0, f, D_star, D = 1000.0, 0.132, 0.00885, 0.000921
# params for a single voxel
params = np.array([S0, f, D_star, D])
mevals = np.array(([D_star, D_star, D_star], [D, D, D]))
# This gives an isotropic signal.
signal = multi_tensor(gtab, mevals, snr=None, S0=S0,
fractions=[f * 100, 100 * (1 - f)])
# Single voxel data
data_single = signal[0]
data_multi = np.zeros((2, 2, 1, len(gtab.bvals)))
data_multi[0, 0, 0] = data_multi[0, 1, 0] = data_multi[
def test_reconst_dki():
with TemporaryDirectory() as out_dir:
data_path, bval_path, bvec_path = get_fnames('small_101D')
vol_img = nib.load(data_path)
volume = vol_img.get_data()
mask = np.ones_like(volume[:, :, :, 0])
mask_img = nib.Nifti1Image(mask.astype(np.uint8), vol_img.affine)
mask_path = pjoin(out_dir, 'tmp_mask.nii.gz')
nib.save(mask_img, mask_path)
dki_flow = ReconstDkiFlow()
args = [data_path, bval_path, bvec_path, mask_path]
dki_flow.run(*args, out_dir=out_dir)
fa_path = dki_flow.last_generated_outputs['out_fa']
fa_data = nib.load(fa_path).get_data()
assert_equal(fa_data.shape, volume.shape[:-1])
tensor_path = dki_flow.last_generated_outputs['out_dt_tensor']
tensor_data = nib.load(tensor_path)
assert_equal(tensor_data.shape[-1], 6)
assert_equal(tensor_data.shape[:-1], volume.shape[:-1])
ga_path = dki_flow.last_generated_outputs['out_ga']
ga_data = nib.load(ga_path).get_data()
assert_equal(ga_data.shape, volume.shape[:-1])
rgb_path = dki_flow.last_generated_outputs['out_rgb']
rgb_data = nib.load(rgb_path)
assert_equal(rgb_data.shape[-1], 3)
assert_equal(rgb_data.shape[:-1], volume.shape[:-1])
md_path = dki_flow.last_generated_outputs['out_md']
md_data = nib.load(md_path).get_data()
assert_equal(md_data.shape, volume.shape[:-1])
ad_path = dki_flow.last_generated_outputs['out_ad']
ad_data = nib.load(ad_path).get_data()
assert_equal(ad_data.shape, volume.shape[:-1])
rd_path = dki_flow.last_generated_outputs['out_rd']
rd_data = nib.load(rd_path).get_data()
assert_equal(rd_data.shape, volume.shape[:-1])
mk_path = dki_flow.last_generated_outputs['out_mk']
mk_data = nib.load(mk_path).get_data()
assert_equal(mk_data.shape, volume.shape[:-1])
ak_path = dki_flow.last_generated_outputs['out_ak']
ak_data = nib.load(ak_path).get_data()
assert_equal(ak_data.shape, volume.shape[:-1])
rk_path = dki_flow.last_generated_outputs['out_rk']
rk_data = nib.load(rk_path).get_data()
assert_equal(rk_data.shape, volume.shape[:-1])
kt_path = dki_flow.last_generated_outputs['out_dk_tensor']
kt_data = nib.load(kt_path)
assert_equal(kt_data.shape[-1], 15)
assert_equal(kt_data.shape[:-1], volume.shape[:-1])
mode_path = dki_flow.last_generated_outputs['out_mode']
mode_data = nib.load(mode_path).get_data()
assert_equal(mode_data.shape, volume.shape[:-1])
evecs_path = dki_flow.last_generated_outputs['out_evec']
evecs_data = nib.load(evecs_path).get_data()
assert_equal(evecs_data.shape[-2:], tuple((3, 3)))
assert_equal(evecs_data.shape[:-2], volume.shape[:-1])
evals_path = dki_flow.last_generated_outputs['out_eval']
evals_data = nib.load(evals_path).get_data()
assert_equal(evals_data.shape[-1], 3)
assert_equal(evals_data.shape[:-1], volume.shape[:-1])
bvals, bvecs = read_bvals_bvecs(bval_path, bvec_path)
bvals[0] = 5.
bvecs = generate_bvecs(len(bvals))
tmp_bval_path = pjoin(out_dir, "tmp.bval")
tmp_bvec_path = pjoin(out_dir, "tmp.bvec")
np.savetxt(tmp_bval_path, bvals)
np.savetxt(tmp_bvec_path, bvecs.T)
dki_flow._force_overwrite = True
npt.assert_warns(UserWarning, dki_flow.run, data_path,
tmp_bval_path, tmp_bvec_path, mask_path,
out_dir=out_dir, b0_threshold=0)
