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

1"""Define the unit tests for the :mod:`colour.models.cie_ucs` 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 (

11 CIE1960UCS_to_XYZ,

12 UCS_to_uv,

13 UCS_to_XYZ,

14 UCS_uv_to_xy,

15 XYZ_to_CIE1960UCS,

16 XYZ_to_UCS,

17 uv_to_UCS,

18 xy_to_UCS_uv,

19)

20 from colour.utilities import domain_range_scale, ignore_numpy_errors

21

22 __author__ = "Colour Developers"

23 __copyright__ = "Copyright 2013 Colour Developers"

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

25 __maintainer__ = "Colour Developers"

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

27 __status__ = "Production"

28

29 __all__ = [

30 "TestXYZ_to_UCS",

31 "TestUCS_to_XYZ",

32 "TestUCS_to_uv",

33 "Testuv_to_UCS",

34 "TestUCS_uv_to_xy",

35 "TestXy_to_UCS_uv",

36 "TestXYZ_to_CIE1960UCS",

37 "TestCIE1960UCS_to_XYZ",

38]

39

40

41 class TestXYZ_to_UCS:

42 """

43 Define :func:`colour.models.cie_ucs.XYZ_to_UCS` definition unit tests

44 methods.

45 """

46

47 def test_XYZ_to_UCS(self) -> None:

48 """Test :func:`colour.models.cie_ucs.XYZ_to_UCS` definition."""

49

50 np.testing.assert_allclose(

51 XYZ_to_UCS(np.array([0.20654008, 0.12197225, 0.05136952])),

52 np.array([0.13769339, 0.12197225, 0.10537310]),

53 atol=TOLERANCE_ABSOLUTE_TESTS,

54 )

55

56 np.testing.assert_allclose(

57 XYZ_to_UCS(np.array([0.14222010, 0.23042768, 0.10495772])),

58 np.array([0.09481340, 0.23042768, 0.32701033]),

59 atol=TOLERANCE_ABSOLUTE_TESTS,

60 )

61

62 np.testing.assert_allclose(

63 XYZ_to_UCS(np.array([0.07818780, 0.06157201, 0.28099326])),

64 np.array([0.05212520, 0.06157201, 0.19376075]),

65 atol=TOLERANCE_ABSOLUTE_TESTS,

66 )

67

68 def test_n_dimensional_XYZ_to_UCS(self) -> None:

69 """

70 Test :func:`colour.models.cie_ucs.XYZ_to_UCS` definition n-dimensional

71 support.

72 """

73

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

75 UCS = XYZ_to_UCS(XYZ)

76

77 UCS = np.tile(UCS, (6, 1))

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

79 np.testing.assert_allclose(XYZ_to_UCS(XYZ), UCS, atol=TOLERANCE_ABSOLUTE_TESTS)

80

81 UCS = np.reshape(UCS, (2, 3, 3))

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

83 np.testing.assert_allclose(XYZ_to_UCS(XYZ), UCS, atol=TOLERANCE_ABSOLUTE_TESTS)

84

85 def test_domain_range_scale_XYZ_to_UCS(self) -> None:

86 """

87 Test :func:`colour.models.cie_ucs.XYZ_to_UCS` definition domain and

88 range scale support.

89 """

90

91 XYZ = np.array([0.0704953400, 0.1008000000, 0.0955831300])

92 UCS = XYZ_to_UCS(XYZ)

93

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

95 for scale, factor in d_r:

96 with domain_range_scale(scale):

97 np.testing.assert_allclose(

98 XYZ_to_UCS(XYZ * factor),

99 UCS * factor,

100 atol=TOLERANCE_ABSOLUTE_TESTS,

101 )

102

103 @ignore_numpy_errors

104 def test_nan_XYZ_to_UCS(self) -> None:

105 """Test :func:`colour.models.cie_ucs.XYZ_to_UCS` definition nan support."""

106

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

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

109 XYZ_to_UCS(cases)

110

111

112 class TestUCS_to_XYZ:

113 """

