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 test_fetch_data():
symmetric362 = SPHERE_FILES['symmetric362']
with TemporaryDirectory() as tmpdir:
md5 = fetcher._get_file_md5(symmetric362)
bad_md5 = '8' * len(md5)
newfile = path.join(tmpdir, "testfile.txt")
# Test that the fetcher can get a file
testfile_url = pathname2url(symmetric362)
testfile_url = urljoin("file:", testfile_url)
files = {"testfile.txt": (testfile_url, md5)}
fetcher.fetch_data(files, tmpdir)
npt.assert_(path.exists(newfile))
# Test that the file is replaced when the md5 doesn't match
with open(newfile, 'a') as f:
f.write("some junk")
fetcher.fetch_data(files, tmpdir)
npt.assert_(path.exists(newfile))
npt.assert_equal(fetcher._get_file_md5(newfile), md5)
# Test that an error is raised when the md5 checksum of the download
# file does not match the expected value
files = {"testfile.txt": (testfile_url, bad_md5)}
npt.assert_raises(fetcher.FetcherError, fetcher.fetch_data, files,
tmpdir)
def test_slr_flow():
with TemporaryDirectory() as out_dir:
data_path = get_fnames('fornix')
streams, hdr = nib.trackvis.read(data_path)
fornix = [s[0] for s in streams]
f = Streamlines(fornix)
f1 = f.copy()
f1_path = pjoin(out_dir, "f1.trk")
save_trk(f1_path, Streamlines(f1), affine=np.eye(4))
f2 = f1.copy()
f2._data += np.array([50, 0, 0])
f2_path = pjoin(out_dir, "f2.trk")
save_trk(f2_path, Streamlines(f2), affine=np.eye(4))
slr_flow = SlrWithQbxFlow(force=True)
slr_flow.run(f1_path, f2_path)
out_path = slr_flow.last_generated_outputs['out_moved']
npt.assert_equal(os.path.isfile(out_path), True)
def test_scraper():
"""Test report scraping."""
# Mock a Sphinx + sphinx_gallery config
with TemporaryDirectory() as tmpdir:
app = Bunch(builder=Bunch(srcdir=str(tmpdir),
outdir=op.join(str(tmpdir),
'_build', 'html')
))
scraper = _ReportScraper()
scraper.app = app
gallery_conf = dict(src_dir=app.builder.srcdir, builder_name='html')
img_fname = op.join(app.builder.srcdir, 'auto_examples', 'images',
'sg_img.png')
target_file = op.join(app.builder.srcdir, 'auto_examples', 'sg.py')
block_vars = dict(image_path_iterator=(img for img in [img_fname]),
example_globals=dict(a=1), target_file=target_file)
# Confirm that HTML isn't accidentally inserted
block = None
rst = scraper(block, block_vars, gallery_conf)
assert rst == ''
# Confirm that HTML is correctly inserted for HTMLReport
report = _gen_report()
block_vars['example_globals']['report'] = report
rst = scraper(block, block_vars, gallery_conf)
# assert "<detail" in rst
assert 'Model details:' in rst
assert 'Design Matrix:' in rst
assert 'Contrasts' in rst
assert 'Mask' in rst
assert 'Stat Maps with Cluster Tables' in rst
assert 'Contrast Plot' in rst
assert 'cluster-details-table' in rst
assert 'Cluster Table' in rst
def test_motion_correction():
data_path, fbvals_path, fbvecs_path = get_fnames('small_64D')
volume = load_nifti_data(data_path)
with TemporaryDirectory() as out_dir:
# Use an abbreviated data-set:
img = nib.load(data_path)
data = img.get_fdata()[..., :10]
nib.save(nib.Nifti1Image(data, img.affine),
os.path.join(out_dir, 'data.nii.gz'))
# Save a subset:
bvals = np.loadtxt(fbvals_path)
bvecs = np.loadtxt(fbvecs_path)
np.savetxt(os.path.join(out_dir, 'bvals.txt'), bvals[:10])
np.savetxt(os.path.join(out_dir, 'bvecs.txt'), bvecs[:10])
motion_correction_flow = MotionCorrectionFlow()
motion_correction_flow._force_overwrite = True
motion_correction_flow.run(os.path.join(out_dir, 'data.nii.gz'),
os.path.join(out_dir, 'bvals.txt'),
os.path.join(out_dir, 'bvecs.txt'),
out_dir=out_dir)
out_path = motion_correction_flow.last_generated_outputs['out_moved']
corrected = load_nifti_data(out_path)
npt.assert_equal(corrected.shape, data.shape)
npt.assert_equal(corrected.min(), data.min())
npt.assert_equal(corrected.max(), data.max())
def test_median_otsu_flow():
with TemporaryDirectory() as out_dir:
data_path, _, _ = get_data('small_25')
volume = nib.load(data_path).get_data()
save_masked = True
median_radius = 3
numpass = 3
autocrop = False
vol_idx = [0]
dilate = 0
mo_flow = MedianOtsuFlow()
mo_flow.run(data_path, out_dir=out_dir, save_masked=save_masked,
median_radius=median_radius, numpass=numpass,
autocrop=autocrop, vol_idx=vol_idx, dilate=dilate)
mask_name = mo_flow.last_generated_outputs['out_mask']
masked_name = mo_flow.last_generated_outputs['out_masked']
masked, mask = median_otsu(volume, median_radius,
numpass, autocrop,
vol_idx, dilate)
result_mask_data = nib.load(join(out_dir, mask_name)).get_data()
npt.assert_array_equal(result_mask_data, mask)
result_masked_data = nib.load(join(out_dir, masked_name)).get_data()
npt.assert_array_equal(result_masked_data, masked)
def test_force_overwrite():
with TemporaryDirectory() as out_dir:
data_path, _, _ = get_data('small_25')
mo_flow = MedianOtsuFlow(output_strategy='absolute')
# Generate the first results
mo_flow.run(data_path, out_dir=out_dir)
mask_file = mo_flow.last_generated_outputs['out_mask']
first_time = os.path.getmtime(mask_file)
# re-run with no force overwrite, modified time should not change
mo_flow.run(data_path, out_dir=out_dir)
mask_file = mo_flow.last_generated_outputs['out_mask']
second_time = os.path.getmtime(mask_file)
assert first_time == second_time
# re-run with force overwrite, modified time should change
mo_flow = MedianOtsuFlow(output_strategy='absolute', force=True)
# Make sure that at least one second elapsed, so that time-stamp is
# different (sometimes measured in whole seconds)
time.sleep(1)
mo_flow.run(data_path, out_dir=out_dir)
mask_file = mo_flow.last_generated_outputs['out_mask']
third_time = os.path.getmtime(mask_file)
assert third_time != second_time
def test_slr_flow():
with TemporaryDirectory() as out_dir:
data_path = get_fnames('fornix')
fornix = load_tractogram(data_path, 'same',
bbox_valid_check=False).streamlines
f = Streamlines(fornix)
f1 = f.copy()
f1_path = pjoin(out_dir, "f1.trk")
sft = StatefulTractogram(f1, data_path, Space.RASMM)
save_tractogram(sft, f1_path, bbox_valid_check=False)
f2 = f1.copy()
f2._data += np.array([50, 0, 0])
f2_path = pjoin(out_dir, "f2.trk")
sft = StatefulTractogram(f2, data_path, Space.RASMM)
save_tractogram(sft, f2_path, bbox_valid_check=False)
slr_flow = SlrWithQbxFlow(force=True)
slr_flow.run(f1_path, f2_path)
out_path = slr_flow.last_generated_outputs['out_moved']
npt.assert_equal(os.path.isfile(out_path), True)
def reconst_flow_core(flow, extra_args=[]):
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()
mask = np.ones_like(volume[:, :, :, 0])
mask_img = nib.Nifti1Image(mask.astype(np.uint8), vol_img.affine)
mask_path = join(out_dir, 'tmp_mask.nii.gz')
nib.save(mask_img, mask_path)
dti_flow = flow()
args = [data_path, bval_path, bvec_path, mask_path]
args.extend(extra_args)
dti_flow.run(*args, out_dir=out_dir)
fa_path = dti_flow.last_generated_outputs['out_fa']
fa_data = nib.load(fa_path).get_data()
assert_equal(fa_data.shape, volume.shape[:-1])
tensor_path = dti_flow.last_generated_outputs['out_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 = dti_flow.last_generated_outputs['out_ga']
ga_data = nib.load(ga_path).get_data()
assert_equal(ga_data.shape, volume.shape[:-1])
rgb_path = dti_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 = dti_flow.last_generated_outputs['out_md']
md_data = nib.load(md_path).get_data()
assert_equal(md_data.shape, volume.shape[:-1])
ad_path = dti_flow.last_generated_outputs['out_ad']
ad_data = nib.load(ad_path).get_data()
assert_equal(ad_data.shape, volume.shape[:-1])
rd_path = dti_flow.last_generated_outputs['out_rd']
rd_data = nib.load(rd_path).get_data()
assert_equal(rd_data.shape, volume.shape[:-1])
mode_path = dti_flow.last_generated_outputs['out_mode']
mode_data = nib.load(mode_path).get_data()
assert_equal(mode_data.shape, volume.shape[:-1])
evecs_path = dti_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 = dti_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])
def test_gibbs_flow():
def generate_slice():
Nori = 32
image = np.zeros((6 * Nori, 6 * Nori))
image[Nori: 2 * Nori, Nori: 2 * Nori] = 1
image[Nori: 2 * Nori, 4 * Nori: 5 * Nori] = 1
image[2 * Nori: 3 * Nori, Nori: 3 * Nori] = 1
image[3 * Nori: 4 * Nori, 2 * Nori: 3 * Nori] = 2
image[3 * Nori: 4 * Nori, 4 * Nori: 5 * Nori] = 1
image[4 * Nori: 5 * Nori, 3 * Nori: 5 * Nori] = 3
# Corrupt image with gibbs ringing
c = np.fft.fft2(image)
c = np.fft.fftshift(c)
c_crop = c[48:144, 48:144]
image_gibbs = abs(np.fft.ifft2(c_crop)/4)
return image_gibbs
with TemporaryDirectory() as out_dir:
image4d = np.zeros((96, 96, 2, 2))
image4d[:, :, 0, 0] = generate_slice()
image4d[:, :, 1, 0] = generate_slice()
image4d[:, :, 0, 1] = generate_slice()
image4d[:, :, 1, 1] = generate_slice()
data_path = os.path.join(out_dir, "random_noise.nii.gz")
save_nifti(data_path, image4d, np.eye(4))
gibbs_flow = GibbsRingingFlow()
gibbs_flow.run(data_path, out_dir=out_dir)
assert_true(os.path.isfile(
gibbs_flow.last_generated_outputs['out_unring']))
def test_mppca_flow():
with TemporaryDirectory() as out_dir:
S0 = 100 + 2 * np.random.standard_normal((22, 23, 30, 20))
data_path = os.path.join(out_dir, "random_noise.nii.gz")
save_nifti(data_path, S0, np.eye(4))
mppca_flow = MPPCAFlow()
mppca_flow.run(data_path, out_dir=out_dir)
assert_true(os.path.isfile(
mppca_flow.last_generated_outputs['out_denoised']))
assert_false(os.path.isfile(
mppca_flow.last_generated_outputs['out_sigma']))
mppca_flow._force_overwrite = True
mppca_flow.run(data_path, return_sigma=True, pca_method='svd',
out_dir=out_dir)
assert_true(os.path.isfile(
mppca_flow.last_generated_outputs['out_denoised']))
assert_true(os.path.isfile(
mppca_flow.last_generated_outputs['out_sigma']))
denoised_path = mppca_flow.last_generated_outputs['out_denoised']
denoised_data = load_nifti_data(denoised_path)
assert_greater(denoised_data.min(), S0.min())
assert_less(denoised_data.max(), S0.max())
npt.assert_equal(np.round(denoised_data.mean()), 100)
def test_bundle_shape_analysis_flow():
with TemporaryDirectory() as dirpath:
data_path = get_fnames('fornix')
fornix = load_tractogram(data_path, 'same',
bbox_valid_check=False).streamlines
f = Streamlines(fornix)
mb = os.path.join(dirpath, "model_bundles")
sub = os.path.join(dirpath, "subjects")
os.mkdir(mb)
sft = StatefulTractogram(f, data_path, Space.RASMM)
save_tractogram(sft,
os.path.join(mb, "temp.trk"),
bbox_valid_check=False)
os.mkdir(sub)
os.mkdir(os.path.join(sub, "patient"))
os.mkdir(os.path.join(sub, "control"))
p = os.path.join(sub, "patient", "10001")
os.mkdir(p)
c = os.path.join(sub, "control", "20002")
os.mkdir(c)
for pre in [p, c]:
os.mkdir(os.path.join(pre, "rec_bundles"))
sft = StatefulTractogram(f, data_path, Space.RASMM)
save_tractogram(sft,
os.path.join(pre, "rec_bundles", "temp.trk"),
bbox_valid_check=False)
os.mkdir(os.path.join(pre, "org_bundles"))
sft = StatefulTractogram(f, data_path, Space.RASMM)
save_tractogram(sft,
os.path.join(pre, "org_bundles", "temp.trk"),
bbox_valid_check=False)
os.mkdir(os.path.join(pre, "anatomical_measures"))
fa = np.random.rand(255, 255, 255)
save_nifti(os.path.join(pre, "anatomical_measures", "fa.nii.gz"),
fa,
affine=np.eye(4))
out_dir = os.path.join(dirpath, "output")
os.mkdir(out_dir)
sm_flow = BundleShapeAnalysis()
sm_flow.run(sub, out_dir=out_dir)
assert_true(os.path.exists(os.path.join(out_dir, "temp.npy")))
def test_lpca_flow():
with TemporaryDirectory() as out_dir:
data_path, fbvals, fbvecs = get_fnames()
lpca_flow = LPCAFlow()
lpca_flow.run(data_path, fbvals, fbvecs, out_dir=out_dir)
assert_true(os.path.isfile(
lpca_flow.last_generated_outputs['out_denoised']))
def test_patch2self_flow():
with TemporaryDirectory() as out_dir:
data_path, fbvals, fbvecs = get_fnames()
patch2self_flow = Patch2SelfFlow()
patch2self_flow.run(data_path, fbvals, out_dir=out_dir)
assert_true(os.path.isfile(
patch2self_flow.last_generated_outputs['out_denoised']))
def test_recobundles_flow():
with TemporaryDirectory() as out_dir:
data_path = get_fnames('fornix')
fornix = load_tractogram(data_path, 'same',
bbox_valid_check=False).streamlines
f = Streamlines(fornix)
f1 = f.copy()
f2 = f1[:15].copy()
f2._data += np.array([40, 0, 0])
f.extend(f2)
f2_path = pjoin(out_dir, "f2.trk")
sft = StatefulTractogram(f2, data_path, Space.RASMM)
save_tractogram(sft, f2_path, bbox_valid_check=False)
f1_path = pjoin(out_dir, "f1.trk")
sft = StatefulTractogram(f, data_path, Space.RASMM)
save_tractogram(sft, f1_path, bbox_valid_check=False)
rb_flow = RecoBundlesFlow(force=True)
rb_flow.run(f1_path,
f2_path,
greater_than=0,
clust_thr=10,
model_clust_thr=5.,
reduction_thr=10,
out_dir=out_dir)
labels = rb_flow.last_generated_outputs['out_recognized_labels']
recog_trk = rb_flow.last_generated_outputs['out_recognized_transf']
rec_bundle = load_tractogram(recog_trk, 'same',
bbox_valid_check=False).streamlines
npt.assert_equal(len(rec_bundle) == len(f2), True)
label_flow = LabelsBundlesFlow(force=True)
label_flow.run(f1_path, labels)
recog_bundle = label_flow.last_generated_outputs['out_bundle']
rec_bundle_org = load_tractogram(recog_bundle,
'same',
bbox_valid_check=False).streamlines
BMD = BundleMinDistanceMetric()
nb_pts = 20
static = set_number_of_points(f2, nb_pts)
moving = set_number_of_points(rec_bundle_org, nb_pts)
BMD.setup(static, moving)
x0 = np.array([0, 0, 0, 0, 0, 0, 1., 1., 1, 0, 0, 0]) # affine
bmd_value = BMD.distance(x0.tolist())
npt.assert_equal(bmd_value < 1, True)
def test_ba():
with TemporaryDirectory() as dirpath:
data_path = get_fnames('fornix')
fornix = load_tractogram(data_path, 'same',
bbox_valid_check=False).streamlines
f = Streamlines(fornix)
mb = os.path.join(dirpath, "model_bundles")
os.mkdir(mb)
sft = StatefulTractogram(f, data_path, Space.RASMM)
save_tractogram(sft,
os.path.join(mb, "temp.trk"),
bbox_valid_check=False)
rb = os.path.join(dirpath, "rec_bundles")
os.mkdir(rb)
sft = StatefulTractogram(f, data_path, Space.RASMM)
save_tractogram(sft,
os.path.join(rb, "temp.trk"),
bbox_valid_check=False)
ob = os.path.join(dirpath, "org_bundles")
os.mkdir(ob)
sft = StatefulTractogram(f, data_path, Space.RASMM)
save_tractogram(sft,
os.path.join(ob, "temp.trk"),
bbox_valid_check=False)
dt = os.path.join(dirpath, "dti_measures")
os.mkdir(dt)
fa = np.random.rand(255, 255, 255)
save_nifti(os.path.join(dt, "fa.nii.gz"), fa, affine=np.eye(4))
out_dir = os.path.join(dirpath, "output")
os.mkdir(out_dir)
bundle_analysis(mb,
rb,
ob,
dt,
group="patient",
subject="10001",
no_disks=100,
out_dir=out_dir)
assert_true(os.path.exists(os.path.join(out_dir, 'fa.h5')))
def test_io_fetch():
fetch_flow = FetchFlow()
with TemporaryDirectory() as out_dir:
fetch_flow.run(['bundle_fa_hcp'])
npt.assert_equal(
os.path.isdir(os.path.join(dipy_home, 'bundle_fa_hcp')), True)
fetch_flow.run(['bundle_fa_hcp'], out_dir=out_dir)
npt.assert_equal(os.path.isdir(os.path.join(out_dir, 'bundle_fa_hcp')),
True)
def reconst_flow_core(flow):
with TemporaryDirectory() as out_dir:
data_path, bval_path, bvec_path = get_data('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.get_affine())
mask_path = join(out_dir, 'tmp_mask.nii.gz')
nib.save(mask_img, mask_path)
reconst_flow = flow()
reconst_flow.run(data_path,
bval_path,
bvec_path,
mask_path,
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()
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()
assert_equal(peaks_dir_data.shape[-1], 15)
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()
assert_equal(peaks_idx_data.shape[-1], 5)
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()
assert_equal(peaks_vals_data.shape[-1], 5)
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()
assert_equal(shm_data.shape[-1], 45)
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)
def reconst_mmri_core(flow, lap, pos):
with TemporaryDirectory() as out_dir:
data_path, bval_path, bvec_path = get_data('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])
def test_recobundles_flow():
with TemporaryDirectory() as out_dir:
data_path = get_fnames('fornix')
streams, hdr = nib.trackvis.read(data_path)
fornix = [s[0] for s in streams]
f = Streamlines(fornix)
f1 = f.copy()
f2 = f1[:15].copy()
f2._data += np.array([40, 0, 0])
f.extend(f2)
f2_path = pjoin(out_dir, "f2.trk")
save_trk(f2_path, f2, affine=np.eye(4))
f1_path = pjoin(out_dir, "f1.trk")
save_trk(f1_path, f, affine=np.eye(4))
rb_flow = RecoBundlesFlow(force=True)
rb_flow.run(f1_path,
f2_path,
greater_than=0,
clust_thr=10,
model_clust_thr=5.,
reduction_thr=10,
out_dir=out_dir)
labels = rb_flow.last_generated_outputs['out_recognized_labels']
recog_trk = rb_flow.last_generated_outputs['out_recognized_transf']
rec_bundle, _ = load_trk(recog_trk)
npt.assert_equal(len(rec_bundle) == len(f2), True)
label_flow = LabelsBundlesFlow(force=True)
label_flow.run(f1_path, labels)
recog_bundle = label_flow.last_generated_outputs['out_bundle']
rec_bundle_org, _ = load_trk(recog_bundle)
BMD = BundleMinDistanceMetric()
nb_pts = 20
static = set_number_of_points(f2, nb_pts)
moving = set_number_of_points(rec_bundle_org, nb_pts)
BMD.setup(static, moving)
x0 = np.array([0, 0, 0, 0, 0, 0, 1., 1., 1, 0, 0, 0]) # affine
bmd_value = BMD.distance(x0.tolist())
npt.assert_equal(bmd_value < 1, True)
def reconst_flow_core(flow, extra_args=[], extra_kwargs={}):
with TemporaryDirectory() as out_dir:
data_path, bval_path, bvec_path = get_fnames('small_25')
volume, affine = load_nifti(data_path)
mask = np.ones_like(volume[:, :, :, 0], dtype=np.uint8)
mask_path = join(out_dir, 'tmp_mask.nii.gz')
save_nifti(mask_path, mask, affine)
dti_flow = flow()
args = [data_path, bval_path, bvec_path, mask_path]
args.extend(extra_args)
kwargs = dict(out_dir=out_dir)
kwargs.update(extra_kwargs)
dti_flow.run(*args, **kwargs)
fa_path = dti_flow.last_generated_outputs['out_fa']
fa_data = load_nifti_data(fa_path)
assert_equal(fa_data.shape, volume.shape[:-1])
tensor_path = dti_flow.last_generated_outputs['out_tensor']
tensor_data = load_nifti_data(tensor_path)
# Per default, tensor data is 5D, with six tensor elements on the last
# dimension, except if nifti_tensor is set to False:
if extra_kwargs.get('nifti_tensor', True):
assert_equal(tensor_data.shape[-1], 6)
assert_equal(tensor_data.shape[:-2], volume.shape[:-1])
else:
assert_equal(tensor_data.shape[-1], 6)
assert_equal(tensor_data.shape[:-1], volume.shape[:-1])
for out_name in ['out_ga', 'out_md', 'out_ad', 'out_rd', 'out_mode']:
out_path = dti_flow.last_generated_outputs[out_name]
out_data = load_nifti_data(out_path)
assert_equal(out_data.shape, volume.shape[:-1])
rgb_path = dti_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])
evecs_path = dti_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 = dti_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])
def test_fetch_ds000030_urls(request_mocker):
with TemporaryDirectory() as tmpdir:
dataset_version = 'ds000030_R1.0.4'
subdir_names = ['ds000030', 'ds000030_R1.0.4', 'uncompressed']
tmp_list = []
for subdir in subdir_names:
tmp_list.append(subdir)
subdirpath = os.path.join(tmpdir, *tmp_list)
os.mkdir(subdirpath)
filepath = os.path.join(subdirpath, 'urls.json')
mock_json_content = ['junk1', 'junk2']
with open(filepath, 'w') as f:
json.dump(mock_json_content, f)
# fetch_ds000030_urls should retrieve the appropriate URLs
urls_path, urls = func.fetch_ds000030_urls(
data_dir=tmpdir,
verbose=1,
)
urls_path = urls_path.replace('/', os.sep)
assert urls_path == filepath
assert urls == mock_json_content
# fetch_openneuro_dataset_index should do the same, but with a warning
with pytest.warns(DeprecationWarning):
urls_path, urls = func.fetch_openneuro_dataset_index(
data_dir=tmpdir,
dataset_version=dataset_version,
verbose=1,
)
urls_path = urls_path.replace('/', os.sep)
assert urls_path == filepath
assert urls == mock_json_content
# fetch_openneuro_dataset_index should even grab ds000030 when you
# provide a different dataset name
with pytest.warns(
UserWarning,
match='"ds000030_R1.0.4" will be downloaded',
):
urls_path, urls = func.fetch_openneuro_dataset_index(
data_dir=tmpdir,
dataset_version='ds500_v2',
verbose=1,
)
urls_path = urls_path.replace('/', os.sep)
assert urls_path == filepath
assert urls == mock_json_content
def reconst_mmri_core(flow, extra_args=[]):
with TemporaryDirectory() as out_dir:
data_path, bval_path, bvec_path = get_data('small_25')
vol_img = nib.load(data_path)
vol_img.get_data()
# mask = np.ones_like(volume[:, :, :, 0])
# mask_img = nib.Nifti1Image(mask.astype(np.uint8), vol_img.affine)
# mask_path = join(out_dir, 'tmp_mask.nii.gz')
# nib.save(mask_img, mask_path)
mmri_flow = flow()
args = [data_path, bval_path, bvec_path]
mmri_flow.run(*args, out_dir=out_dir)
def test_mask():
with TemporaryDirectory() as out_dir:
data_path, _, _ = get_fnames('small_25')
volume, affine = load_nifti(data_path)
mask_flow = MaskFlow()
mask_flow.run(data_path, 10, out_dir=out_dir, ub=9)
assert_false(mask_flow.last_generated_outputs)
mask_flow.run(data_path, 10, out_dir=out_dir)
mask_path = mask_flow.last_generated_outputs['out_mask']
mask_data, mask_affine = load_nifti(mask_path)
npt.assert_equal(mask_data.shape, volume.shape)
npt.assert_array_almost_equal(mask_affine, affine)
def test_split_flow():
with TemporaryDirectory() as out_dir:
split_flow = SplitFlow()
data_path, _, _ = get_fnames()
volume, affine = load_nifti(data_path)
split_flow.run(data_path, out_dir=out_dir)
assert_true(
os.path.isfile(split_flow.last_generated_outputs['out_split']))
split_flow._force_overwrite = True
split_flow.run(data_path, vol_idx=0, out_dir=out_dir)
split_path = split_flow.last_generated_outputs['out_split']
assert_true(os.path.isfile(split_path))
split_data, split_affine = load_nifti(split_path)
npt.assert_equal(split_data.shape, volume[..., 0].shape)
npt.assert_array_almost_equal(split_affine, affine)
def test_reslice():
with TemporaryDirectory() as out_dir:
data_path, _, _ = get_fnames('small_25')
volume = load_nifti_data(data_path)
reslice_flow = ResliceFlow()
reslice_flow.run(data_path, [1.5, 1.5, 1.5], out_dir=out_dir)
out_path = reslice_flow.last_generated_outputs['out_resliced']
resliced = load_nifti_data(out_path)
npt.assert_equal(resliced.shape[0] > volume.shape[0], True)
npt.assert_equal(resliced.shape[1] > volume.shape[1], True)
npt.assert_equal(resliced.shape[2] > volume.shape[2], True)
npt.assert_equal(resliced.shape[-1], volume.shape[-1])
def test_stats():
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 = join(out_dir, 'tmp_mask.nii.gz')
nib.save(mask_img, mask_path)
snr_flow = SNRinCCFlow(force=True)
args = [data_path, bval_path, bvec_path, mask_path]
snr_flow.run(*args, out_dir=out_dir)
assert_true(os.path.exists(os.path.join(out_dir, 'product.json')))
assert_true(
os.stat(os.path.join(out_dir, 'product.json')).st_size != 0)
assert_true(os.path.exists(os.path.join(out_dir, 'cc.nii.gz')))
assert_true(os.stat(os.path.join(out_dir, 'cc.nii.gz')).st_size != 0)
assert_true(os.path.exists(os.path.join(out_dir, 'mask_noise.nii.gz')))
assert_true(
os.stat(os.path.join(out_dir, 'mask_noise.nii.gz')).st_size != 0)
snr_flow._force_overwrite = True
snr_flow.run(*args, out_dir=out_dir)
assert_true(os.path.exists(os.path.join(out_dir, 'product.json')))
assert_true(
os.stat(os.path.join(out_dir, 'product.json')).st_size != 0)
assert_true(os.path.exists(os.path.join(out_dir, 'cc.nii.gz')))
assert_true(os.stat(os.path.join(out_dir, 'cc.nii.gz')).st_size != 0)
assert_true(os.path.exists(os.path.join(out_dir, 'mask_noise.nii.gz')))
assert_true(
os.stat(os.path.join(out_dir, 'mask_noise.nii.gz')).st_size != 0)
snr_flow._force_overwrite = True
snr_flow.run(*args,
bbox_threshold=(0.5, 1, 0, 0.15, 0, 0.2),
out_dir=out_dir)
assert_true(os.path.exists(os.path.join(out_dir, 'product.json')))
assert_true(
os.stat(os.path.join(out_dir, 'product.json')).st_size != 0)
assert_true(os.path.exists(os.path.join(out_dir, 'cc.nii.gz')))
assert_true(os.stat(os.path.join(out_dir, 'cc.nii.gz')).st_size != 0)
assert_true(os.path.exists(os.path.join(out_dir, 'mask_noise.nii.gz')))
assert_true(
os.stat(os.path.join(out_dir, 'mask_noise.nii.gz')).st_size != 0)
def test_ba():
with TemporaryDirectory() as dirpath:
streams, hdr = nib.trackvis.read(get_fnames('fornix'))
fornix = [s[0] for s in streams]
f = Streamlines(fornix)
mb = os.path.join(dirpath, "model_bundles")
os.mkdir(mb)
save_trk(os.path.join(mb, "temp.trk"), f, affine=np.eye(4))
rb = os.path.join(dirpath, "rec_bundles")
os.mkdir(rb)
save_trk(os.path.join(rb, "temp.trk"), f, affine=np.eye(4))
ob = os.path.join(dirpath, "org_bundles")
os.mkdir(ob)
save_trk(os.path.join(ob, "temp.trk"), f, affine=np.eye(4))
dt = os.path.join(dirpath, "dti_measures")
os.mkdir(dt)
fa = np.random.rand(255, 255, 255)
save_nifti(os.path.join(dt, "fa.nii.gz"), fa, affine=np.eye(4))
out_dir = os.path.join(dirpath, "output")
os.mkdir(out_dir)
bundle_analysis(mb,
rb,
ob,
dt,
group="patient",
subject="10001",
no_disks=100,
out_dir=out_dir)
assert_true(os.path.exists(os.path.join(out_dir, 'fa.h5')))
def test_nlmeans_flow():
with TemporaryDirectory() as out_dir:
data_path, _, _ = get_fnames()
volume, affine = load_nifti(data_path)
nlmeans_flow = NLMeansFlow()
nlmeans_flow.run(data_path, out_dir=out_dir)
assert_true(os.path.isfile(
nlmeans_flow.last_generated_outputs['out_denoised']))
nlmeans_flow._force_overwrite = True
nlmeans_flow.run(data_path, sigma=4, out_dir=out_dir)
denoised_path = nlmeans_flow.last_generated_outputs['out_denoised']
assert_true(os.path.isfile(denoised_path))
denoised_data, denoised_affine = load_nifti(denoised_path)
npt.assert_equal(denoised_data.shape, volume.shape)
npt.assert_array_almost_equal(denoised_affine, affine)
def test_mask():
with TemporaryDirectory() as out_dir:
data_path, _, _ = get_data('small_25')
vol_img = nib.load(data_path)
volume = vol_img.get_data()
mask_flow = MaskFlow()
mask_flow.run(data_path, 10, out_dir=out_dir, ub=9)
assert_false(mask_flow.last_generated_outputs)
mask_flow.run(data_path, 10, out_dir=out_dir)
mask_path = mask_flow.last_generated_outputs['out_mask']
mask_img = nib.load(mask_path)
mask_data = mask_img.get_data()
assert_true(mask_data.shape == volume.shape)
nt.assert_array_almost_equal(mask_img.affine, vol_img.affine)
assert_true(mask_data.dtype == np.uint8)
