Coverage for contrast/tests/test_barten1999.py: 100%

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

11 contrast_sensitivity_function_Barten1999,

12 maximum_angular_size_Barten1999,

13 optical_MTF_Barten1999,

14 pupil_diameter_Barten1999,

15 retinal_illuminance_Barten1999,

16 sigma_Barten1999,

17)

18 from colour.utilities import ignore_numpy_errors

19

20 __author__ = "Colour Developers"

21 __copyright__ = "Copyright 2013 Colour Developers"

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

23 __maintainer__ = "Colour Developers"

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

25 __status__ = "Production"

26

27 __all__ = [

28 "TestOpticalMTFBarten1999",

29 "TestPupilDiameterBarten1999",

30 "TestSigmaBarten1999",

31 "TestRetinalIlluminanceBarten1999",

32 "TestMaximumAngularSizeBarten1999",

33 "TestContrastSensitivityFunctionBarten1999",

34]

35

36

37 class TestOpticalMTFBarten1999:

38 """

39 Define :func:`colour.contrast.barten1999.optical_MTF_Barten1999`

40 definition unit tests methods.

41 """

42

43 def test_optical_MTF_Barten1999(self) -> None:

44 """

45 Test :func:`colour.contrast.barten1999.optical_MTF_Barten1999`

46 definition.

47 """

48

49 np.testing.assert_allclose(

50 optical_MTF_Barten1999(4, 0.01),

51 0.968910791191297,

52 atol=TOLERANCE_ABSOLUTE_TESTS,

53 )

54

55 np.testing.assert_allclose(

56 optical_MTF_Barten1999(8, 0.01),

57 0.881323136669471,

58 atol=TOLERANCE_ABSOLUTE_TESTS,

59 )

60

61 np.testing.assert_allclose(

62 optical_MTF_Barten1999(4, 0.05),

63 0.454040738727245,

64 atol=TOLERANCE_ABSOLUTE_TESTS,

65 )

66

67 def test_n_dimensional_optical_MTF_Barten1999(self) -> None:

68 """

69 Test :func:`colour.contrast.barten1999.optical_MTF_Barten1999`

70 definition n-dimensional support.

71 """

72

73 u = np.array([4, 8, 12])

74 sigma = np.array([0.01, 0.05, 0.1])

75 M_opt = optical_MTF_Barten1999(u, sigma)

76

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

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

79 M_opt = np.tile(M_opt, (6, 1))

80 np.testing.assert_allclose(

81 optical_MTF_Barten1999(u, sigma),

82 M_opt,

83 atol=TOLERANCE_ABSOLUTE_TESTS,

84 )

85

86 u = np.reshape(u, (2, 3, 3))

87 sigma = np.reshape(sigma, (2, 3, 3))

88 M_opt = np.reshape(M_opt, (2, 3, 3))

89 np.testing.assert_allclose(

90 optical_MTF_Barten1999(u, sigma),

91 M_opt,

92 atol=TOLERANCE_ABSOLUTE_TESTS,

93 )

94

95 @ignore_numpy_errors

96 def test_nan_optical_MTF_Barten1999(self) -> None:

97 """

98 Test :func:`colour.contrast.barten1999.optical_MTF_Barten1999`

99 definition nan support.

100 """

101

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

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

104 optical_MTF_Barten1999(cases, cases)

105

106

107 class TestPupilDiameterBarten1999:

108 """

109 Define :func:`colour.contrast.barten1999.pupil_diameter_Barten1999`

110 definition unit tests methods.

111 """

112

113 def test_pupil_diameter_Barten1999(self) -> None:

114 """

115 Test :func:`colour.contrast.barten1999.pupil_diameter_Barten1999`

116 definition.

117 """

118

119 np.testing.assert_allclose(

120 pupil_diameter_Barten1999(20, 60),

121 3.262346170373243,

122 atol=TOLERANCE_ABSOLUTE_TESTS,

123 )

124

