def test_peaksFromModelParallel(): SNR = 100 S0 = 100 _, fbvals, fbvecs = get_data('small_64D') bvals = np.load(fbvals) bvecs = np.load(fbvecs) gtab = gradient_table(bvals, bvecs) mevals = np.array(([0.0015, 0.0003, 0.0003], [0.0015, 0.0003, 0.0003])) data, _ = multi_tensor(gtab, mevals, S0, angles=[(0, 0), (60, 0)], fractions=[50, 50], snr=SNR) # test equality with/without multiprocessing model = SimpleOdfModel() pam_multi = peaks_from_model(model, data, _sphere, .5, 45, normalize_peaks=True, return_odf=True, return_sh=True, parallel=True) pam_single = peaks_from_model(model, data, _sphere, .5, 45, normalize_peaks=True, return_odf=True, return_sh=True, parallel=False) assert_array_almost_equal(pam_multi.gfa, pam_single.gfa) assert_array_almost_equal(pam_multi.qa, pam_single.qa) assert_array_almost_equal(pam_multi.peak_values, pam_single.peak_values) assert_array_equal(pam_multi.peak_indices, pam_single.peak_indices) assert_array_almost_equal(pam_multi.peak_dirs, pam_single.peak_dirs) assert_array_almost_equal(pam_multi.shm_coeff, pam_single.shm_coeff) assert_array_almost_equal(pam_multi.odf, pam_single.odf)
def test_peaksFromModel(): data = np.zeros((10, 2)) # Test basic case model = SimpleOdfModel() odf_argmax = _odf.argmax() pam = peaks_from_model(model, data, _sphere, .5, 45, normalize_peaks=True) assert_array_equal(pam.gfa, gfa(_odf)) assert_array_equal(pam.peak_values[:, 0], 1.) assert_array_equal(pam.peak_values[:, 1:], 0.) mn, mx = _odf.min(), _odf.max() assert_array_equal(pam.qa[:, 0], (mx - mn) / mx) assert_array_equal(pam.qa[:, 1:], 0.) assert_array_equal(pam.peak_indices[:, 0], odf_argmax) assert_array_equal(pam.peak_indices[:, 1:], -1) # Test that odf array matches and is right shape pam = peaks_from_model(model, data, _sphere, .5, 45, return_odf=True) expected_shape = (len(data), len(_odf)) assert_equal(pam.odf.shape, expected_shape) assert_true((_odf == pam.odf).all()) assert_array_equal(pam.peak_values[:, 0], _odf.max()) # Test mask mask = (np.arange(10) % 2) == 1 pam = peaks_from_model(model, data, _sphere, .5, 45, mask=mask, normalize_peaks=True) assert_array_equal(pam.gfa[~mask], 0) assert_array_equal(pam.qa[~mask], 0) assert_array_equal(pam.peak_values[~mask], 0) assert_array_equal(pam.peak_indices[~mask], -1) assert_array_equal(pam.gfa[mask], gfa(_odf)) assert_array_equal(pam.peak_values[mask, 0], 1.) assert_array_equal(pam.peak_values[mask, 1:], 0.) mn, mx = _odf.min(), _odf.max() assert_array_equal(pam.qa[mask, 0], (mx - mn) / mx) assert_array_equal(pam.qa[mask, 1:], 0.) assert_array_equal(pam.peak_indices[mask, 0], odf_argmax) assert_array_equal(pam.peak_indices[mask, 1:], -1)
def test_peaks_shm_coeff(): SNR = 100 S0 = 100 _, fbvals, fbvecs = get_data('small_64D') from dipy.data import get_sphere sphere = get_sphere('symmetric724') bvals = np.load(fbvals) bvecs = np.load(fbvecs) gtab = gradient_table(bvals, bvecs) mevals = np.array(([0.0015, 0.0003, 0.0003], [0.0015, 0.0003, 0.0003])) data, _ = multi_tensor(gtab, mevals, S0, angles=[(0, 0), (60, 0)], fractions=[50, 50], snr=SNR) from dipy.reconst.shm import CsaOdfModel model = CsaOdfModel(gtab, 4) pam = peaks_from_model(model, data[None,:], sphere, .5, 45, return_odf=True, return_sh=True) # Test that spherical harmonic coefficients return back correctly B = np.linalg.pinv(pam.invB) odf2 = np.dot(pam.shm_coeff, B) assert_array_almost_equal(pam.odf, odf2) assert_equal(pam.shm_coeff.shape[-1], 45) pam = peaks_from_model(model, data[None,:], sphere, .5, 45, return_odf=True, return_sh=False) assert_equal(pam.shm_coeff, None) pam = peaks_from_model(model, data[None, :], sphere, .5, 45, return_odf=True, return_sh=True, sh_basis_type='mrtrix') B = np.linalg.pinv(pam.invB) odf2 = np.dot(pam.shm_coeff, B) assert_array_almost_equal(pam.odf, odf2)
def pfm(model, data, mask, sphere, parallel=False, min_angle=25.0, relative_peak_th=0.1, sh_order=8): print 'Peak extraction with sh_order : ', sh_order, ' min_angle: ', min_angle, 'deg and relative peak threshold of : ', relative_peak_th peaks = peaks_from_model(model=model, data=data, mask=mask, sphere=sphere, relative_peak_threshold=relative_peak_th, min_separation_angle=min_angle, return_odf=False, return_sh=True, normalize_peaks=False, sh_order=sh_order, sh_basis_type='mrtrix', npeaks=5, parallel=parallel, nbr_process=6) return peaks
response_ar = np.array([mean_evals[0], mean_evals[1], mean_evals[1], S0]) if i < 10 : np.savetxt(dname + 'response_0' + str(i) + '.txt', response_ar) else : np.savetxt(dname + 'response_' + str(i) + '.txt', response_ar) csd_model = ConstrainedSphericalDeconvModel(gtab, (evals, S0)) from dipy.reconst.odf import peaks_from_model peaks = peaks_from_model(model=csd_model, data=data, sphere=sphere, relative_peak_threshold=0.25, min_separation_angle=45, mask=wm_mask, return_odf=False, return_sh=True, normalize_peaks=False, sh_order=8, sh_basis_type='mrtrix', npeaks=5, parallel=True, nbr_process=8) shm_coeff = peaks.shm_coeff myPeaksDirs = peaks.peak_dirs test = np.reshape(myPeaksDirs, [myPeaksDirs.shape[0], myPeaksDirs.shape[1],
# Create diffusion MR gradients gtab = gradient_table(bvals, bvecs) # Resample diffusion data and mask print('... resample data') data, affine = resample(data, affine, zooms, new_zooms) mask, affine = resample(mask, affine, zooms, new_zooms, order=0) # Deconvolution t = time.time() print('... perform deconvolution') dsmodel = DiffusionSpectrumDeconvModel(gtab) dsipeaks = peaks_from_model(model=dsmodel, data=data, sphere=sphere, relative_peak_threshold=.5, min_separation_angle=25, mask=mask, return_odf=True, normalize_peaks=True) #save_pickle(os.path.join(main_dir,tp,'CMP','scalars','dsideconv.pkl'), dsipeaks) # Set headers for output images hdr_gfa = nib.load(fimg).get_header() hdr_gfa.set_data_shape(mask.shape) hdr_gfa.set_zooms(new_zooms) hdr_peaks = nib.load(fimg).get_header() hdr_peaks.set_data_shape((mask.shape[0],mask.shape[1],mask.shape[2],5)) hdr_peaks.set_zooms((new_zooms[0],new_zooms[1],new_zooms[2],1.)) hdr_odf = nib.load(fimg).get_header() hdr_odf.set_data_shape((mask.shape[0],mask.shape[1],mask.shape[2],sphere.x.shape[0])) hdr_odf.set_zooms((new_zooms[0],new_zooms[1],new_zooms[2],1.))
Distribution Function) and return for example the peaks and their indices, or GFA which is similar to FA but for ODF based models. This function mainly needs a reconstruction model, the data and a sphere as input. The sphere is an object that represents the spherical discrete grid where the ODF values will be evaluated. """ sphere = get_sphere('symmetric724') start_time = time.time() csapeaks_parallel = peaks_from_model(model=csamodel, data=data, sphere=sphere, relative_peak_threshold=.8, min_separation_angle=45, mask=None, return_odf=False, normalize_peaks=True, ravel_peaks=False, npeaks=5, parallel=True, nbr_process=2) # default multiprocessing.cpu_count() time_parallel = time.time() - start_time print("peaks_from_model using 2 process ran in : " + str(time_parallel) + " seconds") """ peaks_from_model using 2 process ran in : 114.333221912 seconds, using 2 process """ start_time = time.time() csapeaks = peaks_from_model(model=csamodel,
""" `Peaks_from_model` is used to calculate properties of the ODFs (Orientation Distribution Function) and return for example the peaks and their indices, or GFA which is similar to FA but for ODF based models. This function mainly needs a reconstruction model, the data and a sphere as input. The sphere is an object that represents the spherical discrete grid where the ODF values will be evaluated. """ sphere = get_sphere('symmetric724') csapeaks = peaks_from_model(model=csamodel, data=maskdata, sphere=sphere, relative_peak_threshold=.8, min_separation_angle=45, mask=mask, return_odf=False, normalize_peaks=True) GFA = csapeaks.gfa print('GFA.shape (%d, %d, %d)' % GFA.shape) """ GFA.shape ``(81, 106, 76)`` Apart from GFA, csapeaks also has the attributes peak_values, peak_indices and ODF. peak_values shows the maxima values of the ODF and peak_indices gives us their position on the discrete sphere that was used to do the reconstruction of the ODF. In order to obtain the full ODF, return_odf should be True. Before
ODF = gqfit.odf(sphere) print('ODF.shape (%d, %d, %d)' % ODF.shape) """ ODF.shape ``(96, 96, 724)`` Using peaks_from_model we can find the main peaks of the ODFs and other properties. """ gqpeaks = peaks_from_model(model=gqmodel, data=dataslice, sphere=sphere, relative_peak_threshold=.8, min_separation_angle=45, mask=mask, return_odf=False, normalize_peaks=True) gqpeak_values = gqpeaks.peak_values """ gqpeak_indices show which sphere points have the maximum values. """ gqpeak_indices = gqpeaks.peak_indices """ It is also possible to calculate GFA. """
def test_peaks_shm_coeff(): SNR = 100 S0 = 100 _, fbvals, fbvecs = get_data('small_64D') from dipy.data import get_sphere sphere = get_sphere('symmetric724') bvals = np.load(fbvals) bvecs = np.load(fbvecs) gtab = gradient_table(bvals, bvecs) mevals = np.array(([0.0015, 0.0003, 0.0003], [0.0015, 0.0003, 0.0003])) data, _ = multi_tensor(gtab, mevals, S0, angles=[(0, 0), (60, 0)], fractions=[50, 50], snr=SNR) from dipy.reconst.shm import CsaOdfModel model = CsaOdfModel(gtab, 4) pam = peaks_from_model(model, data[None, :], sphere, .5, 45, return_odf=True, return_sh=True) # Test that spherical harmonic coefficients return back correctly B = np.linalg.pinv(pam.invB) odf2 = np.dot(pam.shm_coeff, B) assert_array_almost_equal(pam.odf, odf2) assert_equal(pam.shm_coeff.shape[-1], 45) pam = peaks_from_model(model, data[None, :], sphere, .5, 45, return_odf=True, return_sh=False) assert_equal(pam.shm_coeff, None) pam = peaks_from_model(model, data[None, :], sphere, .5, 45, return_odf=True, return_sh=True, sh_basis_type='mrtrix') B = np.linalg.pinv(pam.invB) odf2 = np.dot(pam.shm_coeff, B) assert_array_almost_equal(pam.odf, odf2)
""" ODF = gqfit.odf(sphere) print('ODF.shape (%d, %d, %d)' % ODF.shape) """ ODF.shape ``(96, 96, 724)`` Using peaks_from_model we can find the main peaks of the ODFs and other properties. """ gqpeaks = peaks_from_model(model=gqmodel, data=dataslice, sphere=sphere, relative_peak_threshold=.8, min_separation_angle=45, mask=mask, return_odf=False, normalize_peaks=True) gqpeak_values = gqpeaks.peak_values """ gqpeak_indices show which sphere points have the maximum values. """ gqpeak_indices = gqpeaks.peak_indices """ It is also possible to calculate GFA. """ GFA = gqpeaks.gfa
""" csamodel = CsaOdfModel(gtab, 4) """ Peaks from model is used to calculate properties of the ODFs and return for example the peaks and their indices, or GFA which is similar to FA but for ODF based models. """ from dipy.reconst.odf import peaks_from_model peaks = peaks_from_model(model=csamodel, data=data2, sphere=sphere, relative_peak_threshold=.8, min_separation_angle=45, mask=mask, normalize_peaks=True) """ This time we will not use FA as input to EuDX but we will use directly the maximum peaks of the ODF. The a_low threshold is the """ eu = EuDX(peaks.peak_values, peaks.peak_indices, odf_vertices = sphere.vertices, a_low=0.2) csa_streamlines = [streamline for streamline in eu]
from dipy.data import get_sphere sphere = get_sphere('symmetric724') print('>>> Find peaks...') from time import time t0 = time() from dipy.reconst.odf import peaks_from_model peaks = peaks_from_model(model=shore_model, data=data, mask=mask, sphere=sphere, relative_peak_threshold=0.3, min_separation_angle=25, return_odf=False, return_sh=True, normalize_peaks=False, sh_order=8, npeaks=5, parallel=False, nbr_process=6) t1 = time() np.savetxt(join(dname,'shore_peaks_time.txt'), (t1-t0,)) del data print('>>> Save peak indices...') fpeaks = join(dname, 'dwi_peaks_1x1x1.nii.gz') nib.save(nib.Nifti1Image(peaks.peak_indices, affine), fpeaks)