def test_index_img(): img_3d = nibabel.Nifti1Image(np.ones((3, 4, 5)), np.eye(4)) testing.assert_raises_regex(TypeError, "Input data has incompatible dimensionality: " "Expected dimension is 4D and you provided " "a 3D image.", image.index_img, img_3d, 0) affine = np.array([[1., 2., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.], [0., 0., 0., 1.]]) img_4d, _ = testing.generate_fake_fmri(affine=affine) fourth_dim_size = img_4d.shape[3] tested_indices = (list(range(fourth_dim_size)) + [slice(2, 8, 2), [1, 2, 3, 2], [], (np.arange(fourth_dim_size) % 3) == 1]) for i in tested_indices: this_img = image.index_img(img_4d, i) expected_data_3d = img_4d.get_data()[..., i] assert_array_equal(this_img.get_data(), expected_data_3d) assert_array_equal(compat.get_affine(this_img), compat.get_affine(img_4d)) for i in [fourth_dim_size, - fourth_dim_size - 1, [0, fourth_dim_size], np.repeat(True, fourth_dim_size + 1)]: testing.assert_raises_regex( IndexError, 'out of bounds|invalid index|out of range|boolean index', image.index_img, img_4d, i)
def test_index_img(): img_3d = nibabel.Nifti1Image(np.ones((3, 4, 5)), np.eye(4)) testing.assert_raises_regex(TypeError, "Input data has incompatible dimensionality: " "Expected dimension is 4D and you provided " "a 3D image.", image.index_img, img_3d, 0) affine = np.array([[1., 2., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.], [0., 0., 0., 1.]]) img_4d, _ = testing.generate_fake_fmri(affine=affine) fourth_dim_size = img_4d.shape[3] tested_indices = (list(range(fourth_dim_size)) + [slice(2, 8, 2), [1, 2, 3, 2], [], (np.arange(fourth_dim_size) % 3) == 1]) for i in tested_indices: this_img = image.index_img(img_4d, i) expected_data_3d = img_4d.get_data()[..., i] assert_array_equal(this_img.get_data(), expected_data_3d) assert_array_equal(compat.get_affine(this_img), compat.get_affine(img_4d)) for i in [fourth_dim_size, - fourth_dim_size - 1, [0, fourth_dim_size], np.repeat(True, fourth_dim_size + 1)]: testing.assert_raises_regex( IndexError, 'out of bounds|invalid index|out of range', image.index_img, img_4d, i)
def test_math_img(): img1 = Nifti1Image(np.ones((10, 10, 10, 10)), np.eye(4)) img2 = Nifti1Image(np.zeros((10, 10, 10, 10)), np.eye(4)) expected_result = Nifti1Image(np.ones((10, 10, 10)), np.eye(4)) formula = "np.mean(img1, axis=-1) - np.mean(img2, axis=-1)" for create_files in (True, False): with testing.write_tmp_imgs(img1, img2, create_files=create_files) as imgs: result = math_img(formula, img1=imgs[0], img2=imgs[1]) assert_array_equal(result.get_data(), expected_result.get_data()) assert_array_equal(compat.get_affine(result), compat.get_affine(expected_result)) assert_equal(result.shape, expected_result.shape)
def test_resampling_error_checks(): shape = (3, 2, 5, 2) target_shape = (5, 3, 2) affine = np.eye(4) data = np.random.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 assert_raises(ValueError, resample_img, img, target_shape=target_shape) # Invalid shape assert_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) testing.assert_raises_regex(ValueError, 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_equal(img_r, img) img_r = resample_img(img, copy=True) assert_false(np.may_share_memory(img_r.get_data(), img.get_data())) np.testing.assert_almost_equal(img_r.get_data(), img.get_data()) np.testing.assert_almost_equal(compat.get_affine(img_r), compat.get_affine(img)) img_r = resample_img(img, target_affine=affine, target_shape=target_shape, copy=False) assert_equal(img_r, img) img_r = resample_img(img, target_affine=affine, target_shape=target_shape, copy=True) assert_false(np.may_share_memory(img_r.get_data(), img.get_data())) np.testing.assert_almost_equal(img_r.get_data(), img.get_data()) np.testing.assert_almost_equal(compat.get_affine(img_r), compat.get_affine(img))
def test_4d_affine_bounding_box_error(): small_data = np.ones([4, 4, 4]) small_data_4D_affine = np.eye(4) small_data_4D_affine[:3, -1] = np.array([5, 4, 5]) small_img = Nifti1Image(small_data, small_data_4D_affine) bigger_data_4D_affine = np.eye(4) bigger_data = np.zeros([10, 10, 10]) bigger_img = Nifti1Image(bigger_data, bigger_data_4D_affine) # We would like to check whether all/most of the data # will be contained in the resampled image # The measure will be the l2 norm, since some resampling # schemes approximately conserve it def l2_norm(arr): return (arr ** 2).sum() # resample using 4D affine and specified target shape small_to_big_with_shape = resample_img( small_img, target_affine=compat.get_affine(bigger_img), target_shape=bigger_img.shape) # resample using 3D affine and no target shape small_to_big_without_shape_3D_affine = resample_img( small_img, target_affine=compat.get_affine(bigger_img)[:3, :3]) # resample using 4D affine and no target shape small_to_big_without_shape = resample_img( small_img, target_affine=compat.get_affine(bigger_img)) # The first 2 should pass assert_almost_equal(l2_norm(small_data), l2_norm(small_to_big_with_shape.get_data())) assert_almost_equal(l2_norm(small_data), l2_norm(small_to_big_without_shape_3D_affine.get_data())) # After correcting decision tree for 4x4 affine given + no target shape # from "use initial shape" to "calculate minimal bounding box respecting # the affine anchor and the data" assert_almost_equal(l2_norm(small_data), l2_norm(small_to_big_without_shape.get_data())) assert_array_equal(small_to_big_without_shape.shape, small_data_4D_affine[:3, -1] + np.array(small_img.shape))
def test__crop_img_to(): data = np.zeros((5, 6, 7)) data[2:4, 1:5, 3:6] = 1 affine = np.diag((4, 3, 2, 1)) img = nibabel.Nifti1Image(data, affine=affine) slices = [slice(2, 4), slice(1, 5), slice(3, 6)] cropped_img = image._crop_img_to(img, slices, copy=False) new_origin = np.array((4, 3, 2)) * np.array((2, 1, 3)) # check that correct part was extracted: assert_true((cropped_img.get_data() == 1).all()) assert_true(cropped_img.shape == (2, 4, 3)) # check that affine was adjusted correctly assert_true((compat.get_affine(cropped_img)[:3, 3] == new_origin).all()) # check that data was really not copied data[2:4, 1:5, 3:6] = 2 assert_true((cropped_img.get_data() == 2).all()) # check that copying works copied_cropped_img = image._crop_img_to(img, slices) data[2:4, 1:5, 3:6] = 1 assert_true((copied_cropped_img.get_data() == 2).all())
def test_new_img_like_side_effect(): img1 = Nifti1Image(np.ones((2, 2, 2, 2)), affine=np.eye(4)) hash1 = joblib.hash(img1) new_img_like(img1, np.ones((2, 2, 2, 2)), get_affine(img1).copy(), copy_header=True) hash2 = joblib.hash(img1) assert_equal(hash1, hash2)
def _make_data(task="regression", size=4): X, y, w, mask = create_graph_net_simulation_data( snr=1., n_samples=10, size=size, n_points=5, random_state=42, task=task) X_, _ = to_niimgs(X, [size] * 3) mask_ = nibabel.Nifti1Image(mask.astype(np.float), get_affine(X_)) return X, y, w, mask, mask_, X_
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 = img.get_data() 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(compat.get_affine(mean_img), affine) assert_array_equal(mean_img.get_data(), truth) # Test with files with testing.write_tmp_imgs(*imgs) as imgs: mean_img = image.mean_img(imgs) assert_array_equal(compat.get_affine(mean_img), affine) if X64: assert_array_equal(mean_img.get_data(), 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(mean_img.get_data(), truth, rtol=np.finfo(truth.dtype).resolution, atol=0)
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(resampled_mean_image.get_data(), mean_img_with_resampling.get_data()) assert_array_equal(compat.get_affine(resampled_mean_image), compat.get_affine(mean_img_with_resampling)) assert_array_equal(compat.get_affine(mean_img_with_resampling), target_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(ref_img.get_data().shape, dtype=np.bool) affine = compat.get_affine(ref_img) new_img_like(ref_img, data, affine, copy_header=False)
def _make_data(task="regression", size=4): X, y, w, mask = create_graph_net_simulation_data(snr=1., n_samples=10, size=size, n_points=5, random_state=42, task=task) X_, _ = to_niimgs(X, [size] * 3) mask_ = nibabel.Nifti1Image(mask.astype(np.float), get_affine(X_)) return X, y, w, mask, mask_, X_
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 = img.get_data() 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(compat.get_affine(mean_img), affine) assert_array_equal(mean_img.get_data(), truth) # Test with files with testing.write_tmp_imgs(*imgs) as imgs: mean_img = image.mean_img(imgs) assert_array_equal(compat.get_affine(mean_img), affine) if X64: assert_array_equal(mean_img.get_data(), 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(mean_img.get_data(), truth, rtol=np.finfo(truth.dtype).resolution, atol=0)
def compute_confounds(imgs, mask_img, n_confounds=5, get_randomized_svd=False, compute_not_mask=False): """ """ confounds = [] if not isinstance(imgs, collections.Iterable) or \ isinstance(imgs, _basestring): imgs = [imgs, ] img = _utils.check_niimg_4d(imgs[0]) shape = img.shape[:3] affine = get_affine(img) if isinstance(mask_img, _basestring): mask_img = _utils.check_niimg_3d(mask_img) if not _check_same_fov(img, mask_img): mask_img = resample_img( mask_img, target_shape=shape, target_affine=affine, interpolation='nearest') if compute_not_mask: print("Non mask based confounds extraction") not_mask_data = np.logical_not(mask_img.get_data().astype(np.int)) whole_brain_mask = masking.compute_multi_epi_mask(imgs) not_mask = np.logical_and(not_mask_data, whole_brain_mask.get_data()) mask_img = new_img_like(img, not_mask.astype(np.int), affine) for img in imgs: print("[Confounds Extraction] {0}".format(img)) img = _utils.check_niimg_4d(img) print("[Confounds Extraction] high ariance confounds computation]") high_variance = high_variance_confounds(img, mask_img=mask_img, n_confounds=n_confounds) if compute_not_mask and get_randomized_svd: signals = masking.apply_mask(img, mask_img) non_constant = np.any(np.diff(signals, axis=0) != 0, axis=0) signals = signals[:, non_constant] signals = signal.clean(signals, detrend=True) print("[Confounds Extraction] Randomized SVD computation") U, s, V = randomized_svd(signals, n_components=n_confounds, random_state=0) if high_variance is not None: confound_ = np.hstack((U, high_variance)) else: confound_ = U else: confound_ = high_variance confounds.append(confound_) return confounds
def test_iter_img(): img_3d = nibabel.Nifti1Image(np.ones((3, 4, 5)), np.eye(4)) testing.assert_raises_regex(TypeError, "Input data has incompatible dimensionality: " "Expected dimension is 4D and you provided " "a 3D image.", image.iter_img, img_3d) affine = np.array([[1., 2., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.], [0., 0., 0., 1.]]) img_4d, _ = testing.generate_fake_fmri(affine=affine) for i, img in enumerate(image.iter_img(img_4d)): expected_data_3d = img_4d.get_data()[..., i] assert_array_equal(img.get_data(), expected_data_3d) assert_array_equal(compat.get_affine(img), compat.get_affine(img_4d)) with testing.write_tmp_imgs(img_4d) as img_4d_filename: for i, img in enumerate(image.iter_img(img_4d_filename)): expected_data_3d = img_4d.get_data()[..., i] assert_array_equal(img.get_data(), expected_data_3d) assert_array_equal(compat.get_affine(img), compat.get_affine(img_4d)) # enables to delete "img_4d_filename" on windows del img img_3d_list = list(image.iter_img(img_4d)) for i, img in enumerate(image.iter_img(img_3d_list)): expected_data_3d = img_4d.get_data()[..., i] assert_array_equal(img.get_data(), expected_data_3d) assert_array_equal(compat.get_affine(img), compat.get_affine(img_4d)) with testing.write_tmp_imgs(*img_3d_list) as img_3d_filenames: for i, img in enumerate(image.iter_img(img_3d_filenames)): expected_data_3d = img_4d.get_data()[..., i] assert_array_equal(img.get_data(), expected_data_3d) assert_array_equal(compat.get_affine(img), compat.get_affine(img_4d)) # enables to delete "img_3d_filename" on windows del img
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 """ if not LooseVersion(nibabel.__version__) >= LooseVersion('1.2.0'): # Old nibabel do not support MGZ files raise SkipTest ref_img = nibabel.load(os.path.join(datadir, 'test.mgz')) data = np.ones(ref_img.get_data().shape, dtype=np.bool) affine = compat.get_affine(ref_img) new_img_like(ref_img, data, affine, copy_header=False)
def our_load_niimg(niimg, dtype=None): """Load a niimg, check if it is a nibabel SpatialImage and cast if needed Parameters: ----------- niimg: Niimg-like object See http://nilearn.github.io/manipulating_images/input_output.html. Image to load. dtype: {dtype, "auto"} Data type toward which the data should be converted. If "auto", the data will be converted to int32 if dtype is discrete and float32 if it is continuous. Returns: -------- img: image A loaded image object. """ from nilearn.image import new_img_like # avoid circular imports if isinstance(niimg, _basestring): # data is a filename, we load it niimg = nibabel.load(niimg) elif not isinstance(niimg, nibabel.spatialimages.SpatialImage): raise TypeError("Data given cannot be loaded because it is" " not compatible with nibabel format:\n" + short_repr(niimg)) try: this_dtype = niimg.get_data_dtype() except AttributeError: # Nibabel bug this_dtype = niimg.get_data().dtype dtype = _get_target_dtype(this_dtype, dtype) if dtype is not None: niimg = new_img_like(niimg, niimg.get_data().astype(dtype), get_affine(niimg)) return niimg
def test_nifti_maps_masker_2(): # Test resampling in NiftiMapsMasker affine = np.eye(4) shape1 = (10, 11, 12) # fmri shape2 = (13, 14, 15) # mask shape3 = (16, 17, 18) # maps n_regions = 9 length = 3 fmri11_img, _ = generate_random_img(shape1, affine=affine, length=length) _, mask22_img = generate_random_img(shape2, affine=affine, length=length) maps33_img, _ = \ testing.generate_maps(shape3, n_regions, affine=affine) mask_img_4d = nibabel.Nifti1Image(np.ones((2, 2, 2, 2), dtype=np.int8), affine=np.diag((4, 4, 4, 1))) # verify that 4D mask arguments are refused masker = NiftiMapsMasker(maps33_img, mask_img=mask_img_4d) testing.assert_raises_regex( DimensionError, "Input data has incompatible dimensionality: " "Expected dimension is 3D and you provided " "a 4D image.", masker.fit) # Test error checking assert_raises(ValueError, NiftiMapsMasker, maps33_img, resampling_target="mask") assert_raises(ValueError, NiftiMapsMasker, maps33_img, resampling_target="invalid") # Target: mask masker = NiftiMapsMasker(maps33_img, mask_img=mask22_img, resampling_target="mask") masker.fit() np.testing.assert_almost_equal(get_affine(masker.mask_img_), get_affine(mask22_img)) assert_equal(masker.mask_img_.shape, mask22_img.shape) np.testing.assert_almost_equal(get_affine(masker.mask_img_), get_affine(masker.maps_img_)) assert_equal(masker.mask_img_.shape, masker.maps_img_.shape[:3]) transformed = masker.transform(fmri11_img) assert_equal(transformed.shape, (length, n_regions)) fmri11_img_r = masker.inverse_transform(transformed) np.testing.assert_almost_equal(get_affine(fmri11_img_r), get_affine(masker.maps_img_)) assert_equal(fmri11_img_r.shape, (masker.maps_img_.shape[:3] + (length, ))) # Target: maps masker = NiftiMapsMasker(maps33_img, mask_img=mask22_img, resampling_target="maps") masker.fit() np.testing.assert_almost_equal(get_affine(masker.maps_img_), get_affine(maps33_img)) assert_equal(masker.maps_img_.shape, maps33_img.shape) np.testing.assert_almost_equal(get_affine(masker.mask_img_), get_affine(masker.maps_img_)) assert_equal(masker.mask_img_.shape, masker.maps_img_.shape[:3]) transformed = masker.transform(fmri11_img) assert_equal(transformed.shape, (length, n_regions)) fmri11_img_r = masker.inverse_transform(transformed) np.testing.assert_almost_equal(get_affine(fmri11_img_r), get_affine(masker.maps_img_)) assert_equal(fmri11_img_r.shape, (masker.maps_img_.shape[:3] + (length, ))) # Test with clipped maps: mask does not contain all maps. # Shapes do matter in that case affine1 = np.eye(4) shape1 = (10, 11, 12) shape2 = (8, 9, 10) # mask affine2 = np.diag((2, 2, 2, 1)) # just for mask shape3 = (16, 18, 20) # maps n_regions = 9 length = 21 fmri11_img, _ = generate_random_img(shape1, affine=affine1, length=length) _, mask22_img = testing.generate_fake_fmri(shape2, length=1, affine=affine2) # Target: maps maps33_img, _ = \ testing.generate_maps(shape3, n_regions, affine=affine1) masker = NiftiMapsMasker(maps33_img, mask_img=mask22_img, resampling_target="maps") masker.fit() np.testing.assert_almost_equal(get_affine(masker.maps_img_), get_affine(maps33_img)) assert_equal(masker.maps_img_.shape, maps33_img.shape) np.testing.assert_almost_equal(get_affine(masker.mask_img_), get_affine(masker.maps_img_)) assert_equal(masker.mask_img_.shape, masker.maps_img_.shape[:3]) transformed = masker.transform(fmri11_img) assert_equal(transformed.shape, (length, n_regions)) # Some regions have been clipped. Resulting signal must be zero assert_less((transformed.var(axis=0) == 0).sum(), n_regions) fmri11_img_r = masker.inverse_transform(transformed) np.testing.assert_almost_equal(get_affine(fmri11_img_r), get_affine(masker.maps_img_)) assert_equal(fmri11_img_r.shape, (masker.maps_img_.shape[:3] + (length, )))
def test_nifti_maps_masker(): # Check working of shape/affine checks shape1 = (13, 11, 12) affine1 = np.eye(4) shape2 = (12, 10, 14) affine2 = np.diag((1, 2, 3, 1)) n_regions = 9 length = 3 fmri11_img, mask11_img = generate_random_img(shape1, affine=affine1, length=length) fmri12_img, mask12_img = generate_random_img(shape1, affine=affine2, length=length) fmri21_img, mask21_img = generate_random_img(shape2, affine=affine1, length=length) labels11_img, labels_mask_img = \ testing.generate_maps(shape1, n_regions, affine=affine1) # No exception raised here for create_files in (True, False): with testing.write_tmp_imgs(labels11_img, create_files=create_files) \ as labels11: masker11 = NiftiMapsMasker(labels11, resampling_target=None) signals11 = masker11.fit().transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) # enables to delete "labels11" on windows del masker11 masker11 = NiftiMapsMasker(labels11_img, mask_img=mask11_img, resampling_target=None) testing.assert_raises_regex(ValueError, 'has not been fitted. ', masker11.transform, fmri11_img) signals11 = masker11.fit().transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) NiftiMapsMasker(labels11_img).fit_transform(fmri11_img) # Test all kinds of mismatches between shapes and between affines for create_files in (True, False): with testing.write_tmp_imgs(labels11_img, mask12_img, create_files=create_files) as images: labels11, mask12 = images masker11 = NiftiMapsMasker(labels11, resampling_target=None) masker11.fit() assert_raises(ValueError, masker11.transform, fmri12_img) assert_raises(ValueError, masker11.transform, fmri21_img) masker11 = NiftiMapsMasker(labels11, mask_img=mask12, resampling_target=None) assert_raises(ValueError, masker11.fit) masker11 = NiftiMapsMasker(labels11_img, mask_img=mask21_img, resampling_target=None) assert_raises(ValueError, masker11.fit) # Transform, with smoothing (smoke test) masker11 = NiftiMapsMasker(labels11_img, smoothing_fwhm=3, resampling_target=None) signals11 = masker11.fit().transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) masker11 = NiftiMapsMasker(labels11_img, smoothing_fwhm=3, resampling_target=None) signals11 = masker11.fit_transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) testing.assert_raises_regex( ValueError, 'has not been fitted. ', NiftiMapsMasker(labels11_img).inverse_transform, signals11) # Call inverse transform (smoke test) fmri11_img_r = masker11.inverse_transform(signals11) assert_equal(fmri11_img_r.shape, fmri11_img.shape) np.testing.assert_almost_equal(get_affine(fmri11_img_r), get_affine(fmri11_img)) # Test with data and atlas of different shape: the atlas should be # resampled to the data shape22 = (5, 5, 6) affine2 = 2 * np.eye(4) affine2[-1, -1] = 1 fmri22_img, _ = generate_random_img(shape22, affine=affine2, length=length) masker = NiftiMapsMasker(labels11_img, mask_img=mask21_img) masker.fit_transform(fmri22_img) np.testing.assert_array_equal(get_affine(masker._resampled_maps_img_), affine2)
def test_nifti_maps_masker_2(): # Test resampling in NiftiMapsMasker affine = np.eye(4) shape1 = (10, 11, 12) # fmri shape2 = (13, 14, 15) # mask shape3 = (16, 17, 18) # maps n_regions = 9 length = 3 fmri11_img, _ = generate_random_img(shape1, affine=affine, length=length) _, mask22_img = generate_random_img(shape2, affine=affine, length=length) maps33_img, _ = \ testing.generate_maps(shape3, n_regions, affine=affine) mask_img_4d = nibabel.Nifti1Image(np.ones((2, 2, 2, 2), dtype=np.int8), affine=np.diag((4, 4, 4, 1))) # verify that 4D mask arguments are refused masker = NiftiMapsMasker(maps33_img, mask_img=mask_img_4d) testing.assert_raises_regex(DimensionError, "Input data has incompatible dimensionality: " "Expected dimension is 3D and you provided " "a 4D image.", masker.fit) # Test error checking assert_raises(ValueError, NiftiMapsMasker, maps33_img, resampling_target="mask") assert_raises(ValueError, NiftiMapsMasker, maps33_img, resampling_target="invalid") # Target: mask masker = NiftiMapsMasker(maps33_img, mask_img=mask22_img, resampling_target="mask") masker.fit() np.testing.assert_almost_equal(get_affine(masker.mask_img_), get_affine(mask22_img)) assert_equal(masker.mask_img_.shape, mask22_img.shape) np.testing.assert_almost_equal(get_affine(masker.mask_img_), get_affine(masker.maps_img_)) assert_equal(masker.mask_img_.shape, masker.maps_img_.shape[:3]) transformed = masker.transform(fmri11_img) assert_equal(transformed.shape, (length, n_regions)) fmri11_img_r = masker.inverse_transform(transformed) np.testing.assert_almost_equal(get_affine(fmri11_img_r), get_affine(masker.maps_img_)) assert_equal(fmri11_img_r.shape, (masker.maps_img_.shape[:3] + (length,))) # Target: maps masker = NiftiMapsMasker(maps33_img, mask_img=mask22_img, resampling_target="maps") masker.fit() np.testing.assert_almost_equal(get_affine(masker.maps_img_), get_affine(maps33_img)) assert_equal(masker.maps_img_.shape, maps33_img.shape) np.testing.assert_almost_equal(get_affine(masker.mask_img_), get_affine(masker.maps_img_)) assert_equal(masker.mask_img_.shape, masker.maps_img_.shape[:3]) transformed = masker.transform(fmri11_img) assert_equal(transformed.shape, (length, n_regions)) fmri11_img_r = masker.inverse_transform(transformed) np.testing.assert_almost_equal(get_affine(fmri11_img_r), get_affine(masker.maps_img_)) assert_equal(fmri11_img_r.shape, (masker.maps_img_.shape[:3] + (length,))) # Test with clipped maps: mask does not contain all maps. # Shapes do matter in that case affine1 = np.eye(4) shape1 = (10, 11, 12) shape2 = (8, 9, 10) # mask affine2 = np.diag((2, 2, 2, 1)) # just for mask shape3 = (16, 18, 20) # maps n_regions = 9 length = 21 fmri11_img, _ = generate_random_img(shape1, affine=affine1, length=length) _, mask22_img = testing.generate_fake_fmri(shape2, length=1, affine=affine2) # Target: maps maps33_img, _ = \ testing.generate_maps(shape3, n_regions, affine=affine1) masker = NiftiMapsMasker(maps33_img, mask_img=mask22_img, resampling_target="maps") masker.fit() np.testing.assert_almost_equal(get_affine(masker.maps_img_), get_affine(maps33_img)) assert_equal(masker.maps_img_.shape, maps33_img.shape) np.testing.assert_almost_equal(get_affine(masker.mask_img_), get_affine(masker.maps_img_)) assert_equal(masker.mask_img_.shape, masker.maps_img_.shape[:3]) transformed = masker.transform(fmri11_img) assert_equal(transformed.shape, (length, n_regions)) # Some regions have been clipped. Resulting signal must be zero assert_less((transformed.var(axis=0) == 0).sum(), n_regions) fmri11_img_r = masker.inverse_transform(transformed) np.testing.assert_almost_equal(get_affine(fmri11_img_r), get_affine(masker.maps_img_)) assert_equal(fmri11_img_r.shape, (masker.maps_img_.shape[:3] + (length,)))
def test_nifti_maps_masker(): # Check working of shape/affine checks shape1 = (13, 11, 12) affine1 = np.eye(4) shape2 = (12, 10, 14) affine2 = np.diag((1, 2, 3, 1)) n_regions = 9 length = 3 fmri11_img, mask11_img = generate_random_img(shape1, affine=affine1, length=length) fmri12_img, mask12_img = generate_random_img(shape1, affine=affine2, length=length) fmri21_img, mask21_img = generate_random_img(shape2, affine=affine1, length=length) labels11_img, labels_mask_img = \ testing.generate_maps(shape1, n_regions, affine=affine1) # No exception raised here for create_files in (True, False): with testing.write_tmp_imgs(labels11_img, create_files=create_files) \ as labels11: masker11 = NiftiMapsMasker(labels11, resampling_target=None) signals11 = masker11.fit().transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) # enables to delete "labels11" on windows del masker11 masker11 = NiftiMapsMasker(labels11_img, mask_img=mask11_img, resampling_target=None) testing.assert_raises_regex( ValueError, 'has not been fitted. ', masker11.transform, fmri11_img) signals11 = masker11.fit().transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) NiftiMapsMasker(labels11_img).fit_transform(fmri11_img) # Test all kinds of mismatches between shapes and between affines for create_files in (True, False): with testing.write_tmp_imgs(labels11_img, mask12_img, create_files=create_files) as images: labels11, mask12 = images masker11 = NiftiMapsMasker(labels11, resampling_target=None) masker11.fit() assert_raises(ValueError, masker11.transform, fmri12_img) assert_raises(ValueError, masker11.transform, fmri21_img) masker11 = NiftiMapsMasker(labels11, mask_img=mask12, resampling_target=None) assert_raises(ValueError, masker11.fit) del masker11 masker11 = NiftiMapsMasker(labels11_img, mask_img=mask21_img, resampling_target=None) assert_raises(ValueError, masker11.fit) # Transform, with smoothing (smoke test) masker11 = NiftiMapsMasker(labels11_img, smoothing_fwhm=3, resampling_target=None) signals11 = masker11.fit().transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) masker11 = NiftiMapsMasker(labels11_img, smoothing_fwhm=3, resampling_target=None) signals11 = masker11.fit_transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) testing.assert_raises_regex( ValueError, 'has not been fitted. ', NiftiMapsMasker(labels11_img).inverse_transform, signals11) # Call inverse transform (smoke test) fmri11_img_r = masker11.inverse_transform(signals11) assert_equal(fmri11_img_r.shape, fmri11_img.shape) np.testing.assert_almost_equal(get_affine(fmri11_img_r), get_affine(fmri11_img)) # Test with data and atlas of different shape: the atlas should be # resampled to the data shape22 = (5, 5, 6) affine2 = 2 * np.eye(4) affine2[-1, -1] = 1 fmri22_img, _ = generate_random_img(shape22, affine=affine2, length=length) masker = NiftiMapsMasker(labels11_img, mask_img=mask21_img) masker.fit_transform(fmri22_img) np.testing.assert_array_equal( get_affine(masker._resampled_maps_img_), affine2)
def test_reorder_img(): # We need to test on a square array, as rotation does not change # shape, whereas reordering does. shape = (5, 5, 5, 2, 2) rng = np.random.RandomState(42) data = rng.rand(*shape) affine = np.eye(4) affine[:3, -1] = 0.5 * np.array(shape[:3]) ref_img = Nifti1Image(data, affine) # Test with purely positive matrices and compare to a rotation for theta, phi in np.random.randint(4, size=(5, 2)): rot = rotation(theta * np.pi / 2, phi * np.pi / 2) rot[np.abs(rot) < 0.001] = 0 rot[rot > 0.9] = 1 rot[rot < -0.9] = 1 b = 0.5 * np.array(shape[:3]) new_affine = from_matrix_vector(rot, b) rot_img = resample_img(ref_img, target_affine=new_affine) np.testing.assert_array_equal(compat.get_affine(rot_img), new_affine) np.testing.assert_array_equal(rot_img.get_data().shape, shape) reordered_img = reorder_img(rot_img) np.testing.assert_array_equal(compat.get_affine(reordered_img)[:3, :3], np.eye(3)) np.testing.assert_almost_equal(reordered_img.get_data(), data) # Create a non-diagonal affine, and check that we raise a sensible # exception affine[1, 0] = 0.1 ref_img = Nifti1Image(data, affine) testing.assert_raises_regex(ValueError, 'Cannot reorder the axes', reorder_img, ref_img) # Test that no exception is raised when resample='continuous' reorder_img(ref_img, resample='continuous') # Test that resample args gets passed to resample_img interpolation = 'nearest' reordered_img = reorder_img(ref_img, resample=interpolation) resampled_img = resample_img(ref_img, target_affine=compat.get_affine(reordered_img), interpolation=interpolation) np.testing.assert_array_equal(reordered_img.get_data(), resampled_img.get_data()) # Make sure invalid resample argument is included in the error message interpolation = 'an_invalid_interpolation' pattern = "interpolation must be either.+{0}".format(interpolation) testing.assert_raises_regex(ValueError, pattern, reorder_img, ref_img, resample=interpolation) # Test flipping an axis data = rng.rand(*shape) for i in (0, 1, 2): # Make a diagonal affine with a negative axis, and check that # can be reordered, also vary the shape shape = (i + 1, i + 2, 3 - i) affine = np.eye(4) affine[i, i] *= -1 img = Nifti1Image(data, affine) orig_img = copy.copy(img) #x, y, z = img.get_world_coords() #sample = img.values_in_world(x, y, z) img2 = reorder_img(img) # Check that img has not been changed np.testing.assert_array_equal(compat.get_affine(img), compat.get_affine(orig_img)) np.testing.assert_array_equal(img.get_data(), orig_img.get_data()) # Test that the affine is indeed diagonal: np.testing.assert_array_equal(compat.get_affine(img2)[:3, :3], np.diag(np.diag( compat.get_affine(img2)[:3, :3]))) assert_true(np.all(np.diag(compat.get_affine(img2)) >= 0))
def find_region_names_using_cut_coords(coords, atlas_img, labels=None): """Given list of MNI space coordinates, get names of the brain regions. Names of the brain regions are returned by getting nearest coordinates in the given `atlas_img` space iterated over the provided list of `coords`. These new image coordinates are then used to grab the label number (int) and name assigned to it. Last, these names are returned. Parameters ---------- coords : Tuples of coordinates in a list MNI coordinates. atlas_img : Nifti-like image Path to or Nifti-like object. The labels (integers) ordered in this image should be sequential. Example: [0, 1, 2, 3, 4] but not [0, 5, 6, 7]. Helps in returning correct names without errors. labels : str in a list Names of the brain regions assigned to each label in atlas_img. NOTE: label with index 0 is assumed as background. Example: harvard oxford atlas. Hence be removed. Returns ------- new_labels : int in a list Labels in integers generated according to correspondence with given atlas image and provided coordinates. names : str in a list Names of the brain regions generated according to given inputs. """ if not isinstance(coords, collections.Iterable): raise ValueError("coords given must be a list of triplets of " "coordinates in native space [(1, 2, 3)]. " "You provided {0}".format(type(coords))) if isinstance(atlas_img, _basestring): atlas_img = check_niimg(atlas_img) affine = get_affine(atlas_img) atlas_data = _safe_get_data(atlas_img, ensure_finite=True) check_labels_from_atlas = np.unique(atlas_data) if labels is not None: names = [] if not isinstance(labels, collections.Iterable): labels = np.asarray(labels) if isinstance(labels, collections.Iterable) and \ isinstance(check_labels_from_atlas, collections.Iterable): if len(check_labels_from_atlas) != len(labels): warnings.warn("The number of labels provided does not match " "with number of unique labels with atlas image.", stacklevel=2) coords = list(coords) nearest_coordinates = [] for sx, sy, sz in coords: nearest = np.round(coord_transform(sx, sy, sz, np.linalg.inv(affine))) nearest = nearest.astype(int) nearest = (nearest[0], nearest[1], nearest[2]) nearest_coordinates.append(nearest) assert(len(nearest_coordinates) == len(coords)) new_labels = [] for coord_ in nearest_coordinates: # Grab index of current coordinate index = atlas_data[coord_] new_labels.append(index) if labels is not None: names.append(labels[index]) if labels is not None: return new_labels, names else: return new_labels
def test_nifti_labels_masker_resampling(): # Test resampling in NiftiLabelsMasker shape1 = (10, 11, 12) affine = np.eye(4) # mask shape2 = (16, 17, 18) # labels shape3 = (13, 14, 15) n_regions = 9 length = 3 # With data of the same affine fmri11_img, _ = generate_random_img(shape1, affine=affine, length=length) _, mask22_img = generate_random_img(shape2, affine=affine, length=length) labels33_img = testing.generate_labeled_regions(shape3, n_regions, affine=affine) # Test error checking assert_raises(ValueError, NiftiLabelsMasker, labels33_img, resampling_target="mask") assert_raises(ValueError, NiftiLabelsMasker, labels33_img, resampling_target="invalid") # Target: labels masker = NiftiLabelsMasker(labels33_img, mask_img=mask22_img, resampling_target="labels") masker.fit() np.testing.assert_almost_equal(get_affine(masker.labels_img_), get_affine(labels33_img)) assert_equal(masker.labels_img_.shape, labels33_img.shape) np.testing.assert_almost_equal(get_affine(masker.mask_img_), get_affine(masker.labels_img_)) assert_equal(masker.mask_img_.shape, masker.labels_img_.shape[:3]) transformed = masker.transform(fmri11_img) assert_equal(transformed.shape, (length, n_regions)) fmri11_img_r = masker.inverse_transform(transformed) np.testing.assert_almost_equal(get_affine(fmri11_img_r), get_affine(masker.labels_img_)) assert_equal(fmri11_img_r.shape, (masker.labels_img_.shape[:3] + (length,))) # Test with clipped labels: mask does not contain all labels. # Shapes do matter in that case, because there is some resampling # taking place. shape1 = (10, 11, 12) # fmri shape2 = (8, 9, 10) # mask shape3 = (16, 18, 20) # maps n_regions = 9 length = 21 fmri11_img, _ = generate_random_img(shape1, affine=affine, length=length) _, mask22_img = generate_random_img(shape2, affine=affine, length=length) # Target: labels labels33_img = testing.generate_labeled_regions(shape3, n_regions, affine=affine) masker = NiftiLabelsMasker(labels33_img, mask_img=mask22_img, resampling_target="labels") masker.fit() np.testing.assert_almost_equal(get_affine(masker.labels_img_), get_affine(labels33_img)) assert_equal(masker.labels_img_.shape, labels33_img.shape) np.testing.assert_almost_equal(get_affine(masker.mask_img_), get_affine(masker.labels_img_)) assert_equal(masker.mask_img_.shape, masker.labels_img_.shape[:3]) uniq_labels = np.unique(masker.labels_img_.get_data()) assert_equal(uniq_labels[0], 0) assert_equal(len(uniq_labels) - 1, n_regions) transformed = masker.transform(fmri11_img) assert_equal(transformed.shape, (length, n_regions)) # Some regions have been clipped. Resulting signal must be zero assert_less((transformed.var(axis=0) == 0).sum(), n_regions) fmri11_img_r = masker.inverse_transform(transformed) np.testing.assert_almost_equal(get_affine(fmri11_img_r), get_affine(masker.labels_img_)) assert_equal(fmri11_img_r.shape, (masker.labels_img_.shape[:3] + (length,))) # Test with data and atlas of different shape: the atlas should be # resampled to the data shape22 = (5, 5, 6) affine2 = 2 * np.eye(4) affine2[-1, -1] = 1 fmri22_img, _ = generate_random_img(shape22, affine=affine2, length=length) masker = NiftiLabelsMasker(labels33_img, mask_img=mask22_img) masker.fit_transform(fmri22_img) np.testing.assert_array_equal( get_affine(masker._resampled_labels_img_), affine2) # Test with filenames with testing.write_tmp_imgs(fmri22_img) as filename: masker = NiftiLabelsMasker(labels33_img, resampling_target='data') masker.fit_transform(filename)
def test_nifti_labels_masker(): # Check working of shape/affine checks shape1 = (13, 11, 12) affine1 = np.eye(4) shape2 = (12, 10, 14) affine2 = np.diag((1, 2, 3, 1)) n_regions = 9 length = 3 fmri11_img, mask11_img = generate_random_img(shape1, affine=affine1, length=length) fmri12_img, mask12_img = generate_random_img(shape1, affine=affine2, length=length) fmri21_img, mask21_img = generate_random_img(shape2, affine=affine1, length=length) labels11_img = testing.generate_labeled_regions(shape1, affine=affine1, n_regions=n_regions) mask_img_4d = nibabel.Nifti1Image(np.ones((2, 2, 2, 2), dtype=np.int8), affine=np.diag((4, 4, 4, 1))) # verify that 4D mask arguments are refused masker = NiftiLabelsMasker(labels11_img, mask_img=mask_img_4d) testing.assert_raises_regex(DimensionError, "Input data has incompatible dimensionality: " "Expected dimension is 3D and you provided " "a 4D image.", masker.fit) # check exception when transform() called without prior fit() masker11 = NiftiLabelsMasker(labels11_img, resampling_target=None) testing.assert_raises_regex( ValueError, 'has not been fitted. ', masker11.transform, fmri11_img) # No exception raised here signals11 = masker11.fit().transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) masker11 = NiftiLabelsMasker(labels11_img, mask_img=mask11_img, resampling_target=None) signals11 = masker11.fit().transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) # Test all kinds of mismatch between shapes and between affines masker11 = NiftiLabelsMasker(labels11_img, resampling_target=None) masker11.fit() assert_raises(ValueError, masker11.transform, fmri12_img) assert_raises(ValueError, masker11.transform, fmri21_img) masker11 = NiftiLabelsMasker(labels11_img, mask_img=mask12_img, resampling_target=None) assert_raises(ValueError, masker11.fit) masker11 = NiftiLabelsMasker(labels11_img, mask_img=mask21_img, resampling_target=None) assert_raises(ValueError, masker11.fit) # Transform, with smoothing (smoke test) masker11 = NiftiLabelsMasker(labels11_img, smoothing_fwhm=3, resampling_target=None) signals11 = masker11.fit().transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) masker11 = NiftiLabelsMasker(labels11_img, smoothing_fwhm=3, resampling_target=None) signals11 = masker11.fit_transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) testing.assert_raises_regex( ValueError, 'has not been fitted. ', NiftiLabelsMasker(labels11_img).inverse_transform, signals11) # Call inverse transform (smoke test) fmri11_img_r = masker11.inverse_transform(signals11) assert_equal(fmri11_img_r.shape, fmri11_img.shape) np.testing.assert_almost_equal(get_affine(fmri11_img_r), get_affine(fmri11_img))
def test_reorder_img(): # We need to test on a square array, as rotation does not change # shape, whereas reordering does. shape = (5, 5, 5, 2, 2) rng = np.random.RandomState(42) data = rng.rand(*shape) affine = np.eye(4) affine[:3, -1] = 0.5 * np.array(shape[:3]) ref_img = Nifti1Image(data, affine) # Test with purely positive matrices and compare to a rotation for theta, phi in np.random.randint(4, size=(5, 2)): rot = rotation(theta * np.pi / 2, phi * np.pi / 2) rot[np.abs(rot) < 0.001] = 0 rot[rot > 0.9] = 1 rot[rot < -0.9] = 1 b = 0.5 * np.array(shape[:3]) new_affine = from_matrix_vector(rot, b) rot_img = resample_img(ref_img, target_affine=new_affine) np.testing.assert_array_equal(compat.get_affine(rot_img), new_affine) np.testing.assert_array_equal(rot_img.get_data().shape, shape) reordered_img = reorder_img(rot_img) np.testing.assert_array_equal( compat.get_affine(reordered_img)[:3, :3], np.eye(3)) np.testing.assert_almost_equal(reordered_img.get_data(), data) # Create a non-diagonal affine, and check that we raise a sensible # exception affine[1, 0] = 0.1 ref_img = Nifti1Image(data, affine) testing.assert_raises_regex(ValueError, 'Cannot reorder the axes', reorder_img, ref_img) # Test that no exception is raised when resample='continuous' reorder_img(ref_img, resample='continuous') # Test that resample args gets passed to resample_img interpolation = 'nearest' reordered_img = reorder_img(ref_img, resample=interpolation) resampled_img = resample_img( ref_img, target_affine=compat.get_affine(reordered_img), interpolation=interpolation) np.testing.assert_array_equal(reordered_img.get_data(), resampled_img.get_data()) # Make sure invalid resample argument is included in the error message interpolation = 'an_invalid_interpolation' pattern = "interpolation must be either.+{0}".format(interpolation) testing.assert_raises_regex(ValueError, pattern, reorder_img, ref_img, resample=interpolation) # Test flipping an axis data = rng.rand(*shape) for i in (0, 1, 2): # Make a diagonal affine with a negative axis, and check that # can be reordered, also vary the shape shape = (i + 1, i + 2, 3 - i) affine = np.eye(4) affine[i, i] *= -1 img = Nifti1Image(data, affine) orig_img = copy.copy(img) #x, y, z = img.get_world_coords() #sample = img.values_in_world(x, y, z) img2 = reorder_img(img) # Check that img has not been changed np.testing.assert_array_equal(compat.get_affine(img), compat.get_affine(orig_img)) np.testing.assert_array_equal(img.get_data(), orig_img.get_data()) # Test that the affine is indeed diagonal: np.testing.assert_array_equal( compat.get_affine(img2)[:3, :3], np.diag(np.diag(compat.get_affine(img2)[:3, :3]))) assert_true(np.all(np.diag(compat.get_affine(img2)) >= 0))
def test_nifti_labels_masker_resampling(): # Test resampling in NiftiLabelsMasker shape1 = (10, 11, 12) affine = np.eye(4) # mask shape2 = (16, 17, 18) # labels shape3 = (13, 14, 15) n_regions = 9 length = 3 # With data of the same affine fmri11_img, _ = generate_random_img(shape1, affine=affine, length=length) _, mask22_img = generate_random_img(shape2, affine=affine, length=length) labels33_img = testing.generate_labeled_regions(shape3, n_regions, affine=affine) # Test error checking assert_raises(ValueError, NiftiLabelsMasker, labels33_img, resampling_target="mask") assert_raises(ValueError, NiftiLabelsMasker, labels33_img, resampling_target="invalid") # Target: labels masker = NiftiLabelsMasker(labels33_img, mask_img=mask22_img, resampling_target="labels") masker.fit() np.testing.assert_almost_equal(get_affine(masker.labels_img_), get_affine(labels33_img)) assert_equal(masker.labels_img_.shape, labels33_img.shape) np.testing.assert_almost_equal(get_affine(masker.mask_img_), get_affine(masker.labels_img_)) assert_equal(masker.mask_img_.shape, masker.labels_img_.shape[:3]) transformed = masker.transform(fmri11_img) assert_equal(transformed.shape, (length, n_regions)) fmri11_img_r = masker.inverse_transform(transformed) np.testing.assert_almost_equal(get_affine(fmri11_img_r), get_affine(masker.labels_img_)) assert_equal(fmri11_img_r.shape, (masker.labels_img_.shape[:3] + (length, ))) # Test with clipped labels: mask does not contain all labels. # Shapes do matter in that case, because there is some resampling # taking place. shape1 = (10, 11, 12) # fmri shape2 = (8, 9, 10) # mask shape3 = (16, 18, 20) # maps n_regions = 9 length = 21 fmri11_img, _ = generate_random_img(shape1, affine=affine, length=length) _, mask22_img = generate_random_img(shape2, affine=affine, length=length) # Target: labels labels33_img = testing.generate_labeled_regions(shape3, n_regions, affine=affine) masker = NiftiLabelsMasker(labels33_img, mask_img=mask22_img, resampling_target="labels") masker.fit() np.testing.assert_almost_equal(get_affine(masker.labels_img_), get_affine(labels33_img)) assert_equal(masker.labels_img_.shape, labels33_img.shape) np.testing.assert_almost_equal(get_affine(masker.mask_img_), get_affine(masker.labels_img_)) assert_equal(masker.mask_img_.shape, masker.labels_img_.shape[:3]) uniq_labels = np.unique(masker.labels_img_.get_data()) assert_equal(uniq_labels[0], 0) assert_equal(len(uniq_labels) - 1, n_regions) transformed = masker.transform(fmri11_img) assert_equal(transformed.shape, (length, n_regions)) # Some regions have been clipped. Resulting signal must be zero assert_less((transformed.var(axis=0) == 0).sum(), n_regions) fmri11_img_r = masker.inverse_transform(transformed) np.testing.assert_almost_equal(get_affine(fmri11_img_r), get_affine(masker.labels_img_)) assert_equal(fmri11_img_r.shape, (masker.labels_img_.shape[:3] + (length, ))) # Test with data and atlas of different shape: the atlas should be # resampled to the data shape22 = (5, 5, 6) affine2 = 2 * np.eye(4) affine2[-1, -1] = 1 fmri22_img, _ = generate_random_img(shape22, affine=affine2, length=length) masker = NiftiLabelsMasker(labels33_img, mask_img=mask22_img) masker.fit_transform(fmri22_img) np.testing.assert_array_equal(get_affine(masker._resampled_labels_img_), affine2) # Test with filenames with testing.write_tmp_imgs(fmri22_img) as filename: masker = NiftiLabelsMasker(labels33_img, resampling_target='data') masker.fit_transform(filename)
def test_signal_extraction_with_maps_and_labels(): shape = (4, 5, 6) n_regions = 7 length = 8 # Generate labels labels = list(range(n_regions + 1)) # 0 is background labels_img = generate_labeled_regions(shape, n_regions, labels=labels) labels_data = labels_img.get_data() # Convert to maps maps_data = np.zeros(shape + (n_regions,)) for n, l in enumerate(labels): if n == 0: continue maps_data[labels_data == l, n - 1] = 1 maps_img = nibabel.Nifti1Image(maps_data, get_affine(labels_img)) # Generate fake data fmri_img, _ = generate_fake_fmri(shape=shape, length=length, affine=get_affine(labels_img)) # Extract signals from maps and labels: results must be identical. maps_signals, maps_labels = signal_extraction.img_to_signals_maps( fmri_img, maps_img) labels_signals, labels_labels = signal_extraction.img_to_signals_labels( fmri_img, labels_img) np.testing.assert_almost_equal(maps_signals, labels_signals) # Same thing with a mask, containing only 3 regions. mask_data = (labels_data == 1) + (labels_data == 2) + (labels_data == 5) mask_img = nibabel.Nifti1Image(mask_data.astype(np.int8), get_affine(labels_img)) labels_signals, labels_labels = signal_extraction.img_to_signals_labels( fmri_img, labels_img, mask_img=mask_img) maps_signals, maps_labels = signal_extraction.img_to_signals_maps( fmri_img, maps_img, mask_img=mask_img) np.testing.assert_almost_equal(maps_signals, labels_signals) assert_true(maps_signals.shape[1] == n_regions) assert_true(maps_labels == list(range(len(maps_labels)))) assert_true(labels_signals.shape == (length, n_regions)) assert_true(labels_labels == labels[1:]) # Inverse operation (mostly smoke test) labels_img_r = signal_extraction.signals_to_img_labels( labels_signals, labels_img, mask_img=mask_img) assert_true(labels_img_r.shape == shape + (length,)) maps_img_r = signal_extraction.signals_to_img_maps( maps_signals, maps_img, mask_img=mask_img) assert_true(maps_img_r.shape == shape + (length,)) # Check that NaNs in regions inside mask are preserved region1 = labels_data == 2 indices = [ind[:1] for ind in np.where(region1)] fmri_img.get_data()[indices + [slice(None)]] = float('nan') labels_signals, labels_labels = signal_extraction.img_to_signals_labels( fmri_img, labels_img, mask_img=mask_img) assert_true(np.all(np.isnan(labels_signals[:, labels_labels.index(2)])))
def test_nifti_labels_masker(): # Check working of shape/affine checks shape1 = (13, 11, 12) affine1 = np.eye(4) shape2 = (12, 10, 14) affine2 = np.diag((1, 2, 3, 1)) n_regions = 9 length = 3 fmri11_img, mask11_img = generate_random_img(shape1, affine=affine1, length=length) fmri12_img, mask12_img = generate_random_img(shape1, affine=affine2, length=length) fmri21_img, mask21_img = generate_random_img(shape2, affine=affine1, length=length) labels11_img = testing.generate_labeled_regions(shape1, affine=affine1, n_regions=n_regions) mask_img_4d = nibabel.Nifti1Image(np.ones((2, 2, 2, 2), dtype=np.int8), affine=np.diag((4, 4, 4, 1))) # verify that 4D mask arguments are refused masker = NiftiLabelsMasker(labels11_img, mask_img=mask_img_4d) testing.assert_raises_regex( DimensionError, "Input data has incompatible dimensionality: " "Expected dimension is 3D and you provided " "a 4D image.", masker.fit) # check exception when transform() called without prior fit() masker11 = NiftiLabelsMasker(labels11_img, resampling_target=None) testing.assert_raises_regex(ValueError, 'has not been fitted. ', masker11.transform, fmri11_img) # No exception raised here signals11 = masker11.fit().transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) masker11 = NiftiLabelsMasker(labels11_img, mask_img=mask11_img, resampling_target=None) signals11 = masker11.fit().transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) # Test all kinds of mismatch between shapes and between affines masker11 = NiftiLabelsMasker(labels11_img, resampling_target=None) masker11.fit() assert_raises(ValueError, masker11.transform, fmri12_img) assert_raises(ValueError, masker11.transform, fmri21_img) masker11 = NiftiLabelsMasker(labels11_img, mask_img=mask12_img, resampling_target=None) assert_raises(ValueError, masker11.fit) masker11 = NiftiLabelsMasker(labels11_img, mask_img=mask21_img, resampling_target=None) assert_raises(ValueError, masker11.fit) # Transform, with smoothing (smoke test) masker11 = NiftiLabelsMasker(labels11_img, smoothing_fwhm=3, resampling_target=None) signals11 = masker11.fit().transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) masker11 = NiftiLabelsMasker(labels11_img, smoothing_fwhm=3, resampling_target=None) signals11 = masker11.fit_transform(fmri11_img) assert_equal(signals11.shape, (length, n_regions)) testing.assert_raises_regex( ValueError, 'has not been fitted. ', NiftiLabelsMasker(labels11_img).inverse_transform, signals11) # Call inverse transform (smoke test) fmri11_img_r = masker11.inverse_transform(signals11) assert_equal(fmri11_img_r.shape, fmri11_img.shape) np.testing.assert_almost_equal(get_affine(fmri11_img_r), get_affine(fmri11_img))
def test_signal_extraction_with_maps_and_labels(): shape = (4, 5, 6) n_regions = 7 length = 8 # Generate labels labels = list(range(n_regions + 1)) # 0 is background labels_img = generate_labeled_regions(shape, n_regions, labels=labels) labels_data = labels_img.get_data() # Convert to maps maps_data = np.zeros(shape + (n_regions, )) for n, l in enumerate(labels): if n == 0: continue maps_data[labels_data == l, n - 1] = 1 maps_img = nibabel.Nifti1Image(maps_data, get_affine(labels_img)) # Generate fake data fmri_img, _ = generate_fake_fmri(shape=shape, length=length, affine=get_affine(labels_img)) # Extract signals from maps and labels: results must be identical. maps_signals, maps_labels = signal_extraction.img_to_signals_maps( fmri_img, maps_img) labels_signals, labels_labels = signal_extraction.img_to_signals_labels( fmri_img, labels_img) np.testing.assert_almost_equal(maps_signals, labels_signals) # Same thing with a mask, containing only 3 regions. mask_data = (labels_data == 1) + (labels_data == 2) + (labels_data == 5) mask_img = nibabel.Nifti1Image(mask_data.astype(np.int8), get_affine(labels_img)) labels_signals, labels_labels = signal_extraction.img_to_signals_labels( fmri_img, labels_img, mask_img=mask_img) maps_signals, maps_labels = signal_extraction.img_to_signals_maps( fmri_img, maps_img, mask_img=mask_img) np.testing.assert_almost_equal(maps_signals, labels_signals) assert_true(maps_signals.shape[1] == n_regions) assert_true(maps_labels == list(range(len(maps_labels)))) assert_true(labels_signals.shape == (length, n_regions)) assert_true(labels_labels == labels[1:]) # Inverse operation (mostly smoke test) labels_img_r = signal_extraction.signals_to_img_labels(labels_signals, labels_img, mask_img=mask_img) assert_true(labels_img_r.shape == shape + (length, )) maps_img_r = signal_extraction.signals_to_img_maps(maps_signals, maps_img, mask_img=mask_img) assert_true(maps_img_r.shape == shape + (length, )) # Check that NaNs in regions inside mask are preserved region1 = labels_data == 2 indices = [ind[:1] for ind in np.where(region1)] fmri_img.get_data()[indices + [slice(None)]] = float('nan') labels_signals, labels_labels = signal_extraction.img_to_signals_labels( fmri_img, labels_img, mask_img=mask_img) assert_true(np.all(np.isnan(labels_signals[:, labels_labels.index(2)])))