114 Define :func:`colour.models.cie_ucs.UCS_to_XYZ` definition unit tests

115 methods.

116 """

117

118 def test_UCS_to_XYZ(self) -> None:

119 """Test :func:`colour.models.cie_ucs.UCS_to_XYZ` definition."""

120

121 np.testing.assert_allclose(

122 UCS_to_XYZ(np.array([0.13769339, 0.12197225, 0.10537310])),

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

124 atol=TOLERANCE_ABSOLUTE_TESTS,

125 )

126

127 np.testing.assert_allclose(

128 UCS_to_XYZ(np.array([0.09481340, 0.23042768, 0.32701033])),

129 np.array([0.14222010, 0.23042768, 0.10495772]),

130 atol=TOLERANCE_ABSOLUTE_TESTS,

131 )

132

133 np.testing.assert_allclose(

134 UCS_to_XYZ(np.array([0.05212520, 0.06157201, 0.19376075])),

135 np.array([0.07818780, 0.06157201, 0.28099326]),

136 atol=TOLERANCE_ABSOLUTE_TESTS,

137 )

138

139 def test_n_dimensional_UCS_to_XYZ(self) -> None:

140 """

141 Test :func:`colour.models.cie_ucs.UCS_to_XYZ` definition n-dimensional

142 support.

143 """

144

145 UCS = np.array([0.13769339, 0.12197225, 0.10537310])

146 XYZ = UCS_to_XYZ(UCS)

147

148 UCS = np.tile(UCS, (6, 1))

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

150 np.testing.assert_allclose(UCS_to_XYZ(UCS), XYZ, atol=TOLERANCE_ABSOLUTE_TESTS)

151

152 UCS = np.reshape(UCS, (2, 3, 3))

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

154 np.testing.assert_allclose(UCS_to_XYZ(UCS), XYZ, atol=TOLERANCE_ABSOLUTE_TESTS)

155

156 def test_domain_range_scale_UCS_to_XYZ(self) -> None:

157 """

158 Test :func:`colour.models.cie_ucs.UCS_to_XYZ` definition domain and

159 range scale support.

160 """

161

162 UCS = np.array([0.0469968933, 0.1008000000, 0.1637438950])

163 XYZ = UCS_to_XYZ(UCS)

164

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

166 for scale, factor in d_r:

167 with domain_range_scale(scale):

168 np.testing.assert_allclose(

169 UCS_to_XYZ(UCS * factor),

170 XYZ * factor,

171 atol=TOLERANCE_ABSOLUTE_TESTS,

172 )

173

174 @ignore_numpy_errors

175 def test_nan_UCS_to_XYZ(self) -> None:

176 """Test :func:`colour.models.cie_ucs.UCS_to_XYZ` definition nan support."""

177

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

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

180 UCS_to_XYZ(cases)

181

182

183 class TestUCS_to_uv:

184 """

185 Define :func:`colour.models.cie_ucs.UCS_to_uv` definition unit tests

186 methods.

187 """

188

189 def test_UCS_to_uv(self) -> None:

190 """Test :func:`colour.models.cie_ucs.UCS_to_uv` definition."""

191

192 np.testing.assert_allclose(

193 UCS_to_uv(np.array([0.13769339, 0.12197225, 0.10537310])),

194 np.array([0.37720213, 0.33413508]),

195 atol=TOLERANCE_ABSOLUTE_TESTS,

196 )

197

198 np.testing.assert_allclose(

199 UCS_to_uv(np.array([0.09481340, 0.23042768, 0.32701033])),

200 np.array([0.14536327, 0.35328046]),

201 atol=TOLERANCE_ABSOLUTE_TESTS,

202 )

203

204 np.testing.assert_allclose(

205 UCS_to_uv(np.array([0.05212520, 0.06157201, 0.19376075])),

206 np.array([0.16953602, 0.20026156]),

207 atol=TOLERANCE_ABSOLUTE_TESTS,

208 )

209

210 def test_n_dimensional_UCS_to_uv(self) -> None:

211 """