125 np.testing.assert_allclose(

126 pupil_diameter_Barten1999(0.2, 600),

127 3.262346170373243,

128 atol=TOLERANCE_ABSOLUTE_TESTS,

129 )

130

131 np.testing.assert_allclose(

132 pupil_diameter_Barten1999(20, 60, 30),

133 3.519054451149336,

134 atol=TOLERANCE_ABSOLUTE_TESTS,

135 )

136

137 def test_n_dimensional_pupil_diameter_Barten1999(self) -> None:

138 """

139 Test :func:`colour.contrast.barten1999.pupil_diameter_Barten1999`

140 definition n-dimensional support.

141 """

142

143 L = np.array([0.2, 20, 100])

144 X_0 = np.array([60, 120, 240])

145 Y_0 = np.array([60, 30, 15])

146 d = pupil_diameter_Barten1999(L, X_0, Y_0)

147

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

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

150 d = np.tile(d, (6, 1))

151 np.testing.assert_allclose(

152 pupil_diameter_Barten1999(L, X_0, Y_0),

153 d,

154 atol=TOLERANCE_ABSOLUTE_TESTS,

155 )

156

157 L = np.reshape(L, (2, 3, 3))

158 X_0 = np.reshape(X_0, (2, 3, 3))

159 d = np.reshape(d, (2, 3, 3))

160 np.testing.assert_allclose(

161 pupil_diameter_Barten1999(L, X_0, Y_0),

162 d,

163 atol=TOLERANCE_ABSOLUTE_TESTS,

164 )

165

166 @ignore_numpy_errors

167 def test_nan_pupil_diameter_Barten1999(self) -> None:

168 """

169 Test :func:`colour.contrast.barten1999.pupil_diameter_Barten1999`

170 definition nan support.

171 """

172

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

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

175 pupil_diameter_Barten1999(cases, cases, cases)

176

177

178 class TestSigmaBarten1999:

179 """

180 Define :func:`colour.contrast.barten1999.sigma_Barten1999` definition unit

181 tests methods.

182 """

183

184 def test_sigma_Barten1999(self) -> None:

185 """Test :func:`colour.contrast.barten1999.sigma_Barten1999` definition."""

186

187 np.testing.assert_allclose(

188 sigma_Barten1999(0.5 / 60, 0.08 / 60, 2.1),

189 0.008791157173231,

190 atol=TOLERANCE_ABSOLUTE_TESTS,

191 )

192

193 np.testing.assert_allclose(

194 sigma_Barten1999(0.75 / 60, 0.08 / 60, 2.1),

195 0.012809761902549,

196 atol=TOLERANCE_ABSOLUTE_TESTS,

197 )

198

199 np.testing.assert_allclose(

200 sigma_Barten1999(0.5 / 60, 0.16 / 60, 2.1),

201 0.010040141654601,

202 atol=TOLERANCE_ABSOLUTE_TESTS,

203 )

204

205 np.testing.assert_allclose(

206 sigma_Barten1999(0.5 / 60, 0.08 / 60, 2.5),

207 0.008975274678558,

208 atol=TOLERANCE_ABSOLUTE_TESTS,

209 )

210

211 def test_n_dimensional_sigma_Barten1999(self) -> None:

212 """

213 Test :func:`colour.contrast.barten1999.sigma_Barten1999` definition

214 n-dimensional support.

215 """

216

217 sigma_0 = np.array([0.25 / 60, 0.5 / 60, 0.75 / 60])

218 C_ab = np.array([0.04 / 60, 0.08 / 60, 0.16 / 60])

219 d = np.array([2.1, 2.5, 5.0])

220 sigma = sigma_Barten1999(sigma_0, C_ab, d)

221

222 sigma_0 = np.tile(sigma_0, (6, 1))

223 C_ab = np.tile(C_ab, (6, 1))

224 sigma = np.tile(sigma, (6, 1))

225 np.testing.assert_allclose(

226 sigma_Barten1999(sigma_0, C_ab, d),

227 sigma,

228 atol=TOLERANCE_ABSOLUTE_TESTS,

229 )

230

