def organize_stanford_data(path=None):
"""
Create the expected file-system structure for the Stanford HARDI data-set.
"""
dpd.fetch_stanford_hardi()
if path is None:
if not op.exists(afq_home):
os.mkdir(afq_home)
base_folder = op.join(afq_home, 'stanford_hardi', 'derivatives',
'dmriprep')
else:
base_folder = op.join(path, 'stanford_hardi', 'derivatives',
'dmriprep')
if not op.exists(base_folder):
anat_folder = op.join(base_folder, 'sub-01', 'sess-01', 'anat')
os.makedirs(anat_folder, exist_ok=True)
dwi_folder = op.join(base_folder, 'sub-01', 'sess-01', 'dwi')
os.makedirs(dwi_folder, exist_ok=True)
t1_img = dpd.read_stanford_t1()
nib.save(t1_img, op.join(anat_folder, 'sub-01_sess-01_T1w.nii.gz'))
seg_img = dpd.read_stanford_labels()[-1]
nib.save(seg_img,
op.join(anat_folder, 'sub-01_sess-01_aparc+aseg.nii.gz'))
dwi_img, gtab = dpd.read_stanford_hardi()
nib.save(dwi_img, op.join(dwi_folder, 'sub-01_sess-01_dwi.nii.gz'))
np.savetxt(op.join(dwi_folder, 'sub-01_sess-01_dwi.bvecs'), gtab.bvecs)
np.savetxt(op.join(dwi_folder, 'sub-01_sess-01_dwi.bvals'), gtab.bvals)
def test_segment():
dpd.fetch_stanford_hardi()
hardi_dir = op.join(fetcher.dipy_home, "stanford_hardi")
hardi_fdata = op.join(hardi_dir, "HARDI150.nii.gz")
hardi_fbval = op.join(hardi_dir, "HARDI150.bval")
hardi_fbvec = op.join(hardi_dir, "HARDI150.bvec")
file_dict = afd.read_stanford_hardi_tractography()
mapping = file_dict['mapping.nii.gz']
streamlines = file_dict['tractography_subsampled.trk']
templates = afd.read_templates()
bundles = {'CST_L': {'ROIs': [templates['CST_roi1_L'],
templates['CST_roi2_L']],
'rules': [True, True]},
'CST_R': {'ROIs': [templates['CST_roi1_R'],
templates['CST_roi1_R']],
'rules': [True, True]}}
fiber_groups = seg.segment(hardi_fdata,
hardi_fbval,
hardi_fbvec,
streamlines,
bundles,
mapping=mapping,
as_generator=True)
# We asked for 2 fiber groups:
npt.assert_equal(len(fiber_groups), 2)
# There happen to be 8 fibers in the right CST:
CST_R_sl = list(fiber_groups['CST_R'])
npt.assert_equal(len(CST_R_sl), 8)
# Calculate the tract profile for a volume of all-ones:
tract_profile = seg.calculate_tract_profile(
np.ones(nib.load(hardi_fdata).shape[:3]),
CST_R_sl)
npt.assert_equal(tract_profile, np.ones(100))
def exampleDipy():
# example obtained from: http://nipy.org/dipy/examples_built/syn_registration_2d.html
import ssl
if hasattr(ssl, '_create_unverified_context'):
ssl._create_default_https_context = ssl._create_unverified_context
from dipy.data import fetch_stanford_hardi, read_stanford_hardi
fetch_stanford_hardi()
nib_stanford, gtab_stanford = read_stanford_hardi()
stanford_b0 = np.squeeze(nib_stanford.get_data())[..., 0]
from dipy.data.fetcher import fetch_syn_data, read_syn_data
fetch_syn_data()
nib_syn_t1, nib_syn_b0 = read_syn_data()
syn_b0 = np.array(nib_syn_b0.get_data())
from dipy.segment.mask import median_otsu
stanford_b0_masked, stanford_b0_mask = median_otsu(stanford_b0, 4, 4)
syn_b0_masked, syn_b0_mask = median_otsu(syn_b0, 4, 4)
static = stanford_b0_masked
static_affine = nib_stanford.affine
moving = syn_b0_masked
moving_affine = nib_syn_b0.affine
pre_align = np.array(
[[1.02783543e+00, -4.83019053e-02, -6.07735639e-02, -2.57654118e+00],
[4.34051706e-03, 9.41918267e-01, -2.66525861e-01, 3.23579799e+01],
[5.34288908e-02, 2.90262026e-01, 9.80820307e-01, -1.46216651e+01],
[0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 1.00000000e+00]])
from dipy.align.imaffine import AffineMap
affine_map = AffineMap(pre_align,
static.shape, static_affine,
moving.shape, moving_affine)
resampled = affine_map.transform(moving)
metric = CCMetric(3)
level_iters = [10, 10, 5]
sdr = SymmetricDiffeomorphicRegistration(metric, level_iters)
mapping = sdr.optimize(static, moving, static_affine, moving_affine,
pre_align)
warped_moving = mapping.transform(moving)
for slice in range(41 - 12, 41 + 13):
regtools.overlay_slices(static, resampled, slice, 1, 'Static',
'Pre Moving',
'GIFexample1/' + str(slice) + 'T1pre.png')
regtools.overlay_slices(static, warped_moving, slice, 1, 'Static',
'Post moving',
'GIFexample1/' + str(slice) + 'T1post.png')
def organize_stanford_data(path=None):
"""
Create the expected file-system structure for the Stanford HARDI data-set.
"""
dpd.fetch_stanford_hardi()
if path is None:
if not op.exists(afq_home):
os.mkdir(afq_home)
my_path = afq_home
else:
my_path = path
base_folder = op.join(my_path, 'stanford_hardi', 'derivatives', 'dmriprep')
if not op.exists(base_folder):
anat_folder = op.join(base_folder, 'sub-01', 'sess-01', 'anat')
os.makedirs(anat_folder, exist_ok=True)
dwi_folder = op.join(base_folder, 'sub-01', 'sess-01', 'dwi')
os.makedirs(dwi_folder, exist_ok=True)
t1_img = dpd.read_stanford_t1()
nib.save(t1_img, op.join(anat_folder, 'sub-01_sess-01_T1w.nii.gz'))
seg_img = dpd.read_stanford_labels()[-1]
nib.save(seg_img,
op.join(anat_folder, 'sub-01_sess-01_aparc+aseg.nii.gz'))
dwi_img, gtab = dpd.read_stanford_hardi()
nib.save(dwi_img, op.join(dwi_folder, 'sub-01_sess-01_dwi.nii.gz'))
np.savetxt(op.join(dwi_folder, 'sub-01_sess-01_dwi.bvecs'), gtab.bvecs)
np.savetxt(op.join(dwi_folder, 'sub-01_sess-01_dwi.bvals'), gtab.bvals)
dataset_description = {
"BIDSVersion": "1.0.0",
"Name": "Stanford HARDI",
"Subjects": ["sub-01"]
}
desc_file = op.join(my_path, 'stanford_hardi', 'dataset_description.json')
with open(desc_file, 'w') as outfile:
json.dump(dataset_description, outfile)
We show how to apply a Constant Solid Angle ODF (Q-Ball) model from Aganj et.
al (MRM 2010) to your datasets.
First import the necessary modules:
"""
import time
from dipy.data import fetch_stanford_hardi, read_stanford_hardi, get_sphere
from dipy.reconst.shm import CsaOdfModel
from dipy.reconst.peaks import peaks_from_model
"""
Download and read the data for this tutorial.
"""
fetch_stanford_hardi()
img, gtab = read_stanford_hardi()
"""
img contains a nibabel Nifti1Image object (data) and gtab contains a GradientTable
object (gradient information e.g. b-values). For example to read the b-values
it is possible to write print(gtab.bvals).
Load the raw diffusion data and the affine.
"""
data = img.get_data()
print('data.shape (%d, %d, %d, %d)' % data.shape)
"""
data.shape ``(81, 106, 76, 160)``
from os.path import join as pjoin
import numpy as np
from dipy.viz import regtools
from dipy.data import fetch_stanford_hardi
from dipy.data.fetcher import fetch_syn_data
from dipy.io.image import load_nifti
from dipy.align.imaffine import (transform_centers_of_mass, AffineMap,
MutualInformationMetric, AffineRegistration)
from dipy.align.transforms import (TranslationTransform3D, RigidTransform3D,
AffineTransform3D)
"""
Let's fetch two b0 volumes, the static image will be the b0 from the Stanford
HARDI dataset
"""
files, folder = fetch_stanford_hardi()
static_data, static_affine = load_nifti(pjoin(folder, 'HARDI150.nii.gz'))
static = np.squeeze(static_data)[..., 0]
static_grid2world = static_affine
"""
Now the moving image
"""
files, folder = fetch_syn_data()
moving_data, moving_affine = load_nifti(pjoin(folder, 'b0.nii.gz'))
moving = moving_data
moving_grid2world = moving_affine
"""
We can see that the images are far from aligned by drawing one on top of
the other. The images don't even have the same number of voxels, so in order
to draw one on top of the other we need to resample the moving image on a grid
"""
import numpy as np
from dipy.viz import regtools
from dipy.data import fetch_stanford_hardi, read_stanford_hardi
from dipy.data.fetcher import fetch_syn_data, read_syn_data
from dipy.align.imaffine import (transform_centers_of_mass, AffineMap,
MutualInformationMetric, AffineRegistration)
from dipy.align.transforms import (TranslationTransform3D, RigidTransform3D,
AffineTransform3D)
"""
Let's fetch two b0 volumes, the static image will be the b0 from the Stanford
HARDI dataset
"""
fetch_stanford_hardi()
nib_stanford, gtab_stanford = read_stanford_hardi()
static = np.squeeze(nib_stanford.get_data())[..., 0]
static_grid2world = nib_stanford.affine
"""
Now the moving image
"""
fetch_syn_data()
nib_syn_t1, nib_syn_b0 = read_syn_data()
moving = np.array(nib_syn_b0.get_data())
moving_grid2world = nib_syn_b0.affine
"""
We can see that the images are far from aligned by drawing one on top of
the other. The images don't even have the same number of voxels, so in order
to draw one on top of the other we need to resample the moving image on a grid
import dipy.reconst.cross_validation as xval import dipy.reconst.dti as dti import dipy.reconst.csdeconv as csd import scipy.stats as stats """ We fetch some data and select a couple of voxels to perform comparisons on. One lies in the corpus callosum (cc), while the other is in the centrum semiovale (cso), a part of the brain known to contain multiple crossing white matter fiber populations. """ dpd.fetch_stanford_hardi() img, gtab = dpd.read_stanford_hardi() data = img.get_data() cc_vox = data[40, 70, 38] cso_vox = data[30, 76, 38] """ We initialize each kind of model: """ dti_model = dti.TensorModel(gtab) response, ratio = csd.auto_response(gtab, data, roi_radius=10, fa_thr=0.7) csd_model = csd.ConstrainedSphericalDeconvModel(gtab, response)
import dipy.data as dpd """ ``dipy.viz.fvtk`` is used for 3D visualization and matplotlib for 2D visualizations: """ import dipy.viz.fvtk as fvtk import matplotlib.pyplot as plt """ If needed, the ``fetch_stanford_hardi`` function will download the raw dMRI dataset of a single subject. The size of this dataset is 87 MBytes. You only need to fetch once. """ dpd.fetch_stanford_hardi() img, gtab = dpd.read_stanford_hardi() """ We initialize a DTI model class instance using the gradient table used in the measurement. By default, ``dti.TensorModel`` will use a weighted least-squares algorithm (described in [Chang2005]_) to fit the parameters of the model. We initialize this model as a baseline for comparison of noise-corrupted models: """ dti_wls = dti.TensorModel(gtab) """ For the purpose of this example, we will focus on the data from a region of interest (ROI) surrounding the Corpus Callosum. We define that ROI as the following indices: """
def test_segment():
dpd.fetch_stanford_hardi()
hardi_dir = op.join(fetcher.dipy_home, "stanford_hardi")
hardi_fdata = op.join(hardi_dir, "HARDI150.nii.gz")
hardi_img = nib.load(hardi_fdata)
hardi_fbval = op.join(hardi_dir, "HARDI150.bval")
hardi_fbvec = op.join(hardi_dir, "HARDI150.bvec")
file_dict = afd.read_stanford_hardi_tractography()
mapping = file_dict['mapping.nii.gz']
streamlines = file_dict['tractography_subsampled.trk']
streamlines = dts.Streamlines(
dtu.move_streamlines(streamlines[streamlines._lengths > 10],
np.linalg.inv(hardi_img.affine)))
templates = afd.read_templates()
bundles = {
'CST_L': {
'ROIs': [templates['CST_roi1_L'], templates['CST_roi2_L']],
'rules': [True, True],
'prob_map': templates['CST_L_prob_map'],
'cross_midline': None
},
'CST_R': {
'ROIs': [templates['CST_roi1_R'], templates['CST_roi1_R']],
'rules': [True, True],
'prob_map': templates['CST_R_prob_map'],
'cross_midline': None
}
}
fiber_groups = seg.segment(hardi_fdata, hardi_fbval, hardi_fbvec,
streamlines, bundles, mapping)
# We asked for 2 fiber groups:
npt.assert_equal(len(fiber_groups), 2)
# Here's one of them:
CST_R_sl = fiber_groups['CST_R']
# Let's make sure there are streamlines in there:
npt.assert_(len(CST_R_sl) > 0)
# Calculate the tract profile for a volume of all-ones:
tract_profile = seg.calculate_tract_profile(
np.ones(nib.load(hardi_fdata).shape[:3]), CST_R_sl)
npt.assert_almost_equal(tract_profile, np.ones(100))
# Test providing an array input to calculate_tract_profile:
tract_profile = seg.calculate_tract_profile(
np.ones(nib.load(hardi_fdata).shape[:3]),
seg._resample_bundle(CST_R_sl, 100))
npt.assert_almost_equal(tract_profile, np.ones(100))
clean_sl = seg.clean_fiber_group(CST_R_sl)
# Since there are only 8 streamlines here, nothing should happen:
npt.assert_equal(clean_sl, CST_R_sl)
# Setting minimum number of streamlines to a smaller number and
# threshold to a relatively small number will exclude some streamlines:
clean_sl = seg.clean_fiber_group(CST_R_sl, min_sl=2, clean_threshold=2)
npt.assert_equal(len(clean_sl), 3)
# What if you don't have probability maps?
bundles = {
'CST_L': {
'ROIs': [templates['CST_roi1_L'], templates['CST_roi2_L']],
'rules': [True, True],
'cross_midline': False
},
'CST_R': {
'ROIs': [templates['CST_roi1_R'], templates['CST_roi1_R']],
'rules': [True, True],
'cross_midline': False
}
}
fiber_groups = seg.segment(hardi_fdata, hardi_fbval, hardi_fbvec,
streamlines, bundles, mapping)
# This condition should still hold
npt.assert_equal(len(fiber_groups), 2)
npt.assert_(len(fiber_groups['CST_R']) > 0)
def test_segment():
dpd.fetch_stanford_hardi()
hardi_dir = op.join(fetcher.dipy_home, "stanford_hardi")
hardi_fdata = op.join(hardi_dir, "HARDI150.nii.gz")
hardi_fbval = op.join(hardi_dir, "HARDI150.bval")
hardi_fbvec = op.join(hardi_dir, "HARDI150.bvec")
file_dict = afd.read_stanford_hardi_tractography()
mapping = file_dict['mapping.nii.gz']
streamlines = file_dict['tractography_subsampled.trk']
templates = afd.read_templates()
bundles = {'CST_L': {'ROIs': [templates['CST_roi1_L'],
templates['CST_roi2_L']],
'rules': [True, True],
'prob_map': templates['CST_L_prob_map'],
'cross_midline': False},
'CST_R': {'ROIs': [templates['CST_roi1_R'],
templates['CST_roi1_R']],
'rules': [True, True],
'prob_map': templates['CST_R_prob_map'],
'cross_midline': False}}
fiber_groups = seg.segment(hardi_fdata,
hardi_fbval,
hardi_fbvec,
streamlines,
bundles,
mapping=mapping,
as_generator=True)
# We asked for 2 fiber groups:
npt.assert_equal(len(fiber_groups), 2)
# There happen to be 5 fibers in the right CST:
CST_R_sl = fiber_groups['CST_R']
npt.assert_equal(len(CST_R_sl), 5)
# Calculate the tract profile for a volume of all-ones:
tract_profile = seg.calculate_tract_profile(
np.ones(nib.load(hardi_fdata).shape[:3]),
CST_R_sl)
npt.assert_almost_equal(tract_profile, np.ones(100))
# Test providing an array input to calculate_tract_profile:
tract_profile = seg.calculate_tract_profile(
np.ones(nib.load(hardi_fdata).shape[:3]),
seg._resample_bundle(CST_R_sl, 100))
npt.assert_almost_equal(tract_profile, np.ones(100))
clean_sl = seg.clean_fiber_group(CST_R_sl)
# Since there are only 5 streamlines here, nothing should happen:
npt.assert_equal(clean_sl, CST_R_sl)
# Setting minimum number of streamlines to a smaller number and
# threshold to a relatively small number will exclude some streamlines:
clean_sl = seg.clean_fiber_group(CST_R_sl, min_sl=2, clean_threshold=2)
npt.assert_equal(len(clean_sl), 3)
# What if you don't have probability maps?
bundles = {'CST_L': {'ROIs': [templates['CST_roi1_L'],
templates['CST_roi2_L']],
'rules': [True, True],
'cross_midline': False},
'CST_R': {'ROIs': [templates['CST_roi1_R'],
templates['CST_roi1_R']],
'rules': [True, True],
'cross_midline': False}}
fiber_groups = seg.segment(hardi_fdata,
hardi_fbval,
hardi_fbvec,
streamlines,
bundles,
mapping=mapping,
as_generator=True)
# This condition should still hold
npt.assert_equal(len(fiber_groups), 2)
# But one of the streamlines has switched identities without the
# probability map to guide selection
npt.assert_equal(len(fiber_groups['CST_R']), 6)
import numpy as np
from dipy.viz import regtools
from dipy.data import fetch_stanford_hardi, read_stanford_hardi
from dipy.data.fetcher import fetch_syn_data, read_syn_data
from dipy.align.imaffine import (transform_centers_of_mass, AffineMap,
MutualInformationMetric, AffineRegistration)
from dipy.align.transforms import (TranslationTransform3D, RigidTransform3D,
AffineTransform3D)
from dipy.io.image import load_nifti
"""
fetch_stanford_hardi()
nib_stanford, gtab_stanford = read_stanford_hardi()
nifti_data = np.squeeze(nib_stanford.get_data())[..., 0]
nifti_affine = nib_stanford.affine
"""
from dipy.io.image import load_nifti
mynifti = load_nifti("/Volumes/Data/Badea/Lab/19abb14/N57437_nii4D.nii")
nifti_data = np.squeeze(mynifti[0])[..., 0]
nifti_affine = mynifti[1]
mynifti = load_nifti("/Volumes/Data/Badea/Lab/19abb14/N57500_nii4D.nii")
nifti_data2 = np.squeeze(mynifti[0])[..., 0]
nifti_affine2 = mynifti[1]
identity = np.eye(4)
affine_map = AffineMap(identity, nifti_data.shape, nifti_affine,
nifti_data2.shape, nifti_affine2)
resampled = affine_map.transform(nifti_data2)
regtools.overlay_slices(nifti_data, resampled, None, 0, "nifti_data",
"nifti_data2", "resampled_0.png")