Coverage for algebra/coordinates/tests/test_transformations.py: 100%

1"""

2 Define the unit tests for the

3:mod:`colour.algebra.coordinates.transformations` module.

4"""

5

6 from __future__ import annotations

7

8 from itertools import product

9

10 import numpy as np

11

12 from colour.algebra import (

13 cartesian_to_cylindrical,

14 cartesian_to_polar,

15 cartesian_to_spherical,

16 cylindrical_to_cartesian,

17 polar_to_cartesian,

18 spherical_to_cartesian,

19)

20 from colour.constants import TOLERANCE_ABSOLUTE_TESTS

21 from colour.utilities import ignore_numpy_errors

22

23 __author__ = "Colour Developers"

24 __copyright__ = "Copyright 2013 Colour Developers"

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

26 __maintainer__ = "Colour Developers"

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

28 __status__ = "Production"

29

30 __all__ = [

31 "TestCartesianToSpherical",

32 "TestSphericalToCartesian",

33 "TestCartesianToPolar",

34 "TestPolarToCartesian",

35 "TestCartesianToCylindrical",

36 "TestCylindricalToCartesian",

37]

38

39

40 class TestCartesianToSpherical:

41 """

42 Define :func:`colour.algebra.coordinates.transformations.\

43 cartesian_to_spherical` definition unit tests methods.

44 """

45

46 def test_cartesian_to_spherical(self) -> None:

47 """

48 Test :func:`colour.algebra.coordinates.transformations.\

49 cartesian_to_spherical` definition.

50 """

51

52 np.testing.assert_allclose(

53 cartesian_to_spherical(np.array([3, 1, 6])),

54 np.array([6.78232998, 0.48504979, 0.32175055]),

55 atol=TOLERANCE_ABSOLUTE_TESTS,

56 )

57

58 np.testing.assert_allclose(

59 cartesian_to_spherical(np.array([-1, 9, 16])),

60 np.array([18.38477631, 0.51501513, 1.68145355]),

61 atol=TOLERANCE_ABSOLUTE_TESTS,

62 )

63

64 np.testing.assert_allclose(

65 cartesian_to_spherical(np.array([6.3434, -0.9345, 18.5675])),

66 np.array([19.64342307, 0.33250603, -0.14626640]),

67 atol=TOLERANCE_ABSOLUTE_TESTS,

68 )

69

70 def test_n_dimensional_cartesian_to_spherical(self) -> None:

71 """

72 Test :func:`colour.algebra.coordinates.transformations.\

73 cartesian_to_spherical` definition n-dimensional arrays support.

74 """

75

76 a_i = np.array([3, 1, 6])

77 a_o = cartesian_to_spherical(a_i)

78

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

80 a_o = np.tile(a_o, (6, 1))

81 np.testing.assert_allclose(

82 cartesian_to_spherical(a_i), a_o, atol=TOLERANCE_ABSOLUTE_TESTS

83 )

84

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

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

87 np.testing.assert_allclose(

88 cartesian_to_spherical(a_i), a_o, atol=TOLERANCE_ABSOLUTE_TESTS

89 )

90

91 @ignore_numpy_errors

92 def test_nan_cartesian_to_spherical(self) -> None:

93 """

94 Test :func:`colour.algebra.coordinates.transformations.\

95 cartesian_to_spherical` definition nan support.

96 """

97

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

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

100 cartesian_to_spherical(cases)

101

102

103 class TestSphericalToCartesian:

104 """

105 Define :func:`colour.algebra.coordinates.transformations.\

106 spherical_to_cartesian` definition unit tests methods.

107 """

108

109 def test_spherical_to_cartesian(self) -> None:

110 """

111 Test :func:`colour.algebra.coordinates.transformations.\

112 spherical_to_cartesian` definition.

113 """

114

115 np.testing.assert_allclose(

116 spherical_to_cartesian(np.array([6.78232998, 0.48504979, 0.32175055])),

117 np.array([3.00000000, 0.99999999, 6.00000000]),

118 atol=TOLERANCE_ABSOLUTE_TESTS,

119 )

120

121 np.testing.assert_allclose(

122 spherical_to_cartesian(np.array([18.38477631, 0.51501513, 1.68145355])),

123 np.array([-1.00000003, 9.00000007, 15.99999996]),

124 atol=TOLERANCE_ABSOLUTE_TESTS,

125 )

126

127 np.testing.assert_allclose(

128 spherical_to_cartesian(np.array([19.64342307, 0.33250603, -0.14626640])),

129 np.array([6.34339996, -0.93449999, 18.56750001]),

130 atol=TOLERANCE_ABSOLUTE_TESTS,

131 )

132

133 def test_n_dimensional_spherical_to_cartesian(self) -> None:

134 """

135 Test :func:`colour.algebra.coordinates.transformations.\

136 spherical_to_cartesian` definition n-dimensional arrays support.

137 """

138

139 a_i = np.array([6.78232998, 0.48504979, 0.32175055])

140 a_o = spherical_to_cartesian(a_i)

141

142 a_i = np.tile(a_i, (6, 1))

143 a_o = np.tile(a_o, (6, 1))