231 sigma_0 = np.reshape(sigma_0, (2, 3, 3))

232 C_ab = np.reshape(C_ab, (2, 3, 3))

233 sigma = np.reshape(sigma, (2, 3, 3))

234 np.testing.assert_allclose(

235 sigma_Barten1999(sigma_0, C_ab, d),

236 sigma,

237 atol=TOLERANCE_ABSOLUTE_TESTS,

238 )

239

240 @ignore_numpy_errors

241 def test_nan_sigma_Barten1999(self) -> None:

242 """

243 Test :func:`colour.contrast.barten1999.sigma_Barten1999`

244 definition nan support.

245 """

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 sigma_Barten1999(cases, cases, cases)

250

251

252 class TestRetinalIlluminanceBarten1999:

253 """

254 Define :func:`colour.contrast.barten1999.retinal_illuminance_Barten1999`

255 definition unit tests methods.

256 """

257

258 def test_retinal_illuminance_Barten1999(self) -> None:

259 """

260 Test :func:`colour.contrast.barten1999.retinal_illuminance_Barten1999`

261 definition.

262 """

263

264 np.testing.assert_allclose(

265 retinal_illuminance_Barten1999(20, 2.1, True),

266 66.082316060529919,

267 atol=TOLERANCE_ABSOLUTE_TESTS,

268 )

269

270 np.testing.assert_allclose(

271 retinal_illuminance_Barten1999(20, 2.5, True),

272 91.815644777503664,

273 atol=TOLERANCE_ABSOLUTE_TESTS,

274 )

275

276 np.testing.assert_allclose(

277 retinal_illuminance_Barten1999(20, 2.1, False),

278 69.272118011654939,

279 atol=TOLERANCE_ABSOLUTE_TESTS,

280 )

281

282 def test_n_dimensional_retinal_illuminance_Barten1999(self) -> None:

283 """

284 Test :func:`colour.contrast.barten1999.retinal_illuminance_Barten1999`

285 definition n-dimensional support.

286 """

287

288 L = np.array([0.2, 20, 100])

289 d = np.array([2.1, 2.5, 5.0])

290 E = retinal_illuminance_Barten1999(L, d)

291

292 L = np.tile(L, (6, 1))

293 d = np.tile(d, (6, 1))

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

295 np.testing.assert_allclose(

296 retinal_illuminance_Barten1999(L, d),

297 E,

298 atol=TOLERANCE_ABSOLUTE_TESTS,

299 )

300

301 L = np.reshape(L, (2, 3, 3))

302 d = np.reshape(d, (2, 3, 3))

303 E = np.reshape(E, (2, 3, 3))

304 np.testing.assert_allclose(

305 retinal_illuminance_Barten1999(L, d),

306 E,

307 atol=TOLERANCE_ABSOLUTE_TESTS,

308 )

309

310 @ignore_numpy_errors

311 def test_nan_retinal_illuminance_Barten1999(self) -> None:

312 """

313 Test :func:`colour.contrast.barten1999.retinal_illuminance_Barten1999`

314 definition nan support.

315 """

316

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

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

319 retinal_illuminance_Barten1999(cases, cases)

320

321

322 class TestMaximumAngularSizeBarten1999:

323 """

324 Define :func:`colour.contrast.barten1999.maximum_angular_size_Barten1999`

325 definition unit tests methods.

326 """

327

328 def test_maximum_angular_size_Barten1999(self) -> None:

329 """

330 Test :func:`colour.contrast.barten1999.\

331 maximum_angular_size_Barten1999` definition.

332 """

333

334 np.testing.assert_allclose(

335 maximum_angular_size_Barten1999(4, 60, 12, 15),

336 3.572948005052482,

337 atol=TOLERANCE_ABSOLUTE_TESTS,

338 )

339

340 np.testing.assert_allclose(

341 maximum_angular_size_Barten1999(8, 60, 12, 15),

342 1.851640199545103,

343 atol=TOLERANCE_ABSOLUTE_TESTS,

344 )

345

