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 test_density_map():
file_dict = afd.read_stanford_hardi_tractography()
# subsample even more
subsampled_tractography = file_dict["tractography_subsampled.trk"][441:444]
sft = StatefulTractogram(subsampled_tractography,
file_dict["mapping.nii.gz"], Space.VOX)
density_map = afv.density_map(sft)
npt.assert_equal(int(np.sum(density_map.get_fdata())), 69)
def test_slr_registration():
# have to import subject sls
file_dict = afd.read_stanford_hardi_tractography()
streamlines = file_dict['tractography_subsampled.trk']
# have to import sls atlas
afd.fetch_hcp_atlas_16_bundles()
atlas_fname = op.join(afd.afq_home, 'hcp_atlas_16_bundles',
'Atlas_in_MNI_Space_16_bundles', 'whole_brain',
'whole_brain_MNI.trk')
hcp_atlas = load_tractogram(atlas_fname, 'same', bbox_valid_check=False)
with nbtmp.InTemporaryDirectory() as tmpdir:
mapping = slr_registration(streamlines,
hcp_atlas.streamlines,
moving_affine=subset_b0_img.affine,
static_affine=subset_t2_img.affine,
moving_shape=subset_b0_img.shape,
static_shape=subset_t2_img.shape,
progressive=False,
greater_than=10,
rm_small_clusters=1,
rng=np.random.RandomState(seed=8))
warped_moving = mapping.transform(subset_b0)
npt.assert_equal(warped_moving.shape, subset_t2.shape)
mapping_fname = op.join(tmpdir, 'mapping.npy')
write_mapping(mapping, mapping_fname)
file_mapping = read_mapping(mapping_fname, subset_b0_img,
subset_t2_img)
# Test that it has the same effect on the data:
warped_from_file = file_mapping.transform(subset_b0)
npt.assert_equal(warped_from_file, warped_moving)
# Test that it is, attribute by attribute, identical:
for k in mapping.__dict__:
assert (np.all(
mapping.__getattribute__(k) == file_mapping.__getattribute__(
k)))
from dipy.io.stateful_tractogram import StatefulTractogram, Space
import AFQ.data as afd
import AFQ.tractography as aft
import AFQ.registration as reg
import AFQ.segmentation as seg
import AFQ.dti as dti
from AFQ.utils.volume import patch_up_roi
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']
tg = StatefulTractogram(streamlines, hardi_img, Space.RASMM)
tg.to_vox()
streamlines = tg.streamlines
# streamlines = dts.Streamlines(
# dtu.transform_tracking_output(
# streamlines[streamlines._lengths > 10],
# np.linalg.inv(hardi_img.affine)))
def test_segment():
templates = afd.read_templates()
def test_AFQ_data2():
"""
Test with some actual data again, this time for track segmentation
"""
tmpdir = nbtmp.InTemporaryDirectory()
afd.organize_stanford_data(path=tmpdir.name)
preafq_path = op.join(tmpdir.name, 'stanford_hardi',
'derivatives', 'preafq')
myafq = api.AFQ(preafq_path=preafq_path,
sub_prefix='sub',
bundle_list=["SLF", "ARC", "CST", "FP"])
# Replace the mapping and streamlines with precomputed:
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([s for s in streamlines if s.shape[0] > 100],
np.linalg.inv(myafq.dwi_affine[0])))
sl_file = op.join(myafq.data_frame.results_dir[0],
'sub-01_sess-01_dwiDTI_det_streamlines.trk')
aus.write_trk(sl_file, streamlines, affine=myafq.dwi_affine[0])
mapping_file = op.join(myafq.data_frame.results_dir[0],
'sub-01_sess-01_dwi_mapping.nii.gz')
nib.save(mapping, mapping_file)
reg_prealign_file = op.join(myafq.data_frame.results_dir[0], 'sub-01_sess-01_dwi_reg_prealign.npy')
np.save(reg_prealign_file, np.eye(4))
tgram = nib.streamlines.load(myafq.bundles[0]).tractogram
bundles = aus.tgram_to_bundles(tgram, myafq.bundle_dict)
npt.assert_equal(len(bundles['CST_R']), 2)
# Test ROI exporting:
myafq.export_rois()
assert op.exists(op.join(myafq.data_frame['results_dir'][0],
'ROIs',
'CST_R_roi1_include.nii.gz'))
# Test bundles exporting:
myafq.export_bundles()
assert op.exists(op.join(myafq.data_frame['results_dir'][0],
'bundles',
'CST_R.trk'))
tract_profiles = pd.read_csv(myafq.tract_profiles[0])
assert tract_profiles.shape == (800, 5)
# Before we run the CLI, we'll remove the bundles and ROI folders, to see
# that the CLI generates them
shutil.rmtree(op.join(myafq.data_frame['results_dir'][0],
'bundles'))
shutil.rmtree(op.join(myafq.data_frame['results_dir'][0],
'ROIs'))
# Test the CLI:
print("Running the CLI:")
cmd = "pyAFQ " + preafq_path
out = os.system(cmd)
assert out == 0
# The combined tract profiles should already exist from the CLI Run:
from_file = pd.read_csv(op.join(myafq.afq_dir, 'tract_profiles.csv'))
# And should be identical to what we would get by rerunning this:
combined_profiles = myafq.combine_profiles()
assert combined_profiles.shape == (800, 7)
assert_frame_equal(combined_profiles, from_file)
# Make sure the CLI did indeed generate these:
assert op.exists(op.join(myafq.data_frame['results_dir'][0],
'ROIs',
'CST_R_roi1_include.nii.gz'))
assert op.exists(op.join(myafq.data_frame['results_dir'][0],
'bundles',
'CST_R.trk'))
def test_AFQ_data_planes():
"""
Test with some actual data again, this time for track segmentation
"""
tmpdir = nbtmp.InTemporaryDirectory()
afd.organize_stanford_data(path=tmpdir.name)
dmriprep_path = op.join(tmpdir.name, 'stanford_hardi', 'derivatives',
'dmriprep')
seg_algo = "planes"
bundle_names = ["SLF", "ARC", "CST", "FP"]
myafq = api.AFQ(dmriprep_path=dmriprep_path,
sub_prefix='sub',
seg_algo=seg_algo,
bundle_names=bundle_names,
odf_model="DTI")
# Replace the mapping and streamlines with precomputed:
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([s for s in streamlines if s.shape[0] > 100],
np.linalg.inv(myafq.dwi_affine[0])))
sl_file = op.join(myafq.data_frame.results_dir[0],
'sub-01_sess-01_dwiDTI_det_streamlines.trk')
aus.write_trk(sl_file, streamlines, affine=myafq.dwi_affine[0])
mapping_file = op.join(myafq.data_frame.results_dir[0],
'sub-01_sess-01_dwi_mapping.nii.gz')
nib.save(mapping, mapping_file)
reg_prealign_file = op.join(myafq.data_frame.results_dir[0],
'sub-01_sess-01_dwi_reg_prealign.npy')
np.save(reg_prealign_file, np.eye(4))
tgram = nib.streamlines.load(myafq.bundles[0]).tractogram
bundles = aus.tgram_to_bundles(tgram, myafq.bundle_dict)
npt.assert_(len(bundles['CST_L']) > 0)
# Test ROI exporting:
myafq.export_rois()
assert op.exists(
op.join(myafq.data_frame['results_dir'][0], 'ROIs',
'CST_R_roi1_include.nii.gz'))
# Test bundles exporting:
myafq.export_bundles()
assert op.exists(
op.join(myafq.data_frame['results_dir'][0], 'bundles', 'CST_R.trk'))
tract_profiles = pd.read_csv(myafq.tract_profiles[0])
assert tract_profiles.shape == (800, 5)
# Before we run the CLI, we'll remove the bundles and ROI folders, to see
# that the CLI generates them
shutil.rmtree(op.join(myafq.data_frame['results_dir'][0], 'bundles'))
shutil.rmtree(op.join(myafq.data_frame['results_dir'][0], 'ROIs'))
# Test the CLI:
print("Running the CLI:")
cmd = "pyAFQ " + dmriprep_path
out = os.system(cmd)
assert out == 0
# The combined tract profiles should already exist from the CLI Run:
from_file = pd.read_csv(op.join(myafq.afq_dir, 'tract_profiles.csv'))
# And should be identical to what we would get by rerunning this:
combined_profiles = myafq.combine_profiles()
assert combined_profiles.shape == (800, 7)
assert_frame_equal(combined_profiles, from_file)
# Make sure the CLI did indeed generate these:
assert op.exists(
op.join(myafq.data_frame['results_dir'][0], 'ROIs',
'CST_R_roi1_include.nii.gz'))
assert op.exists(
op.join(myafq.data_frame['results_dir'][0], 'bundles', 'CST_R.trk'))
# def test_AFQ_data_recobundles():
# tmpdir = nbtmp.InTemporaryDirectory()
# afd.fetch_hcp(["100206"], hcp_bucket='hcp-openaccess', profile_name="hcp",
# path=tmpdir.name)
# dmriprep_path = op.join(tmpdir.name, 'HCP', 'derivatives', 'dmriprep')
# seg_algo = "recobundles"
# bundle_names = ["F", "CST", "AF", "CC_ForcepsMajor"]
# myafq = api.AFQ(dmriprep_path=dmriprep_path,
# sub_prefix='sub',
# seg_algo=seg_algo,
# bundle_names=bundle_names,
# odf_model="DTI",
# b0_threshold=15)
# # Replace the streamlines with precomputed:
# path_to_trk = dpd.fetcher.fetch_target_tractogram_hcp()
# path_to_trk = dpd.fetcher.get_target_tractogram_hcp()
# sl_file = op.join(myafq.data_frame.results_dir[0], 'sub-100206_sess-01_dwiDTI_det_streamlines.trk')
# shutil.copy(path_to_trk, sl_file)
# myafq.data_frame["streamlines_file"] = sl_file
# print("here")
# tgram = nib.streamlines.load(myafq.bundles[0]).tractogram
# print("here")
# bundles = aus.tgram_to_bundles(tgram, myafq.bundle_dict)
# npt.assert_(len(bundles['CST_L']) > 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_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_AFQ_data_waypoint():
"""
Test with some actual data again, this time for track segmentation
"""
tmpdir, bids_path, _ = get_temp_hardi()
bundle_names = ["SLF", "ARC", "CST", "FP"]
tracking_params = dict(odf_model="dti",
seed_mask=RoiMask(),
n_seeds=100,
random_seeds=True,
rng_seed=42)
segmentation_params = dict(filter_by_endpoints=False,
seg_algo="AFQ",
return_idx=True)
clean_params = dict(return_idx=True)
myafq = api.AFQ(bids_path=bids_path,
dmriprep='vistasoft',
bundle_info=bundle_names,
scalars=["dti_FA", "dti_MD"],
robust_tensor_fitting=True,
tracking_params=tracking_params,
segmentation_params=segmentation_params,
clean_params=clean_params)
# Replace the mapping and streamlines with precomputed:
file_dict = afd.read_stanford_hardi_tractography()
mapping = file_dict['mapping.nii.gz']
streamlines = file_dict['tractography_subsampled.trk']
streamlines = dts.Streamlines(
dtu.transform_tracking_output(
[s for s in streamlines if s.shape[0] > 100],
np.linalg.inv(myafq.dwi_affine[0])))
mapping_file = op.join(
myafq.data_frame.results_dir[0],
'sub-01_ses-01_dwi_mapping_from-DWI_to_MNI_xfm.nii.gz')
nib.save(mapping, mapping_file)
reg_prealign_file = op.join(
myafq.data_frame.results_dir[0],
'sub-01_ses-01_dwi_prealign_from-DWI_to-MNI_xfm.npy')
np.save(reg_prealign_file, np.eye(4))
tgram = load_tractogram(myafq.bundles[0], myafq.dwi_img[0])
bundles = aus.tgram_to_bundles(tgram, myafq.bundle_dict, myafq.dwi_img[0])
npt.assert_(len(bundles['CST_L']) > 0)
# Test ROI exporting:
myafq.export_rois()
assert op.exists(
op.join(myafq.data_frame['results_dir'][0], 'ROIs',
'sub-01_ses-01_dwi_desc-ROI-CST_R-1-include.json'))
# Test bundles exporting:
myafq.export_bundles()
assert op.exists(
op.join(
myafq.data_frame['results_dir'][0], 'bundles',
'sub-01_ses-01_dwi_space-RASMM_model-DTI_desc-det-AFQ-CST_L_tractography.trk'
)) # noqa
# Test creation of file with bundle indices:
assert op.exists(
op.join(
myafq.data_frame['results_dir'][0],
'sub-01_ses-01_dwi_space-RASMM_model-DTI_desc-det-AFQ-clean_tractography_idx.json'
)) # noqa
tract_profiles = pd.read_csv(myafq.tract_profiles[0])
assert tract_profiles.shape == (400, 5)
myafq.plot_tract_profiles()
assert op.exists(
op.join(
myafq.data_frame['results_dir'][0],
'sub-01_ses-01_dwi_space-RASMM_model-DTI_desc-det-AFQ_dti_fa_profile_plots.png'
)) # noqa
assert op.exists(
op.join(
myafq.data_frame['results_dir'][0],
'sub-01_ses-01_dwi_space-RASMM_model-DTI_desc-det-AFQ_dti_md_profile_plots.png'
)) # noqa
# Before we run the CLI, we'll remove the bundles and ROI folders, to see
# that the CLI generates them
shutil.rmtree(op.join(myafq.data_frame['results_dir'][0], 'bundles'))
shutil.rmtree(op.join(myafq.data_frame['results_dir'][0], 'ROIs'))
# Test the CLI:
print("Running the CLI:")
# Set up config to use the same parameters as above:
# ROI mask needs to be put in quotes in config
tracking_params = dict(odf_model="DTI",
seed_mask="RoiMask()",
n_seeds=100,
random_seeds=True,
rng_seed=42)
config = dict(BIDS=dict(bids_path=bids_path, dmriprep='vistasoft'),
REGISTRATION=dict(robust_tensor_fitting=True),
BUNDLES=dict(bundle_info=bundle_names,
scalars=["dti_fa", "dti_md"]),
VIZ=dict(viz_backend="plotly_no_gif"),
TRACTOGRAPHY=tracking_params,
SEGMENTATION=segmentation_params,
CLEANING=clean_params)
config_file = op.join(tmpdir.name, "afq_config.toml")
with open(config_file, 'w') as ff:
toml.dump(config, ff)
cmd = "pyAFQ " + config_file
out = os.system(cmd)
assert out == 0
# The combined tract profiles should already exist from the CLI Run:
from_file = pd.read_csv(
myafq._get_fname(myafq.data_frame.iloc[0], '_profiles.csv'))
# And should be identical to what we would get by rerunning this:
combined_profiles = myafq.combine_profiles()
assert combined_profiles.shape == (400, 7)
assert_series_equal(combined_profiles['dti_fa'], from_file['dti_fa'])
# Make sure the CLI did indeed generate these:
myafq.export_rois()
assert op.exists(
op.join(myafq.data_frame['results_dir'][0], 'ROIs',
'sub-01_ses-01_dwi_desc-ROI-CST_R-1-include.json'))
myafq.export_bundles()
assert op.exists(
op.join(
myafq.data_frame['results_dir'][0], 'bundles',
'sub-01_ses-01_dwi_space-RASMM_model-DTI_desc-det-AFQ-CST_L_tractography.trk'
)) # noqa
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)
def test_AFQ_data_waypoint():
"""
Test with some actual data again, this time for track segmentation
"""
tmpdir = nbtmp.InTemporaryDirectory()
afd.organize_stanford_data(path=tmpdir.name)
dmriprep_path = op.join(tmpdir.name, 'stanford_hardi',
'derivatives', 'dmriprep')
bundle_names = ["SLF", "ARC", "CST", "FP"]
tracking_params = dict(odf_model="DTI")
segmentation_params = dict(filter_by_endpoints=False,
seg_algo="AFQ",
return_idx=True)
clean_params = dict(return_idx=True)
myafq = api.AFQ(dmriprep_path=dmriprep_path,
sub_prefix='sub',
bundle_names=bundle_names,
scalars=["dti_fa", "dti_md"],
tracking_params=tracking_params,
segmentation_params=segmentation_params,
clean_params=clean_params)
# Replace the mapping and streamlines with precomputed:
file_dict = afd.read_stanford_hardi_tractography()
mapping = file_dict['mapping.nii.gz']
streamlines = file_dict['tractography_subsampled.trk']
streamlines = dts.Streamlines(
dtu.transform_tracking_output(
[s for s in streamlines if s.shape[0] > 100],
np.linalg.inv(myafq.dwi_affine[0])))
sl_file = op.join(
myafq.data_frame.results_dir[0],
'sub-01_sess-01_dwi_space-RASMM_model-DTI_desc-det_tractography.trk')
sft = StatefulTractogram(streamlines, myafq.data_frame.dwi_file[0],
Space.VOX)
save_tractogram(sft, sl_file, bbox_valid_check=False)
mapping_file = op.join(
myafq.data_frame.results_dir[0],
'sub-01_sess-01_dwi_mapping_from-DWI_to_MNI_xfm.nii.gz')
nib.save(mapping, mapping_file)
reg_prealign_file = op.join(
myafq.data_frame.results_dir[0],
'sub-01_sess-01_dwi_prealign_from-DWI_to-MNI_xfm.npy')
np.save(reg_prealign_file, np.eye(4))
tgram = load_tractogram(myafq.bundles[0], myafq.dwi_img[0])
bundles = aus.tgram_to_bundles(tgram, myafq.bundle_dict, myafq.dwi_img[0])
npt.assert_(len(bundles['CST_R']) > 0)
# Test ROI exporting:
myafq.export_rois()
assert op.exists(op.join(
myafq.data_frame['results_dir'][0],
'ROIs',
'sub-01_sess-01_dwi_desc-ROI-CST_R-1-include.json'))
# Test bundles exporting:
myafq.export_bundles()
assert op.exists(op.join(
myafq.data_frame['results_dir'][0],
'bundles',
'sub-01_sess-01_dwi_space-RASMM_model-DTI_desc-det-AFQ-CST_L_tractography.trk')) # noqa
# Test creation of file with bundle indices:
assert op.exists(op.join(
myafq.data_frame['results_dir'][0],
'sub-01_sess-01_dwi_space-RASMM_model-DTI_desc-det-AFQ-clean_tractography_idx.json')) # noqa
tract_profiles = pd.read_csv(myafq.tract_profiles[0])
assert tract_profiles.shape == (800, 5)
# Before we run the CLI, we'll remove the bundles and ROI folders, to see
# that the CLI generates them
shutil.rmtree(op.join(myafq.data_frame['results_dir'][0],
'bundles'))
shutil.rmtree(op.join(myafq.data_frame['results_dir'][0],
'ROIs'))
# Test the CLI:
print("Running the CLI:")
# Bare bones config only points to the files
config = dict(files=dict(dmriprep_path=dmriprep_path))
config_file = op.join(tmpdir.name, "afq_config.toml")
with open(config_file, 'w') as ff:
toml.dump(config, ff)
cmd = "pyAFQ " + config_file
out = os.system(cmd)
assert out == 0
# The combined tract profiles should already exist from the CLI Run:
from_file = pd.read_csv(op.join(myafq.afq_dir, 'tract_profiles.csv'))
# And should be identical to what we would get by rerunning this:
combined_profiles = myafq.combine_profiles()
assert combined_profiles.shape == (800, 7)
assert_frame_equal(combined_profiles, from_file)
# Make sure the CLI did indeed generate these:
myafq.export_rois()
assert op.exists(op.join(
myafq.data_frame['results_dir'][0],
'ROIs',
'sub-01_sess-01_dwi_desc-ROI-CST_R-1-include.json'))
myafq.export_bundles()
assert op.exists(op.join(
myafq.data_frame['results_dir'][0],
'bundles',
'sub-01_sess-01_dwi_space-RASMM_model-DTI_desc-det-AFQ-CST_L_tractography.trk')) # noqa
def test_AFQ_data_waypoint():
"""
Test with some actual data again, this time for track segmentation
"""
tmpdir, bids_path, _ = get_temp_hardi()
t1_path = op.join(tmpdir.name, "T1.nii.gz")
nib.save(afd.read_mni_template(mask=True, weight="T1w"), t1_path)
bundle_names = ["SLF", "ARC", "CST", "FP"]
tracking_params = dict(odf_model="dti",
seed_mask=RoiMask(),
n_seeds=100,
random_seeds=True,
rng_seed=42)
segmentation_params = dict(filter_by_endpoints=False,
seg_algo="AFQ",
return_idx=True)
clean_params = dict(return_idx=True)
myafq = api.AFQ(
bids_path=bids_path,
dmriprep='vistasoft',
bundle_info=bundle_names,
scalars=["dti_FA", "dti_MD",
TemplateScalar("T1", t1_path)],
robust_tensor_fitting=True,
tracking_params=tracking_params,
segmentation_params=segmentation_params,
clean_params=clean_params)
# Replace the mapping and streamlines with precomputed:
file_dict = afd.read_stanford_hardi_tractography()
mapping = file_dict['mapping.nii.gz']
streamlines = file_dict['tractography_subsampled.trk']
streamlines = dts.Streamlines(
dtu.transform_tracking_output(
[s for s in streamlines if s.shape[0] > 100],
np.linalg.inv(myafq.dwi_affine["01"])))
mapping_file = op.join(
myafq.results_dir["01"],
'sub-01_ses-01_dwi_mapping_from-DWI_to_MNI_xfm.nii.gz')
nib.save(mapping, mapping_file)
reg_prealign_file = op.join(
myafq.results_dir["01"],
'sub-01_ses-01_dwi_prealign_from-DWI_to-MNI_xfm.npy')
np.save(reg_prealign_file, np.eye(4))
tgram = load_tractogram(myafq.bundles["01"], myafq.img["01"])
bundles = aus.tgram_to_bundles(tgram, myafq.bundle_dict, myafq.img["01"])
npt.assert_(len(bundles['CST_L']) > 0)
# Test ROI exporting:
myafq.export_rois()
assert op.exists(
op.join(myafq.results_dir["01"], 'ROIs',
'sub-01_ses-01_dwi_desc-ROI-CST_R-1-include.json'))
# Test bundles exporting:
myafq.export_indiv_bundles()
assert op.exists(
op.join(
myafq.results_dir["01"], 'bundles',
'sub-01_ses-01_dwi_space-RASMM_model-DTI_desc-det-AFQ-CST_L_tractography.trk'
)) # noqa
tract_profile_fname = myafq.profiles["01"]
tract_profiles = pd.read_csv(tract_profile_fname)
assert tract_profiles.shape == (500, 6)
myafq.tract_profile_plots
assert op.exists(
op.join(
myafq.results_dir["01"], "tract_profile_plots",
'sub-01_ses-01_dwi_space-RASMM_model-DTI_desc-det-AFQ_dti_fa_profile_plots.png'
)) # noqa
assert op.exists(
op.join(
myafq.results_dir["01"], "tract_profile_plots",
'sub-01_ses-01_dwi_space-RASMM_model-DTI_desc-det-AFQ_dti_md_profile_plots.png'
)) # noqa
# Before we run the CLI, we'll remove the bundles and ROI folders, to see
# that the CLI generates them
shutil.rmtree(op.join(myafq.results_dir["01"], 'bundles'))
shutil.rmtree(op.join(myafq.results_dir["01"], 'ROIs'))
os.remove(tract_profile_fname)
# Test the CLI:
print("Running the CLI:")
# Set up config to use the same parameters as above:
# ROI mask needs to be put in quotes in config
tracking_params = dict(odf_model="DTI",
seed_mask="RoiMask()",
n_seeds=100,
random_seeds=True,
rng_seed=42)
config = dict(BIDS=dict(bids_path=bids_path, dmriprep='vistasoft'),
DATA=dict(robust_tensor_fitting=True),
BUNDLES=dict(bundle_info=bundle_names,
scalars=[
"dti_fa", "dti_md",
f"TemplateScalar('T1', '{t1_path}')"
]),
VIZ=dict(viz_backend="plotly_no_gif"),
TRACTOGRAPHY=tracking_params,
SEGMENTATION=segmentation_params,
CLEANING=clean_params)
config_file = op.join(tmpdir.name, "afq_config.toml")
with open(config_file, 'w') as ff:
toml.dump(config, ff)
# save memory
results_dir = myafq.results_dir["01"]
del myafq
gc.collect()
cmd = "pyAFQ " + config_file
completed_process = subprocess.run(cmd, shell=True, capture_output=True)
if completed_process.returncode != 0:
print(completed_process.stdout)
print(completed_process.stderr)
assert completed_process.returncode == 0
# The tract profiles should already exist from the CLI Run:
from_file = pd.read_csv(tract_profile_fname)
assert from_file.shape == (500, 6)
assert_series_equal(tract_profiles['dti_fa'], from_file['dti_fa'])
# Make sure the CLI did indeed generate these:
assert op.exists(
op.join(results_dir, 'ROIs',
'sub-01_ses-01_dwi_desc-ROI-CST_R-1-include.json'))
assert op.exists(
op.join(
results_dir, 'bundles',
'sub-01_ses-01_dwi_space-RASMM_model-DTI_desc-det-AFQ-CST_L_tractography.trk'
)) # noqa
