def test_nifti_labels_masker_with_nans_and_infs_in_data(): """Apply a NiftiLabelsMasker to 4D data containing NaNs and infs. The masker should replace those NaNs and infs with zeros, while raising a warning. """ length = 3 n_regions = 9 fmri_img, mask_img = generate_random_img((13, 11, 12), affine=np.eye(4), length=length) labels_img = data_gen.generate_labeled_regions((13, 11, 12), affine=np.eye(4), n_regions=n_regions) # Introduce nans with data type float # See issues: # - https://github.com/nilearn/nilearn/issues/2580 (why floats) # - https://github.com/nilearn/nilearn/issues/2711 (why test) fmri_data = get_data(fmri_img).astype(np.float32) fmri_data[:, :, 7, :] = np.nan fmri_data[:, :, 4, 0] = np.inf fmri_img = nibabel.Nifti1Image(fmri_data, np.eye(4)) masker = NiftiLabelsMasker(labels_img, mask_img=mask_img) with pytest.warns(UserWarning, match="Non-finite values detected."): sig = masker.fit_transform(fmri_img) assert sig.shape == (length, n_regions) assert np.all(np.isfinite(sig))
def test_standardization(): rng = np.random.RandomState(42) data_shape = (9, 9, 5) n_samples = 500 signals = rng.standard_normal(size=(np.prod(data_shape), n_samples)) means = rng.standard_normal(size=(np.prod(data_shape), 1)) * 50 + 1000 signals += means img = nibabel.Nifti1Image(signals.reshape(data_shape + (n_samples, )), np.eye(4)) labels = data_gen.generate_labeled_regions((9, 9, 5), 10) # Unstandarized masker = NiftiLabelsMasker(labels, standardize=False) unstandarized_label_signals = masker.fit_transform(img) # z-score masker = NiftiLabelsMasker(labels, standardize='zscore') trans_signals = masker.fit_transform(img) np.testing.assert_almost_equal(trans_signals.mean(0), 0) np.testing.assert_almost_equal(trans_signals.std(0), 1) # psc masker = NiftiLabelsMasker(labels, standardize='psc') trans_signals = masker.fit_transform(img) np.testing.assert_almost_equal(trans_signals.mean(0), 0) np.testing.assert_almost_equal( trans_signals, (unstandarized_label_signals / unstandarized_label_signals.mean(0) * 100 - 100))
def test_generate_labeled_regions(): """Minimal testing of generate_labeled_regions""" shape = (3, 4, 5) n_regions = 10 regions = generate_labeled_regions(shape, n_regions) assert_true(regions.shape == shape) assert (len(np.unique(get_data(regions))) == n_regions + 1)
def test_generate_labeled_regions(): """Minimal testing of generate_labeled_regions""" shape = (3, 4, 5) n_regions = 10 regions = generate_labeled_regions(shape, n_regions) assert_true(regions.shape == shape) assert (len(np.unique(regions.get_data())) == n_regions + 1)
def _schaefer_img(match, request): info = match.groupdict() shape = (15, 14, 13) affine = np.eye(4) * float(info["res"]) affine[3, 3] = 1. img = data_gen.generate_labeled_regions( shape, int(info["n_rois"]), affine=affine) return serialize_niimg(img)
def test_error_messages_connected_label_regions(): shape = (13, 11, 12) affine = np.eye(4) n_regions = 2 labels_img = generate_labeled_regions(shape, affine=affine, n_regions=n_regions) assert_raises_regex(ValueError, "Expected 'min_size' to be specified as integer.", connected_label_regions, labels_img=labels_img, min_size='a') assert_raises_regex(ValueError, "'connect_diag' must be specified as True or False.", connected_label_regions, labels_img=labels_img, connect_diag=None)
def test_error_messages_connected_label_regions(): shape = (13, 11, 12) affine = np.eye(4) n_regions = 2 labels_img = generate_labeled_regions(shape, affine=affine, n_regions=n_regions) with pytest.raises( ValueError, match="Expected 'min_size' to be specified as integer."): connected_label_regions(labels_img=labels_img, min_size='a') with pytest.raises( ValueError, match="'connect_diag' must be specified as True or False."): connected_label_regions(labels_img=labels_img, connect_diag=None)
def test_nifti_labels_masker_with_mask(): shape = (13, 11, 12) affine = np.eye(4) fmri_img, mask_img = generate_random_img(shape, affine=affine, length=3) labels_img = data_gen.generate_labeled_regions(shape, affine=affine, n_regions=7) masker = NiftiLabelsMasker( labels_img, resampling_target=None, mask_img=mask_img) signals = masker.fit().transform(fmri_img) bg_masker = NiftiMasker(mask_img).fit() masked_labels = bg_masker.inverse_transform(bg_masker.transform(labels_img)) masked_masker = NiftiLabelsMasker( masked_labels, resampling_target=None, mask_img=mask_img) masked_signals = masked_masker.fit().transform(fmri_img) assert np.allclose(signals, masked_signals)
def input_parameters(masker_class, data_img_3d): n_regions = 9 shape = (13, 11, 12) affine = np.diag([2, 2, 2, 1]) labels = ["background"] labels += [f"region_{i}" for i in range(1, n_regions + 1)] if masker_class == NiftiMasker: return {"mask_img": data_img_3d} if masker_class == NiftiLabelsMasker: labels_img = generate_labeled_regions(shape, n_regions=n_regions, affine=affine) return {"labels_img": labels_img, "labels": labels} elif masker_class == NiftiMapsMasker: label_img, _ = generate_maps(shape, n_regions=n_regions, affine=affine) return {"maps_img": label_img}
def test_3d_images(): # Test that the NiftiLabelsMasker works with 3D images affine = np.eye(4) n_regions = 3 shape3 = (2, 2, 2) labels33_img = data_gen.generate_labeled_regions(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 = NiftiLabelsMasker(labels33_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_nifti_labels_masker_with_nans_and_infs(): length = 3 n_regions = 9 fmri_img, mask_img = generate_random_img((13, 11, 12), affine=np.eye(4), length=length) labels_img = data_gen.generate_labeled_regions((13, 11, 12), affine=np.eye(4), n_regions=n_regions) # nans mask_data = get_data(mask_img) mask_data[:, :, 7] = np.nan mask_data[:, :, 4] = np.inf mask_img = nibabel.Nifti1Image(mask_data, np.eye(4)) masker = NiftiLabelsMasker(labels_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_nifti_labels_masker_with_nans_and_infs(): length = 3 n_regions = 9 fmri_img, mask_img = generate_random_img((13, 11, 12), affine=np.eye(4), length=length) labels_img = data_gen.generate_labeled_regions((13, 11, 12), affine=np.eye(4), n_regions=n_regions) # nans mask_data = mask_img.get_data() mask_data[:, :, 7] = np.nan mask_data[:, :, 4] = np.inf mask_img = nibabel.Nifti1Image(mask_data, np.eye(4)) masker = NiftiLabelsMasker(labels_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_labels_masker_with_nans_and_infs(): length = 3 n_regions = 9 fmri_img, mask_img = generate_random_img((13, 11, 12), affine=np.eye(4), length=length) labels_img = data_gen.generate_labeled_regions((13, 11, 12), affine=np.eye(4), n_regions=n_regions) # Introduce nans with data type float # See issue: https://github.com/nilearn/nilearn/issues/2580 mask_data = get_data(mask_img).astype(np.float32) mask_data[:, :, 7] = np.nan mask_data[:, :, 4] = np.inf mask_img = nibabel.Nifti1Image(mask_data, np.eye(4)) masker = NiftiLabelsMasker(labels_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_largest_cc(): """ Check the extraction of the largest connected component. """ a = np.zeros((6, 6, 6)) pytest.raises(ValueError, largest_connected_component, a) a[1:3, 1:3, 1:3] = 1 np.testing.assert_equal(a, largest_connected_component(a)) # A simple test with non-native dtype a_change_type = a.astype('>f8') np.testing.assert_equal(a, largest_connected_component(a_change_type)) b = a.copy() b[5, 5, 5] = 1 np.testing.assert_equal(a, largest_connected_component(b)) # A simple test with non-native dtype b_change_type = b.astype('>f8') np.testing.assert_equal(a, largest_connected_component(b_change_type)) # Tests for correct errors, when an image or string are passed. img = data_gen.generate_labeled_regions(shape=(10, 11, 12), n_regions=2) pytest.raises(ValueError, largest_connected_component, img) pytest.raises(ValueError, largest_connected_component, "Test String")
def test_empty_report(): # Data for NiftiMasker data = np.zeros((9, 9, 9)) data[3:-3, 3:-3, 3:-3] = 10 data_img_3d = Nifti1Image(data, np.eye(4)) # Data for NiftiLabelsMasker shape = (13, 11, 12) affine = np.diag([2, 2, 2, 1]) n_regions = 9 labels_img = data_gen.generate_labeled_regions(shape, affine=affine, n_regions=n_regions) # turn off reporting maskers = [input_data.NiftiMasker(reports=False), input_data.NiftiLabelsMasker(labels_img, reports=False)] for masker in maskers: masker.fit(data_img_3d) assert masker._reporting_data is None assert masker._reporting() == [None] with pytest.warns(UserWarning, match=("Report generation not enabled ! " "No visual outputs will be created.")): masker.generate_report()
def parcellation_data(): """Fixture for parcellations.""" parcels_tmp = tempfile.NamedTemporaryFile(mode='w+', suffix='.nii.gz') labels = pd.DataFrame({"label": list(map("label_{}".format, range(16)))})['label'].values.tolist() parcellation = data_gen.generate_labeled_regions((7, 6, 5), 16) parcels = parcellation.get_fdata() net_parcels_map_nifti_file = str(parcels_tmp.name) parcellation.to_filename(net_parcels_map_nifti_file) [coords, indices] = find_parcellation_cut_coords(parcellation, 0, return_label_names=True) coords = list(tuple(x) for x in coords) yield { 'net_parcels_map_nifti_file': net_parcels_map_nifti_file, 'parcels': parcels, 'labels': labels, 'coords': coords, 'indices': indices } parcels_tmp.close()
def test_largest_cc(): """ Check the extraction of the largest connected component. """ a = np.zeros((6, 6, 6)) assert_raises(ValueError, largest_connected_component, a) a[1:3, 1:3, 1:3] = 1 np.testing.assert_equal(a, largest_connected_component(a)) # A simple test with non-native dtype a_change_type = a.astype('>f8') np.testing.assert_equal(a, largest_connected_component(a_change_type)) b = a.copy() b[5, 5, 5] = 1 np.testing.assert_equal(a, largest_connected_component(b)) # A simple test with non-native dtype b_change_type = b.astype('>f8') np.testing.assert_equal(a, largest_connected_component(b_change_type)) # Tests for correct errors, when an image or string are passed. img = data_gen.generate_labeled_regions(shape=(10, 11, 12), n_regions=2) assert_raises(ValueError, largest_connected_component, img) assert_raises(ValueError, largest_connected_component, "Test String")
def test_largest_cc_img(): """ Check the extraction of the largest connected component, for niftis Similar to smooth_img tests for largest connected_component_img, here also only the added features for largest_connected_component are tested. """ # Test whether dimension of 3Dimg and list of 3Dimgs are kept. shapes = ((10, 11, 12), (13, 14, 15)) regions = [1, 3] img1 = data_gen.generate_labeled_regions(shape=shapes[0], n_regions=regions[0]) img2 = data_gen.generate_labeled_regions(shape=shapes[1], n_regions=regions[1]) for create_files in (False, True): with testing.write_tmp_imgs(img1, img2, create_files=create_files) as imgs: # List of images as input out = largest_connected_component_img(imgs) assert isinstance(out, list) assert len(out) == 2 for o, s in zip(out, shapes): assert o.shape == (s) # Single image as input out = largest_connected_component_img(imgs[0]) assert isinstance(out, Nifti1Image) assert out.shape == (shapes[0]) # Test whether 4D Nifti throws the right error. img_4D = data_gen.generate_fake_fmri(shapes[0], length=17) pytest.raises(DimensionError, largest_connected_component_img, img_4D) # tests adapted to non-native endian data dtype img1_change_dtype = nibabel.Nifti1Image(get_data(img1).astype('>f8'), affine=img1.affine) img2_change_dtype = nibabel.Nifti1Image(get_data(img2).astype('>f8'), affine=img2.affine) for create_files in (False, True): with testing.write_tmp_imgs(img1_change_dtype, img2_change_dtype, create_files=create_files) as imgs: # List of images as input out = largest_connected_component_img(imgs) assert isinstance(out, list) assert len(out) == 2 for o, s in zip(out, shapes): assert o.shape == (s) # Single image as input out = largest_connected_component_img(imgs[0]) assert isinstance(out, Nifti1Image) assert out.shape == (shapes[0]) # Test the output with native and without native out_native = largest_connected_component_img(img1) out_non_native = largest_connected_component_img(img1_change_dtype) np.testing.assert_equal(get_data(out_native), get_data(out_non_native))
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, labels_img.affine) # Generate fake data fmri_img, _ = generate_fake_fmri(shape=shape, length=length, affine=labels_img.affine) # 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), labels_img.affine) 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_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 = get_data(labels_img) # 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, labels_img.affine) # Generate fake data fmri_img, _ = generate_fake_fmri(shape=shape, length=length, affine=labels_img.affine) # 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), labels_img.affine) 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)] get_data(fmri_img)[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_connected_label_regions(): shape = (13, 11, 12) affine = np.eye(4) n_regions = 9 labels_img = generate_labeled_regions(shape, affine=affine, n_regions=n_regions) labels_data = get_data(labels_img) n_labels_wo_reg_ext = len(np.unique(labels_data)) # region extraction without specifying min_size extracted_regions_on_labels_img = connected_label_regions(labels_img) extracted_regions_labels_data = get_data(extracted_regions_on_labels_img) n_labels_wo_min = len(np.unique(extracted_regions_labels_data)) assert n_labels_wo_reg_ext < n_labels_wo_min # with specifying min_size extracted_regions_with_min = connected_label_regions(labels_img, min_size=100) extracted_regions_with_min_data = get_data(extracted_regions_with_min) n_labels_with_min = len(np.unique(extracted_regions_with_min_data)) assert n_labels_wo_min > n_labels_with_min # Test connect_diag=False ext_reg_without_connect_diag = connected_label_regions(labels_img, connect_diag=False) data_wo_connect_diag = get_data(ext_reg_without_connect_diag) n_labels_wo_connect_diag = len(np.unique(data_wo_connect_diag)) assert n_labels_wo_connect_diag > n_labels_wo_reg_ext # If min_size is large and if all the regions are removed then empty image # will be returned extract_reg_min_size_large = connected_label_regions(labels_img, min_size=500) assert np.unique(get_data(extract_reg_min_size_large)) == 0 # Test the names of the brain regions given in labels. # Test labels for 9 regions in n_regions labels = [ 'region_a', 'region_b', 'region_c', 'region_d', 'region_e', 'region_f', 'region_g', 'region_h', 'region_i' ] # If labels are provided, first return will contain extracted labels image # and second return will contain list of new names generated based on same # name with assigned on both hemispheres for example. extracted_reg, new_labels = connected_label_regions(labels_img, min_size=100, labels=labels) # The length of new_labels returned can differ depending upon min_size. If # min_size given is more small regions can be removed therefore newly # generated labels can be less than original size of labels. Or if min_size # is less then newly generated labels can be more. # We test here whether labels returned are empty or not. assert new_labels != '' assert len(new_labels) <= len(labels) # labels given in numpy array labels = np.asarray(labels) extracted_reg2, new_labels2 = connected_label_regions(labels_img, labels=labels) assert new_labels != '' # By default min_size is less, so newly generated labels can be more. assert len(new_labels2) >= len(labels) # If number of labels provided are wrong (which means less than number of # unique labels in labels_img), then we raise an error # Test whether error raises unique_labels = set(np.unique(np.asarray(get_data(labels_img)))) unique_labels.remove(0) # labels given are less than n_regions=9 provided_labels = [ 'region_a', 'region_c', 'region_f', 'region_g', 'region_h', 'region_i' ] assert len(provided_labels) < len(unique_labels) with pytest.raises(ValueError): connected_label_regions(labels_img, labels=provided_labels) # Test if unknown/negative integers are provided as labels in labels_img, # we raise an error and test the same whether error is raised. labels_data = np.zeros(shape, dtype=np.int) h0 = shape[0] // 2 h1 = shape[1] // 2 h2 = shape[2] // 2 labels_data[:h0, :h1, :h2] = 1 labels_data[:h0, :h1, h2:] = 2 labels_data[:h0, h1:, :h2] = 3 labels_data[:h0, h1:, h2:] = 4 labels_data[h0:, :h1, :h2] = 5 labels_data[h0:, :h1, h2:] = 6 labels_data[h0:, h1:, :h2] = np.nan labels_data[h0:, h1:, h2:] = np.inf neg_labels_img = nibabel.Nifti1Image(labels_data, affine) with pytest.raises(ValueError): connected_label_regions(labels_img=neg_labels_img) # If labels_img provided is 4D Nifti image, then test whether error is # raised or not. Since this function accepts only 3D image. labels_4d_data = np.zeros((shape) + (2, )) labels_data[h0:, h1:, :h2] = 0 labels_data[h0:, h1:, h2:] = 0 labels_4d_data[..., 0] = labels_data labels_4d_data[..., 1] = labels_data labels_img_4d = nibabel.Nifti1Image(labels_4d_data, np.eye(4)) with pytest.raises(DimensionError): connected_label_regions(labels_img=labels_img_4d) # Test if labels (or names to regions) given is a string without a list. # Then, we expect it to be split to regions extracted and returned as list. labels_in_str = 'region_a' labels_img_in_str = generate_labeled_regions(shape, affine=affine, n_regions=1) extract_regions, new_labels = connected_label_regions(labels_img_in_str, labels=labels_in_str) assert isinstance(new_labels, list) # If user has provided combination of labels, then function passes without # breaking and new labels are returned based upon given labels and should # be equal or more based on regions extracted combined_labels = [ 'region_a', '1', 'region_b', '2', 'region_c', '3', 'region_d', '4', 'region_e' ] ext_reg, new_labels = connected_label_regions(labels_img, labels=combined_labels) assert len(new_labels) >= len(combined_labels)
def test_nifti_labels_masker_report(data_img_3d, mask): shape = (13, 11, 12) affine = np.diag([2, 2, 2, 1]) n_regions = 9 labels = ['background' ] + ['region_{}'.format(i) for i in range(1, n_regions + 1)] EXPECTED_COLUMNS = [ 'label value', 'region name', 'size (in mm^3)', 'relative size (in %)' ] labels_img = generate_labeled_regions(shape, affine=affine, n_regions=n_regions) labels_img_floats = new_img_like(labels_img, get_data(labels_img).astype(float)) masker = NiftiLabelsMasker(labels_img_floats, labels=labels) masker.fit() masker.generate_report() # Check that providing incorrect labels raises an error masker = NiftiLabelsMasker(labels_img, labels=labels[:-1]) masker.fit() with pytest.raises(ValueError, match="Mismatch between the number of provided labels"): masker.generate_report() masker = NiftiLabelsMasker(labels_img, labels=labels) masker.fit() # Check that a warning is given when generating the report # since no image was provided to fit with pytest.warns(UserWarning, match="No image provided to fit in NiftiLabelsMasker"): masker.generate_report() # No image was provided to fit, regions are plotted using # plot_roi such that no contour should be in the image display = masker._reporting() for d in ['x', 'y', 'z']: assert len(display[0].axes[d].ax.collections) == 0 masker = NiftiLabelsMasker(labels_img, labels=labels) masker.fit(data_img_3d) display = masker._reporting() for d in ['x', 'y', 'z']: assert len(display[0].axes[d].ax.collections) > 0 assert len(display[0].axes[d].ax.collections) <= n_regions masker = NiftiLabelsMasker(labels_img, labels=labels, mask_img=mask) masker.fit(data_img_3d) report = masker.generate_report() assert masker._reporting_data is not None # Check that background label was left as default assert masker.background_label == 0 assert masker._report_content['description'] == ( 'This reports shows the regions defined by the labels of the mask.') # Check that the number of regions is correct assert masker._report_content['number_of_regions'] == n_regions # Check that all expected columns are present with the right size for col in EXPECTED_COLUMNS: assert col in masker._report_content['summary'] assert len(masker._report_content['summary'][col]) == n_regions # Check that labels match assert masker._report_content['summary']['region name'] == labels[1:] # Relative sizes of regions should sum to 100% assert_almost_equal( sum(masker._report_content['summary']['relative size (in %)']), 100) _check_html(report) assert "Regions summary" in str(report) # Check region sizes calculations expected_region_sizes = Counter(get_data(labels_img).ravel()) for r in range(1, n_regions + 1): assert_almost_equal( masker._report_content['summary']['size (in mm^3)'][r - 1], expected_region_sizes[r] * np.abs(np.linalg.det(affine[:3, :3]))) # Check that region labels are no displayed in the report # when they were not provided by the user. masker = NiftiLabelsMasker(labels_img) masker.fit() report = masker.generate_report() for col in EXPECTED_COLUMNS: if col == "region name": assert col not in masker._report_content["summary"] else: assert col in masker._report_content["summary"] assert len(masker._report_content['summary'][col]) == n_regions
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 = data_gen.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(masker.labels_img_.affine, labels33_img.affine) assert_equal(masker.labels_img_.shape, labels33_img.shape) np.testing.assert_almost_equal(masker.mask_img_.affine, masker.labels_img_.affine) 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(fmri11_img_r.affine, masker.labels_img_.affine) 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 = data_gen.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(masker.labels_img_.affine, labels33_img.affine) assert_equal(masker.labels_img_.shape, labels33_img.shape) np.testing.assert_almost_equal(masker.mask_img_.affine, masker.labels_img_.affine) 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(fmri11_img_r.affine, masker.labels_img_.affine) 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(masker._resampled_labels_img_.affine, affine2) # Test with filenames with testing.write_tmp_imgs(fmri22_img) as filename: masker = NiftiLabelsMasker(labels33_img, resampling_target='data') masker.fit_transform(filename) # test labels masker with resampling target in 'data', 'labels' to return # resampled labels having number of labels equal with transformed shape of # 2nd dimension. This tests are added based on issue #1673 in Nilearn shape = (13, 11, 12) affine = np.eye(4) * 2 fmri_img, _ = generate_random_img(shape, affine=affine, length=21) labels_img = data_gen.generate_labeled_regions((9, 8, 6), affine=np.eye(4), n_regions=10) for resampling_target in ['data', 'labels']: masker = NiftiLabelsMasker(labels_img=labels_img, resampling_target=resampling_target) transformed = masker.fit_transform(fmri_img) resampled_labels_img = masker._resampled_labels_img_ n_resampled_labels = len(np.unique(resampled_labels_img.get_data())) assert_equal(n_resampled_labels - 1, transformed.shape[1]) # inverse transform compressed_img = masker.inverse_transform(transformed) # Test that compressing the image a second time should yield an image # with the same data as compressed_img. transformed2 = masker.fit_transform(fmri_img) # inverse transform again compressed_img2 = masker.inverse_transform(transformed2) np.testing.assert_array_equal(compressed_img.get_data(), compressed_img2.get_data())
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 = data_gen.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(fmri11_img_r.affine, fmri11_img.affine)
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 = data_gen.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) with pytest.raises(DimensionError, match="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) with pytest.raises(ValueError, match='has not been fitted. '): masker11.transform(fmri11_img) # No exception raised here signals11 = masker11.fit().transform(fmri11_img) assert signals11.shape == (length, n_regions) # No exception should be raised either masker11 = NiftiLabelsMasker(labels11_img, resampling_target=None) masker11.fit() masker11.inverse_transform(signals11) masker11 = NiftiLabelsMasker(labels11_img, mask_img=mask11_img, resampling_target=None) signals11 = masker11.fit().transform(fmri11_img) assert signals11.shape == (length, n_regions) # Test all kinds of mismatch between shapes and between affines masker11 = NiftiLabelsMasker(labels11_img, resampling_target=None) masker11.fit() pytest.raises(ValueError, masker11.transform, fmri12_img) pytest.raises(ValueError, masker11.transform, fmri21_img) masker11 = NiftiLabelsMasker(labels11_img, mask_img=mask12_img, resampling_target=None) pytest.raises(ValueError, masker11.fit) masker11 = NiftiLabelsMasker(labels11_img, mask_img=mask21_img, resampling_target=None) pytest.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 signals11.shape == (length, n_regions) masker11 = NiftiLabelsMasker(labels11_img, smoothing_fwhm=3, resampling_target=None) signals11 = masker11.fit_transform(fmri11_img) assert signals11.shape == (length, n_regions) with pytest.raises(ValueError, match='has not been fitted. '): NiftiLabelsMasker(labels11_img).inverse_transform(signals11) # Call inverse transform (smoke test) fmri11_img_r = masker11.inverse_transform(signals11) assert fmri11_img_r.shape == fmri11_img.shape np.testing.assert_almost_equal(fmri11_img_r.affine, fmri11_img.affine)
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 = data_gen.generate_labeled_regions(shape3, n_regions, affine=affine) # Test error checking pytest.raises(ValueError, NiftiLabelsMasker, labels33_img, resampling_target="mask") pytest.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(masker.labels_img_.affine, labels33_img.affine) assert masker.labels_img_.shape == labels33_img.shape np.testing.assert_almost_equal(masker.mask_img_.affine, masker.labels_img_.affine) assert masker.mask_img_.shape == masker.labels_img_.shape[:3] transformed = masker.transform(fmri11_img) assert transformed.shape == (length, n_regions) fmri11_img_r = masker.inverse_transform(transformed) np.testing.assert_almost_equal(fmri11_img_r.affine, masker.labels_img_.affine) assert (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 = data_gen.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(masker.labels_img_.affine, labels33_img.affine) assert masker.labels_img_.shape == labels33_img.shape np.testing.assert_almost_equal(masker.mask_img_.affine, masker.labels_img_.affine) assert masker.mask_img_.shape == masker.labels_img_.shape[:3] uniq_labels = np.unique(get_data(masker.labels_img_)) assert uniq_labels[0] == 0 assert len(uniq_labels) - 1 == n_regions transformed = masker.transform(fmri11_img) assert transformed.shape == (length, n_regions) # Some regions have been clipped. Resulting signal must be zero assert (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.labels_img_.affine) assert (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(masker._resampled_labels_img_.affine, affine2) # Test with filenames with testing.write_tmp_imgs(fmri22_img) as filename: masker = NiftiLabelsMasker(labels33_img, resampling_target='data') masker.fit_transform(filename) # test labels masker with resampling target in 'data', 'labels' to return # resampled labels having number of labels equal with transformed shape of # 2nd dimension. This tests are added based on issue #1673 in Nilearn shape = (13, 11, 12) affine = np.eye(4) * 2 fmri_img, _ = generate_random_img(shape, affine=affine, length=21) labels_img = data_gen.generate_labeled_regions((9, 8, 6), affine=np.eye(4), n_regions=10) for resampling_target in ['data', 'labels']: masker = NiftiLabelsMasker(labels_img=labels_img, resampling_target=resampling_target) if resampling_target == 'data': with pytest.warns(UserWarning, match=("After resampling the label image " "to the data image, the following " "labels were removed")): transformed = masker.fit_transform(fmri_img) else: transformed = masker.fit_transform(fmri_img) resampled_labels_img = masker._resampled_labels_img_ n_resampled_labels = len(np.unique(get_data(resampled_labels_img))) assert n_resampled_labels - 1 == transformed.shape[1] # inverse transform compressed_img = masker.inverse_transform(transformed) # Test that compressing the image a second time should yield an image # with the same data as compressed_img. transformed2 = masker.fit_transform(fmri_img) # inverse transform again compressed_img2 = masker.inverse_transform(transformed2) np.testing.assert_array_equal(get_data(compressed_img), get_data(compressed_img2))
def test_connected_label_regions(): shape = (13, 11, 12) affine = np.eye(4) n_regions = 9 labels_img = generate_labeled_regions(shape, affine=affine, n_regions=n_regions) labels_data = labels_img.get_data() n_labels_wo_reg_ext = len(np.unique(labels_data)) # region extraction without specifying min_size extracted_regions_on_labels_img = connected_label_regions(labels_img) extracted_regions_labels_data = extracted_regions_on_labels_img.get_data() n_labels_wo_min = len(np.unique(extracted_regions_labels_data)) assert_true(n_labels_wo_reg_ext < n_labels_wo_min) # with specifying min_size extracted_regions_with_min = connected_label_regions(labels_img, min_size=100) extracted_regions_with_min_data = extracted_regions_with_min.get_data() n_labels_with_min = len(np.unique(extracted_regions_with_min_data)) assert_true(n_labels_wo_min > n_labels_with_min) # Test connect_diag=False ext_reg_without_connect_diag = connected_label_regions(labels_img, connect_diag=False) data_wo_connect_diag = ext_reg_without_connect_diag.get_data() n_labels_wo_connect_diag = len(np.unique(data_wo_connect_diag)) assert_true(n_labels_wo_connect_diag > n_labels_wo_reg_ext) # If min_size is large and if all the regions are removed then empty image # will be returned extract_reg_min_size_large = connected_label_regions(labels_img, min_size=500) assert_true(np.unique(extract_reg_min_size_large.get_data()) == 0) # Test the names of the brain regions given in labels. # Test labels for 9 regions in n_regions labels = ['region_a', 'region_b', 'region_c', 'region_d', 'region_e', 'region_f', 'region_g', 'region_h', 'region_i'] # If labels are provided, first return will contain extracted labels image # and second return will contain list of new names generated based on same # name with assigned on both hemispheres for example. extracted_reg, new_labels = connected_label_regions(labels_img, min_size=100, labels=labels) # The length of new_labels returned can differ depending upon min_size. If # min_size given is more small regions can be removed therefore newly # generated labels can be less than original size of labels. Or if min_size # is less then newly generated labels can be more. # We test here whether labels returned are empty or not. assert_not_equal(new_labels, '') assert_true(len(new_labels) <= len(labels)) # labels given in numpy array labels = np.asarray(labels) extracted_reg2, new_labels2 = connected_label_regions(labels_img, labels=labels) assert_not_equal(new_labels, '') # By default min_size is less, so newly generated labels can be more. assert_true(len(new_labels2) >= len(labels)) # If number of labels provided are wrong (which means less than number of # unique labels in labels_img), then we raise an error # Test whether error raises unique_labels = set(np.unique(np.asarray(labels_img.get_data()))) unique_labels.remove(0) # labels given are less than n_regions=9 provided_labels = ['region_a', 'region_c', 'region_f', 'region_g', 'region_h', 'region_i'] assert_true(len(provided_labels) < len(unique_labels)) np.testing.assert_raises(ValueError, connected_label_regions, labels_img, labels=provided_labels) # Test if unknown/negative integers are provided as labels in labels_img, # we raise an error and test the same whether error is raised. labels_data = np.zeros(shape, dtype=np.int) h0 = shape[0] // 2 h1 = shape[1] // 2 h2 = shape[2] // 2 labels_data[:h0, :h1, :h2] = 1 labels_data[:h0, :h1, h2:] = 2 labels_data[:h0, h1:, :h2] = 3 labels_data[:h0, h1:, h2:] = 4 labels_data[h0:, :h1, :h2] = 5 labels_data[h0:, :h1, h2:] = 6 labels_data[h0:, h1:, :h2] = np.nan labels_data[h0:, h1:, h2:] = np.inf neg_labels_img = nibabel.Nifti1Image(labels_data, affine) np.testing.assert_raises(ValueError, connected_label_regions, labels_img=neg_labels_img) # If labels_img provided is 4D Nifti image, then test whether error is # raised or not. Since this function accepts only 3D image. labels_4d_data = np.zeros((shape) + (2, )) labels_data[h0:, h1:, :h2] = 0 labels_data[h0:, h1:, h2:] = 0 labels_4d_data[..., 0] = labels_data labels_4d_data[..., 1] = labels_data labels_img_4d = nibabel.Nifti1Image(labels_4d_data, np.eye(4)) np.testing.assert_raises(DimensionError, connected_label_regions, labels_img=labels_img_4d) # Test if labels (or names to regions) given is a string without a list. # Then, we expect it to be split to regions extracted and returned as list. labels_in_str = 'region_a' labels_img_in_str = generate_labeled_regions(shape, affine=affine, n_regions=1) extract_regions, new_labels = connected_label_regions(labels_img_in_str, labels=labels_in_str) assert_true(isinstance(new_labels, list)) # If user has provided combination of labels, then function passes without # breaking and new labels are returned based upon given labels and should # be equal or more based on regions extracted combined_labels = ['region_a', '1', 'region_b', '2', 'region_c', '3', 'region_d', '4', 'region_e'] ext_reg, new_labels = connected_label_regions(labels_img, labels=combined_labels) assert_true(len(new_labels) >= len(combined_labels))
def test_largest_cc_img(): """ Check the extraction of the largest connected component, for niftis Similiar to smooth_img tests for largest connected_component_img, here also only the added features for largest_connected_component are tested. """ # Test whether dimension of 3Dimg and list of 3Dimgs are kept. shapes = ((10, 11, 12), (13, 14, 15)) regions = [1, 3] img1 = data_gen.generate_labeled_regions(shape=shapes[0], n_regions=regions[0]) img2 = data_gen.generate_labeled_regions(shape=shapes[1], n_regions=regions[1]) for create_files in (False, True): with testing.write_tmp_imgs(img1, img2, create_files=create_files) as imgs: # List of images as input out = largest_connected_component_img(imgs) assert_true(isinstance(out, list)) assert_true(len(out) == 2) for o, s in zip(out, shapes): assert_true(o.shape == (s)) # Single image as input out = largest_connected_component_img(imgs[0]) assert_true(isinstance(out, Nifti1Image)) assert_true(out.shape == (shapes[0])) # Test whether 4D Nifti throws the right error. img_4D = data_gen.generate_fake_fmri(shapes[0], length=17) assert_raises(DimensionError, largest_connected_component_img, img_4D) # tests adapted to non-native endian data dtype img1_change_dtype = nibabel.Nifti1Image(img1.get_data().astype('>f8'), affine=img1.affine) img2_change_dtype = nibabel.Nifti1Image(img2.get_data().astype('>f8'), affine=img2.affine) for create_files in (False, True): with testing.write_tmp_imgs(img1_change_dtype, img2_change_dtype, create_files=create_files) as imgs: # List of images as input out = largest_connected_component_img(imgs) assert_true(isinstance(out, list)) assert_true(len(out) == 2) for o, s in zip(out, shapes): assert_true(o.shape == (s)) # Single image as input out = largest_connected_component_img(imgs[0]) assert_true(isinstance(out, Nifti1Image)) assert_true(out.shape == (shapes[0])) # Test the output with native and without native out_native = largest_connected_component_img(img1) out_non_native = largest_connected_component_img(img1_change_dtype) np.testing.assert_equal(out_native.get_data(), out_non_native.get_data())