346 np.testing.assert_allclose(

347 maximum_angular_size_Barten1999(4, 120, 12, 15),

348 3.577708763999663,

349 atol=TOLERANCE_ABSOLUTE_TESTS,

350 )

351

352 np.testing.assert_allclose(

353 maximum_angular_size_Barten1999(4, 60, 24, 15),

354 3.698001308168194,

355 atol=TOLERANCE_ABSOLUTE_TESTS,

356 )

357

358 np.testing.assert_allclose(

359 maximum_angular_size_Barten1999(4, 60, 12, 30),

360 6.324555320336758,

361 atol=TOLERANCE_ABSOLUTE_TESTS,

362 )

363

364 def test_n_dimensional_maximum_angular_size_Barten1999(self) -> None:

365 """

366 Test :func:`colour.contrast.barten1999.\

367 maximum_angular_size_Barten1999` definition n-dimensional support.

368 """

369

370 u = np.array([4, 8, 12])

371 X_0 = np.array([60, 120, 240])

372 X_max = np.array([12, 14, 16])

373 N_max = np.array([15, 20, 25])

374 X = maximum_angular_size_Barten1999(u, X_0, X_max, N_max)

375

376 u = np.tile(u, (6, 1))

377 X_0 = np.tile(X_0, (6, 1))

378 X = np.tile(X, (6, 1))

379 np.testing.assert_allclose(

380 maximum_angular_size_Barten1999(u, X_0, X_max, N_max),

381 X,

382 atol=TOLERANCE_ABSOLUTE_TESTS,

383 )

384

385 u = np.reshape(u, (2, 3, 3))

386 X_0 = np.reshape(X_0, (2, 3, 3))

387 X = np.reshape(X, (2, 3, 3))

388 np.testing.assert_allclose(

389 maximum_angular_size_Barten1999(u, X_0, X_max, N_max),

390 X,

391 atol=TOLERANCE_ABSOLUTE_TESTS,

392 )

393

394 @ignore_numpy_errors

395 def test_nan_maximum_angular_size_Barten1999(self) -> None:

396 """

397 Test :func:`colour.contrast.barten1999.\

398 maximum_angular_size_Barten1999` definition nan support.

399 """

400

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

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

403 maximum_angular_size_Barten1999(cases, cases, cases, cases)

404

405

406 class TestContrastSensitivityFunctionBarten1999:

407 """

408 Define :func:`colour.contrast.barten1999.\

409 contrast_sensitivity_function_Barten1999` definition unit tests methods.

410 """

411

412 def test_contrast_sensitivity_function_Barten1999(self) -> None:

413 """

414 Test :func:`colour.contrast.barten1999.\

415 contrast_sensitivity_function_Barten1999` definition.

416 """

417

418 np.testing.assert_allclose(

419 contrast_sensitivity_function_Barten1999(

420 u=4,

421 sigma=0.01,

422 E=65,

423 X_0=60,

424 X_max=12,

425 Y_0=60,

426 Y_max=12,

427 p=1.2 * 10**6,

428 ),

429 352.761342126727020,

430 atol=TOLERANCE_ABSOLUTE_TESTS,

431 )

432

433 np.testing.assert_allclose(

434 contrast_sensitivity_function_Barten1999(

435 u=8,

436 sigma=0.01,

437 E=65,

438 X_0=60,

439 X_max=12,

440 Y_0=60,

441 Y_max=12,

442 p=1.2 * 10**6,

443 ),

444 177.706338840717340,

445 atol=TOLERANCE_ABSOLUTE_TESTS,

446 )

447

448 np.testing.assert_allclose(

449 contrast_sensitivity_function_Barten1999(

450 u=4,

451 sigma=0.02,

452 E=65,

453 X_0=60,

454 X_max=12,

455 Y_0=60,

456 Y_max=12,

457 p=1.2 * 10**6,

458 ),

459 320.872401634215750,

460 atol=TOLERANCE_ABSOLUTE_TESTS,

461 )

462