212 Test :func:`colour.models.cie_ucs.UCS_to_uv` definition n-dimensional

213 support.

214 """

215

216 UCS = np.array([0.13769339, 0.12197225, 0.10537310])

217 uv = UCS_to_uv(UCS)

218

219 UCS = np.tile(UCS, (6, 1))

220 uv = np.tile(uv, (6, 1))

221 np.testing.assert_allclose(UCS_to_uv(UCS), uv, atol=TOLERANCE_ABSOLUTE_TESTS)

222

223 UCS = np.reshape(UCS, (2, 3, 3))

224 uv = np.reshape(uv, (2, 3, 2))

225 np.testing.assert_allclose(UCS_to_uv(UCS), uv, atol=TOLERANCE_ABSOLUTE_TESTS)

226

227 def test_domain_range_scale_UCS_to_uv(self) -> None:

228 """

229 Test :func:`colour.models.cie_ucs.UCS_to_uv` definition domain and

230 range scale support.

231 """

232

233 UCS = np.array([0.0469968933, 0.1008000000, 0.1637438950])

234 uv = UCS_to_uv(UCS)

235

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

237 for scale, factor in d_r:

238 with domain_range_scale(scale):

239 np.testing.assert_allclose(

240 UCS_to_uv(UCS * factor), uv, atol=TOLERANCE_ABSOLUTE_TESTS

241 )

242

243 @ignore_numpy_errors

244 def test_nan_UCS_to_uv(self) -> None:

245 """Test :func:`colour.models.cie_ucs.UCS_to_uv` definition nan support."""

246

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

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

249 UCS_to_uv(cases)

250

251

252 class Testuv_to_UCS:

253 """

254 Define :func:`colour.models.cie_ucs.uv_to_UCS` definition unit tests

255 methods.

256 """

257

258 def test_uv_to_UCS(self) -> None:

259 """Test :func:`colour.models.cie_ucs.uv_to_UCS` definition."""

260

261 np.testing.assert_allclose(

262 uv_to_UCS(np.array([0.37720213, 0.33413508])),

263 np.array([1.12889114, 1.00000000, 0.86391046]),

264 atol=TOLERANCE_ABSOLUTE_TESTS,

265 )

266

267 np.testing.assert_allclose(

268 uv_to_UCS(np.array([0.14536327, 0.35328046])),

269 np.array([0.41146705, 1.00000000, 1.41914520]),

270 atol=TOLERANCE_ABSOLUTE_TESTS,

271 )

272

273 np.testing.assert_allclose(

274 uv_to_UCS(np.array([0.16953602, 0.20026156])),

275 np.array([0.84657295, 1.00000000, 3.14689659]),

276 atol=TOLERANCE_ABSOLUTE_TESTS,

277 )

278

279 np.testing.assert_allclose(

280 uv_to_UCS(np.array([0.37720213, 0.33413508]), V=0.18),

281 np.array([0.20320040, 0.18000000, 0.15550388]),

282 atol=TOLERANCE_ABSOLUTE_TESTS,

283 )

284

285 def test_n_dimensional_uv_to_UCS(self) -> None:

286 """

287 Test :func:`colour.models.cie_ucs.uv_to_UCS` definition n-dimensional

288 support.

289 """

290

291 uv = np.array([0.37720213, 0.33413508])

292 UCS = uv_to_UCS(uv)

293

294 uv = np.tile(uv, (6, 1))

295 UCS = np.tile(UCS, (6, 1))

296 np.testing.assert_allclose(uv_to_UCS(uv), UCS, atol=TOLERANCE_ABSOLUTE_TESTS)

297

298 uv = np.reshape(uv, (2, 3, 2))

299 UCS = np.reshape(UCS, (2, 3, 3))

300 np.testing.assert_allclose(uv_to_UCS(uv), UCS, atol=TOLERANCE_ABSOLUTE_TESTS)

301

302 def test_domain_range_scale_uv_to_UCS(self) -> None:

303 """

304 Test :func:`colour.models.cie_ucs.uv_to_UCS` definition domain and

