Coverage for nilearn/plotting/surface/tests/test_plotly_backend.py: 0%

44 statements  

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

1"""Test nilearn.plotting.surface._plotly_backend functions.""" 

2 

3import numpy as np 

4import pytest 

5 

6from nilearn.plotting.surface._plotly_backend import ( 

7 _configure_title, 

8 _get_camera_view_from_elevation_and_azimut, 

9 _get_camera_view_from_string_view, 

10 _get_view_plot_surf, 

11) 

12 

13pytest.importorskip( 

14 "plotly", 

15 reason="Plotly is not installed; required to run the tests!", 

16) 

17 

18EXPECTED_CAMERAS_PLOTLY = [ 

19 ( 

20 "left", 

21 "lateral", 

22 (0, 180), 

23 { 

24 "eye": {"x": -1.5, "y": 0, "z": 0}, 

25 "up": {"x": 0, "y": 0, "z": 1}, 

26 "center": {"x": 0, "y": 0, "z": 0}, 

27 }, 

28 ), 

29 ( 

30 "left", 

31 "medial", 

32 (0, 0), 

33 { 

34 "eye": {"x": 1.5, "y": 0, "z": 0}, 

35 "up": {"x": 0, "y": 0, "z": 1}, 

36 "center": {"x": 0, "y": 0, "z": 0}, 

37 }, 

38 ), 

39 # Dorsal left 

40 ( 

41 "left", 

42 "dorsal", 

43 (90, 0), 

44 { 

45 "eye": {"x": 0, "y": 0, "z": 1.5}, 

46 "up": {"x": -1, "y": 0, "z": 0}, 

47 "center": {"x": 0, "y": 0, "z": 0}, 

48 }, 

49 ), 

50 # Ventral left 

51 ( 

52 "left", 

53 "ventral", 

54 (270, 0), 

55 { 

56 "eye": {"x": 0, "y": 0, "z": -1.5}, 

57 "up": {"x": 1, "y": 0, "z": 0}, 

58 "center": {"x": 0, "y": 0, "z": 0}, 

59 }, 

60 ), 

61 # Anterior left 

62 ( 

63 "left", 

64 "anterior", 

65 (0, 90), 

66 { 

67 "eye": {"x": 0, "y": 1.5, "z": 0}, 

68 "up": {"x": 0, "y": 0, "z": 1}, 

69 "center": {"x": 0, "y": 0, "z": 0}, 

70 }, 

71 ), 

72 # Posterior left 

73 ( 

74 "left", 

75 "posterior", 

76 (0, 270), 

77 { 

78 "eye": {"x": 0, "y": -1.5, "z": 0}, 

79 "up": {"x": 0, "y": 0, "z": 1}, 

80 "center": {"x": 0, "y": 0, "z": 0}, 

81 }, 

82 ), 

83 # Lateral right 

84 ( 

85 "right", 

86 "lateral", 

87 (0, 0), 

88 { 

89 "eye": {"x": 1.5, "y": 0, "z": 0}, 

90 "up": {"x": 0, "y": 0, "z": 1}, 

91 "center": {"x": 0, "y": 0, "z": 0}, 

92 }, 

93 ), 

94 # Medial right 

95 ( 

96 "right", 

97 "medial", 

98 (0, 180), 

99 { 

100 "eye": {"x": -1.5, "y": 0, "z": 0}, 

101 "up": {"x": 0, "y": 0, "z": 1}, 

102 "center": {"x": 0, "y": 0, "z": 0}, 

103 }, 

104 ), 

105 # Dorsal right 

106 ( 

107 "right", 

108 "dorsal", 

109 (90, 0), 

110 { 

111 "eye": {"x": 0, "y": 0, "z": 1.5}, 

112 "up": {"x": -1, "y": 0, "z": 0}, 

113 "center": {"x": 0, "y": 0, "z": 0}, 

114 }, 

115 ), 

116 # Ventral right 

117 ( 

118 "right", 

119 "ventral", 

120 (270, 0), 

121 { 

122 "eye": {"x": 0, "y": 0, "z": -1.5}, 

123 "up": {"x": 1, "y": 0, "z": 0}, 

124 "center": {"x": 0, "y": 0, "z": 0}, 

125 }, 

126 ), 

127 # Anterior right 

128 ( 

129 "right", 

130 "anterior", 

131 (0, 90), 

132 { 

133 "eye": {"x": 0, "y": 1.5, "z": 0}, 

134 "up": {"x": 0, "y": 0, "z": 1}, 

135 "center": {"x": 0, "y": 0, "z": 0}, 

136 }, 

137 ), 

138 # Posterior right 

139 ( 

140 "right", 

141 "posterior", 

142 (0, 270), 

143 { 

144 "eye": {"x": 0, "y": -1.5, "z": 0}, 

145 "up": {"x": 0, "y": 0, "z": 1}, 

146 "center": {"x": 0, "y": 0, "z": 0}, 

147 }, 

148 ), 

149] 

