def test_region_extractor_fit_and_transform(): n_regions = 9 n_subjects = 5 maps, mask_img = generate_maps((40, 40, 40), n_regions=n_regions) # smoke test to RegionExtractor with thresholding_strategy='ratio_n_voxels' extract_ratio = RegionExtractor(maps, threshold=0.2, thresholding_strategy='ratio_n_voxels') extract_ratio.fit() assert_not_equal(extract_ratio.regions_img_, '') assert_true(extract_ratio.regions_img_.shape[-1] >= 9) # smoke test with threshold=string and strategy=percentile extractor = RegionExtractor(maps, threshold=30, thresholding_strategy='percentile', mask_img=mask_img) extractor.fit() assert_true(extractor.index_, np.ndarray) assert_not_equal(extractor.regions_img_, '') assert_true(extractor.regions_img_.shape[-1] >= 9) n_regions_extracted = extractor.regions_img_.shape[-1] shape = (91, 109, 91, 7) expected_signal_shape = (7, n_regions_extracted) for id_ in range(n_subjects): img, data = _make_random_data(shape) # smoke test NiftiMapsMasker transform inherited in Region Extractor signal = extractor.transform(img) assert_equal(expected_signal_shape, signal.shape) # smoke test with high resolution image maps, mask_img = generate_maps((20, 20, 20), n_regions=n_regions, affine=.2 * np.eye(4)) extract_ratio = RegionExtractor(maps, thresholding_strategy='ratio_n_voxels', smoothing_fwhm=.6, min_region_size=.4) extract_ratio.fit() assert_not_equal(extract_ratio.regions_img_, '') assert_true(extract_ratio.regions_img_.shape[-1] >= 9) # smoke test with zeros on the diagonal of the affine affine = np.eye(4) affine[[0, 1]] = affine[[1, 0]] # permutes first and second lines maps, mask_img = generate_maps((40, 40, 40), n_regions=n_regions, affine=affine) extract_ratio = RegionExtractor(maps, threshold=0.2, thresholding_strategy='ratio_n_voxels') extract_ratio.fit() assert_not_equal(extract_ratio.regions_img_, '') assert_true(extract_ratio.regions_img_.shape[-1] >= 9)
def test_nans_threshold_maps_ratio(): maps, _ = generate_maps((10, 10, 10), n_regions=2) data = maps.get_data() data[:, :, 0] = np.nan maps_img = nibabel.Nifti1Image(data, np.eye(4)) thr_maps = _threshold_maps_ratio(maps_img, threshold=0.8)
def test_invalid_threshold_strategies(): maps, _ = generate_maps((6, 8, 10), n_regions=1) extract_strategy_check = RegionExtractor(maps, thresholding_strategy='n_') valid_strategies = ['ratio_n_voxels', 'img_value', 'percentile'] assert_raises_regex(ValueError, "'thresholding_strategy' should be either of " "these".format(valid_strategies), extract_strategy_check.fit)
def test_isnan_threshold_img_data(): shape = (10, 10, 10) maps, _ = data_gen.generate_maps(shape, n_regions=2) data = maps.get_data() 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_invalid_thresholds_in_threshold_maps_ratio(): maps, _ = generate_maps((10, 11, 12), n_regions=2) for invalid_threshold in ['80%', 'auto', -1.0]: assert_raises_regex(ValueError, "threshold given as ratio to the number of voxels must " "be Real number and should be positive and between 0 and " "total number of maps i.e. n_maps={0}. " "You provided {1}".format(maps.shape[-1], invalid_threshold), _threshold_maps_ratio, maps, threshold=invalid_threshold)
def test_threshold_as_none_and_string_cases(): maps, _ = generate_maps((6, 8, 10), n_regions=1) extract_thr_none_check = RegionExtractor(maps, threshold=None) assert_raises_regex(ValueError, "The given input to threshold is not valid.", extract_thr_none_check.fit) extract_thr_string_check = RegionExtractor(maps, threshold='30%') assert_raises_regex(ValueError, "The given input to threshold is not valid.", extract_thr_string_check.fit)
def test_invalids_extract_types_in_connected_regions(): maps, _ = generate_maps((10, 11, 12), n_regions=2) valid_names = ['connected_components', 'local_regions'] # test whether same error raises as expected when invalid inputs # are given to extract_type in connected_regions function message = ("'extract_type' should be {0}") for invalid_extract_type in ['connect_region', 'local_regios']: assert_raises_regex(ValueError, message.format(valid_names), connected_regions, maps, extract_type=invalid_extract_type)
def test_generate_maps(): # Basic testing of generate_maps() shape = (10, 11, 12) n_regions = 9 maps_img, _ = generate_maps(shape, n_regions, border=1) maps = maps_img.get_data() assert_true(maps.shape == shape + (n_regions,)) # no empty map assert_true(np.all(abs(maps).sum(axis=0).sum(axis=0).sum(axis=0) > 0)) # check border assert_true(np.all(maps[0, ...] == 0)) assert_true(np.all(maps[:, 0, ...] == 0)) assert_true(np.all(maps[:, :, 0, :] == 0))
def test_threshold_img(): # to check whether passes with valid threshold inputs shape = (10, 20, 30) maps, _ = data_gen.generate_maps(shape, n_regions=4) affine = np.eye(4) mask_img = nibabel.Nifti1Image(np.ones((shape), dtype=np.int8), affine) for img in iter_img(maps): # when threshold is a float value thr_maps_img = threshold_img(img, threshold=0.8) # when we provide mask image thr_maps_percent = threshold_img(img, threshold=1, mask_img=mask_img) # when threshold is a percentile thr_maps_percent2 = threshold_img(img, threshold='2%')
def test_connected_regions(): # 4D maps n_regions = 4 maps, mask_img = generate_maps((30, 30, 30), n_regions=n_regions) # 3D maps map_img = np.zeros((30, 30, 30)) + 0.1 * np.random.randn(30, 30, 30) map_img = nibabel.Nifti1Image(map_img, affine=np.eye(4)) # smoke test for function connected_regions and also to check # if the regions extracted should be equal or more than already present. # 4D image case for extract_type in ['connected_components', 'local_regions']: connected_extraction_img, index = connected_regions(maps, min_region_size=10, extract_type=extract_type) assert_true(connected_extraction_img.shape[-1] >= n_regions) assert_true(index, np.ndarray) # For 3D images regions extracted should be more than equal to one connected_extraction_3d_img, _ = connected_regions(map_img, min_region_size=10, extract_type=extract_type) assert_true(connected_extraction_3d_img.shape[-1] >= 1) # Test input mask_img mask = mask_img.get_data() mask[1, 1, 1] = 0 extraction_with_mask_img, index = connected_regions(maps, mask_img=mask_img) assert_true(extraction_with_mask_img.shape[-1] >= 1) extraction_without_mask_img, index = connected_regions(maps) assert_true(np.all(extraction_with_mask_img.get_data()[mask == 0] == 0.)) assert_false(np.all(extraction_without_mask_img.get_data()[mask == 0] == 0.)) # mask_img with different shape mask = np.zeros(shape=(10, 11, 12), dtype=np.int) mask[1:-1, 1:-1, 1:-1] = 1 affine = np.array([[2., 0., 0., 0.], [0., 2., 0., 0.], [0., 0., 2., 0.], [0., 0., 0., 2.]]) mask_img = nibabel.Nifti1Image(mask, affine=affine) extraction_not_same_fov_mask, _ = connected_regions(maps, mask_img=mask_img) assert_equal(maps.shape[:3], extraction_not_same_fov_mask.shape[:3]) assert_not_equal(mask_img.shape, extraction_not_same_fov_mask.shape[:3]) extraction_not_same_fov, _ = connected_regions(maps) assert_greater(np.sum(extraction_not_same_fov.get_data() == 0), np.sum(extraction_not_same_fov_mask.get_data() == 0))
def test_validity_threshold_value_in_threshold_img(): shape = (6, 8, 10) maps, _ = data_gen.generate_maps(shape, n_regions=2) # testing to raise same error when threshold=None case testing.assert_raises_regex(ValueError, "The input parameter 'threshold' is empty. ", threshold_img, maps, threshold=None) invalid_threshold_values = ['90t%', 's%', 't', '0.1'] name = 'threshold' for thr in invalid_threshold_values: testing.assert_raises_regex(ValueError, '{0}.+should be a number followed by ' 'the percent sign'.format(name), threshold_img, maps, threshold=thr)
def test_threshold_maps_ratio(): # smoke test for function _threshold_maps_ratio with randomly # generated maps # make sure that n_regions (4th dimension) are kept same even # in thresholded image maps, _ = generate_maps((6, 8, 10), n_regions=3) thr_maps = _threshold_maps_ratio(maps, threshold=1.0) assert_true(thr_maps.shape[-1] == maps.shape[-1]) # check that the size should be same for 3D image # before and after thresholding img = np.zeros((30, 30, 30)) + 0.1 * np.random.randn(30, 30, 30) img = nibabel.Nifti1Image(img, affine=np.eye(4)) thr_maps_3d = _threshold_maps_ratio(img, threshold=0.5) assert_true(img.shape == thr_maps_3d.shape)
def test_connected_regions(): # 4D maps n_regions = 4 maps, mask_img = generate_maps((30, 30, 30), n_regions=n_regions) # 3D maps map_img = np.zeros((30, 30, 30)) + 0.1 * np.random.randn(30, 30, 30) map_img = nibabel.Nifti1Image(map_img, affine=np.eye(4)) # smoke test for function connected_regions and also to check # if the regions extracted should be equal or more than already present. # 4D image case for extract_type in ['connected_components', 'local_regions']: connected_extraction_img, index = connected_regions( maps, min_region_size=10, extract_type=extract_type) assert_true(connected_extraction_img.shape[-1] >= n_regions) assert_true(index, np.ndarray) # For 3D images regions extracted should be more than equal to one connected_extraction_3d_img, _ = connected_regions( map_img, min_region_size=10, extract_type=extract_type) assert_true(connected_extraction_3d_img.shape[-1] >= 1) # Test input mask_img mask = mask_img.get_data() mask[1, 1, 1] = 0 extraction_with_mask_img, index = connected_regions(maps, mask_img=mask_img) assert_true(extraction_with_mask_img.shape[-1] >= 1) extraction_without_mask_img, index = connected_regions(maps) assert_true(np.all(extraction_with_mask_img.get_data()[mask == 0] == 0.)) assert_false( np.all(extraction_without_mask_img.get_data()[mask == 0] == 0.)) # mask_img with different shape mask = np.zeros(shape=(10, 11, 12), dtype=np.int) mask[1:-1, 1:-1, 1:-1] = 1 affine = np.array([[2., 0., 0., 0.], [0., 2., 0., 0.], [0., 0., 2., 0.], [0., 0., 0., 2.]]) mask_img = nibabel.Nifti1Image(mask, affine=affine) extraction_not_same_fov_mask, _ = connected_regions(maps, mask_img=mask_img) assert_equal(maps.shape[:3], extraction_not_same_fov_mask.shape[:3]) assert_not_equal(mask_img.shape, extraction_not_same_fov_mask.shape[:3]) extraction_not_same_fov, _ = connected_regions(maps) assert_greater(np.sum(extraction_not_same_fov.get_data() == 0), np.sum(extraction_not_same_fov_mask.get_data() == 0))
def test_3d_images(): # Test that the NiftiMapsMasker works with 3D images affine = np.eye(4) n_regions = 3 shape3 = (16, 17, 18) maps33_img, _ = data_gen.generate_maps(shape3, n_regions) mask_img = nibabel.Nifti1Image(np.ones(shape3, dtype=np.int8), affine=affine) epi_img1 = nibabel.Nifti1Image(np.ones(shape3), affine=affine) epi_img2 = nibabel.Nifti1Image(np.ones(shape3), affine=affine) masker = NiftiMapsMasker(maps33_img, mask_img=mask_img) epis = masker.fit_transform(epi_img1) assert (epis.shape == (1, 3)) epis = masker.fit_transform([epi_img1, epi_img2]) assert (epis.shape == (2, 3))
def test_validity_threshold_value_in_threshold_img(): """Check that invalid values to threshold_img's threshold parameter raise Exceptions. """ shape = (6, 8, 10) maps, _ = data_gen.generate_maps(shape, n_regions=2) # testing to raise same error when threshold=None case with pytest.raises( TypeError, match="threshold should be either a number or a string", ): threshold_img(maps, threshold=None) invalid_threshold_values = ['90t%', 's%', 't', '0.1'] name = 'threshold' for thr in invalid_threshold_values: with pytest.raises(ValueError, match='{0}.+should be a number followed by ' 'the percent sign'.format(name)): threshold_img(maps, threshold=thr)
def test_nifti_maps_masker_with_nans_and_infs(): """Apply a NiftiMapsMasker containing NaNs and infs. The masker should replace those NaNs and infs with zeros, without raising a warning. """ length = 3 n_regions = 8 fmri_img, mask_img = generate_random_img((13, 11, 12), affine=np.eye(4), length=length) maps_img, maps_mask_img = data_gen.generate_maps((13, 11, 12), n_regions, affine=np.eye(4)) # Add NaNs and infs to atlas maps_data = get_data(maps_img).astype(np.float32) mask_data = get_data(mask_img).astype(np.float32) maps_data = maps_data * mask_data[..., None] # Choose a good voxel from the first label vox_idx = np.where(maps_data[..., 0] > 0) i1, j1, k1 = vox_idx[0][0], vox_idx[1][0], vox_idx[2][0] i2, j2, k2 = vox_idx[0][1], vox_idx[1][1], vox_idx[2][1] maps_data[:, :, :, 0] = np.nan maps_data[i2, j2, k2, 0] = np.inf maps_data[i1, j1, k1, 0] = 1 maps_img = nibabel.Nifti1Image(maps_data, np.eye(4)) # No warning, because maps_img is run through clean_img # *before* _safe_get_data. masker = NiftiMapsMasker(maps_img, mask_img=mask_img) sig = masker.fit_transform(fmri_img) assert sig.shape == (length, n_regions) assert np.all(np.isfinite(sig))
def test_fetch_atlas_pauli_2017(tmp_path, request_mocker): labels = pd.DataFrame({ "label": list(map("label_{}".format, range(16))) }).to_csv(sep="\t", header=False) det_atlas = data_gen.generate_labeled_regions((7, 6, 5), 16) prob_atlas, _ = data_gen.generate_maps((7, 6, 5), 16) request_mocker.url_mapping["*osf.io/6qrcb/*"] = labels request_mocker.url_mapping["*osf.io/5mqfx/*"] = det_atlas request_mocker.url_mapping["*osf.io/w8zq2/*"] = prob_atlas data_dir = str(tmp_path / 'pauli_2017') data = atlas.fetch_atlas_pauli_2017('det', data_dir) assert len(data.labels) == 16 values = get_data(nibabel.load(data.maps)) assert len(np.unique(values)) == 17 data = atlas.fetch_atlas_pauli_2017('prob', data_dir) assert nibabel.load(data.maps).shape[-1] == 16 with pytest.raises(NotImplementedError): atlas.fetch_atlas_pauli_2017('junk for testing', data_dir)
def test_threshold_maps_ratio(): # smoke test for function _threshold_maps_ratio with randomly # generated maps maps, _ = generate_maps((6, 8, 10), n_regions=3) # test that there is no side effect maps.get_data()[:3] = 100 maps_data = maps.get_data().copy() thr_maps = _threshold_maps_ratio(maps, threshold=1.0) np.testing.assert_array_equal(maps.get_data(), maps_data) # make sure that n_regions (4th dimension) are kept same even # in thresholded image assert_true(thr_maps.shape[-1] == maps.shape[-1]) # check that the size should be same for 3D image # before and after thresholding img = np.zeros((30, 30, 30)) + 0.1 * np.random.randn(30, 30, 30) img = nibabel.Nifti1Image(img, affine=np.eye(4)) thr_maps_3d = _threshold_maps_ratio(img, threshold=0.5) assert_true(img.shape == thr_maps_3d.shape)
def test_threshold_maps_ratio(): # smoke test for function _threshold_maps_ratio with randomly # generated maps maps, _ = generate_maps((6, 8, 10), n_regions=3) # test that there is no side effect get_data(maps)[:3] = 100 maps_data = get_data(maps).copy() thr_maps = _threshold_maps_ratio(maps, threshold=1.0) np.testing.assert_array_equal(get_data(maps), maps_data) # make sure that n_regions (4th dimension) are kept same even # in thresholded image assert thr_maps.shape[-1] == maps.shape[-1] # check that the size should be same for 3D image # before and after thresholding img = np.zeros((30, 30, 30)) + 0.1 * np.random.randn(30, 30, 30) img = nibabel.Nifti1Image(img, affine=np.eye(4)) thr_maps_3d = _threshold_maps_ratio(img, threshold=0.5) assert img.shape == thr_maps_3d.shape
def test_nifti_maps_masker_with_nans(): length = 3 n_regions = 8 fmri_img, mask_img = generate_random_img((13, 11, 12), affine=np.eye(4), length=length) maps_img, maps_mask_img = data_gen.generate_maps((13, 11, 12), n_regions, affine=np.eye(4)) # nans maps_data = maps_img.get_data() mask_data = mask_img.get_data() maps_data[:, 9, 9] = np.nan maps_data[:, 5, 5] = np.inf mask_data[:, :, 7] = np.nan mask_data[:, :, 5] = np.inf maps_img = nibabel.Nifti1Image(maps_data, np.eye(4)) mask_img = nibabel.Nifti1Image(mask_data, np.eye(4)) masker = NiftiMapsMasker(maps_img, mask_img=mask_img) sig = masker.fit_transform(fmri_img) assert_equal(sig.shape, (length, n_regions)) assert_true(np.all(np.isfinite(sig)))
def test_nifti_maps_masker_with_nans(): length = 3 n_regions = 8 fmri_img, mask_img = generate_random_img((13, 11, 12), affine=np.eye(4), length=length) maps_img, maps_mask_img = data_gen.generate_maps((13, 11, 12), n_regions, affine=np.eye(4)) # nans maps_data = get_data(maps_img) mask_data = get_data(mask_img) maps_data[:, 9, 9] = np.nan maps_data[:, 5, 5] = np.inf mask_data[:, :, 7] = np.nan mask_data[:, :, 5] = np.inf maps_img = nibabel.Nifti1Image(maps_data, np.eye(4)) mask_img = nibabel.Nifti1Image(mask_data, np.eye(4)) masker = NiftiMapsMasker(maps_img, mask_img=mask_img) sig = masker.fit_transform(fmri_img) assert sig.shape == (length, n_regions) assert np.all(np.isfinite(sig))
def test_signal_extraction_with_maps(): shape = (10, 11, 12) n_regions = 9 n_instants = 13 # Generate signals rand_gen = np.random.RandomState(0) maps_img, mask_img = generate_maps(shape, n_regions, border=1) maps_data = maps_img.get_data() data = np.zeros(shape + (n_instants,), dtype=np.float32) mask_4d_img = nibabel.Nifti1Image(np.ones((shape + (2, ))), np.eye(4)) signals = np.zeros((n_instants, maps_data.shape[-1])) for n in range(maps_data.shape[-1]): signals[:, n] = rand_gen.randn(n_instants) data[maps_data[..., n] > 0, :] = signals[:, n] img = nibabel.Nifti1Image(data, np.eye(4)) # verify that 4d masks are refused assert_raises_regex(TypeError, _TEST_DIM_ERROR_MSG, signal_extraction.img_to_signals_maps, img, maps_img, mask_img=mask_4d_img) # Get signals signals_r, labels = signal_extraction.img_to_signals_maps( img, maps_img, mask_img=mask_img) # The output must be identical to the input signals, because every region # is homogeneous: there is the same signal in all voxels of one given # region (and all maps are uniform). np.testing.assert_almost_equal(signals, signals_r) # Same thing without mask (in that case) signals_r, labels = signal_extraction.img_to_signals_maps(img, maps_img) np.testing.assert_almost_equal(signals, signals_r) # Recover image img_r = signal_extraction.signals_to_img_maps(signals, maps_img, mask_img=mask_img) np.testing.assert_almost_equal(img_r.get_data(), img.get_data()) img_r = signal_extraction.signals_to_img_maps(signals, maps_img) np.testing.assert_almost_equal(img_r.get_data(), img.get_data()) # Test input validation data_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 5)), np.eye(4)) good_maps_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 7)), np.eye(4)) bad_maps1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5, 7)), np.eye(4)) bad_maps2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 7)), 2 * np.eye(4)) good_mask_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), np.eye(4)) bad_mask1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5)), np.eye(4)) bad_mask2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), 2 * np.eye(4)) assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img, bad_maps1_img) assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img, bad_maps2_img) assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img, bad_maps1_img, mask_img=good_mask_img) assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img, bad_maps2_img, mask_img=good_mask_img) assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img, good_maps_img, mask_img=bad_mask1_img) assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img, good_maps_img, mask_img=bad_mask2_img)
def test_signal_extraction_with_maps(): shape = (10, 11, 12) n_regions = 9 n_instants = 13 # Generate signals rand_gen = np.random.RandomState(0) maps_img, mask_img = generate_maps(shape, n_regions, border=1) maps_data = get_data(maps_img) data = np.zeros(shape + (n_instants, ), dtype=np.float32) mask_4d_img = nibabel.Nifti1Image(np.ones((shape + (2, ))), np.eye(4)) signals = np.zeros((n_instants, maps_data.shape[-1])) for n in range(maps_data.shape[-1]): signals[:, n] = rand_gen.randn(n_instants) data[maps_data[..., n] > 0, :] = signals[:, n] img = nibabel.Nifti1Image(data, np.eye(4)) # verify that 4d masks are refused assert_raises_regex(TypeError, _TEST_DIM_ERROR_MSG, signal_extraction.img_to_signals_maps, img, maps_img, mask_img=mask_4d_img) # Get signals signals_r, labels = signal_extraction.img_to_signals_maps( img, maps_img, mask_img=mask_img) # The output must be identical to the input signals, because every region # is homogeneous: there is the same signal in all voxels of one given # region (and all maps are uniform). np.testing.assert_almost_equal(signals, signals_r) # Same thing without mask (in that case) signals_r, labels = signal_extraction.img_to_signals_maps(img, maps_img) np.testing.assert_almost_equal(signals, signals_r) # Recover image img_r = signal_extraction.signals_to_img_maps(signals, maps_img, mask_img=mask_img) np.testing.assert_almost_equal(get_data(img_r), get_data(img)) img_r = signal_extraction.signals_to_img_maps(signals, maps_img) np.testing.assert_almost_equal(get_data(img_r), get_data(img)) # Test input validation data_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 5)), np.eye(4)) good_maps_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 7)), np.eye(4)) bad_maps1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5, 7)), np.eye(4)) bad_maps2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4, 7)), 2 * np.eye(4)) good_mask_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), np.eye(4)) bad_mask1_img = nibabel.Nifti1Image(np.zeros((2, 3, 5)), np.eye(4)) bad_mask2_img = nibabel.Nifti1Image(np.zeros((2, 3, 4)), 2 * np.eye(4)) assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img, bad_maps1_img) assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img, bad_maps2_img) assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img, bad_maps1_img, mask_img=good_mask_img) assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img, bad_maps2_img, mask_img=good_mask_img) assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img, good_maps_img, mask_img=bad_mask1_img) assert_raises(ValueError, signal_extraction.img_to_signals_maps, data_img, good_maps_img, mask_img=bad_mask2_img)
def test_region_extractor_fit_and_transform(): n_regions = 9 n_subjects = 5 maps, mask_img = generate_maps((40, 40, 40), n_regions=n_regions) # Test maps are zero in the mask mask_data = get_data(mask_img) mask_data[1, 1, 1] = 0 extractor_without_mask = RegionExtractor(maps) extractor_without_mask.fit() extractor_with_mask = RegionExtractor(maps, mask_img=mask_img) extractor_with_mask.fit() assert not np.all( get_data(extractor_without_mask.regions_img_)[mask_data == 0] == 0.) assert np.all( get_data(extractor_with_mask.regions_img_)[mask_data == 0] == 0.) # smoke test to RegionExtractor with thresholding_strategy='ratio_n_voxels' extract_ratio = RegionExtractor(maps, threshold=0.2, thresholding_strategy='ratio_n_voxels') extract_ratio.fit() assert extract_ratio.regions_img_ != '' assert extract_ratio.regions_img_.shape[-1] >= 9 # smoke test with threshold=string and strategy=percentile extractor = RegionExtractor(maps, threshold=30, thresholding_strategy='percentile', mask_img=mask_img) extractor.fit() assert extractor.index_, np.ndarray assert extractor.regions_img_ != '' assert extractor.regions_img_.shape[-1] >= 9 n_regions_extracted = extractor.regions_img_.shape[-1] shape = (91, 109, 91, 7) expected_signal_shape = (7, n_regions_extracted) for id_ in range(n_subjects): img, data = _make_random_data(shape) # smoke test NiftiMapsMasker transform inherited in Region Extractor signal = extractor.transform(img) assert expected_signal_shape == signal.shape # smoke test with high resolution image maps, mask_img = generate_maps((20, 20, 20), n_regions=n_regions, affine=.2 * np.eye(4)) extract_ratio = RegionExtractor(maps, thresholding_strategy='ratio_n_voxels', smoothing_fwhm=.6, min_region_size=.4) extract_ratio.fit() assert extract_ratio.regions_img_ != '' assert extract_ratio.regions_img_.shape[-1] >= 9 # smoke test with zeros on the diagonal of the affine affine = np.eye(4) affine[[0, 1]] = affine[[1, 0]] # permutes first and second lines maps, mask_img = generate_maps((40, 40, 40), n_regions=n_regions, affine=affine) extract_ratio = RegionExtractor(maps, threshold=0.2, thresholding_strategy='ratio_n_voxels') extract_ratio.fit() assert extract_ratio.regions_img_ != '' assert extract_ratio.regions_img_.shape[-1] >= 9
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 = \ data_gen.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(fmri11_img_r.affine, fmri11_img.affine) # 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(masker._resampled_maps_img_.affine, 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, _ = \ data_gen.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(masker.mask_img_.affine, mask22_img.affine) assert_equal(masker.mask_img_.shape, mask22_img.shape) np.testing.assert_almost_equal(masker.mask_img_.affine, masker.maps_img_.affine) 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(fmri11_img_r.affine, masker.maps_img_.affine) 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(masker.maps_img_.affine, maps33_img.affine) assert_equal(masker.maps_img_.shape, maps33_img.shape) np.testing.assert_almost_equal(masker.mask_img_.affine, masker.maps_img_.affine) 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(fmri11_img_r.affine, masker.maps_img_.affine) 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 = data_gen.generate_fake_fmri(shape2, length=1, affine=affine2) # Target: maps maps33_img, _ = \ data_gen.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(masker.maps_img_.affine, maps33_img.affine) assert_equal(masker.maps_img_.shape, maps33_img.shape) np.testing.assert_almost_equal(masker.mask_img_.affine, masker.maps_img_.affine) 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(fmri11_img_r.affine, masker.maps_img_.affine) assert_equal(fmri11_img_r.shape, (masker.maps_img_.shape[:3] + (length, )))
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, _ = \ data_gen.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(masker.mask_img_.affine, mask22_img.affine) assert_equal(masker.mask_img_.shape, mask22_img.shape) np.testing.assert_almost_equal(masker.mask_img_.affine, masker.maps_img_.affine) 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(fmri11_img_r.affine, masker.maps_img_.affine) 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(masker.maps_img_.affine, maps33_img.affine) assert_equal(masker.maps_img_.shape, maps33_img.shape) np.testing.assert_almost_equal(masker.mask_img_.affine, masker.maps_img_.affine) 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(fmri11_img_r.affine, masker.maps_img_.affine) 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 = data_gen.generate_fake_fmri(shape2, length=1, affine=affine2) # Target: maps maps33_img, _ = \ data_gen.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(masker.maps_img_.affine, maps33_img.affine) assert_equal(masker.maps_img_.shape, maps33_img.shape) np.testing.assert_almost_equal(masker.mask_img_.affine, masker.maps_img_.affine) 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(fmri11_img_r.affine, masker.maps_img_.affine) 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 = \ data_gen.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(fmri11_img_r.affine, fmri11_img.affine) # 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(masker._resampled_maps_img_.affine, affine2)
def niftimapsmasker_inputs(): n_regions = 9 shape = (13, 11, 12) affine = np.diag([2, 2, 2, 1]) label_img, _ = generate_maps(shape, n_regions=n_regions, affine=affine) return {"maps_img": label_img}