def test_compute_epi_mask(): mean_image = np.ones((9, 9, 3)) mean_image[3:-2, 3:-2, :] = 10 mean_image[5, 5, :] = 11 mean_image = Nifti1Image(mean_image, np.eye(4)) mask1 = compute_epi_mask(mean_image, opening=False) mask2 = compute_epi_mask(mean_image, exclude_zeros=True, opening=False) # With an array with no zeros, exclude_zeros should not make # any difference np.testing.assert_array_equal(get_data(mask1), get_data(mask2)) # Check that padding with zeros does not change the extracted mask mean_image2 = np.zeros((30, 30, 3)) mean_image2[3:12, 3:12, :] = get_data(mean_image) mean_image2 = Nifti1Image(mean_image2, np.eye(4)) mask3 = compute_epi_mask(mean_image2, exclude_zeros=True, opening=False) np.testing.assert_array_equal(get_data(mask1), get_data(mask3)[3:12, 3:12]) # However, without exclude_zeros, it does mask3 = compute_epi_mask(mean_image2, opening=False) assert not np.allclose(get_data(mask1), get_data(mask3)[3:12, 3:12]) # Check that we get a ValueError for incorrect shape mean_image = np.ones((9, 9)) mean_image[3:-3, 3:-3] = 10 mean_image[5, 5] = 100 mean_image = Nifti1Image(mean_image, np.eye(4)) pytest.raises(ValueError, compute_epi_mask, mean_image) # Check that we get a useful warning for empty masks mean_image = np.zeros((9, 9, 9)) mean_image[0, 0, 1] = -1 mean_image[0, 0, 0] = 1.2 mean_image[0, 0, 2] = 1.1 mean_image = Nifti1Image(mean_image, np.eye(4)) with pytest.warns(MaskWarning, match='Computed an empty mask'): compute_epi_mask(mean_image, exclude_zeros=True)
def test_dict_learning(): data, mask_img, components, rng = _make_canica_test_data(n_subjects=8) masker = NiftiMasker(mask_img=mask_img).fit() mask = get_data(mask_img) != 0 flat_mask = mask.ravel() dict_init = masker.inverse_transform(components[:, flat_mask]) dict_learning = DictLearning(n_components=4, random_state=0, dict_init=dict_init, mask=mask_img, smoothing_fwhm=0., alpha=1) dict_learning_auto_init = DictLearning(n_components=4, random_state=0, mask=mask_img, smoothing_fwhm=0., n_epochs=10, alpha=1) maps = {} for estimator in [dict_learning, dict_learning_auto_init]: estimator.fit(data) maps[estimator] = get_data(estimator.components_img_) maps[estimator] = np.reshape( np.rollaxis(maps[estimator], 3, 0)[:, mask], (4, flat_mask.sum())) masked_components = components[:, flat_mask] for this_dict_learning in [dict_learning]: these_maps = maps[this_dict_learning] S = np.sqrt(np.sum(masked_components ** 2, axis=1)) S[S == 0] = 1 masked_components /= S[:, np.newaxis] S = np.sqrt(np.sum(these_maps ** 2, axis=1)) S[S == 0] = 1 these_maps /= S[:, np.newaxis] K = np.abs(masked_components.dot(these_maps.T)) recovered_maps = np.sum(K > 0.9) assert(recovered_maps >= 2) # Smoke test n_epochs > 1 dict_learning = DictLearning(n_components=4, random_state=0, dict_init=dict_init, mask=mask_img, smoothing_fwhm=0., n_epochs=2, alpha=1) dict_learning.fit(data)
def significance_map(subject_scores, mask): """ Parameters ---------- subject_scores : list list of niimgs or paths to NIfTI files representing the MVPA scores for each subject mask : Niimg-like object boolean image giving location of voxels containing usable signals Returns ------- t_map : numpy.ndarray array of t-statistic values indicating the significance of each voxel for condition A; same shape as the mask p_map : numpy.ndarray array of p-values associated with the t-statistics in t_map """ score_maps = [] for score_map in subject_scores: if isinstance(score_map, str): score_map = get_data(load_img(score_map)) else: score_map = get_data(score_map) score_maps.append(np.expand_dims(score_map, axis=3)) mask = np.mean(score_maps, axis=0).astype(bool) score_maps = np.concatenate(score_maps, axis=-1) t_map = np.zeros_like(mask, dtype=np.float64) p_map = np.zeros_like(mask, dtype=np.float64) for x in range(mask.shape[0]): for y in range(mask.shape[1]): for z in range(mask.shape[2]): if not mask[x][y][z]: continue # Significance values from each subject for one voxel sample = score_maps[x][y][z] test = stats.ttest_1samp(sample, popmean=0.0) t_map[x][y][z] = test.statistic p_map[x][y][z] = test.pvalue return t_map, p_map
def test_pd_index_img(): # confirm indices from pandas dataframes are handled correctly if 'pandas' not in sys.modules: raise pytest.skip(msg='Pandas not available') affine = np.array([[1., 2., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.], [0., 0., 0., 1.]]) img_4d, _ = data_gen.generate_fake_fmri(affine=affine) fourth_dim_size = img_4d.shape[3] rng = np.random.RandomState(42) arr = rng.uniform(size=fourth_dim_size) > 0.5 df = pd.DataFrame({"arr": arr}) np_index_img = image.index_img(img_4d, arr) pd_index_img = image.index_img(img_4d, df) assert_array_equal(get_data(np_index_img), get_data(pd_index_img))
def test_compute_multi_gray_matter_mask(): pytest.raises(TypeError, compute_multi_gray_matter_mask, []) # Check error raised if images with different shapes are given as input imgs = [Nifti1Image(np.ones((9, 9, 9)), np.eye(4)), Nifti1Image(np.ones((9, 9, 8)), np.eye(4))] pytest.raises(ValueError, compute_multi_gray_matter_mask, imgs) # Check results are the same if affine is the same imgs1 = [Nifti1Image(np.random.randn(9, 9, 9), np.eye(4)), Nifti1Image(np.random.randn(9, 9, 9), np.eye(4))] mask1 = compute_multi_gray_matter_mask(imgs1) imgs2 = [Nifti1Image(np.random.randn(9, 9, 9), np.eye(4)), Nifti1Image(np.random.randn(9, 9, 9), np.eye(4))] mask2 = compute_multi_gray_matter_mask(imgs2) assert_array_equal(get_data(mask1), get_data(mask2))
def get_block(image, block_height): N = image.get_data().astype(float) N -= N.min() if N.max() > 0: N /= N.max() N = (N * 256).astype('uint16') # ^ normalize into 0 - 256 range mid = len(N) // 2 half = block_height // 2 return N[mid - half:mid + half]
def test_mean_img_resample(): # Test resampling in mean_img with a permutation of the axes rng = np.random.RandomState(42) data = rng.rand(5, 6, 7, 40) affine = np.diag((4, 3, 2, 1)) img = nibabel.Nifti1Image(data, affine=affine) mean_img = nibabel.Nifti1Image(data.mean(axis=-1), affine=affine) target_affine = affine[:, [1, 0, 2, 3]] # permutation of axes mean_img_with_resampling = image.mean_img(img, target_affine=target_affine) resampled_mean_image = resampling.resample_img(mean_img, target_affine=target_affine) assert_array_equal(get_data(resampled_mean_image), get_data(mean_img_with_resampling)) assert_array_equal(resampled_mean_image.affine, mean_img_with_resampling.affine) assert_array_equal(mean_img_with_resampling.affine, target_affine)
def test_isnan_threshold_img_data(): shape = (10, 10, 10) maps, _ = data_gen.generate_maps(shape, n_regions=2) data = get_data(maps) data[:, :, 0] = np.nan maps_img = nibabel.Nifti1Image(data, np.eye(4)) # test threshold_img to converge properly when input image has nans. threshold_img(maps_img, threshold=0.8)
def test_crop(): # Testing that padding of arrays and cropping of images work symmetrically shape = (4, 6, 2) data = np.ones(shape) padded = _pad_array(data, [3, 2, 4, 4, 5, 7]) padd_nii = Nifti1Image(padded, np.eye(4)) cropped = crop_img(padd_nii, pad=False) np.testing.assert_equal(get_data(cropped), data)
def test_smooth_img(): # This function only checks added functionalities compared # to _smooth_array() shapes = ((10, 11, 12), (13, 14, 15)) lengths = (17, 18) fwhm = (1., 2., 3.) img1, mask1 = data_gen.generate_fake_fmri(shape=shapes[0], length=lengths[0]) img2, mask2 = data_gen.generate_fake_fmri(shape=shapes[1], length=lengths[1]) for create_files in (False, True): with testing.write_tmp_imgs(img1, img2, create_files=create_files) as imgs: # List of images as input out = image.smooth_img(imgs, fwhm) assert isinstance(out, list) assert len(out) == 2 for o, s, l in zip(out, shapes, lengths): assert o.shape == (s + (l, )) # Single image as input out = image.smooth_img(imgs[0], fwhm) assert isinstance(out, nibabel.Nifti1Image) assert out.shape == (shapes[0] + (lengths[0], )) # Check corner case situations when fwhm=0, See issue #1537 # Test whether function smooth_img raises a warning when fwhm=0. with pytest.warns(UserWarning): image.smooth_img(img1, fwhm=0.) # Test output equal when fwhm=None and fwhm=0 out_fwhm_none = image.smooth_img(img1, fwhm=None) out_fwhm_zero = image.smooth_img(img1, fwhm=0.) assert_array_equal(get_data(out_fwhm_none), get_data(out_fwhm_zero)) data1 = np.zeros((10, 11, 12)) data1[2:4, 1:5, 3:6] = 1 data2 = np.zeros((13, 14, 15)) data2[2:4, 1:5, 3:6] = 9 img1_nifti2 = nibabel.Nifti2Image(data1, affine=np.eye(4)) img2_nifti2 = nibabel.Nifti2Image(data2, affine=np.eye(4)) out = image.smooth_img([img1_nifti2, img2_nifti2], fwhm=1.)
def test_resampling_error_checks(): rng = np.random.RandomState(42) shape = (3, 2, 5, 2) target_shape = (5, 3, 2) affine = np.eye(4) data = rng.randint(0, 10, shape) img = Nifti1Image(data, affine) # Correct parameters: no exception resample_img(img, target_shape=target_shape, target_affine=affine) resample_img(img, target_affine=affine) with testing.write_tmp_imgs(img) as filename: resample_img(filename, target_shape=target_shape, target_affine=affine) # Missing parameter pytest.raises(ValueError, resample_img, img, target_shape=target_shape) # Invalid shape pytest.raises(ValueError, resample_img, img, target_shape=(2, 3), target_affine=affine) # Invalid interpolation interpolation = 'an_invalid_interpolation' pattern = "interpolation must be either.+{0}".format(interpolation) with pytest.raises(ValueError, match=pattern): resample_img(img, target_shape=target_shape, target_affine=affine, interpolation="an_invalid_interpolation" ) # Noop target_shape = shape[:3] img_r = resample_img(img, copy=False) assert img_r == img img_r = resample_img(img, copy=True) assert not np.may_share_memory(get_data(img_r), get_data(img)) np.testing.assert_almost_equal(get_data(img_r), get_data(img)) np.testing.assert_almost_equal(img_r.affine, img.affine) img_r = resample_img(img, target_affine=affine, target_shape=target_shape, copy=False) assert img_r == img img_r = resample_img(img, target_affine=affine, target_shape=target_shape, copy=True) assert not np.may_share_memory(get_data(img_r), get_data(img)) np.testing.assert_almost_equal(get_data(img_r), get_data(img)) np.testing.assert_almost_equal(img_r.affine, img.affine)
def test_new_img_like_mgz(): """Check that new images can be generated with bool MGZ type This is usually when computing masks using MGZ inputs, e.g. when using plot_stap_map """ ref_img = nibabel.load(os.path.join(datadir, 'test.mgz')) data = np.ones(get_data(ref_img).shape, dtype=bool) affine = ref_img.affine new_img_like(ref_img, data, affine, copy_header=False)
def test_threshold_img_copy(): """Test the behavior of threshold_img's copy parameter.""" img_ones = Nifti1Image(np.ones((10, 10, 10, 10)), np.eye(4)) # Check that copy does not mutate. It returns modified copy. thresholded = threshold_img(img_ones, 2) # threshold 2 > 1 # Original img_ones should have all ones. assert_array_equal(get_data(img_ones), np.ones((10, 10, 10, 10))) # Thresholded should have all zeros. assert_array_equal(get_data(thresholded), np.zeros((10, 10, 10, 10))) # Check that not copying does mutate. img_to_mutate = Nifti1Image(np.ones((10, 10, 10, 10)), np.eye(4)) thresholded = threshold_img(img_to_mutate, 2, copy=False) # Check that original mutates assert_array_equal(get_data(img_to_mutate), np.zeros((10, 10, 10, 10))) # And that returned value is also thresholded. assert_array_equal(get_data(img_to_mutate), get_data(thresholded))
def test_mask_4d(): # Dummy mask mask = np.zeros((10, 10, 10), dtype=int) mask[3:7, 3:7, 3:7] = 1 mask_bool = mask.astype(bool) mask_img = Nifti1Image(mask, np.eye(4)) # Dummy data data = np.zeros((10, 10, 10, 5), dtype=int) data[..., 0] = 1 data[..., 1] = 2 data[..., 2] = 3 data_img_4d = Nifti1Image(data, np.eye(4)) data_imgs = [ index_img(data_img_4d, 0), index_img(data_img_4d, 1), index_img(data_img_4d, 2) ] # check whether transform is indeed selecting niimgs subset sample_mask = np.array([0, 2]) masker = NiftiMasker(mask_img=mask_img) masker.fit() data_trans = masker.transform(data_imgs, sample_mask=sample_mask) data_trans_img = index_img(data_img_4d, sample_mask) data_trans_direct = get_data(data_trans_img)[mask_bool, :] data_trans_direct = np.swapaxes(data_trans_direct, 0, 1) assert_array_equal(data_trans, data_trans_direct) masker = NiftiMasker(mask_img=mask_img) masker.fit() data_trans2 = masker.transform(data_img_4d, sample_mask=sample_mask) assert_array_equal(data_trans2, data_trans_direct) diff_sample_mask = np.array([2, 4]) data_trans_img_diff = index_img(data_img_4d, diff_sample_mask) data_trans_direct_diff = get_data(data_trans_img_diff)[mask_bool, :] data_trans_direct_diff = np.swapaxes(data_trans_direct_diff, 0, 1) masker = NiftiMasker(mask_img=mask_img) masker.fit() data_trans3 = masker.transform(data_img_4d, sample_mask=diff_sample_mask) assert_array_equal(data_trans3, data_trans_direct_diff)
def test_resampling_result_axis_permutation(): # Transform real data using easily checkable transformations # For now: axis permutations # create a cuboid full of deterministic data, padded with one # voxel thickness of zeros core_shape = (3, 5, 4) core_data = np.arange(np.prod(core_shape)).reshape(core_shape) full_data_shape = np.array(core_shape) + 2 full_data = np.zeros(full_data_shape) full_data[[slice(1, 1 + s) for s in core_shape]] = core_data source_img = Nifti1Image(full_data, np.eye(4)) axis_permutations = [[0, 1, 2], [1, 0, 2], [2, 1, 0], [0, 2, 1]] # check 3x3 transformation matrix for ap in axis_permutations: target_affine = np.eye(3)[ap] resampled_img = resample_img(source_img, target_affine=target_affine) resampled_data = get_data(resampled_img) what_resampled_data_should_be = full_data.transpose(ap) assert_array_almost_equal(resampled_data, what_resampled_data_should_be) # check 4x4 transformation matrix offset = np.array([-2, 1, -3]) for ap in axis_permutations: target_affine = np.eye(4) target_affine[:3, :3] = np.eye(3)[ap] target_affine[:3, 3] = offset resampled_img = resample_img(source_img, target_affine=target_affine) resampled_data = get_data(resampled_img) offset_cropping = np.vstack( [-offset[ap][np.newaxis, :], np.zeros([1, 3])]).T.ravel().astype(int) what_resampled_data_should_be = _pad_array(full_data.transpose(ap), list(offset_cropping)) assert_array_almost_equal(resampled_data, what_resampled_data_should_be)
def test_mean_img(): rng = np.random.RandomState(42) data1 = np.zeros((5, 6, 7)) data2 = rng.rand(5, 6, 7) data3 = rng.rand(5, 6, 7, 3) affine = np.diag((4, 3, 2, 1)) img1 = nibabel.Nifti1Image(data1, affine=affine) img2 = nibabel.Nifti1Image(data2, affine=affine) img3 = nibabel.Nifti1Image(data3, affine=affine) for imgs in ([img1, ], [img1, img2], [img2, img1, img2], [img3, img1, img2], # Mixture of 4D and 3D images ): arrays = list() # Ground-truth: for img in imgs: img = get_data(img) if img.ndim == 4: img = np.mean(img, axis=-1) arrays.append(img) truth = np.mean(arrays, axis=0) mean_img = image.mean_img(imgs) assert_array_equal(mean_img.affine, affine) assert_array_equal(get_data(mean_img), truth) # Test with files with testing.write_tmp_imgs(*imgs) as imgs: mean_img = image.mean_img(imgs) assert_array_equal(mean_img.affine, affine) if X64: assert_array_equal(get_data(mean_img), truth) else: # We don't really understand but arrays are not # exactly equal on 32bit. Given that you can not do # much real world data analysis with nilearn on a # 32bit machine it is not worth investigating more assert_allclose(get_data(mean_img), truth, rtol=np.finfo(truth.dtype).resolution, atol=0)
def test_downsample(): """ Test resampling with a 1/2 down-sampling affine. """ rng = np.random.RandomState(42) shape = (6, 3, 6, 2) data = rng.random_sample(shape) affine = np.eye(4) rot_img = resample_img(Nifti1Image(data, affine), target_affine=2 * affine, interpolation='nearest') downsampled = data[::2, ::2, ::2, ...] x, y, z = downsampled.shape[:3] np.testing.assert_almost_equal(downsampled, get_data(rot_img)[:x, :y, :z, ...]) rot_img_2 = resample_img(Nifti1Image(data, affine), target_affine=2 * affine, interpolation='nearest', force_resample=True) np.testing.assert_almost_equal(get_data(rot_img_2), get_data(rot_img)) # Test with non native endian data # Test to check that if giving non native endian data as input should # work as normal and expected to return the same output as above tests. # Big endian data ('>f8') for copy in [True, False]: rot_img = resample_img(Nifti1Image(data.astype('>f8'), affine), target_affine=2 * affine, interpolation='nearest', copy=copy) np.testing.assert_almost_equal(downsampled, get_data(rot_img)[:x, :y, :z, ...]) # Little endian data for copy in [True, False]: rot_img = resample_img(Nifti1Image(data.astype('<f8'), affine), target_affine=2 * affine, interpolation='nearest', copy=copy) np.testing.assert_almost_equal(downsampled, get_data(rot_img)[:x, :y, :z, ...])
def test_compute_gray_matter_mask(): image = Nifti1Image(np.ones((9, 9, 9)), np.eye(4)) mask = compute_gray_matter_mask(image, threshold=-1) mask1 = np.zeros((9, 9, 9)) mask1[2:-2, 2:-2, 2:-2] = 1 np.testing.assert_array_equal(mask1, get_data(mask)) # Check that we get a useful warning for empty masks with pytest.warns(masking.MaskWarning): compute_gray_matter_mask(image, threshold=1) # Check that masks obtained from same FOV are the same img1 = Nifti1Image(np.full((9, 9, 9), np.random.rand()), np.eye(4)) img2 = Nifti1Image(np.full((9, 9, 9), np.random.rand()), np.eye(4)) mask_img1 = compute_gray_matter_mask(img1) mask_img2 = compute_gray_matter_mask(img2) np.testing.assert_array_equal(get_data(mask_img1), get_data(mask_img2))
def make_timeseries_for_prf(bolds): """Takes a list of 4d nifti filenames, averages, cuts extra timepoints""" for i, bold_file in enumerate(bolds): img = load_img(bold_file) data = get_data(img) print(data.shape) if i == 0: all_data = np.empty((*data.shape, len(bolds))) all_data[:, :, :, :, i] = data mean_timeseries = np.average(all_data, -1) return nib.Nifti1Image(mean_timeseries[:, :, :, :138], img.affine)
def _testdata_3d_for_resampling(img, binary): """Returns testing data for resampling tests. Data can be binarize or not. """ data = get_data(img) if binary: data[data > 0] = 1 data[data < 0] = 0 affine = np.array([[1., -1., 0., 0.], [1., 1., 0., 0.], [0., 0., 1., 0.], [0., 0., 0., 1.]]) return Nifti1Image(data, affine)
def test_compute_multi_gray_matter_mask(): # Check mask is correctly is correctly calculated imgs = [Nifti1Image(np.random.rand(9, 9, 5), np.eye(4)), Nifti1Image(np.random.rand(9, 9, 5), np.eye(4))] masker = MultiNiftiMasker(mask_strategy='template') masker.fit(imgs) # Check that the order of the images does not change the output masker2 = MultiNiftiMasker(mask_strategy='template') masker2.fit(imgs[::-1]) mask = masker.mask_img_ mask2 = masker2.mask_img_ mask_ref = np.zeros((9, 9, 5)) mask_ref[2:7, 2:7, 2] = 1 np.testing.assert_array_equal(get_data(mask), mask_ref) np.testing.assert_array_equal(get_data(mask2), mask_ref)
def test_fetch_atlas_pauli_2017(): data_dir = os.path.join(tst.tmpdir, 'pauli_2017') data = atlas.fetch_atlas_pauli_2017('labels', data_dir) assert_equal(len(data.labels), 16) values = get_data(nibabel.load(data.maps)) assert_equal(len(np.unique(values)), 17) data = atlas.fetch_atlas_pauli_2017('prob', data_dir) assert_equal(nibabel.load(data.maps).shape[-1], 16)
def test_logistic_path_scores(): iris = load_iris() X, y = iris.data, iris.target _, mask = to_niimgs(X, [2, 2, 2]) mask = get_data(mask).astype(bool) alphas = [1., .1, .01] test_scores, best_w = logistic_path_scores(_graph_net_logistic, X, y, mask, alphas, .5, np.arange(len(X)), np.arange(len(X)), {})[:2] test_scores = test_scores[0] assert len(test_scores) == len(alphas) assert X.shape[1] + 1 == len(best_w)
def load_mask(self, mask): if mask is not None: if 'mask' in mask or 'lh_' in mask or 'rh_' in mask: fname = os.path.join(self.subj.masks, '%s.nii.gz' % (mask)) else: fname = os.path.join(self.subj.masks, '%s_mask.nii.gz') if not os.path.exists(fname): fname = os.path.join(self.subj.masks, '%s.nii.gz' % (mask)) return get_data(fname)
def test_matrix_orientation(): """Test if processing is performed along the correct axis.""" # the "step" kind generate heavyside-like signals for each voxel. # all signals being identical, standardizing along the wrong axis # would leave a null signal. Along the correct axis, the step remains. fmri, mask = data_gen.generate_fake_fmri(shape=(40, 41, 42), kind="step") masker = NiftiMasker(mask_img=mask, standardize=True, detrend=True) timeseries = masker.fit_transform(fmri) assert (timeseries.shape[0] == fmri.shape[3]) assert (timeseries.shape[1] == get_data(mask).sum()) std = timeseries.std(axis=0) assert (std.shape[0] == timeseries.shape[1]) # paranoid assert (not np.any(std < 0.1)) # Test inverse transform masker = NiftiMasker(mask_img=mask, standardize=False, detrend=False) masker.fit() timeseries = masker.transform(fmri) recovered = masker.inverse_transform(timeseries) np.testing.assert_array_almost_equal(get_data(recovered), get_data(fmri))
def test_high_level_glm_with_paths(): shapes, rk = ((7, 8, 7, 15), (7, 8, 7, 14)), 3 with InTemporaryDirectory(): mask_file, fmri_files, design_files = write_fake_fmri_data_and_design(shapes, rk) multi_session_model = FirstLevelModel(mask_img=None).fit( fmri_files, design_matrices=design_files) z_image = multi_session_model.compute_contrast(np.eye(rk)[1]) assert_array_equal(z_image.affine, load(mask_file).affine) assert get_data(z_image).std() < 3. # Delete objects attached to files to avoid WindowsError when deleting # temporary directory (in Windows) del z_image, fmri_files, multi_session_model
def test_reorder_img_non_native_endianness(): def _get_resampled_img(dtype): data = np.ones((10, 10, 10), dtype=dtype) data[3:7, 3:7, 3:7] = 2 affine = np.eye(4) theta = math.pi / 6. c = math.cos(theta) s = math.sin(theta) affine = np.array([[1, 0, 0, 0], [0, c, -s, 0], [0, s, c, 0], [0, 0, 0, 1]]) img = Nifti1Image(data, affine) return resample_img(img, target_affine=np.eye(4)) img_1 = _get_resampled_img('<f8') img_2 = _get_resampled_img('>f8') np.testing.assert_equal(get_data(img_1), get_data(img_2))
def test_get_clusters_table_not_modifying_stat_image(): shape = (9, 10, 11) data = np.zeros(shape) data[2:4, 5:7, 6:8] = 5. data[0:3, 0:3, 0:3] = 6. stat_img = nib.Nifti1Image(data, np.eye(4)) data_orig = get_data(stat_img).copy() # test one cluster should be removed clusters_table = get_clusters_table( stat_img, 4, cluster_threshold=10, two_sided=True ) assert np.allclose(data_orig, get_data(stat_img)) assert len(clusters_table) == 1 # test no clusters should be removed stat_img = nib.Nifti1Image(data, np.eye(4)) clusters_table = get_clusters_table( stat_img, 4, cluster_threshold=7, two_sided=False ) assert np.allclose(data_orig, get_data(stat_img)) assert len(clusters_table) == 2 # test cluster threshold is None stat_img = nib.Nifti1Image(data, np.eye(4)) clusters_table = get_clusters_table( stat_img, 4, cluster_threshold=None, two_sided=False ) assert np.allclose(data_orig, get_data(stat_img)) assert len(clusters_table) == 2
def test_clean_img(): rng = np.random.RandomState(0) data = rng.randn(10, 10, 10, 100) + .5 data_flat = data.T.reshape(100, -1) data_img = nibabel.Nifti1Image(data, np.eye(4)) pytest.raises( ValueError, image.clean_img, data_img, t_r=None, low_pass=0.1) data_img_ = image.clean_img( data_img, detrend=True, standardize=False, low_pass=0.1, t_r=1.0) data_flat_ = signal.clean( data_flat, detrend=True, standardize=False, low_pass=0.1, t_r=1.0) np.testing.assert_almost_equal(get_data(data_img_).T.reshape(100, -1), data_flat_) # if NANs data[:, 9, 9] = np.nan # if infinity data[:, 5, 5] = np.inf nan_img = nibabel.Nifti1Image(data, np.eye(4)) clean_im = image.clean_img(nan_img, ensure_finite=True) assert np.any(np.isfinite(get_data(clean_im))), True # test_clean_img_passing_nifti2image data_img_nifti2 = nibabel.Nifti2Image(data, np.eye(4)) data_img_nifti2_ = image.clean_img( data_img_nifti2, detrend=True, standardize=False, low_pass=0.1, t_r=1.0) # if mask_img img, mask_img = data_gen.generate_fake_fmri(shape=(10, 10, 10), length=10) data_img_mask_ = image.clean_img(img, mask_img=mask_img) # Checks that output with full mask and without is equal data_img_ = image.clean_img(img) np.testing.assert_almost_equal(get_data(data_img_), get_data(data_img_mask_))
def test_view_img_on_surf(): img = _get_img() surfaces = datasets.fetch_surf_fsaverage() html = html_surface.view_img_on_surf(img, threshold='92.3%') check_html(html) html = html_surface.view_img_on_surf(img, threshold=0, surf_mesh=surfaces) check_html(html) html = html_surface.view_img_on_surf(img, threshold=.4, title="SOME_TITLE") assert "SOME_TITLE" in html.html check_html(html) html = html_surface.view_img_on_surf( img, threshold=.4, cmap='hot', black_bg=True) check_html(html) with pytest.raises(DimensionError): html_surface.view_img_on_surf([img, img]) img_4d = image.new_img_like(img, get_data(img)[:, :, :, np.newaxis]) assert len(img_4d.shape) == 4 html = html_surface.view_img_on_surf(img, threshold='92.3%') check_html(html) np.clip(get_data(img), 0, None, out=get_data(img)) html = html_surface.view_img_on_surf(img, symmetric_cmap=False) check_html(html)