def test_pscalar(): scalar_map = create_scalar_map((0, )) parcel_map = create_parcel_map((1, )) matrix = ci.Cifti2Matrix() matrix.append(scalar_map) matrix.append(parcel_map) hdr = ci.Cifti2Header(matrix) data = np.random.randn(2, 3) img = ci.Cifti2Image(data, hdr) img.nifti_header.set_intent('NIFTI_INTENT_CONNECTIVITY_PARCELLATED_SCALAR') with InTemporaryDirectory(): ci.save(img, 'test.pscalar.nii') img2 = nib.load('test.pscalar.nii') assert_equal(img2.nifti_header.get_intent()[0], 'ConnParcelScalr') assert_true(isinstance(img2, ci.Cifti2Image)) assert_true((img2.get_data() == data).all()) check_scalar_map(img2.header.matrix.get_index_map(0)) check_parcel_map(img2.header.matrix.get_index_map(1)) del img2
def test_dlabel(): label_map = create_label_map((0, )) geometry_map = create_geometry_map((1, )) matrix = ci.Cifti2Matrix() matrix.append(label_map) matrix.append(geometry_map) hdr = ci.Cifti2Header(matrix) data = np.random.randn(2, 9) img = ci.Cifti2Image(data, hdr) img.nifti_header.set_intent('NIFTI_INTENT_CONNECTIVITY_DENSE_LABELS') with InTemporaryDirectory(): ci.save(img, 'test.dlabel.nii') img2 = nib.load('test.dlabel.nii') assert_equal(img2.nifti_header.get_intent()[0], 'ConnDenseLabel') assert_true(isinstance(img2, ci.Cifti2Image)) assert_true((img2.get_data() == data).all()) check_label_map(img2.header.matrix.get_index_map(0)) check_geometry_map(img2.header.matrix.get_index_map(1)) del img2
def test_dpy(): fname = 'test.bin' with InTemporaryDirectory(): dpw = Dpy(fname, 'w') A=np.ones((5,3)) B=2*A.copy() C=3*A.copy() dpw.write_track(A) dpw.write_track(B) dpw.write_track(C) dpw.write_tracks([C,B,A]) dpw.close() dpr = Dpy(fname, 'r') assert_equal(dpr.version()=='0.0.1',True) T=dpr.read_tracksi([0,1,2,0,0,2]) T2=dpr.read_tracks() assert_equal(len(T2),6) dpr.close() assert_array_equal(A,T[0]) assert_array_equal(C,T[5])
def test_high_level_glm_with_paths(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1), ) mask, FUNCFILE, _ = write_fake_fmri_data_and_design(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # Ordinary Least Squares case model = SecondLevelModel(mask_img=mask) # asking for contrast before model fit gives error with pytest.raises(ValueError): model.compute_contrast([]) # fit model Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) model = model.fit(Y, design_matrix=X) c1 = np.eye(len(model.design_matrix_.columns))[0] z_image = model.compute_contrast(c1, output_type='z_score') assert isinstance(z_image, Nifti1Image) assert_array_equal(z_image.affine, load(mask).affine) # Provide a masker as mask_img masker = NiftiMasker(mask) with pytest.warns(UserWarning, match="Parameter memory of the masker overridden"): SecondLevelModel(mask_img=masker, verbose=1).fit(Y, design_matrix=X) # try with target_shape target_shape = (10, 10, 10) target_affine = np.eye(4) target_affine[0, 3] = 1 model = SecondLevelModel(mask_img=mask, target_shape=target_shape, target_affine=target_affine) z_image = model.fit(Y, design_matrix=X).compute_contrast(c1) assert_array_equal(z_image.shape, target_shape) assert_array_equal(z_image.affine, target_affine) # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del Y, FUNCFILE, func_img, model
def test_high_level_glm_with_data(): with InTemporaryDirectory(): shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 16)), 3 mask, fmri_data, design_matrices = write_fake_fmri_data_and_design( shapes, rk) multi_session_model = FirstLevelModel(mask_img=None).fit( fmri_data, design_matrices=design_matrices) n_voxels = get_data(multi_session_model.masker_.mask_img_).sum() z_image = multi_session_model.compute_contrast(np.eye(rk)[1]) assert np.sum(get_data(z_image) != 0) == n_voxels assert get_data(z_image).std() < 3. # with mask multi_session_model = FirstLevelModel(mask_img=mask).fit( fmri_data, design_matrices=design_matrices) z_image = multi_session_model.compute_contrast(np.eye(rk)[:2], output_type='z_score') p_value = multi_session_model.compute_contrast(np.eye(rk)[:2], output_type='p_value') stat_image = multi_session_model.compute_contrast(np.eye(rk)[:2], output_type='stat') effect_image = multi_session_model.compute_contrast( np.eye(rk)[:2], output_type='effect_size') variance_image = multi_session_model.compute_contrast( np.eye(rk)[:2], output_type='effect_variance') assert_array_equal(get_data(z_image) == 0., get_data(load(mask)) == 0.) assert (get_data(variance_image)[get_data(load(mask)) > 0] > .001).all() all_images = multi_session_model.compute_contrast(np.eye(rk)[:2], output_type='all') assert_array_equal(get_data(all_images['z_score']), get_data(z_image)) assert_array_equal(get_data(all_images['p_value']), get_data(p_value)) assert_array_equal(get_data(all_images['stat']), get_data(stat_image)) assert_array_equal(get_data(all_images['effect_size']), get_data(effect_image)) assert_array_equal(get_data(all_images['effect_variance']), get_data(variance_image)) # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del (all_images, design_matrices, effect_image, fmri_data, mask, multi_session_model, n_voxels, p_value, rk, shapes, stat_image, variance_image, z_image)
def test_create_second_level_design(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1),) mask, FUNCFILE, _ = write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] first_level_input = _first_level_dataframe() first_level_input['effects_map_path'] = [FUNCFILE] * 4 confounds = [['01', 0.1], ['02', 0.75]] confounds = pd.DataFrame(confounds, columns=['subject_id', 'f1']) design = create_second_level_design(first_level_input, confounds) expected_design = np.array([[1, 0, 1, 0, 0.1], [0, 1, 1, 0, 0.1], [1, 0, 0, 1, 0.75], [0, 1, 0, 1, 0.75]]) assert_array_equal(design, expected_design) assert_true(len(design.columns) == 2 + 2 + 1) assert_true(len(design) == 2 + 2) model = SecondLevelModel(mask=mask).fit(first_level_input, confounds=confounds) design = model.design_matrix_ assert_array_equal(design, expected_design) assert_true(len(design.columns) == 2 + 2 + 1) assert_true(len(design) == 2 + 2)
def test_parcel_based_analysis(): # Generate an image shape = (7, 8, 4) n_subj = 5 n_parcel, nn, mu = 10, 6, 1. with InTemporaryDirectory() as dir_context: data_image = ['image_%d.nii' % i for i in range(5)] for datim in data_image: surrogate_3d_dataset(shape=shape, out_image_file=datim) ldata = np.random.randn(n_subj, np.prod(shape), 1) domain = grid_domain_from_shape(shape) parcels = hparcel(domain, ldata, n_parcel, mu=3.0) prfx = parcellation_based_analysis(parcels, data_image, test_id='one_sample', rfx_path='prfx.nii', condition_id='', swd=dir_context) assert exists('prfx.nii') assert np.abs(prfx).max() < 15
def test_pconnscalar(): parcel_map = create_parcel_map((0, 1)) scalar_map = create_scalar_map((2, )) matrix = ci.Cifti2Matrix() matrix.append(parcel_map) matrix.append(scalar_map) hdr = ci.Cifti2Header(matrix) data = np.random.randn(3, 3, 13) img = ci.Cifti2Image(data, hdr) with InTemporaryDirectory(): ci.save(img, 'test.pconnscalar.nii') img2 = ci.load('test.pconnscalar.nii') assert_true((img2.get_data() == data).all()) assert_equal(img2.header.matrix.get_index_map(0), img2.header.matrix.get_index_map(1)) check_parcel_map(img2.header.matrix.get_index_map(0)) check_scalar_map(img2.header.matrix.get_index_map(2)) del img2
def test_high_level_glm_with_paths(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1), ) mask, FUNCFILE, _ = _write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # Ordinary Least Squares case model = SecondLevelModel(mask_img=mask) # asking for contrast before model fit gives error assert_raises(ValueError, model.compute_contrast, []) # fit model Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) model = model.fit(Y, design_matrix=X) c1 = np.eye(len(model.design_matrix_.columns))[0] z_image = model.compute_contrast(c1, output_type='z_score') assert_true(isinstance(z_image, Nifti1Image)) assert_array_equal(z_image.affine, load(mask).affine) # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del Y, FUNCFILE, func_img, model
def test_io_save_peaks_error(): with InTemporaryDirectory(): fname = 'test.pam5' pam = PeaksAndMetrics() npt.assert_raises(IOError, save_peaks, 'test.pam', pam) npt.assert_raises(ValueError, save_peaks, fname, pam) pam.affine = np.eye(4) pam.peak_dirs = np.random.rand(10, 10, 10, 5, 3) pam.peak_values = np.zeros((10, 10, 10, 5)) pam.peak_indices = np.zeros((10, 10, 10, 5)) pam.shm_coeff = np.zeros((10, 10, 10, 45)) pam.sphere = default_sphere pam.B = np.zeros((45, default_sphere.vertices.shape[0])) pam.total_weight = 0.5 pam.ang_thr = 60 pam.gfa = np.zeros((10, 10, 10)) pam.qa = np.zeros((10, 10, 10, 5)) pam.odf = np.zeros((10, 10, 10, default_sphere.vertices.shape[0]))
def test_trackvis(): with InTemporaryDirectory(): fname = 'trackvis_test.trk' affine = np.eye(4) # Test save trackvis_save_trk(fname, streamlines, affine, np.array([50, 50, 50])) tfile = nib.streamlines.load(fname) npt.assert_array_equal(affine, tfile.affine) npt.assert_array_equal(np.array([1., 1., 1.]), tfile.header.get('voxel_sizes')) npt.assert_array_equal(np.array([50, 50, 50]), tfile.header.get('dimensions')) npt.assert_equal(len(tfile.streamlines), len(streamlines)) npt.assert_array_almost_equal(tfile.streamlines[1], streamline, decimal=4) # Test Deprecations npt.assert_warns(DeprecationWarning, trackvis_save_trk, fname, streamlines, affine, np.array([50, 50, 50]))
def test_second_level_model_contrast_computation_with_memory_caching(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1), ) mask, FUNCFILE, _ = _write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # Ordinary Least Squares case model = SecondLevelModel(mask_img=mask, memory='nilearn_cache') # fit model Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) model = model.fit(Y, design_matrix=X) ncol = len(model.design_matrix_.columns) c1 = np.eye(ncol)[0, :] # test memory caching for compute_contrast model.compute_contrast(c1, output_type='z_score') # or simply pass nothing model.compute_contrast() # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del func_img, FUNCFILE, model, X, Y
def test_csv_io(): # test the csv io on design matrices tr = 1.0 frame_times = np.linspace(0, 127 * tr, 128) events = modulated_event_paradigm() DM = make_first_level_design_matrix( frame_times, events, hrf_model='glover', drift_model='polynomial', drift_order=3, ) path = 'design_matrix.csv' with InTemporaryDirectory(): DM.to_csv(path) DM2 = pd.read_csv(path, index_col=0) _, matrix, names = check_design_matrix(DM) _, matrix_, names_ = check_design_matrix(DM2) assert_almost_equal(matrix, matrix_) assert names == names_
def test_fmri_inputs(): # Test processing of FMRI inputs with InTemporaryDirectory(): shapes = ((7, 8, 9, 10), ) mask, FUNCFILE, _ = write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) T = func_img.shape[-1] conf = pd.DataFrame([0, 0]) des = pd.DataFrame(np.ones((T, 1)), columns=['']) des_fname = 'design.csv' des.to_csv(des_fname) for fi in func_img, FUNCFILE: for d in des, des_fname: FirstLevelModel().fit(fi, design_matrices=d) FirstLevelModel(mask=None).fit([fi], design_matrices=d) FirstLevelModel(mask=mask).fit(fi, design_matrices=[d]) FirstLevelModel(mask=mask).fit([fi], design_matrices=[d]) FirstLevelModel(mask=mask).fit([fi, fi], design_matrices=[d, d]) FirstLevelModel(mask=None).fit((fi, fi), design_matrices=(d, d)) assert_raises(ValueError, FirstLevelModel(mask=None).fit, [fi, fi], d) assert_raises(ValueError, FirstLevelModel(mask=None).fit, fi, [d, d]) # At least paradigms or design have to be given assert_raises(ValueError, FirstLevelModel(mask=None).fit, fi) # If paradigms are given then both tr and slice time ref were # required assert_raises(ValueError, FirstLevelModel(mask=None).fit, fi, d) assert_raises(ValueError, FirstLevelModel(mask=None, t_r=1.0).fit, fi, d) assert_raises( ValueError, FirstLevelModel(mask=None, slice_time_ref=0.).fit, fi, d) # confounds rows do not match n_scans assert_raises(ValueError, FirstLevelModel(mask=None).fit, fi, d, conf)
def test_non_parametric_inference_contrast_computation(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1),) mask, FUNCFILE, _ = write_fake_fmri_data_and_design(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # asking for contrast before model fit gives error with pytest.raises(ValueError): non_parametric_inference(None, None, None, 'intercept', mask) # fit model Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) # formula should work without second-level contrast neg_log_pvals_img = non_parametric_inference(Y, design_matrix=X, mask=mask, n_perm=100) ncol = len(X.columns) c1, cnull = np.eye(ncol)[0, :], np.zeros(ncol) # formula should work with second-level contrast neg_log_pvals_img = non_parametric_inference(Y, design_matrix=X, second_level_contrast=c1, mask=mask, n_perm=100) # formula should work passing variable name directly neg_log_pvals_img = \ non_parametric_inference(Y, design_matrix=X, second_level_contrast='intercept', mask=mask, n_perm=100) # passing null contrast should give back a value error with pytest.raises(ValueError): non_parametric_inference(Y, X, cnull, 'intercept', mask) # passing wrong parameters with pytest.raises(ValueError): non_parametric_inference(Y, X, [], 'intercept', mask) # check that passing no explicit contrast when the design # matrix has more than one columns raises an error X = pd.DataFrame(np.random.rand(4, 2), columns=['r1', 'r2']) with pytest.raises(ValueError): non_parametric_inference(Y, X, None) del func_img, FUNCFILE, neg_log_pvals_img, X, Y
def test_high_level_glm_with_data(): # New API with InTemporaryDirectory(): shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 16)), 3 mask, fmri_data, design_matrices = write_fake_fmri_data(shapes, rk) multi_session_model = FirstLevelModel(mask=None).fit( fmri_data, design_matrices=design_matrices) n_voxels = multi_session_model.masker_.mask_img_.get_data().sum() z_image = multi_session_model.compute_contrast(np.eye(rk)[1]) assert_equal(np.sum(z_image.get_data() != 0), n_voxels) assert_true(z_image.get_data().std() < 3.) # with mask multi_session_model = FirstLevelModel(mask=mask).fit( fmri_data, design_matrices=design_matrices) z_image = multi_session_model.compute_contrast(np.eye(rk)[:2], output_type='z_score') p_value = multi_session_model.compute_contrast(np.eye(rk)[:2], output_type='p_value') stat_image = multi_session_model.compute_contrast(np.eye(rk)[:2], output_type='stat') effect_image = multi_session_model.compute_contrast( np.eye(rk)[:2], output_type='effect_size') variance_image = multi_session_model.compute_contrast( np.eye(rk)[:2], output_type='effect_variance') assert_array_equal(z_image.get_data() == 0., load(mask).get_data() == 0.) assert_true((variance_image.get_data()[load(mask).get_data() > 0] > .001).all()) all_images = multi_session_model.compute_contrast(np.eye(rk)[:2], output_type='all') assert_array_equal(all_images['z_score'].get_data(), z_image.get_data()) assert_array_equal(all_images['p_value'].get_data(), p_value.get_data()) assert_array_equal(all_images['stat'].get_data(), stat_image.get_data()) assert_array_equal(all_images['effect_size'].get_data(), effect_image.get_data()) assert_array_equal(all_images['effect_variance'].get_data(), variance_image.get_data())
def record_events(self): """ Records events during the interaction. The recording is represented as a list of VTK events that happened during the interaction. The recorded events are then returned. Returns ------- events : str Recorded events (one per line). Notes ----- Since VTK only allows recording events to a file, we use a temporary file from which we then read the events. """ with InTemporaryDirectory(): filename = "recorded_events.log" recorder = vtk.vtkInteractorEventRecorder() recorder.SetInteractor(self.iren) recorder.SetFileName(filename) def _stop_recording_and_close(obj, evt): recorder.Stop() self.iren.TerminateApp() self.iren.AddObserver("ExitEvent", _stop_recording_and_close) recorder.EnabledOn() recorder.Record() self.initialize() self.render() self.iren.Start() # Retrieved recorded events. events = open(filename).read() return events
def test_first_level_model_glm_computation(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 10), ) mask, FUNCFILE, _ = write_fake_fmri_data_and_design(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # basic test based on basic_paradigm and glover hrf t_r = 10.0 slice_time_ref = 0. events = basic_paradigm() # Ordinary Least Squares case model = FirstLevelModel(t_r, slice_time_ref, mask_img=mask, drift_model='polynomial', drift_order=3, minimize_memory=False) model = model.fit(func_img, events) # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del mask, FUNCFILE, func_img, model
def test_img_data_dtype(): # Ignoring complex, binary, 128+ bit, RGBA nifti1_dtypes = (np.uint8, np.uint16, np.uint32, np.uint64, np.int8, np.int16, np.int32, np.int64, np.float32, np.float64) dtype_matches = [] with InTemporaryDirectory(): for logical_dtype in nifti1_dtypes: dataobj = np.random.uniform(0, 255, size=(2, 2, 2)).astype(logical_dtype) for on_disk_dtype in nifti1_dtypes: img = Nifti1Image(dataobj, np.eye(4)) img.set_data_dtype(on_disk_dtype) img.to_filename('test.nii') loaded = nb.load('test.nii') # To verify later that sometimes these differ meaningfully dtype_matches.append( loaded.get_data_dtype() == niimg.img_data_dtype(loaded)) assert (np.array( loaded.dataobj).dtype == niimg.img_data_dtype(loaded)) # Verify that the distinction is worth making assert any(dtype_matches) assert not all(dtype_matches)
def test_nibabel_readwritedata(): with InTemporaryDirectory(): for name in datafiles: img = nib.load(name) nib.save(img, 'test.nii') img2 = nib.load('test.nii') assert len(img.header.matrix) == len(img2.header.matrix) # Order should be preserved in load/save for mim1, mim2 in zip(img.header.matrix, img2.header.matrix): named_maps1 = [m_ for m_ in mim1 if isinstance(m_, ci.Cifti2NamedMap)] named_maps2 = [m_ for m_ in mim2 if isinstance(m_, ci.Cifti2NamedMap)] assert len(named_maps1) == len(named_maps2) for map1, map2 in zip(named_maps1, named_maps2): assert map1.map_name == map2.map_name if map1.label_table is None: assert map2.label_table is None else: assert len(map1.label_table) == len(map2.label_table) assert_array_almost_equal(img.dataobj, img2.dataobj)
def test_slm_reporting(use_method): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1), ) mask, FUNCFILE, _ = write_fake_fmri_data_and_design(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) model = SecondLevelModel() Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) model = model.fit(Y, design_matrix=X) c1 = np.eye(len(model.design_matrix_.columns))[0] if use_method: report_slm = glmr.make_glm_report(model, c1) else: report_slm = model.generate_report(c1) # catches & raises UnicodeEncodeError in HTMLDocument.get_iframe() report_iframe = report_slm.get_iframe() # So flake8 doesn't complain about not using variable (F841) report_iframe # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del Y, FUNCFILE, func_img, model
def test_first_level_model_glm_computation(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 10), ) mask, FUNCFILE, _ = write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # basic test based on basic_paradigm and glover hrf t_r = 1.0 slice_time_ref = 0. paradigm = basic_paradigm() # ols case model = FirstLevelModel(t_r, slice_time_ref, mask=mask, drift_model='polynomial', drift_order=3, minimize_memory=False) model = model.fit(func_img, paradigm) labels1 = model.labels_[0] results1 = model.results_[0] labels2, results2 = run_glm(model.masker_.transform(func_img), model.design_matrices_[0], 'ar1')
def test_second_level_model_contrast_computation(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1), ) mask, FUNCFILE, _ = write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # Ordinary Least Squares case model = SecondLevelModel(mask=mask) # asking for contrast before model fit gives error assert_raises(ValueError, model.compute_contrast, 'intercept') # fit model Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) model = model.fit(Y, design_matrix=X) ncol = len(model.design_matrix_.columns) c1, cnull = np.eye(ncol)[0, :], np.zeros(ncol) # smoke test for different contrasts in fixed effects model.compute_contrast(c1) model.compute_contrast(c1, output_type='z_score') model.compute_contrast(c1, output_type='stat') model.compute_contrast(c1, output_type='p_value') model.compute_contrast(c1, output_type='effect_size') model.compute_contrast(c1, output_type='effect_variance') # formula should work (passing variable name directly) model.compute_contrast('intercept') # or simply pass nothing model.compute_contrast() # passing null contrast should give back a value error assert_raises(ValueError, model.compute_contrast, cnull) # passing wrong parameters assert_raises(ValueError, model.compute_contrast, []) assert_raises(ValueError, model.compute_contrast, c1, None, '') assert_raises(ValueError, model.compute_contrast, c1, None, []) assert_raises(ValueError, model.compute_contrast, c1, None, None, '') # check that passing no explicit contrast when the dsign # matrix has morr than one columns raises an error X = pd.DataFrame(np.random.rand(4, 2), columns=['r1', 'r2']) model = model.fit(Y, design_matrix=X) assert_raises(ValueError, model.compute_contrast, None)
def test_save2b(): # A test to ensure that when a file is saved, the affine and the # data agree. This image comes from a NIFTI file. This example has a # non-diagonal affine matrix for the spatial part, but is 'diagonal' for the # space part. # # make a 5x5 transformation (for 4d image) step = np.array([3.45, 2.3, 4.5, 6.9]) A = np.random.standard_normal((3, 3)) B = np.diag(list(step) + [1]) B[:3, :3] = A shape = (13, 5, 7, 3) cmap = api.vox2mni(B) data = np.random.standard_normal(shape) img = api.Image(data, cmap) with InTemporaryDirectory(): save_image(img, TMP_FNAME) img2 = load_image(TMP_FNAME) assert_array_almost_equal(img.affine, img2.affine) assert_equal(img.shape, img2.shape) assert_array_almost_equal(img2.get_data(), img.get_data()) del img2
def test_flm_reporting(use_method): with InTemporaryDirectory(): shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 16)), 3 mask, fmri_data, design_matrices = write_fake_fmri_data_and_design( shapes, rk) flm = FirstLevelModel(mask_img=mask).fit( fmri_data, design_matrices=design_matrices) contrast = np.eye(3)[1] if use_method: report_flm = flm.generate_report(contrast, plot_type='glass', height_control=None, min_distance=15, alpha=0.001, threshold=2.78) else: report_flm = glmr.make_glm_report( flm, contrast, plot_type='glass', height_control=None, min_distance=15, alpha=0.001, threshold=2.78, ) ''' catches & raises UnicodeEncodeError in HTMLDocument.get_iframe() Python2's limited unicode support causes HTMLDocument.get_iframe() to mishandle certain unicode characters, like the greek alpha symbol and raises this error. Calling HTMLDocument.get_iframe() here causes the tests to fail on Python2, alerting us if such a situation arises due to future modifications. ''' report_iframe = report_flm.get_iframe() # So flake8 doesn't complain about not using variable (F841) report_iframe del mask, flm, fmri_data
def test_write_screen_res(): img = ni.load_image(funcfile) with InTemporaryDirectory(): res = screen(img) os.mkdir('myresults') write_screen_res(res, 'myresults', 'myana') pca_img = ni.load_image(pjoin('myresults', 'pca_myana.nii')) assert_equal(pca_img.shape, img.shape[:-1] + (10,)) # Make sure we get the same output image even from rolled image # Do fancy roll to put time axis first, and slice axis last. This does # a stress test on the axis ordering, but also makes sure that we are # getting the number of components from the right place. If we were # getting the number of components from the length of the last axis, # instead of the length of the 't' axis in the returned pca image, this # would be wrong (=21) which would also be more than the number of # basis vectors (19) so raise an error rimg = img.reordered_axes([3, 2, 0, 1]) os.mkdir('rmyresults') rres = screen(rimg) write_screen_res(rres, 'rmyresults', 'myana') rpca_img = ni.load_image(pjoin('rmyresults', 'pca_myana.nii')) assert_equal(rpca_img.shape, img.shape[:-1] + (10,)) del pca_img, rpca_img
def test_second_level_model_glm_computation(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 1), ) mask, FUNCFILE, _ = _write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # Ordinary Least Squares case model = SecondLevelModel(mask_img=mask) Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) model = model.fit(Y, design_matrix=X) model.compute_contrast() labels1 = model.labels_ results1 = model.results_ labels2, results2 = run_glm(model.masker_.transform(Y), X.values, 'ols') assert_almost_equal(labels1, labels2, decimal=1) assert_equal(len(results1), len(results2)) # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del func_img, FUNCFILE, model, X, Y
def test_first_level_glm_computation_with_memory_caching(): with InTemporaryDirectory(): shapes = ((7, 8, 9, 10), ) mask, FUNCFILE, _ = _write_fake_fmri_data(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) # initialize FirstLevelModel with memory option enabled t_r = 10.0 slice_time_ref = 0. events = basic_paradigm() # Ordinary Least Squares case model = FirstLevelModel(t_r, slice_time_ref, mask_img=mask, drift_model='polynomial', drift_order=3, memory='nilearn_cache', memory_level=1, minimize_memory=False) model.fit(func_img, events) # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del mask, func_img, FUNCFILE, model
def test_high_level_non_parametric_inference_with_paths(): with InTemporaryDirectory(): n_perm = 100 shapes = ((7, 8, 9, 1),) mask, FUNCFILE, _ = write_fake_fmri_data_and_design(shapes) FUNCFILE = FUNCFILE[0] func_img = load(FUNCFILE) Y = [func_img] * 4 X = pd.DataFrame([[1]] * 4, columns=['intercept']) c1 = np.eye(len(X.columns))[0] neg_log_pvals_img = non_parametric_inference(Y, design_matrix=X, second_level_contrast=c1, mask=mask, n_perm=n_perm) neg_log_pvals = get_data(neg_log_pvals_img) assert isinstance(neg_log_pvals_img, Nifti1Image) assert_array_equal(neg_log_pvals_img.affine, load(mask).affine) assert np.all(neg_log_pvals <= - np.log10(1.0 / (n_perm + 1))) assert np.all(0 <= neg_log_pvals) # Delete objects attached to files to avoid WindowsError when deleting # temporary directory del X, Y, FUNCFILE, func_img, neg_log_pvals_img
def test_qb_commandline_output_path_handling(): with InTemporaryDirectory(): # Create temporary subdirectory for input and for output os.mkdir('work') os.mkdir('output') os.chdir('work') tracks_file = get_data('fornix') # Need to specify an output directory with a "../" style path # to trigger old bug. cmd = [ "dipy_quickbundles", tracks_file, '--pkl_file', 'mypickle.pkl', '--out_file', os.path.join('..', 'output', 'tracks300.trk') ] out = run_command(cmd) assert_equal(out[0], 0) # Make sure the files were created in the output directory os.chdir('../') output_files_list = glob.glob('output/tracks300_*.trk') assert_true(output_files_list)