def test_GradientTable(): gradients = np.array( [[0, 0, 0], [1, 0, 0], [0, 0, 1], [3, 4, 0], [5, 0, 12]], 'float') expected_bvals = np.array([0, 1, 1, 5, 13]) expected_b0s_mask = expected_bvals == 0 expected_bvecs = gradients / (expected_bvals + expected_b0s_mask)[:, None] gt = GradientTable(gradients, b0_threshold=0) npt.assert_array_almost_equal(gt.bvals, expected_bvals) npt.assert_array_equal(gt.b0s_mask, expected_b0s_mask) npt.assert_array_almost_equal(gt.bvecs, expected_bvecs) npt.assert_array_almost_equal(gt.gradients, gradients) gt = GradientTable(gradients, b0_threshold=1) npt.assert_array_equal(gt.b0s_mask, [1, 1, 1, 0, 0]) npt.assert_array_equal(gt.bvals, expected_bvals) npt.assert_array_equal(gt.bvecs, expected_bvecs) # checks negative values in gtab npt.assert_raises(ValueError, GradientTable, -1) npt.assert_raises(ValueError, GradientTable, np.ones((6, 2))) npt.assert_raises(ValueError, GradientTable, np.ones((6, ))) with warnings.catch_warnings(record=True) as w: bad_gt = gradient_table(expected_bvals, expected_bvecs, b0_threshold=200) assert len(w) == 1
def test_GradientTable(): gradients = np.array([[0, 0, 0], [1, 0, 0], [0, 0, 1], [3, 4, 0], [5, 0, 12]], 'float') expected_bvals = np.array([0, 1, 1, 5, 13]) expected_b0s_mask = expected_bvals == 0 expected_bvecs = gradients / (expected_bvals + expected_b0s_mask)[:, None] gt = GradientTable(gradients, b0_threshold=0) npt.assert_array_almost_equal(gt.bvals, expected_bvals) npt.assert_array_equal(gt.b0s_mask, expected_b0s_mask) npt.assert_array_almost_equal(gt.bvecs, expected_bvecs) npt.assert_array_almost_equal(gt.gradients, gradients) gt = GradientTable(gradients, b0_threshold=1) npt.assert_array_equal(gt.b0s_mask, [1, 1, 1, 0, 0]) npt.assert_array_equal(gt.bvals, expected_bvals) npt.assert_array_equal(gt.bvecs, expected_bvecs) npt.assert_raises(ValueError, GradientTable, np.ones((6, 2))) npt.assert_raises(ValueError, GradientTable, np.ones((6,)))
def test_mcsd_model_delta(): sh_order = 8 gtab = get_3shell_gtab() shells = np.unique(gtab.bvals // 100.) * 100. response = sim_response(sh_order, shells, evals_d) model = MultiShellDeconvModel(gtab, response) iso = response.iso theta, phi = default_sphere.theta, default_sphere.phi B = shm.real_sph_harm(response.m, response.n, theta[:, None], phi[:, None]) wm_delta = model.delta.copy() # set isotropic components to zero wm_delta[:iso] = 0. wm_delta = _expand(model.m, iso, wm_delta) for i, s in enumerate(shells): g = GradientTable(default_sphere.vertices * s) signal = model.predict(wm_delta, g) expected = np.dot(response.response[i, iso:], B.T) npt.assert_array_almost_equal(signal, expected) signal = model.predict(wm_delta, gtab) fit = model.fit(signal) m = model.m npt.assert_array_almost_equal(fit.shm_coeff[m != 0], 0., 2)
def gen_hardi(self, snr=20): bval = 3000 sph = load_sphere(refinement=2) gtab = GradientTable(bval * sph.v.T, b0_threshold=0) l_labels = gtab.bvecs.shape[0] val_base = 1e-6 * 300 S_data = np.zeros((self.res, self.res, l_labels), order='C') for (x, y) in itertools.product(range(self.res), repeat=2): mid = self.delta * (np.array([x, y]) + 0.5) norms = [np.sum(c['dirs'][x, y, :]**2)**0.5 for c in self.curves] if sum(norms) < 1e-6: mevals = np.array([[val_base, val_base, val_base]]) sticks = np.array([[1, 0, 0]]) fracs = [100] else: fracs = 100.0 * np.array(norms) / sum(norms) mevals = np.array([[(1.0 + norm * 4.0) * val_base, val_base, val_base] for norm in norms]) sticks = np.array([ np.array([c['dirs'][x, y, 0], c['dirs'][x, y, 1], 0]) / norm if norm > 1e-6 else np.array([1, 0, 0]) for c, norm in zip(self.curves, norms) ]) signal, _ = multi_tensor(gtab, mevals, S0=1., angles=sticks, fractions=fracs, snr=snr) S_data[x, y, :] = signal return gtab, S_data
def _run_interface(self, runtime): ## Load the 4D image files img = nb.load(self.inputs.in_file) data = img.get_data() affine = img.get_affine() ## Load the gradient strengths and directions bvals = np.loadtxt(self.inputs.bvals) gradients = np.loadtxt(self.inputs.bvecs).T ## Place in Dipy's preferred format gtab = GradientTable(gradients) gtab.bvals = bvals ## Mask the data so that tensors are not fit for ## unnecessary voxels mask = data[..., 0] > 50 ## Fit the tensors to the data tenmodel = dti.TensorModel(gtab) tenfit = tenmodel.fit(data, mask) ## Calculate the mode of each voxel's tensor mode_data = tenfit.mode ## Write as a 3D Nifti image with the original affine img = nb.Nifti1Image(mode_data, affine) out_file = op.abspath(self._gen_outfilename()) nb.save(img, out_file) iflogger.info('Tensor mode image saved as {i}'.format(i=out_file)) return runtime
def sim_response(sh_order, bvals, evals=evals_d, csf_md=csf_md, gm_md=gm_md): bvals = np.array(bvals, copy=True) evecs = np.zeros((3, 3)) z = np.array([0, 0, 1.]) evecs[:, 0] = z evecs[:2, 1:] = np.eye(2) n = np.arange(0, sh_order + 1, 2) m = np.zeros_like(n) big_sphere = default_sphere.subdivide() theta, phi = big_sphere.theta, big_sphere.phi B = shm.real_sph_harm(m, n, theta[:, None], phi[:, None]) A = shm.real_sph_harm(0, 0, 0, 0) response = np.empty([len(bvals), len(n) + 2]) for i, bvalue in enumerate(bvals): gtab = GradientTable(big_sphere.vertices * bvalue) wm_response = single_tensor(gtab, 1., evals, evecs, snr=None) response[i, 2:] = np.linalg.lstsq(B, wm_response)[0] response[i, 0] = np.exp(-bvalue * csf_md) / A response[i, 1] = np.exp(-bvalue * gm_md) / A return MultiShellResponse(response, sh_order, bvals)
def test_mcsd_model_delta(): sh_order = 8 gtab = get_3shell_gtab() response = multi_shell_fiber_response(sh_order, [0, 1000, 2000, 3500], wm_response, gm_response, csf_response) model = MultiShellDeconvModel(gtab, response) iso = response.iso theta, phi = default_sphere.theta, default_sphere.phi B = shm.real_sh_descoteaux_from_index( response.m, response.n, theta[:, None], phi[:, None]) wm_delta = model.delta.copy() # set isotropic components to zero wm_delta[:iso] = 0. wm_delta = _expand(model.m, iso, wm_delta) for i, s in enumerate([0, 1000, 2000, 3500]): g = GradientTable(default_sphere.vertices * s) signal = model.predict(wm_delta, g) expected = np.dot(response.response[i, iso:], B.T) npt.assert_array_almost_equal(signal, expected) signal = model.predict(wm_delta, gtab) fit = model.fit(signal) m = model.m npt.assert_array_almost_equal(fit.shm_coeff[m != 0], 0., 2)
def multi_shell_fiber_response(sh_order, bvals, evals, csf_md, gm_md, sphere=None): """Fiber response function estimation for multi-shell data. Parameters ---------- sh_order : int Maximum spherical harmonics order. bvals : ndarray Array containing the b-values. evals : (3,) ndarray Eigenvalues of the diffusion tensor. csf_md : float CSF tissue mean diffusivity value. gm_md : float GM tissue mean diffusivity value. sphere : `dipy.core.Sphere` instance, optional Sphere where the signal will be evaluated. Returns ------- MultiShellResponse MultiShellResponse object. """ bvals = np.array(bvals, copy=True) evecs = np.zeros((3, 3)) z = np.array([0, 0, 1.]) evecs[:, 0] = z evecs[:2, 1:] = np.eye(2) n = np.arange(0, sh_order + 1, 2) m = np.zeros_like(n) if sphere is None: sphere = default_sphere big_sphere = sphere.subdivide() theta, phi = big_sphere.theta, big_sphere.phi B = shm.real_sph_harm(m, n, theta[:, None], phi[:, None]) A = shm.real_sph_harm(0, 0, 0, 0) response = np.empty([len(bvals), len(n) + 2]) for i, bvalue in enumerate(bvals): gtab = GradientTable(big_sphere.vertices * bvalue) wm_response = single_tensor(gtab, 1., evals, evecs, snr=None) response[i, 2:] = np.linalg.lstsq(B, wm_response)[0] response[i, 0] = np.exp(-bvalue * csf_md) / A response[i, 1] = np.exp(-bvalue * gm_md) / A return MultiShellResponse(response, sh_order, bvals)
def test_GradientTable(): gradients = np.array([[0, 0, 0], [1, 0, 0], [0, 0, 1], [3, 4, 0], [5, 0, 12]], 'float') expected_bvals = np.array([0, 1, 1, 5, 13]) expected_b0s_mask = expected_bvals == 0 expected_bvecs = gradients / (expected_bvals + expected_b0s_mask)[:, None] gt = GradientTable(gradients, b0_threshold=0) npt.assert_('B-values shape (5,)' in gt.__str__()) npt.assert_array_almost_equal(gt.bvals, expected_bvals) npt.assert_array_equal(gt.b0s_mask, expected_b0s_mask) npt.assert_array_almost_equal(gt.bvecs, expected_bvecs) npt.assert_array_almost_equal(gt.gradients, gradients) gt = GradientTable(gradients, b0_threshold=1) npt.assert_array_equal(gt.b0s_mask, [1, 1, 1, 0, 0]) npt.assert_array_equal(gt.bvals, expected_bvals) npt.assert_array_equal(gt.bvecs, expected_bvecs) # checks negative values in gtab npt.assert_raises(ValueError, GradientTable, -1) npt.assert_raises(ValueError, GradientTable, np.ones((6, 2))) npt.assert_raises(ValueError, GradientTable, np.ones((6,))) with warnings.catch_warnings(record=True) as l_warns: bad_gt = gradient_table(expected_bvals, expected_bvecs, b0_threshold=200) # Select only UserWarning selected_w = [w for w in l_warns if issubclass(w.category, UserWarning)] assert len(selected_w) >= 1 msg = [str(m.message) for m in selected_w] npt.assert_equal('b0_threshold has a value > 199' in msg, True)
def synth_unimodals_linear(bval=3000, imagedims=(12, )): d_image = len(imagedims) n_image = np.prod(imagedims) sph = load_sphere(refinement=2) l_labels = sph.mdims['l_labels'] gtab = GradientTable(bval * sph.v.T, b0_threshold=0) S_data_orig = np.stack([ one_fiber_signal(gtab, r, snr=None, eval_factor=15) for r in np.linspace(-45, 45, n_image) ]).reshape(imagedims + (l_labels, )) return S_data_orig, S_data_orig.copy(), gtab
def synth_unimodals(bval=3000, imagedims=(8, ), jiggle=10, snr=None): d_image = len(imagedims) n_image = np.prod(imagedims) sph = load_sphere(refinement=2) l_labels = sph.mdims['l_labels'] gtab = GradientTable(bval * sph.v.T, b0_threshold=0) S_data_orig = np.stack([one_fiber_signal(gtab, 0, snr=None)]*n_image) \ .reshape(imagedims + (l_labels,)) S_data = np.stack([ one_fiber_signal(gtab, 0 + r, snr=snr) for r in jiggle * np.random.randn(n_image) ]).reshape(imagedims + (l_labels, )) return S_data_orig, S_data, gtab
def synth_bimodals(bval=3000, const_width=5, snr=None): imagedims = (const_width * 2, ) d_image = len(imagedims) n_image = np.prod(imagedims) sph = load_sphere(refinement=2) l_labels = sph.mdims['l_labels'] gtab = GradientTable(bval * sph.v.T, b0_threshold=0) S_data = np.stack( [two_fiber_signal(gtab, [0, 70], snr=None)] * const_width + [uniform_signal(gtab, snr=None)] * const_width).reshape(imagedims + (l_labels, )) S_data_orig = S_data.copy() if snr is not None: S_data[:] = add_noise(S_data_orig, snr=snr) return S_data_orig, S_data, gtab
def bench_csdeconv(center=(50, 40, 40), width=12): img, gtab, labels_img = read_stanford_labels() data = img.get_data() labels = labels_img.get_data() shape = labels.shape mask = np.in1d(labels, [1, 2]) mask.shape = shape a, b, c = center hw = width // 2 idx = (slice(a - hw, a + hw), slice(b - hw, b + hw), slice(c - hw, c + hw)) data_small = data[idx].copy() mask_small = mask[idx].copy() voxels = mask_small.sum() cmd = "model.fit(data_small, mask_small)" print("== Benchmarking CSD fit on %d voxels ==" % voxels) msg = "SH order - %d, gradient directons - %d :: %g sec" # Basic case sh_order = 8 ConstrainedSphericalDeconvModel(gtab, None, sh_order=sh_order) time = npt.measure(cmd) print(msg % (sh_order, num_grad(gtab), time)) # Smaller data set # data_small = data_small[..., :75].copy() gtab = GradientTable(gtab.gradients[:75]) ConstrainedSphericalDeconvModel(gtab, None, sh_order=sh_order) time = npt.measure(cmd) print(msg % (sh_order, num_grad(gtab), time)) # Super resolution sh_order = 12 ConstrainedSphericalDeconvModel(gtab, None, sh_order=sh_order) time = npt.measure(cmd) print(msg % (sh_order, num_grad(gtab), time))
def __init__(self, data=None, gtab=None, mask=None): if data is None: data = np.random.uniform(100, 300, size=(50, 50, 3, 100)) if gtab is None: b0s = 20 * np.ones([20, 1]) b1000s = 1020 * np.ones([80, 1]) bvals = np.append(b0s, b1000s, 0) np.random.shuffle(bvals) phis = np.random.uniform(0, 2 * np.pi, (100, 1)) thetas = np.arccos(np.random.uniform(-1, 1, (100, 1))) x = bvals * np.sin(thetas) * np.cos(phis) y = bvals * np.sin(thetas) * np.cos(phis) z = bvals * np.cos(thetas) gradients = np.append(x, np.append(y, z, 1), 1) gtab = GradientTable(gradients) if mask is None: mask = np.ones([50, 50, 3]) self.data = data self.mask = mask self.gtab = gtab
def nonlinfit_fn(dwi, bvecs, bvals, base_name): import nibabel as nb import numpy as np import os.path as op import dipy.reconst.dti as dti from dipy.core.gradients import GradientTable dwi_img = nb.load(dwi) dwi_data = dwi_img.get_data() dwi_affine = dwi_img.get_affine() from dipy.segment.mask import median_otsu b0_mask, mask = median_otsu(dwi_data, 2, 4) # Mask the data so that tensors are not fit for # unnecessary voxels mask_img = nb.Nifti1Image(mask.astype(np.float32), dwi_affine) b0_imgs = nb.Nifti1Image(b0_mask.astype(np.float32), dwi_affine) b0_img = nb.four_to_three(b0_imgs)[0] out_mask_name = op.abspath(base_name + '_binary_mask.nii.gz') out_b0_name = op.abspath(base_name + '_b0_mask.nii.gz') nb.save(mask_img, out_mask_name) nb.save(b0_img, out_b0_name) # Load the gradient strengths and directions bvals = np.loadtxt(bvals) gradients = np.loadtxt(bvecs).T # Place in Dipy's preferred format gtab = GradientTable(gradients) gtab.bvals = bvals # Fit the tensors to the data tenmodel = dti.TensorModel(gtab, fit_method="NLLS") tenfit = tenmodel.fit(dwi_data, mask) # Calculate the fit, fa, and md of each voxel's tensor tensor_data = tenfit.lower_triangular() print('Computing anisotropy measures (FA, MD, RGB)') from dipy.reconst.dti import fractional_anisotropy, color_fa evals = tenfit.evals.astype(np.float32) FA = fractional_anisotropy(np.abs(evals)) FA = np.clip(FA, 0, 1) MD = dti.mean_diffusivity(np.abs(evals)) norm = dti.norm(tenfit.quadratic_form) RGB = color_fa(FA, tenfit.evecs) evecs = tenfit.evecs.astype(np.float32) mode = tenfit.mode.astype(np.float32) # Write tensor as a 4D Nifti image with the original affine tensor_fit_img = nb.Nifti1Image(tensor_data.astype(np.float32), dwi_affine) mode_img = nb.Nifti1Image(mode.astype(np.float32), dwi_affine) norm_img = nb.Nifti1Image(norm.astype(np.float32), dwi_affine) FA_img = nb.Nifti1Image(FA.astype(np.float32), dwi_affine) evecs_img = nb.Nifti1Image(evecs, dwi_affine) evals_img = nb.Nifti1Image(evals, dwi_affine) rgb_img = nb.Nifti1Image(np.array(255 * RGB, 'uint8'), dwi_affine) MD_img = nb.Nifti1Image(MD.astype(np.float32), dwi_affine) out_tensor_file = op.abspath(base_name + "_tensor.nii.gz") out_mode_file = op.abspath(base_name + "_mode.nii.gz") out_fa_file = op.abspath(base_name + "_fa.nii.gz") out_norm_file = op.abspath(base_name + "_norm.nii.gz") out_evals_file = op.abspath(base_name + "_evals.nii.gz") out_evecs_file = op.abspath(base_name + "_evecs.nii.gz") out_rgb_fa_file = op.abspath(base_name + "_rgb_fa.nii.gz") out_md_file = op.abspath(base_name + "_md.nii.gz") nb.save(rgb_img, out_rgb_fa_file) nb.save(norm_img, out_norm_file) nb.save(mode_img, out_mode_file) nb.save(tensor_fit_img, out_tensor_file) nb.save(evecs_img, out_evecs_file) nb.save(evals_img, out_evals_file) nb.save(FA_img, out_fa_file) nb.save(MD_img, out_md_file) print('Tensor fit image saved as {i}'.format(i=out_tensor_file)) print('FA image saved as {i}'.format(i=out_fa_file)) print('MD image saved as {i}'.format(i=out_md_file)) return out_tensor_file, out_fa_file, out_md_file, \ out_evecs_file, out_evals_file, out_rgb_fa_file, out_norm_file, \ out_mode_file, out_mask_name, out_b0_name
def multi_shell_fiber_response(sh_order, bvals, wm_rf, gm_rf, csf_rf, sphere=None, tol=20): """Fiber response function estimation for multi-shell data. Parameters ---------- sh_order : int Maximum spherical harmonics order. bvals : ndarray Array containing the b-values. Must be unique b-values, like outputed by `dipy.core.gradients.unique_bvals_tolerance`. wm_rf : (4, len(bvals)) ndarray Response function of the WM tissue, for each bvals. gm_rf : (4, len(bvals)) ndarray Response function of the GM tissue, for each bvals. csf_rf : (4, len(bvals)) ndarray Response function of the CSF tissue, for each bvals. sphere : `dipy.core.Sphere` instance, optional Sphere where the signal will be evaluated. Returns ------- MultiShellResponse MultiShellResponse object. """ NUMPY_1_14_PLUS = LooseVersion(np.__version__) >= LooseVersion('1.14.0') rcond_value = None if NUMPY_1_14_PLUS else -1 bvals = np.array(bvals, copy=True) evecs = np.zeros((3, 3)) z = np.array([0, 0, 1.]) evecs[:, 0] = z evecs[:2, 1:] = np.eye(2) n = np.arange(0, sh_order + 1, 2) m = np.zeros_like(n) if sphere is None: sphere = default_sphere big_sphere = sphere.subdivide() theta, phi = big_sphere.theta, big_sphere.phi B = shm.real_sh_descoteaux_from_index(m, n, theta[:, None], phi[:, None]) A = shm.real_sh_descoteaux_from_index(0, 0, 0, 0) response = np.empty([len(bvals), len(n) + 2]) if bvals[0] < tol: gtab = GradientTable(big_sphere.vertices * 0) wm_response = single_tensor(gtab, wm_rf[0, 3], wm_rf[0, :3], evecs, snr=None) response[0, 2:] = np.linalg.lstsq(B, wm_response, rcond=rcond_value)[0] response[0, 1] = gm_rf[0, 3] / A response[0, 0] = csf_rf[0, 3] / A for i, bvalue in enumerate(bvals[1:]): gtab = GradientTable(big_sphere.vertices * bvalue) wm_response = single_tensor(gtab, wm_rf[i, 3], wm_rf[i, :3], evecs, snr=None) response[i + 1, 2:] = np.linalg.lstsq(B, wm_response, rcond=rcond_value)[0] response[i + 1, 1] = gm_rf[i, 3] * np.exp(-bvalue * gm_rf[i, 0]) / A response[i + 1, 0] = csf_rf[i, 3] * np.exp(-bvalue * csf_rf[i, 0]) / A S0 = [csf_rf[0, 3], gm_rf[0, 3], wm_rf[0, 3]] else: warnings.warn("""No b0 given. Proceeding either way.""", UserWarning) for i, bvalue in enumerate(bvals): gtab = GradientTable(big_sphere.vertices * bvalue) wm_response = single_tensor(gtab, wm_rf[i, 3], wm_rf[i, :3], evecs, snr=None) response[i, 2:] = np.linalg.lstsq(B, wm_response, rcond=rcond_value)[0] response[i, 1] = gm_rf[i, 3] * np.exp(-bvalue * gm_rf[i, 0]) / A response[i, 0] = csf_rf[i, 3] * np.exp(-bvalue * csf_rf[i, 0]) / A S0 = [csf_rf[0, 3], gm_rf[0, 3], wm_rf[0, 3]] return MultiShellResponse(response, sh_order, bvals, S0=S0)
def test_GradientTable_btensor_calculation(): # Generate a gradient table without specifying b-tensors gradients = np.array( [[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1], [3, 4, 0], [5, 0, 12]], 'float') # Check that when btens attribute not specified it takes the value of None gt = GradientTable(gradients) npt.assert_equal(gt.btens, None) # Check that btens are correctly created if specified gt = GradientTable(gradients, btens='LTE') # Check that the number of b tensors is correct npt.assert_equal(gt.btens.shape[0], gt.bvals.shape[0]) for i, (bval, bten) in enumerate(zip(gt.bvals, gt.btens)): # Check that the b tensor magnitude is correct npt.assert_almost_equal(np.trace(bten), bval) # Check that the b tensor orientation is correct if bval != 0: evals, evecs = np.linalg.eig(bten) dot_prod = np.dot(np.real(evecs[:, np.argmax(evals)]), gt.bvecs[i]) npt.assert_almost_equal(np.abs(dot_prod), 1) # Check btens input option 1 for btens in ['LTE', 'PTE', 'STE', 'CTE']: gt = GradientTable(gradients, btens=btens) # Check that the number of b tensors is correct npt.assert_equal(gt.bvals.shape[0], gt.btens.shape[0]) for i, (bval, bvec, bten) in enumerate(zip(gt.bvals, gt.bvecs, gt.btens)): # Check that the b tensor magnitude is correct npt.assert_almost_equal(np.trace(bten), bval) # Check that the b tensor orientation is correct if btens == ('LTE' or 'CTE'): if bval != 0: evals, evecs = np.linalg.eig(bten) dot_prod = np.dot(np.real(evecs[:, np.argmax(evals)]), bvec) npt.assert_almost_equal(np.abs(dot_prod), 1) elif btens == 'PTE': if bval != 0: evals, evecs = np.linalg.eig(bten) dot_prod = np.dot(np.real(evecs[:, np.argmin(evals)]), bvec) npt.assert_almost_equal(np.abs(dot_prod), 1) # Check btens input option 2 btens = np.array(['LTE', 'PTE', 'STE', 'CTE', 'LTE', 'PTE']) gt = GradientTable(gradients, btens=btens) # Check that the number of b tensors is correct npt.assert_equal(gt.bvals.shape[0], gt.btens.shape[0]) for i, (bval, bvec, bten) in enumerate(zip(gt.bvals, gt.bvecs, gt.btens)): # Check that the b tensor magnitude is correct npt.assert_almost_equal(np.trace(bten), bval) # Check that the b tensor orientation is correct if btens[i] == ('LTE' or 'CTE'): if bval != 0: evals, evecs = np.linalg.eig(bten) dot_prod = np.dot(np.real(evecs[:, np.argmax(evals)]), bvec) npt.assert_almost_equal(np.abs(dot_prod), 1) elif btens[i] == 'PTE': if bval != 0: evals, evecs = np.linalg.eig(bten) dot_prod = np.dot(np.real(evecs[:, np.argmin(evals)]), bvec) npt.assert_almost_equal(np.abs(dot_prod), 1) # Check btens input option 3 btens = np.array([np.eye(3, 3) for i in range(6)]) gt = GradientTable(gradients, btens=btens) npt.assert_equal(btens, gt.btens) npt.assert_equal(gt.bvals.shape[0], gt.btens.shape[0]) # Check invalid input npt.assert_raises(ValueError, GradientTable, gradients=gradients, btens='PPP') npt.assert_raises(ValueError, GradientTable, gradients=gradients, btens=np.array([np.eye(3, 3) for i in range(10)])) npt.assert_raises(ValueError, GradientTable, gradients=gradients, btens=np.zeros((10, 10)))
def gtab_getter(): gradfile = pjoin(DATA_DIR, filename) grad = np.loadtxt(gradfile, delimiter=',') gtab = GradientTable(grad) return gtab
return A * B directions, values = peak_directions_nl(discrete_eval, 0.) assert_equal(directions.shape, (3, 3)) directions, values = peak_directions_nl(discrete_eval, .6) assert_equal(directions.shape, (2, 3)) directions, values = peak_directions_nl(discrete_eval, .8) assert_equal(directions.shape, (1, 3)) assert_almost_equal(values, 3 * 3 / np.sqrt(3)) _sphere = create_unit_hemisphere(4) _odf = (_sphere.vertices * [1, 2, 3]).sum(-1) _gtab = GradientTable(np.ones((64, 3))) class SimpleOdfModel(OdfModel): sphere = _sphere def fit(self, data): fit = SimpleOdfFit(self, data) fit.model = self return fit class SimpleOdfFit(OdfFit): def odf(self, sphere=None): if sphere is None: sphere = self.model.sphere
def gtable_from_qvecs(qvecs, b0_threshold=10): """ qvecs: Nx3 """ return GradientTable(qvecs, b0_threshold)
#!/usr/bin/env python # -*- coding: utf-8 -*- """Tests for `bonndit.gradients` module.""" from bonndit.utils.gradients import gtab_reorient, gtab_rotate from dipy.core.gradients import GradientTable import numpy as np GRADIENTS = np.array([[2500, 0, 0], [0, 2500, 0], [0, 0, 2500], [0, 0, 0]]) gtab = GradientTable(GRADIENTS) def test_gtab_rotate(): rot_matrix = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]) assert (gtab_rotate(gtab, rot_matrix).gradients == GRADIENTS).all() def test_gtab_rotate2(): rot_matrix = np.array([[1, 0, 1], [0, 1, 0], [0, 0, 0]]) assert (gtab_rotate(gtab, rot_matrix).gradients == np.array([[2500, 0, 0], [0, 2500, 0], [2500, 0, 0], [0, 0, 0]])).all() def test_gtab_reorient(): old_vec = np.array((0, 0, 1)) new_vec = np.array((0, 0, 1)) assert (gtab_reorient(gtab, old_vec, new_vec).gradients == GRADIENTS).all()