Coverage for models/tests/test_hdr_cie_lab.py: 100%

1"""Define the unit tests for the :mod:`colour.models.hdr_cie_lab` module."""

2

3 from __future__ import annotations

4

5 from itertools import product

6

7 import numpy as np

8

9 from colour.constants import TOLERANCE_ABSOLUTE_TESTS

10 from colour.models import XYZ_to_hdr_CIELab, hdr_CIELab_to_XYZ

11 from colour.models.hdr_cie_lab import exponent_hdr_CIELab

12 from colour.utilities import domain_range_scale, ignore_numpy_errors

13

14 __author__ = "Colour Developers"

15 __copyright__ = "Copyright 2013 Colour Developers"

16 __license__ = "BSD-3-Clause - https://opensource.org/licenses/BSD-3-Clause"

17 __maintainer__ = "Colour Developers"

18 __email__ = "colour-developers@colour-science.org"

19 __status__ = "Production"

20

21 __all__ = [

22 "TestExponent_hdr_CIELab",

23 "TestXYZ_to_hdr_CIELab",

24 "TestHdr_CIELab_to_XYZ",

25]

26

27

28 class TestExponent_hdr_CIELab:

29 """

30 Define :func:`colour.models.hdr_cie_lab.exponent_hdr_CIELab`

31 definition unit tests methods.

32 """

33

34 def test_exponent_hdr_CIELab(self) -> None:

35 """

36 Test :func:`colour.models.hdr_cie_lab.exponent_hdr_CIELab`

37 definition.

38 """

39

40 np.testing.assert_allclose(

41 exponent_hdr_CIELab(0.2, 100),

42 0.473851073746817,

43 atol=TOLERANCE_ABSOLUTE_TESTS,

44 )

45

46 np.testing.assert_allclose(

47 exponent_hdr_CIELab(0.4, 100),

48 0.656101486726362,

49 atol=TOLERANCE_ABSOLUTE_TESTS,

50 )

51

52 np.testing.assert_allclose(

53 exponent_hdr_CIELab(0.4, 100, method="Fairchild 2010"),

54 1.326014370643925,

55 atol=TOLERANCE_ABSOLUTE_TESTS,

56 )

57

58 np.testing.assert_allclose(

59 exponent_hdr_CIELab(0.2, 1000),

60 0.710776610620225,

61 atol=TOLERANCE_ABSOLUTE_TESTS,

62 )

63

64 def test_n_dimensional_exponent_hdr_CIELab(self) -> None:

65 """

66 Test :func:`colour.models.hdr_cie_lab.exponent_hdr_CIELab`

67 definition n-dimensional arrays support.

68 """

69

70 Y_s = 0.2

71 Y_abs = 100

72 epsilon = exponent_hdr_CIELab(Y_s, Y_abs)

73

74 Y_s = np.tile(Y_s, 6)

75 Y_abs = np.tile(Y_abs, 6)

76 epsilon = np.tile(epsilon, 6)

77 np.testing.assert_allclose(

78 exponent_hdr_CIELab(Y_s, Y_abs),

79 epsilon,

80 atol=TOLERANCE_ABSOLUTE_TESTS,

81 )

82

83 Y_s = np.reshape(Y_s, (2, 3))

84 Y_abs = np.reshape(Y_abs, (2, 3))

85 epsilon = np.reshape(epsilon, (2, 3))

86 np.testing.assert_allclose(

87 exponent_hdr_CIELab(Y_s, Y_abs),

88 epsilon,

89 atol=TOLERANCE_ABSOLUTE_TESTS,

90 )

91

92 Y_s = np.reshape(Y_s, (2, 3, 1))

93 Y_abs = np.reshape(Y_abs, (2, 3, 1))

94 epsilon = np.reshape(epsilon, (2, 3, 1))

95 np.testing.assert_allclose(

96 exponent_hdr_CIELab(Y_s, Y_abs),

97 epsilon,

98 atol=TOLERANCE_ABSOLUTE_TESTS,

99 )

100

101 def test_domain_range_scale_exponent_hdr_CIELab(self) -> None:

102 """

103 Test :func:`colour.models.hdr_cie_lab.exponent_hdr_CIELab` definition

104 domain and range scale support.

105 """

106

107 Y_s = 0.2

108 Y_abs = 100

109 epsilon = exponent_hdr_CIELab(Y_s, Y_abs)

110

111 d_r = (("reference", 1), ("1", 1), ("100", 100))

112 for scale, factor in d_r:

113 with domain_range_scale(scale):

114 np.testing.assert_allclose(

115 exponent_hdr_CIELab(Y_s * factor, Y_abs),

116 epsilon,

117 atol=TOLERANCE_ABSOLUTE_TESTS,

118 )

119

120 @ignore_numpy_errors

121 def test_nan_exponent_hdr_CIELab(self) -> None:

122 """

123 Test :func:`colour.models.hdr_cie_lab.exponent_hdr_CIELab`

124 definition nan support.

125 """

126

127 cases = np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan])

128 exponent_hdr_CIELab(cases, cases)

129

130

131 class TestXYZ_to_hdr_CIELab:

132 """

133 Define :func:`colour.models.hdr_cie_lab.XYZ_to_hdr_CIELab` definition unit

134 tests methods.

135 """

136

137 def test_XYZ_to_hdr_CIELab(self) -> None:

138 """Test :func:`colour.models.hdr_cie_lab.XYZ_to_hdr_CIELab` definition."""

139

140 np.testing.assert_allclose(

141 XYZ_to_hdr_CIELab(np.array([0.20654008, 0.12197225, 0.05136952])),

142 np.array([51.87002062, 60.47633850, 32.14551912]),

143 atol=TOLERANCE_ABSOLUTE_TESTS,

144 )

145

146 np.testing.assert_allclose(

147 XYZ_to_hdr_CIELab(

148 np.array([0.20654008, 0.12197225, 0.05136952]),

149 np.array([0.44757, 0.40745]),

150 ),

151 np.array([51.87002062, 44.49667330, -6.69619196]),

152 atol=TOLERANCE_ABSOLUTE_TESTS,

153 )

154

155 np.testing.assert_allclose(

156 XYZ_to_hdr_CIELab(

157 np.array([0.20654008, 0.12197225, 0.05136952]),

158 np.array([0.44757, 0.40745]),

159 method="Fairchild 2010",

160 ),

161 np.array([31.99621114, 95.08564341, -14.14047055]),

162 atol=TOLERANCE_ABSOLUTE_TESTS,

163 )

164

165 np.testing.assert_allclose(

166 XYZ_to_hdr_CIELab(np.array([0.20654008, 0.12197225, 0.05136952]), Y_s=0.5),

167 np.array([23.10388654, 59.31425004, 23.69960142]),

168 atol=TOLERANCE_ABSOLUTE_TESTS,

169 )

170

171 np.testing.assert_allclose(

172 XYZ_to_hdr_CIELab(

173 np.array([0.20654008, 0.12197225, 0.05136952]), Y_abs=1000

174 ),

175 np.array([29.77261805, 62.58315675, 27.31232673]),

176 atol=TOLERANCE_ABSOLUTE_TESTS,

177 )

178

179 def test_n_dimensional_XYZ_to_hdr_CIELab(self) -> None:

180 """

181 Test :func:`colour.models.hdr_cie_lab.XYZ_to_hdr_CIELab` definition

182 n-dimensional support.

183 """

184

185 XYZ = np.array([0.20654008, 0.12197225, 0.05136952])

186 illuminant = np.array([0.31270, 0.32900])

187 Y_s = 0.2

188 Y_abs = 100

189 Lab_hdr = XYZ_to_hdr_CIELab(XYZ, illuminant, Y_s, Y_abs)

190

191 XYZ = np.tile(XYZ, (6, 1))

192 Lab_hdr = np.tile(Lab_hdr, (6, 1))

193 np.testing.assert_allclose(

194 XYZ_to_hdr_CIELab(XYZ, illuminant, Y_s, Y_abs),

195 Lab_hdr,

196 atol=TOLERANCE_ABSOLUTE_TESTS,

197 )

198

199 illuminant = np.tile(illuminant, (6, 1))