144 np.testing.assert_allclose(

145 spherical_to_cartesian(a_i), a_o, atol=TOLERANCE_ABSOLUTE_TESTS

146 )

147

148 a_i = np.reshape(a_i, (2, 3, 3))

149 a_o = np.reshape(a_o, (2, 3, 3))

150 np.testing.assert_allclose(

151 spherical_to_cartesian(a_i), a_o, atol=TOLERANCE_ABSOLUTE_TESTS

152 )

153

154 @ignore_numpy_errors

155 def test_nan_spherical_to_cartesian(self) -> None:

156 """

157 Test :func:`colour.algebra.coordinates.transformations.\

158 spherical_to_cartesian` definition nan support.

159 """

160

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

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

163 spherical_to_cartesian(cases)

164

165

166 class TestCartesianToPolar:

167 """

168 Define :func:`colour.algebra.coordinates.transformations.\

169 cartesian_to_polar` definition unit tests methods.

170 """

171

172 def test_cartesian_to_polar(self) -> None:

173 """

174 Test :func:`colour.algebra.coordinates.transformations.\

175 cartesian_to_polar` definition.

176 """

177

178 np.testing.assert_allclose(

179 cartesian_to_polar(np.array([3, 1])),

180 np.array([3.16227766, 0.32175055]),

181 atol=TOLERANCE_ABSOLUTE_TESTS,

182 )

183

184 np.testing.assert_allclose(

185 cartesian_to_polar(np.array([-1, 9])),

186 np.array([9.05538514, 1.68145355]),

187 atol=TOLERANCE_ABSOLUTE_TESTS,

188 )

189

190 np.testing.assert_allclose(

191 cartesian_to_polar(np.array([6.3434, -0.9345])),

192 np.array([6.41186508, -0.14626640]),

193 atol=TOLERANCE_ABSOLUTE_TESTS,

194 )

195

196 def test_n_dimensional_cartesian_to_polar(self) -> None:

197 """

198 Test :func:`colour.algebra.coordinates.transformations.\

199 cartesian_to_polar` definition n-dimensional arrays support.

200 """

201

202 a_i = np.array([3, 1])

203 a_o = cartesian_to_polar(a_i)

204

205 a_i = np.tile(a_i, (6, 1))

206 a_o = np.tile(a_o, (6, 1))

207 np.testing.assert_allclose(

208 cartesian_to_polar(a_i), a_o, atol=TOLERANCE_ABSOLUTE_TESTS

209 )

210

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

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

213 np.testing.assert_allclose(

214 cartesian_to_polar(a_i), a_o, atol=TOLERANCE_ABSOLUTE_TESTS

215 )

216

217 @ignore_numpy_errors

218 def test_nan_cartesian_to_polar(self) -> None:

219 """

220 Test :func:`colour.algebra.coordinates.transformations.\

221 cartesian_to_polar` definition nan support.

222 """

223

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

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

226 cartesian_to_polar(cases)

227

228

229 class TestPolarToCartesian:

230 """

231 Define :func:`colour.algebra.coordinates.transformations.\

232 polar_to_cartesian` definition unit tests methods.

233 """

234

235 def test_polar_to_cartesian(self) -> None:

236 """

237 Test :func:`colour.algebra.coordinates.transformations.\

238 polar_to_cartesian` definition.

239 """

240

241 np.testing.assert_allclose(

242 polar_to_cartesian(np.array([0.32175055, 1.08574654])),

243 np.array([0.15001697, 0.28463718]),

244 atol=TOLERANCE_ABSOLUTE_TESTS,

245 )

246

247 np.testing.assert_allclose(

248 polar_to_cartesian(np.array([1.68145355, 1.05578119])),

249 np.array([0.82819662, 1.46334425]),

250 atol=TOLERANCE_ABSOLUTE_TESTS,

251 )

252

253 np.testing.assert_allclose(

254 polar_to_cartesian(np.array([-0.14626640, 1.23829030])),

255 np.array([-0.04774323, -0.13825500]),

256 atol=TOLERANCE_ABSOLUTE_TESTS,

257 )

258

259 def test_n_dimensional_polar_to_cartesian(self) -> None:

260 """

261 Test :func:`colour.algebra.coordinates.transformations.\

262 polar_to_cartesian` definition n-dimensional arrays support.

263 """

264

265 a_i = np.array([3.16227766, 0.32175055])

266 a_o = polar_to_cartesian(a_i)

267

268 a_i = np.tile(a_i, (6, 1))

269 a_o = np.tile(a_o, (6, 1))

270 np.testing.assert_allclose(

271 polar_to_cartesian(a_i), a_o, atol=TOLERANCE_ABSOLUTE_TESTS

272 )

273

274 a_i = np.reshape(a_i, (2, 3, 2))

275 a_o = np.reshape(a_o, (2, 3, 2))

276 np.testing.assert_allclose(

277 polar_to_cartesian(a_i), a_o, atol=TOLERANCE_ABSOLUTE_TESTS

278 )

279

280 @ignore_numpy_errors

281 def test_nan_polar_to_cartesian(self) -> None:

282 """

283 Test :func:`colour.algebra.coordinates.transformations.\

284 polar_to_cartesian` definition nan support.

285 """

286

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

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

289 polar_to_cartesian(cases)

290

291

292 class TestCartesianToCylindrical:

293 """

294 Define :func:`colour.algebra.coordinates.transformations.\

295 cartesian_to_cylindrical` definition unit tests methods.

296 """

297

298 def test_cartesian_to_cylindrical(self) -> None:

299 """

300 Test :func:`colour.algebra.coordinates.transformations.\

301 cartesian_to_cylindrical` definition.

302 """

303

304 np.testing.assert_allclose(

305 cartesian_to_cylindrical(np.array([3, 1, 6])),

306 np.array([3.16227766, 0.32175055, 6.00000000]),

307 atol=TOLERANCE_ABSOLUTE_TESTS,

308 )

309

310 np.testing.assert_allclose(

311 cartesian_to_cylindrical(np.array([-1, 9, 16])),

312 np.array([9.05538514, 1.68145355, 16.00000000]),

313 atol=TOLERANCE_ABSOLUTE_TESTS,

314 )

315

316 np.testing.assert_allclose(

317 cartesian_to_cylindrical(np.array([6.3434, -0.9345, 18.5675])),

318 np.array([6.41186508, -0.14626640, 18.56750000]),

319 atol=TOLERANCE_ABSOLUTE_TESTS,

320 )

321

322 def test_n_dimensional_cartesian_to_cylindrical(self) -> None:

323 """

324 Test :func:`colour.algebra.coordinates.transformations.\

325 cartesian_to_cylindrical` definition n-dimensional arrays support.

326 """

327

328 a_i = np.array([3, 1, 6])

329 a_o = cartesian_to_cylindrical(a_i)

330

331 a_i = np.tile(a_i, (6, 1))

332 a_o = np.tile(a_o, (6, 1))

333 np.testing.assert_allclose(

334 cartesian_to_cylindrical(a_i), a_o, atol=TOLERANCE_ABSOLUTE_TESTS

335 )

336

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

338 a_o = np.reshape(a_o, (2, 3, 3))

339 np.testing.assert_allclose(

340 cartesian_to_cylindrical(a_i), a_o, atol=TOLERANCE_ABSOLUTE_TESTS

341 )

342

343 @ignore_numpy_errors

344 def test_nan_cartesian_to_cylindrical(self) -> None:

345 """

346 Test :func:`colour.algebra.coordinates.transformations.\

347 cartesian_to_cylindrical` definition nan support.

348 """

349

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

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

352 cartesian_to_cylindrical(cases)

353

354

355 class TestCylindricalToCartesian:

356 """

357 Define :func:`colour.algebra.coordinates.transformations.\

358 cylindrical_to_cartesian` definition unit tests methods.

359 """

360

361 def test_cylindrical_to_cartesian(self) -> None:

362 """

363 Test :func:`colour.algebra.coordinates.transformations.\

364 cylindrical_to_cartesian` definition.

365 """

366

367 np.testing.assert_allclose(

368 cylindrical_to_cartesian(np.array([0.32175055, 1.08574654, 6.78232998])),

369 np.array([0.15001697, 0.28463718, 6.78232998]),

370 atol=TOLERANCE_ABSOLUTE_TESTS,

371 )

372

373 np.testing.assert_allclose(

374 cylindrical_to_cartesian(np.array([1.68145355, 1.05578119, 18.38477631])),

375 np.array([0.82819662, 1.46334425, 18.38477631]),

376 atol=TOLERANCE_ABSOLUTE_TESTS,

377 )

378

379 np.testing.assert_allclose(

380 cylindrical_to_cartesian(np.array([-0.14626640, 1.23829030, 19.64342307])),

381 np.array([-0.04774323, -0.13825500, 19.64342307]),

382 atol=TOLERANCE_ABSOLUTE_TESTS,

383 )

384

385 def test_n_dimensional_cylindrical_to_cartesian(self) -> None:

386 """

387 Test :func:`colour.algebra.coordinates.transformations.\

388 cylindrical_to_cartesian` definition n-dimensional arrays support.

389 """

390

391 a_i = np.array([3.16227766, 0.32175055, 6.00000000])

392 a_o = cylindrical_to_cartesian(a_i)

393

394 a_i = np.tile(a_i, (6, 1))

395 a_o = np.tile(a_o, (6, 1))

396 np.testing.assert_allclose(

397 cylindrical_to_cartesian(a_i), a_o, atol=TOLERANCE_ABSOLUTE_TESTS

398 )

399

400 a_i = np.reshape(a_i, (2, 3, 3))

401 a_o = np.reshape(a_o, (2, 3, 3))

402 np.testing.assert_allclose(

403 cylindrical_to_cartesian(a_i), a_o, atol=TOLERANCE_ABSOLUTE_TESTS

404 )

405

406 @ignore_numpy_errors

407 def test_nan_cylindrical_to_cartesian(self) -> None:

408 """

409 Test :func:`colour.algebra.coordinates.transformations.\

410 cylindrical_to_cartesian` definition nan support.

411 """

412

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

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

415 cylindrical_to_cartesian(cases)