305 range scale support.

306 """

307

308 uv = np.array([0.37720213, 0.33413508])

309 V = 1

310 UCS = uv_to_UCS(uv, V)

311

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

313 for scale, factor in d_r:

314 with domain_range_scale(scale):

315 np.testing.assert_allclose(

316 uv_to_UCS(uv, V * factor),

317 UCS * factor,

318 atol=TOLERANCE_ABSOLUTE_TESTS,

319 )

320

321 @ignore_numpy_errors

322 def test_nan_uv_to_UCS(self) -> None:

323 """Test :func:`colour.models.cie_ucs.uv_to_UCS` definition nan support."""

324

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

326 cases = np.array(list(set(product(cases, repeat=2))))

327 uv_to_UCS(cases)

328

329

330 class TestUCS_uv_to_xy:

331 """

332 Define :func:`colour.models.cie_ucs.UCS_uv_to_xy` definition unit tests

333 methods.

334 """

335

336 def test_UCS_uv_to_xy(self) -> None:

337 """Test :func:`colour.models.cie_ucs.UCS_uv_to_xy` definition."""

338

339 np.testing.assert_allclose(

340 UCS_uv_to_xy(np.array([0.37720213, 0.33413508])),

341 np.array([0.54369555, 0.32107941]),

342 atol=TOLERANCE_ABSOLUTE_TESTS,

343 )

344

345 np.testing.assert_allclose(

346 UCS_uv_to_xy(np.array([0.14536327, 0.35328046])),

347 np.array([0.29777734, 0.48246445]),

348 atol=TOLERANCE_ABSOLUTE_TESTS,

349 )

350

351 np.testing.assert_allclose(

352 UCS_uv_to_xy(np.array([0.16953602, 0.20026156])),

353 np.array([0.18582823, 0.14633764]),

354 atol=TOLERANCE_ABSOLUTE_TESTS,

355 )

356

357 def test_n_dimensional_UCS_uv_to_xy(self) -> None:

358 """

359 Test :func:`colour.models.cie_ucs.UCS_uv_to_xy` definition

360 n-dimensional arrays support.

361 """

362

363 uv = np.array([0.37720213, 0.33413508])

364 xy = UCS_uv_to_xy(uv)

365

366 uv = np.tile(uv, (6, 1))

367 xy = np.tile(xy, (6, 1))

368 np.testing.assert_allclose(UCS_uv_to_xy(uv), xy, atol=TOLERANCE_ABSOLUTE_TESTS)

369

370 uv = np.reshape(uv, (2, 3, 2))

371 xy = np.reshape(xy, (2, 3, 2))

372 np.testing.assert_allclose(UCS_uv_to_xy(uv), xy, atol=TOLERANCE_ABSOLUTE_TESTS)

373

374 @ignore_numpy_errors

375 def test_nan_UCS_uv_to_xy(self) -> None:

376 """

377 Test :func:`colour.models.cie_ucs.UCS_uv_to_xy` definition nan

378 support.

379 """

380

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

382 cases = np.array(list(set(product(cases, repeat=2))))

383 UCS_uv_to_xy(cases)

384

385

386 class TestXy_to_UCS_uv:

387 """

388 Define :func:`colour.models.cie_ucs.xy_to_UCS_uv` definition unit tests

389 methods.

390 """

391

392 def test_xy_to_UCS_uv(self) -> None:

393 """Test :func:`colour.models.cie_ucs.xy_to_UCS_uv` definition."""

394

395 np.testing.assert_allclose(

396 xy_to_UCS_uv(np.array([0.54369555, 0.32107941])),

397 np.array([0.37720213, 0.33413508]),

398 atol=TOLERANCE_ABSOLUTE_TESTS,

399 )

400

401 np.testing.assert_allclose(

402 xy_to_UCS_uv(np.array([0.29777734, 0.48246445])),

403 np.array([0.14536327, 0.35328046]),

404 atol=TOLERANCE_ABSOLUTE_TESTS,

405 )

406

407 np.testing.assert_allclose(

408 xy_to_UCS_uv(np.array([0.18582823, 0.14633764])),

409 np.array([0.16953602, 0.20026156]),

410 atol=TOLERANCE_ABSOLUTE_TESTS,

411 )

412

413 def test_n_dimensional_xy_to_UCS_uv(self) -> None:

414 """