200 Y_s = np.tile(Y_s, 6)

201 Y_abs = np.tile(Y_abs, 6)

202 np.testing.assert_allclose(

203 XYZ_to_hdr_CIELab(XYZ, illuminant, Y_s, Y_abs),

204 Lab_hdr,

205 atol=TOLERANCE_ABSOLUTE_TESTS,

206 )

207

208 XYZ = np.reshape(XYZ, (2, 3, 3))

209 illuminant = np.reshape(illuminant, (2, 3, 2))

210 Y_s = np.reshape(Y_s, (2, 3))

211 Y_abs = np.reshape(Y_abs, (2, 3))

212 Lab_hdr = np.reshape(Lab_hdr, (2, 3, 3))

213 np.testing.assert_allclose(

214 XYZ_to_hdr_CIELab(XYZ, illuminant, Y_s, Y_abs),

215 Lab_hdr,

216 atol=TOLERANCE_ABSOLUTE_TESTS,

217 )

218

219 def test_domain_range_scale_XYZ_to_hdr_CIELab(self) -> None:

220 """

221 Test :func:`colour.models.hdr_cie_lab.XYZ_to_hdr_CIELab` definition

222 domain and range scale support.

223 """

224

225 XYZ = np.array([0.20654008, 0.12197225, 0.05136952])

226 illuminant = np.array([0.31270, 0.32900])

227 Y_s = 0.2

228 Y_abs = 100

229 Lab_hdr = XYZ_to_hdr_CIELab(XYZ, illuminant, Y_s, Y_abs)

230

231 d_r = (("reference", 1, 1), ("1", 1, 0.01), ("100", 100, 1))

232 for scale, factor_a, factor_b in d_r:

233 with domain_range_scale(scale):

234 np.testing.assert_allclose(

235 XYZ_to_hdr_CIELab(

236 XYZ * factor_a, illuminant, Y_s * factor_a, Y_abs

237 ),

238 Lab_hdr * factor_b,

239 atol=TOLERANCE_ABSOLUTE_TESTS,

240 )

241

242 @ignore_numpy_errors

243 def test_nan_XYZ_to_hdr_CIELab(self) -> None:

244 """

245 Test :func:`colour.models.hdr_cie_lab.XYZ_to_hdr_CIELab` definition

246 nan support.

247 """

248

249 cases = [-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]

250 cases = np.array(list(set(product(cases, repeat=3))))

251 XYZ_to_hdr_CIELab(cases, cases[..., 0:2], cases[..., 0], cases[..., 0])

252

253

254 class TestHdr_CIELab_to_XYZ:

255 """

256 Define :func:`colour.models.hdr_cie_lab.hdr_CIELab_to_XYZ` definition unit

257 tests methods.

258 """

259

260 def test_hdr_CIELab_to_XYZ(self) -> None:

261 """Test :func:`colour.models.hdr_cie_lab.hdr_CIELab_to_XYZ` definition."""

262

263 np.testing.assert_allclose(

264 hdr_CIELab_to_XYZ(np.array([51.87002062, 60.47633850, 32.14551912])),

265 np.array([0.20654008, 0.12197225, 0.05136952]),

266 atol=TOLERANCE_ABSOLUTE_TESTS,

267 )

268

269 np.testing.assert_allclose(

270 hdr_CIELab_to_XYZ(

271 np.array([51.87002062, 44.49667330, -6.69619196]),

272 np.array([0.44757, 0.40745]),

273 ),

274 np.array([0.20654008, 0.12197225, 0.05136952]),

275 atol=TOLERANCE_ABSOLUTE_TESTS,

276 )

277

278 np.testing.assert_allclose(

279 hdr_CIELab_to_XYZ(

280 np.array([31.99621114, 95.08564341, -14.14047055]),

281 np.array([0.44757, 0.40745]),

282 method="Fairchild 2010",

283 ),

284 np.array([0.20654008, 0.12197225, 0.05136952]),

285 atol=TOLERANCE_ABSOLUTE_TESTS,

286 )

287

