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)