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_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)
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)