288 np.testing.assert_allclose(

289 hdr_CIELab_to_XYZ(

290 np.array([23.10388654, 59.31425004, 23.69960142]), Y_s=0.5

291 ),

292 np.array([0.20654008, 0.12197225, 0.05136952]),

293 atol=TOLERANCE_ABSOLUTE_TESTS,

294 )

295

296 np.testing.assert_allclose(

297 hdr_CIELab_to_XYZ(

298 np.array([29.77261805, 62.58315675, 27.31232673]), Y_abs=1000

299 ),

300 np.array([0.20654008, 0.12197225, 0.05136952]),

301 atol=TOLERANCE_ABSOLUTE_TESTS,

302 )

303

304 def test_n_dimensional_hdr_CIELab_to_XYZ(self) -> None:

305 """

306 Test :func:`colour.models.hdr_cie_lab.hdr_CIELab_to_XYZ` definition

307 n-dimensional support.

308 """

309

310 Lab_hdr = np.array([51.87002062, 60.47633850, 32.14551912])

311 illuminant = np.array([0.31270, 0.32900])

312 Y_s = 0.2

313 Y_abs = 100

314 XYZ = hdr_CIELab_to_XYZ(Lab_hdr, illuminant, Y_s, Y_abs)

315

316 Lab_hdr = np.tile(Lab_hdr, (6, 1))

317 XYZ = np.tile(XYZ, (6, 1))

318 np.testing.assert_allclose(

319 hdr_CIELab_to_XYZ(Lab_hdr, illuminant, Y_s, Y_abs),

320 XYZ,

321 atol=TOLERANCE_ABSOLUTE_TESTS,

322 )

323

324 illuminant = np.tile(illuminant, (6, 1))

325 Y_s = np.tile(Y_s, 6)

326 Y_abs = np.tile(Y_abs, 6)

327 np.testing.assert_allclose(

328 hdr_CIELab_to_XYZ(Lab_hdr, illuminant, Y_s, Y_abs),

329 XYZ,

330 atol=TOLERANCE_ABSOLUTE_TESTS,

331 )

332

333 Lab_hdr = np.reshape(Lab_hdr, (2, 3, 3))

334 illuminant = np.reshape(illuminant, (2, 3, 2))

335 Y_s = np.reshape(Y_s, (2, 3))

336 Y_abs = np.reshape(Y_abs, (2, 3))

337 XYZ = np.reshape(XYZ, (2, 3, 3))

338 np.testing.assert_allclose(

339 hdr_CIELab_to_XYZ(Lab_hdr, illuminant, Y_s, Y_abs),

340 XYZ,

341 atol=TOLERANCE_ABSOLUTE_TESTS,

342 )

343

344 def test_domain_range_scale_hdr_CIELab_to_XYZ(self) -> None:

345 """

346 Test :func:`colour.models.hdr_cie_lab.hdr_CIELab_to_XYZ` definition

347 domain and range scale support.

348 """

349

350 Lab_hdr = np.array([26.46461067, -24.61332600, -4.84796811])

351 illuminant = np.array([0.31270, 0.32900])

352 Y_s = 0.2

353 Y_abs = 100

354 XYZ = hdr_CIELab_to_XYZ(Lab_hdr, illuminant, Y_s, Y_abs)

355

356 d_r = (("reference", 1, 1, 1), ("1", 0.01, 1, 1), ("100", 1, 100, 100))

357 for scale, factor_a, factor_b, factor_c in d_r:

358 with domain_range_scale(scale):

359 np.testing.assert_allclose(

360 hdr_CIELab_to_XYZ(

361 Lab_hdr * factor_a, illuminant, Y_s * factor_b, Y_abs

362 ),

363 XYZ * factor_c,

364 atol=TOLERANCE_ABSOLUTE_TESTS,

365 )

366

367 @ignore_numpy_errors

368 def test_nan_hdr_CIELab_to_XYZ(self) -> None:

369 """

370 Test :func:`colour.models.hdr_cie_lab.hdr_CIELab_to_XYZ` definition

371 nan support.

372 """

373

374 cases = [-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]

375 cases = np.array(list(set(product(cases, repeat=3))))

376 hdr_CIELab_to_XYZ(cases, cases[..., 0:2], cases[..., 0], cases[..., 0])