415 Test :func:`colour.models.cie_ucs.xy_to_UCS_uv` definition

416 n-dimensional arrays support.

417 """

418

419 xy = np.array([0.54369555, 0.32107941])

420 uv = xy_to_UCS_uv(xy)

421

422 xy = np.tile(xy, (6, 1))

423 uv = np.tile(uv, (6, 1))

424 np.testing.assert_allclose(xy_to_UCS_uv(xy), uv, atol=TOLERANCE_ABSOLUTE_TESTS)

425

426 xy = np.reshape(xy, (2, 3, 2))

427 uv = np.reshape(uv, (2, 3, 2))

428 np.testing.assert_allclose(xy_to_UCS_uv(xy), uv, atol=TOLERANCE_ABSOLUTE_TESTS)

429

430 @ignore_numpy_errors

431 def test_nan_xy_to_UCS_uv(self) -> None:

432 """

433 Test :func:`colour.models.cie_ucs.xy_to_UCS_uv` definition nan

434 support.

435 """

436

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

438 cases = np.array(list(set(product(cases, repeat=2))))

439 xy_to_UCS_uv(cases)

440

441

442 class TestXYZ_to_CIE1960UCS:

443 """

444 Define :func:`colour.models.cie_ucs.XYZ_to_CIE1960UCS` definition unit tests

445 methods.

446 """

447

448 def test_XYZ_to_CIE1960UCS(self) -> None:

449 """Test :func:`colour.models.cie_ucs.XYZ_to_CIE1960UCS` definition."""

450

451 np.testing.assert_allclose(

452 XYZ_to_CIE1960UCS(np.array([0.20654008, 0.12197225, 0.05136952])),

453 np.array([0.37720213, 0.33413509, 0.12197225]),

454 atol=TOLERANCE_ABSOLUTE_TESTS,

455 )

456

457 np.testing.assert_allclose(

458 XYZ_to_CIE1960UCS(np.array([0.14222010, 0.23042768, 0.10495772])),

459 np.array([0.14536327, 0.35328046, 0.23042768]),

460 atol=TOLERANCE_ABSOLUTE_TESTS,

461 )

462

463 np.testing.assert_allclose(

464 XYZ_to_CIE1960UCS(np.array([0.07818780, 0.06157201, 0.28099326])),

465 np.array([0.16953603, 0.20026156, 0.06157201]),

466 atol=TOLERANCE_ABSOLUTE_TESTS,

467 )

468

469 def test_n_dimensional_XYZ_to_CIE1960UCS(self) -> None:

470 """

471 Test :func:`colour.models.cie_ucs.XYZ_to_CIE1960UCS` definition n-dimensional

472 support.

473 """

474

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

476 uvV = XYZ_to_CIE1960UCS(XYZ)

477

478 uvV = np.tile(uvV, (6, 1))

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

480 np.testing.assert_allclose(

481 XYZ_to_CIE1960UCS(XYZ), uvV, atol=TOLERANCE_ABSOLUTE_TESTS

482 )

483

484 uvV = np.reshape(uvV, (2, 3, 3))

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

486 np.testing.assert_allclose(

487 XYZ_to_CIE1960UCS(XYZ), uvV, atol=TOLERANCE_ABSOLUTE_TESTS

488 )

489

490 def test_domain_range_scale_XYZ_to_CIE1960UCS(self) -> None:

491 """

492 Test :func:`colour.models.cie_ucs.XYZ_to_CIE1960UCS` definition domain and

493 range scale support.