463 np.testing.assert_allclose(

464 contrast_sensitivity_function_Barten1999(

465 u=4,

466 sigma=0.01,

467 E=130,

468 X_0=60,

469 X_max=12,

470 Y_0=60,

471 Y_max=12,

472 p=1.2 * 10**6,

473 ),

474 455.171315756946400,

475 atol=TOLERANCE_ABSOLUTE_TESTS,

476 )

477

478 np.testing.assert_allclose(

479 contrast_sensitivity_function_Barten1999(

480 u=4,

481 sigma=0.01,

482 E=65,

483 X_0=120,

484 X_max=12,

485 Y_0=60,

486 Y_max=12,

487 p=1.2 * 10**6,

488 ),

489 352.996281545740660,

490 atol=TOLERANCE_ABSOLUTE_TESTS,

491 )

492

493 np.testing.assert_allclose(

494 contrast_sensitivity_function_Barten1999(

495 u=4,

496 sigma=0.01,

497 E=65,

498 X_0=60,

499 X_max=24,

500 Y_0=60,

501 Y_max=12,

502 p=1.2 * 10**6,

503 ),

504 358.881580104493650,

505 atol=TOLERANCE_ABSOLUTE_TESTS,

506 )

507

508 np.testing.assert_allclose(

509 contrast_sensitivity_function_Barten1999(

510 u=4,

511 sigma=0.01,

512 E=65,

513 X_0=240,

514 X_max=12,

515 Y_0=60,

516 Y_max=12,

517 p=1.2 * 10**6,

518 ),

519 contrast_sensitivity_function_Barten1999(

520 u=4,

521 sigma=0.01,

522 E=65,

523 X_0=60,

524 X_max=12,

525 Y_0=240,

526 Y_max=12,

527 p=1.2 * 10**6,

528 ),

529 atol=TOLERANCE_ABSOLUTE_TESTS,

530 )

531

532 np.testing.assert_allclose(

533 contrast_sensitivity_function_Barten1999(

534 u=4,

535 sigma=0.01,

536 E=65,

537 X_0=60,

538 X_max=12,

539 Y_0=60,

540 Y_max=12,

541 p=1.4 * 10**6,

542 ),

543 374.791328640476140,

544 atol=TOLERANCE_ABSOLUTE_TESTS,

545 )

546

547 def test_n_dimensional_contrast_sensitivity_function_Barten1999(self) -> None:

548 """

549 Test :func:`colour.contrast.barten1999.\

550 contrast_sensitivity_function_Barten1999` definition n-dimensional support.

551 """

552

553 u = np.array([4, 8, 12])

554 sigma = np.array([0.01, 0.02, 0.04])

555 E = np.array([0.65, 90, 1500])

556 X_0 = np.array([60, 120, 240])

557 S = contrast_sensitivity_function_Barten1999(u=u, sigma=sigma, E=E, X_0=X_0)

558

559 u = np.tile(u, (6, 1))

560 E = np.tile(E, (6, 1))

561 S = np.tile(S, (6, 1))

562 np.testing.assert_allclose(

563 contrast_sensitivity_function_Barten1999(u=u, sigma=sigma, E=E, X_0=X_0),

564 S,

565 atol=TOLERANCE_ABSOLUTE_TESTS,

566 )

567

568 u = np.reshape(u, (2, 3, 3))

569 E = np.reshape(E, (2, 3, 3))

570 S = np.reshape(S, (2, 3, 3))

571 np.testing.assert_allclose(

572 contrast_sensitivity_function_Barten1999(u=u, sigma=sigma, E=E, X_0=X_0),

573 S,

574 atol=TOLERANCE_ABSOLUTE_TESTS,

575 )

576

577 @ignore_numpy_errors

578 def test_nan_contrast_sensitivity_function_Barten1999(self) -> None:

579 """

580 Test :func:`colour.contrast.barten1999.\

581 contrast_sensitivity_function_Barten1999` definition nan support.

582 """

583

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

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

586 contrast_sensitivity_function_Barten1999(

587 u=cases, sigma=cases, E=cases, X_0=cases

588 )