Coverage for nilearn/datasets/tests/test_struct.py: 0%

98 statements  

« prev     ^ index     » next       coverage.py v7.9.1, created at 2025-06-16 12:32 +0200

1"""Test the datasets module.""" 

2 

3from pathlib import Path 

4 

5import pandas as pd 

6import pytest 

7from nibabel import Nifti1Image 

8from sklearn.utils import Bunch 

9 

10from nilearn.datasets import struct 

11from nilearn.datasets.struct import ( 

12 fetch_surf_fsaverage, 

13 load_fsaverage, 

14 load_fsaverage_data, 

15) 

16from nilearn.datasets.tests._testing import ( 

17 check_type_fetcher, 

18 dict_to_archive, 

19 list_to_archive, 

20) 

21from nilearn.surface import PolyMesh, SurfaceImage 

22 

23 

24def test_fetch_icbm152_2009(tmp_path, request_mocker): 

25 dataset = struct.fetch_icbm152_2009(data_dir=str(tmp_path), verbose=0) 

26 

27 check_type_fetcher(dataset) 

28 assert isinstance(dataset.csf, str) 

29 assert isinstance(dataset.eye_mask, str) 

30 assert isinstance(dataset.face_mask, str) 

31 assert isinstance(dataset.gm, str) 

32 assert isinstance(dataset.mask, str) 

33 assert isinstance(dataset.pd, str) 

34 assert isinstance(dataset.t1, str) 

35 assert isinstance(dataset.t2, str) 

36 assert isinstance(dataset.t2_relax, str) 

37 assert isinstance(dataset.wm, str) 

38 assert request_mocker.url_count == 1 

39 

40 

41def _make_oasis_data(dartel=True): 

42 n_subjects = 457 

43 prefix = "mwrc" if dartel else "mwc" 

44 ids = pd.DataFrame( 

45 {"ID": [f"OAS1_{i:04}" for i in range(n_subjects)]} 

46 ).to_csv(index=False, sep="\t") 

47 data = {"oasis_cross-sectional.csv": ids, "data_usage_agreement.txt": ""} 

48 path_pattern = str( 

49 Path( 

50 "OAS1_{subj:04}_MR1", 

51 "{prefix}{kind}OAS1_{subj:04}_MR1_mpr_anon_fslswapdim_bet.nii.gz", 

52 ) 

53 ) 

54 for i in range(457): 

55 for kind in [1, 2]: 

56 data[path_pattern.format(subj=i, kind=kind, prefix=prefix)] = "" 

57 return dict_to_archive(data) 

58 

59 

60def test_fetch_oasis_vbm(tmp_path, request_mocker): 

61 request_mocker.url_mapping["*archive_dartel.tgz*"] = _make_oasis_data() 

62 request_mocker.url_mapping["*archive.tgz*"] = _make_oasis_data(False) 

63 

64 dataset = struct.fetch_oasis_vbm(data_dir=str(tmp_path), verbose=0) 

65 

66 check_type_fetcher(dataset) 

67 assert len(dataset.gray_matter_maps) == 403 

68 assert len(dataset.white_matter_maps) == 403 

69 assert isinstance(dataset.gray_matter_maps[0], str) 

70 assert isinstance(dataset.white_matter_maps[0], str) 

71 assert isinstance(dataset.ext_vars, pd.DataFrame) 

72 assert isinstance(dataset.data_usage_agreement, str) 

73 assert request_mocker.url_count == 1 

74 

75 dataset = struct.fetch_oasis_vbm( 

76 data_dir=str(tmp_path), dartel_version=False, verbose=0 

77 ) 

78 

79 check_type_fetcher(dataset) 

80 assert len(dataset.gray_matter_maps) == 415 

81 assert len(dataset.white_matter_maps) == 415 

82 assert isinstance(dataset.gray_matter_maps[0], str) 

83 assert isinstance(dataset.white_matter_maps[0], str) 

84 assert isinstance(dataset.ext_vars, pd.DataFrame) 

85 assert isinstance(dataset.data_usage_agreement, str) 

86 assert request_mocker.url_count == 2 

87 

88 