494 """

495

496 XYZ = np.array([0.0704953400, 0.1008000000, 0.0955831300])

497 uvV = XYZ_to_CIE1960UCS(XYZ)

498

499 d_r = (("reference", 1, 1), ("1", 1, 1), ("100", 100, np.array([1, 1, 100])))

500 for scale, factor_a, factor_b in d_r:

501 with domain_range_scale(scale):

502 np.testing.assert_allclose(

503 XYZ_to_CIE1960UCS(XYZ * factor_a),

504 uvV * factor_b,

505 atol=TOLERANCE_ABSOLUTE_TESTS,

506 )

507

508 @ignore_numpy_errors

509 def test_nan_XYZ_to_CIE1960UCS(self) -> None:

510 """

511 Test :func:`colour.models.cie_ucs.XYZ_to_CIE1960UCS` definition nan

512 support.

513 """

514

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

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

517 XYZ_to_CIE1960UCS(cases)

518

519

520 class TestCIE1960UCS_to_XYZ:

521 """

522 Define :func:`colour.models.cie_ucs.CIE1960UCS_to_XYZ` definition unit tests

523 methods.

524 """

525

526 def test_CIE1960UCS_to_XYZ(self) -> None:

527 """Test :func:`colour.models.cie_ucs.CIE1960UCS_to_XYZ` definition."""

528

529 np.testing.assert_allclose(

530 CIE1960UCS_to_XYZ(np.array([0.37720213, 0.33413509, 0.12197225])),

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

532 atol=TOLERANCE_ABSOLUTE_TESTS,

533 )

534

535 np.testing.assert_allclose(

536 CIE1960UCS_to_XYZ(np.array([0.14536327, 0.35328046, 0.23042768])),

537 np.array([0.14222010, 0.23042768, 0.10495772]),

538 atol=TOLERANCE_ABSOLUTE_TESTS,

539 )

540

541 np.testing.assert_allclose(

542 CIE1960UCS_to_XYZ(np.array([0.16953603, 0.20026156, 0.06157201])),

543 np.array([0.07818780, 0.06157201, 0.28099326]),

544 atol=TOLERANCE_ABSOLUTE_TESTS,

545 )

546

547 def test_n_dimensional_CIE1960UCS_to_XYZ(self) -> None:

548 """

549 Test :func:`colour.models.cie_ucs.CIE1960UCS_to_XYZ` definition n-dimensional

550 support.

551 """

552

553 uvV = np.array([0.37720213, 0.33413509, 0.12197225])

554 XYZ = CIE1960UCS_to_XYZ(uvV)

555

556 uvV = np.tile(uvV, (6, 1))

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

558 np.testing.assert_allclose(

559 CIE1960UCS_to_XYZ(uvV), XYZ, atol=TOLERANCE_ABSOLUTE_TESTS

560 )

561

562 uvV = np.reshape(uvV, (2, 3, 3))

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

564 np.testing.assert_allclose(

565 CIE1960UCS_to_XYZ(uvV), XYZ, atol=TOLERANCE_ABSOLUTE_TESTS

566 )

567

568 def test_domain_range_scale_CIE1960UCS_to_XYZ(self) -> None:

569 """

570 Test :func:`colour.models.cie_ucs.CIE1960UCS_to_XYZ` definition domain and

571 range scale support.

572 """

573

574 uvV = np.array([0.0469968933, 0.1008000000, 0.1637438950])

575 XYZ = CIE1960UCS_to_XYZ(uvV)

576

577 d_r = (("reference", 1, 1), ("1", 1, 1), ("100", np.array([1, 1, 100]), 100))

578 for scale, factor_a, factor_b in d_r:

579 with domain_range_scale(scale):

580 np.testing.assert_allclose(

581 CIE1960UCS_to_XYZ(uvV * factor_a),

582 XYZ * factor_b,

583 atol=TOLERANCE_ABSOLUTE_TESTS,

584 )

585

586 @ignore_numpy_errors

587 def test_nan_CIE1960UCS_to_XYZ(self) -> None:

588 """

589 Test :func:`colour.models.cie_ucs.CIE1960UCS_to_XYZ` definition nan

590 support.

591 """

592

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

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

595 CIE1960UCS_to_XYZ(cases)