150 

151 

152def test_configure_title(): 

153 """Test nilearn.plotting.surface._plotly_backend._configure_title.""" 

154 assert _configure_title(None, None) == {} 

155 assert _configure_title(None, 22) == {} 

156 config = _configure_title("Test Title", 22, color="green") 

157 assert config["text"] == "Test Title" 

158 assert config["x"] == 0.5 

159 assert config["y"] == 0.96 

160 assert config["xanchor"] == "center" 

161 assert config["yanchor"] == "top" 

162 assert config["font"]["size"] == 22 

163 assert config["font"]["color"] == "green" 

164 

165 

166@pytest.mark.parametrize("full_view", EXPECTED_CAMERAS_PLOTLY) 

167def test_get_camera_view_from_string_view(full_view): 

168 """Test if 

169 nilearn.plotting.surface._plotly_backend._get_camera_view_from_string_view 

170 returns expected values. 

171 """ 

172 hemi, view_name, (elev, azim), expected_camera_view = full_view 

173 camera_view_string = _get_camera_view_from_string_view(hemi, view_name) 

174 

175 # Check each camera view parameter 

176 for k in ["center", "eye", "up"]: 

177 # Check camera view obtained from string view 

178 assert np.allclose( 

179 list(camera_view_string[k].values()), 

180 list(expected_camera_view[k].values()), 

181 ) 

182 

183 

184@pytest.mark.parametrize("full_view", EXPECTED_CAMERAS_PLOTLY) 

185def test_get_camera_view_from_elev_azim(full_view): 

186 """Test if 

187 nilearn.plotting.surface._plotly_backend._get_camera_view_from_elevation_and_azimut 

188 returns expected values. 

189 """ 

190 hemi, view_name, (elev, azim), expected_camera_view = full_view 

191 camera_view_elev_azim = _get_camera_view_from_elevation_and_azimut( 

192 (elev, azim) 

193 ) 

194 # Check each camera view parameter 

195 for k in ["center", "eye", "up"]: 

196 # Check camera view obtained from elevation & azimut 

197 assert np.allclose( 

198 list(camera_view_elev_azim[k].values()), 

199 list(expected_camera_view[k].values()), 

200 ) 

201 

202 

203@pytest.mark.parametrize("full_view", EXPECTED_CAMERAS_PLOTLY) 

204def test_get_view_plot_surf(full_view): 

205 """Test if 

206 nilearn.plotting.surface._plotly_backend.PlotlySurfaceBackend._get_view_plot_surf 

207 returns expected values. 

208 """ 

209 hemi, view_name, (elev, azim), expected_camera_view = full_view 

210 camera_view = _get_view_plot_surf(hemi, view_name) 

211 camera_view_elev_azim = _get_view_plot_surf(hemi, (elev, azim)) 

212 # Check each camera view parameter 

213 for k in ["center", "eye", "up"]: 

214 # Check default camera view 

215 assert np.allclose( 

216 list(camera_view[k].values()), 

217 list(expected_camera_view[k].values()), 

218 ) 

219 # Check camera view obtained from elevation & azimut 

220 assert np.allclose( 

221 list(camera_view_elev_azim[k].values()), 

222 list(expected_camera_view[k].values()), 

223 ) 

224 

225 

226@pytest.mark.parametrize("hemi,view", [("foo", "medial"), ("bar", "anterior")]) 

227def test_get_view_plot_surf_hemisphere_errors(hemi, view): 

228 """Test 

229 nilearn.plotting.surface._plotly_backend.PlotlySurfaceBackend._get_view_plot_surf 

230 for invalid hemisphere values. 

231 """ 

232 with pytest.raises(ValueError, match="Invalid hemispheres definition"): 

233 _get_view_plot_surf(hemi, view) 

234 

235 

236@pytest.mark.parametrize( 

237 "hemi,view", 

238 [ 

239 ("left", "foo"), 

240 ("right", "bar"), 

241 ("both", "lateral"), 

242 ("both", "medial"), 

243 ("both", "foo"), 

244 ], 

245) 

246def test_get_view_plot_surf_view_errors(hemi, view): 

247 """Test 

248 nilearn.plotting.surface._plotly_backend.PlotlySurfaceBackend._get_view_plot_surf 

249 for invalid view values. 

250 """ 

251 with pytest.raises(ValueError, match="Invalid view definition"): 

252 _get_view_plot_surf(hemi, view)