def test_mppca_flow():
with TemporaryDirectory() as out_dir:
S0 = 100 + 2 * np.random.standard_normal((22, 23, 30, 20))
data_path = os.path.join(out_dir, "random_noise.nii.gz")
save_nifti(data_path, S0, np.eye(4))
mppca_flow = MPPCAFlow()
mppca_flow.run(data_path, out_dir=out_dir)
assert_true(os.path.isfile(
mppca_flow.last_generated_outputs['out_denoised']))
assert_false(os.path.isfile(
mppca_flow.last_generated_outputs['out_sigma']))
mppca_flow._force_overwrite = True
mppca_flow.run(data_path, return_sigma=True, pca_method='svd',
out_dir=out_dir)
assert_true(os.path.isfile(
mppca_flow.last_generated_outputs['out_denoised']))
assert_true(os.path.isfile(
mppca_flow.last_generated_outputs['out_sigma']))
denoised_path = mppca_flow.last_generated_outputs['out_denoised']
denoised_data = load_nifti_data(denoised_path)
assert_greater(denoised_data.min(), S0.min())
assert_less(denoised_data.max(), S0.max())
npt.assert_equal(np.round(denoised_data.mean()), 100)
def test_patch2self_random_noise():
S0 = 30 + 2 * np.random.standard_normal((20, 20, 20, 50))
bvals = np.repeat(30, 50)
S0nb = p2s.patch2self(S0, bvals, model='ols')
assert_greater(S0nb.min(), S0.min())
assert_equal(np.round(S0nb.mean()), 30)
def test_patch2self_boundary():
# patch2self preserves boundaries
S0 = 100 + np.zeros((20, 20, 20, 20))
noise = 2 * np.random.standard_normal((20, 20, 20, 20))
S0 += noise
S0[:10, :10, :10, :10] = 300 + noise[:10, :10, :10, :10]
bvals = np.repeat(100, 20)
p2s.patch2self(S0, bvals)
assert_greater(S0[9, 9, 9, 9], 290)
assert_less(S0[10, 10, 10, 10], 110)
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_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_patch2self_random_noise():
S0 = 30 + 2 * np.random.standard_normal((20, 20, 20, 50))
bvals = np.repeat(30, 50)
# shift = True
S0den_shift = p2s.patch2self(S0, bvals, model='ols', shift_intensity=True)
assert_greater_equal(S0den_shift.min(), S0.min())
assert_less_equal(np.round(S0den_shift.mean()), 30)
# clip = True
S0den_clip = p2s.patch2self(S0, bvals, model='ols',
clip_negative_vals=True)
assert_greater(S0den_clip.min(), S0.min())
assert_equal(np.round(S0den_clip.mean()), 30)
# both clip and shift = True, and int patch_radius
S0den_clip = p2s.patch2self(S0, bvals, patch_radius=0, model='ols',
clip_negative_vals=True,
shift_intensity=True)
assert_greater(S0den_clip.min(), S0.min())
assert_equal(np.round(S0den_clip.mean()), 30)
# both clip and shift = False
S0den_clip = p2s.patch2self(S0, bvals, model='ols',
clip_negative_vals=False,
shift_intensity=False)
assert_greater(S0den_clip.min(), S0.min())
assert_equal(np.round(S0den_clip.mean()), 30)
def test_csdeconv():
SNR = 100
S0 = 1
_, fbvals, fbvecs = get_fnames('small_64D')
bvals, bvecs = read_bvals_bvecs(fbvals, fbvecs)
gtab = gradient_table(bvals, bvecs, b0_threshold=0)
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, S0, angles=angles,
fractions=[50, 50], snr=SNR)
sphere = get_sphere('symmetric362')
odf_gt = multi_tensor_odf(sphere.vertices, mevals, angles, [50, 50])
response = (np.array([0.0015, 0.0003, 0.0003]), S0)
csd = ConstrainedSphericalDeconvModel(gtab, response)
csd_fit = csd.fit(S)
assert_equal(csd_fit.shm_coeff[0] > 0, True)
fodf = csd_fit.odf(sphere)
directions, _, _ = peak_directions(odf_gt, sphere)
directions2, _, _ = peak_directions(fodf, sphere)
ang_sim = angular_similarity(directions, directions2)
assert_equal(ang_sim > 1.9, True)
assert_equal(directions.shape[0], 2)
assert_equal(directions2.shape[0], 2)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always", category=UserWarning)
_ = ConstrainedSphericalDeconvModel(gtab, response, sh_order=10)
assert_greater(len([lw for lw in w if issubclass(lw.category,
UserWarning)]), 0)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always", category=UserWarning)
ConstrainedSphericalDeconvModel(gtab, response, sh_order=8)
assert_equal(len([lw for lw in w if issubclass(lw.category,
UserWarning)]), 0)
mevecs = []
for s in sticks:
mevecs += [all_tensor_evecs(s).T]
S2 = single_tensor(gtab, 100, mevals[0], mevecs[0], snr=None)
big_S = np.zeros((10, 10, 10, len(S2)))
big_S[:] = S2
aresponse, aratio = auto_response(gtab, big_S, roi_center=(5, 5, 4),
roi_radius=3, fa_thr=0.5)
assert_array_almost_equal(aresponse[0], response[0])
assert_almost_equal(aresponse[1], 100)
assert_almost_equal(aratio, response[0][1] / response[0][0])
auto_response(gtab, big_S, roi_radius=3, fa_thr=0.5)
assert_array_almost_equal(aresponse[0], response[0])
_, _, nvoxels = auto_response(gtab, big_S, roi_center=(5, 5, 4),
roi_radius=30, fa_thr=0.5,
return_number_of_voxels=True)
assert_equal(nvoxels, 1000)
_, _, nvoxels = auto_response(gtab, big_S, roi_center=(5, 5, 4),
roi_radius=30, fa_thr=1,
return_number_of_voxels=True)
assert_equal(nvoxels, 0)