89@pytest.mark.parametrize( 

90 "func", 

91 [ 

92 struct.load_mni152_brain_mask, 

93 struct.load_mni152_gm_mask, 

94 struct.load_mni152_gm_template, 

95 struct.load_mni152_template, 

96 struct.load_mni152_wm_mask, 

97 struct.load_mni152_wm_template, 

98 ], 

99) 

100@pytest.mark.parametrize("resolution", [None, 2]) 

101def test_load_mni152(func, resolution): 

102 img = func(resolution=resolution) 

103 

104 assert isinstance(img, Nifti1Image) 

105 

106 check_type_fetcher(img) 

107 

108 if resolution is None: 

109 expected_shape = (197, 233, 189) 

110 expected_zooms = (1.0, 1.0, 1.0) 

111 elif resolution == 2: 

112 expected_shape = (99, 117, 95) 

113 expected_zooms = (2.0, 2.0, 2.0) 

114 

115 assert img.shape == expected_shape 

116 assert img.header.get_zooms() == expected_zooms 

117 

118 

119def test_fetch_icbm152_brain_gm_mask(tmp_path): 

120 dataset = struct.fetch_icbm152_2009(data_dir=str(tmp_path), verbose=0) 

121 struct.load_mni152_template(resolution=2).to_filename(dataset.gm) 

122 grey_matter_img = struct.fetch_icbm152_brain_gm_mask( 

123 data_dir=str(tmp_path), verbose=0 

124 ) 

125 

126 check_type_fetcher(grey_matter_img) 

127 assert isinstance(grey_matter_img, Nifti1Image) 

128 

129 

130@pytest.mark.parametrize( 

131 "mesh", 

132 [ 

133 "fsaverage3", 

134 "fsaverage4", 

135 "fsaverage5", 

136 "fsaverage6", 

137 "fsaverage7", 

138 "fsaverage", 

139 ], 

140) 

141def test_fetch_surf_fsaverage(mesh, tmp_path, request_mocker): 

142 # Define attribute list that nilearn meshs should contain 

143 # (each attribute should eventually map to a _.gii.gz file 

144 # named after the attribute) 

145 mesh_attributes = { 

146 f"{part}_{side}" 

147 for part in [ 

148 "area", 

149 "curv", 

150 "flat", 

151 "infl", 

152 "pial", 

153 "sphere", 

154 "sulc", 

155 "thick", 

156 "white", 

157 ] 

158 for side in ["left", "right"] 

159 } 

160 

161 # Mock fsaverage3, 4, 6, 7 download (with actual url) 

162 fs_urls = [ 

163 "https://osf.io/azhdf/download", 

164 "https://osf.io/28uma/download", 

165 "https://osf.io/jzxyr/download", 

166 "https://osf.io/svf8k/download", 

167 ] 

168 for fs_url in fs_urls: 

169 request_mocker.url_mapping[fs_url] = list_to_archive( 

170 [f"{name}.gii.gz" for name in mesh_attributes] 

171 ) 

172 

173 dataset = fetch_surf_fsaverage(mesh, data_dir=str(tmp_path)) 

174 

175 check_type_fetcher(dataset) 

176 

177 assert mesh_attributes.issubset(set(dataset.keys())) 

178 

179 

180def test_fetch_load_fsaverage(): 

181 """Check that PolyMesh are returned.""" 

182 result = load_fsaverage() 

183 check_type_fetcher(result) 

184 assert isinstance(result, Bunch) 

185 assert isinstance(result.pial, PolyMesh) 

186 nb_vertices_fsaverage5 = 10242 

187 assert result["pial"].parts["left"].n_vertices == nb_vertices_fsaverage5 

188 assert result.pial.parts["left"].n_vertices == nb_vertices_fsaverage5 

189 

190 

191def test_load_fsaverage_data_smoke(): 

192 assert isinstance(load_fsaverage_data(), SurfaceImage) 

193 

194 

195def test_load_fsaverage_data_errors(): 

196 """Give incorrect value argument.""" 

197 with pytest.raises(ValueError, match="'mesh_type' must be one of"): 

198 load_fsaverage_data(mesh_type="foo") 

199 with pytest.raises(ValueError, match="'data_type' must be one of"): 

200 load_fsaverage_data(data_type="foo")