def test_get_domain_range_scale(self):
"""
Tests :func:`colour.utilities.common.get_domain_range_scale`
definition.
"""
with domain_range_scale('Reference'):
self.assertEqual(get_domain_range_scale(), 'reference')
with domain_range_scale('1'):
self.assertEqual(get_domain_range_scale(), '1')
with domain_range_scale('100'):
self.assertEqual(get_domain_range_scale(), '100')
def test_domain_range_scale_XYZ_to_LLAB(self):
"""
Tests :func:`colour.appearance.llab.XYZ_to_LLAB` definition domain
and range scale support.
"""
XYZ = np.array([19.01, 20.00, 21.78])
XYZ_0 = np.array([95.05, 100.00, 108.88])
Y_b = 20.0
L = 318.31
surround = LLAB_VIEWING_CONDITIONS['ref_average_4_minus']
specification = XYZ_to_LLAB(XYZ, XYZ_0, Y_b, L, surround)[:5]
d_r = (
('reference', 1, 1),
(1, 0.01, np.array([1, 1, 1 / 360, 1, 1])),
(100, 1, np.array([1, 1, 100 / 360, 1, 1])),
)
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
XYZ_to_LLAB(XYZ * factor_a, XYZ_0 * factor_a, Y_b, L,
surround)[:5],
specification * factor_b,
decimal=7)
def test_domain_range_scale_XYZ_to_Nayatani95(self):
"""
Tests :func:`colour.appearance.nayatani95.XYZ_to_Nayatani95` definition
domain and range scale support.
"""
XYZ = np.array([19.01, 20.00, 21.78])
XYZ_n = np.array([95.05, 100.00, 108.88])
Y_o = 20.0
E_o = 5000.0
E_or = 1000.0
specification = XYZ_to_Nayatani95(XYZ, XYZ_n, Y_o, E_o, E_or)[:6]
d_r = (
('reference', 1, 1),
(1, 0.01, np.array([1, 1, 1 / 360, 1, 1, 1])),
(100, 1, np.array([1, 1, 100 / 360, 1, 1, 1])),
)
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
XYZ_to_Nayatani95(XYZ * factor_a, XYZ_n * factor_a, Y_o,
E_o, E_or)[:6],
specification * factor_b,
decimal=7)
def test_from_range_100(self):
"""
Tests :func:`colour.utilities.common.from_range_100` definition.
"""
with domain_range_scale('Reference'):
self.assertEqual(from_range_100(1), 1)
with domain_range_scale('1'):
self.assertEqual(from_range_100(1), 0.01)
with domain_range_scale('100'):
self.assertEqual(from_range_100(1), 1)
with domain_range_scale('1'):
self.assertEqual(from_range_100(1, np.pi), 1 / np.pi)
def test_domain_range_scale_XYZ_to_ATD95(self):
"""
Tests :func:`colour.appearance.atd95.XYZ_to_ATD95` definition domain
and range scale support.
"""
XYZ = np.array([19.01, 20.00, 21.78])
XYZ_0 = np.array([95.05, 100.00, 108.88])
Y_0 = 318.31
k_1 = 0.0
k_2 = 50.0
specification = XYZ_to_ATD95(XYZ, XYZ_0, Y_0, k_1, k_2)
d_r = (
('reference', 1, 1),
(1, 0.01, np.array([1 / 360, 1, 1, 1, 1, 1, 1, 1, 1])),
(100, 1, np.array([100 / 360, 1, 1, 1, 1, 1, 1, 1, 1])),
)
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
XYZ_to_ATD95(XYZ * factor_a, XYZ_0 * factor_a, Y_0, k_1,
k_2),
specification * factor_b,
decimal=7)
def test_from_range_degrees(self):
"""
Tests :func:`colour.utilities.common.from_range_degrees` definition.
"""
with domain_range_scale('Reference'):
self.assertEqual(from_range_degrees(1), 1)
with domain_range_scale('1'):
self.assertEqual(from_range_degrees(1), 1 / 360)
with domain_range_scale('100'):
self.assertEqual(from_range_degrees(1), 1 / 3.6)
with domain_range_scale('100'):
self.assertEqual(from_range_degrees(1, np.pi), 1 / (np.pi / 100))
def oetf_reverse_ARIBSTDB67(E_p, r=0.5, constants=ARIBSTDB67_CONSTANTS):
"""
Defines *ARIB STD-B67 (Hybrid Log-Gamma)* reverse opto-electrical transfer
function (OETF / OECF).
Parameters
----------
E_p : numeric or array_like
Non-linear signal :math:`E'`.
r : numeric, optional
Video level corresponding to reference white level.
constants : Structure, optional
*ARIB STD-B67 (Hybrid Log-Gamma)* constants.
Returns
-------
numeric or ndarray
Voltage :math:`E` normalised by the reference white level and
proportional to the implicit light intensity that would be detected
with a reference camera color channel R, G, B.
Notes
-----
+------------+-----------------------+---------------+
| **Domain** | **Scale - Reference** | **Scale - 1** |
+============+=======================+===============+
| ``E_p`` | [0, 1] | [0, 1] |
+------------+-----------------------+---------------+
+------------+-----------------------+---------------+
| **Range** | **Scale - Reference** | **Scale - 1** |
+============+=======================+===============+
| ``E`` | [0, 1] | [0, 1] |
+------------+-----------------------+---------------+
References
----------
:cite:`AssociationofRadioIndustriesandBusinesses2015a`
Examples
--------
>>> oetf_reverse_ARIBSTDB67(0.212132034355964) # doctest: +ELLIPSIS
0.1799999...
"""
E_p = to_domain_1(E_p)
a = constants.a
b = constants.b
c = constants.c
with domain_range_scale('ignore'):
E = np.where(
E_p <= oetf_ARIBSTDB67(1),
(E_p / r) ** 2,
np.exp((E_p - c) / a) + b,
)
return as_float(from_range_1(E))
def test_domain_range_scale_XYZ_to_RLAB(self):
"""
Tests :func:`colour.appearance.rlab.XYZ_to_RLAB` definition domain and
range scale support.
"""
XYZ = np.array([19.01, 20.00, 21.78])
XYZ_n = np.array([109.85, 100, 35.58])
Y_n = 31.83
sigma = RLAB_VIEWING_CONDITIONS['Average']
D = RLAB_D_FACTOR['Hard Copy Images']
specification = XYZ_to_RLAB(XYZ, XYZ_n, Y_n, sigma, D)[:4]
d_r = (
('reference', 1, 1),
(1, 0.01, np.array([1, 1, 1 / 360, 1])),
(100, 1, np.array([1, 1, 100 / 360, 1])),
)
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
XYZ_to_RLAB(XYZ * factor_a, XYZ_n * factor_a, Y_n, sigma,
D)[:4],
specification * factor_b,
decimal=7)
def test_domain_range_scale_XYZ_to_CAM16(self):
"""
Tests :func:`colour.appearance.cam16.XYZ_to_CAM16` definition domain
and range scale support.
"""
XYZ = np.array([19.01, 20.00, 21.78])
XYZ_w = np.array([95.05, 100.00, 108.88])
L_A = 318.31
Y_b = 20.0
surround = CAM16_VIEWING_CONDITIONS['Average']
specification = XYZ_to_CAM16(XYZ, XYZ_w, L_A, Y_b, surround)[:-1]
d_r = (
('reference', 1, 1),
(1, 0.01, np.array([1, 1, 1 / 360, 1, 1, 1, 1 / 360])),
(100, 1, np.array([1, 1, 100 / 360, 1, 1, 1, 100 / 360])),
)
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
XYZ_to_CAM16(XYZ * factor_a, XYZ_w * factor_a, L_A, Y_b,
surround)[:-1],
specification * factor_b,
decimal=7)
def error_function(XYZ, Ljg):
"""
Error function.
"""
# Error must be computed in "reference" domain and range.
with domain_range_scale('ignore'):
error = np.linalg.norm(XYZ_to_OSA_UCS(XYZ) - Ljg)
return error
def test_to_domain_10(self):
"""
Tests :func:`colour.utilities.common.to_domain_10` definition.
"""
with domain_range_scale('Reference'):
self.assertEqual(to_domain_10(1), 1)
with domain_range_scale('1'):
self.assertEqual(to_domain_10(1), 10)
with domain_range_scale('100'):
self.assertEqual(to_domain_10(1), 0.1)
with domain_range_scale('100'):
self.assertEqual(to_domain_10(1, np.pi), 1 / np.pi)
with domain_range_scale('100'):
self.assertEqual(
to_domain_10(1, dtype=np.float16).dtype, np.float16)
def test_to_domain_int(self):
"""
Tests :func:`colour.utilities.common.to_domain_int` definition.
"""
with domain_range_scale('Reference'):
self.assertEqual(to_domain_int(1), 1)
with domain_range_scale('1'):
self.assertEqual(to_domain_int(1), 255)
with domain_range_scale('100'):
self.assertEqual(to_domain_int(1), 2.55)
with domain_range_scale('100'):
self.assertEqual(to_domain_int(1, 10), 10.23)
with domain_range_scale('100'):
self.assertEqual(
to_domain_int(1, dtype=np.float16).dtype, np.float16)
def test_to_domain_degrees(self):
"""
Tests :func:`colour.utilities.common.to_domain_degrees` definition.
"""
with domain_range_scale('Reference'):
self.assertEqual(to_domain_degrees(1), 1)
with domain_range_scale('1'):
self.assertEqual(to_domain_degrees(1), 360)
with domain_range_scale('100'):
self.assertEqual(to_domain_degrees(1), 3.6)
with domain_range_scale('100'):
self.assertEqual(to_domain_degrees(1, np.pi), np.pi / 100)
with domain_range_scale('100'):
self.assertEqual(
to_domain_degrees(1, dtype=np.float16).dtype, np.float16)
def test_from_range_int(self):
"""
Tests :func:`colour.utilities.common.from_range_int` definition.
"""
with domain_range_scale('Reference'):
self.assertEqual(from_range_int(1), 1)
with domain_range_scale('1'):
self.assertEqual(from_range_int(1), 1 / 255)
with domain_range_scale('100'):
self.assertEqual(from_range_int(1), 1 / 2.55)
with domain_range_scale('100'):
self.assertEqual(from_range_int(1, 10), 1 / (1023 / 100))
with domain_range_scale('100'):
self.assertEqual(
from_range_int(1, dtype=np.float16).dtype, np.float16)
def test_set_domain_range_scale(self):
"""
Tests :func:`colour.utilities.common.set_domain_range_scale`
definition.
"""
with domain_range_scale('Reference'):
set_domain_range_scale('1')
self.assertEqual(get_domain_range_scale(), '1')
with domain_range_scale('Reference'):
set_domain_range_scale('100')
self.assertEqual(get_domain_range_scale(), '100')
with domain_range_scale('1'):
set_domain_range_scale('Reference')
self.assertEqual(get_domain_range_scale(), 'reference')
self.assertRaises(AssertionError,
lambda: set_domain_range_scale('Invalid'))
def plot_multi_cctfs(cctfs=None, decoding_cctf=False, **kwargs):
"""
Plots given colour component transfer functions.
Parameters
----------
cctfs : array_like, optional
Colour component transfer function to plot.
decoding_cctf : bool
Plot the decoding colour component transfer function instead.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.plot_multi_functions`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> plot_multi_cctfs(['ITU-R BT.709', 'sRGB']) # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_Multi_CCTFs.png
:align: center
:alt: plot_multi_cctfs
"""
if cctfs is None:
cctfs = ('ITU-R BT.709', 'sRGB')
cctfs = filter_passthrough(
DECODING_CCTFS if decoding_cctf else ENCODING_CCTFS, cctfs)
mode = 'Decoding' if decoding_cctf else 'Encoding'
title = '{0} - {1} CCTFs'.format(', '.join([cctf for cctf in cctfs]), mode)
settings = {
'bounding_box': (0, 1, 0, 1),
'legend': True,
'title': title,
'x_label': 'Signal Value' if decoding_cctf else 'Tristimulus Value',
'y_label': 'Tristimulus Value' if decoding_cctf else 'Signal Value',
}
settings.update(kwargs)
with domain_range_scale(1):
return plot_multi_functions(cctfs, **settings)
def eotf_SMPTE240M(V_r):
"""
Defines *SMPTE 240M* electro-optical transfer function (EOTF / EOCF).
Parameters
----------
V_r : numeric or array_like
Video signal level :math:`V_r` driving the reference reproducer
normalised to the system reference white.
Returns
-------
numeric or ndarray
Light output :math:`L_r` from the reference reproducer normalised to
the system reference white.
Notes
-----
+------------+-----------------------+---------------+
| **Domain** | **Scale - Reference** | **Scale - 1** |
+============+=======================+===============+
| ``V_c`` | [0, 1] | [0, 1] |
+------------+-----------------------+---------------+
+------------+-----------------------+---------------+
| **Range** | **Scale - Reference** | **Scale - 1** |
+============+=======================+===============+
| ``L_c`` | [0, 1] | [0, 1] |
+------------+-----------------------+---------------+
References
----------
:cite:`SocietyofMotionPictureandTelevisionEngineers1999b`
Examples
--------
>>> eotf_SMPTE240M(0.402285796753870) # doctest: +ELLIPSIS
0.1...
"""
V_r = to_domain_1(V_r)
with domain_range_scale('ignore'):
L_r = np.where(
V_r < oetf_SMPTE240M(0.0228),
V_r / 4,
spow((V_r + 0.1115) / 1.1115, 1 / 0.45),
)
return as_float(from_range_1(L_r))
def oetf_reverse_sRGB(V):
"""
Defines the *sRGB* colourspace reverse opto-electronic transfer function
(OETF / OECF).
Parameters
----------
V : numeric or array_like
Electrical signal :math:`V`.
Returns
-------
numeric or ndarray
Corresponding *luminance* :math:`L` of the image.
Notes
-----
+------------+-----------------------+---------------+
| **Domain** | **Scale - Reference** | **Scale - 1** |
+============+=======================+===============+
| ``V`` | [0, 1] | [0, 1] |
+------------+-----------------------+---------------+
+------------+-----------------------+---------------+
| **Range** | **Scale - Reference** | **Scale - 1** |
+============+=======================+===============+
| ``L`` | [0, 1] | [0, 1] |
+------------+-----------------------+---------------+
References
----------
:cite:`InternationalElectrotechnicalCommission1999a`,
:cite:`InternationalTelecommunicationUnion2015i`
Examples
--------
>>> oetf_reverse_sRGB(0.461356129500442) # doctest: +ELLIPSIS
0.1...
"""
V = to_domain_1(V)
with domain_range_scale('ignore'):
L = np.where(
V <= oetf_sRGB(0.0031308),
V / 12.92,
spow((V + 0.055) / 1.055, 2.4),
)
return as_float(from_range_1(L))
def test_domain_range_scale_log_decoding_ERIMMRGB(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.rimm_romm_rgb.\
log_decoding_ERIMMRGB` definition domain and range scale support.
"""
X_p = 0.410052389492129
X = log_decoding_ERIMMRGB(X_p)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
log_decoding_ERIMMRGB(X_p * factor), X * factor, decimal=7)
def test_domain_range_scale_XYZ_to_IPT(self):
"""
Tests :func:`colour.models.ipt.XYZ_to_IPT` definition domain and
range scale support.
"""
XYZ = np.array([0.20654008, 0.12197225, 0.05136952])
IPT = XYZ_to_IPT(XYZ)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
XYZ_to_IPT(XYZ * factor), IPT * factor, decimal=7)
def test_domain_range_scale_oetf_ARIBSTDB67(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.arib_std_b67.\
oetf_ARIBSTDB67` definition domain and range scale support.
"""
E = 0.18
E_p = oetf_ARIBSTDB67(E)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
oetf_ARIBSTDB67(E * factor), E_p * factor, decimal=7)
def test_domain_range_scale_yellowness_ASTMD1925(self):
"""
Tests :func:`colour.colorimetry.yellowness.yellowness_ASTMD1925`
definition domain and range scale support.
"""
XYZ = np.array([95.00000000, 100.00000000, 105.00000000])
YI = 10.299999999999997
d_r = (('reference', 1), (1, 0.01), (100, 1))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
yellowness_ASTMD1925(XYZ * factor), YI * factor, decimal=7)
def test_domain_range_scale_oetf_ROMMRGB(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.rimm_romm_rgb.\
oetf_ROMMRGB` definition domain and range scale support.
"""
X = 0.18
X_p = oetf_ROMMRGB(X)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
oetf_ROMMRGB(X * factor), X_p * factor, decimal=7)
def test_domain_range_scale_eotf_reverse_BT1886(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_1886.\
eotf_reverse_BT1886` definition domain and range scale support.
"""
L = 0.18
V = eotf_reverse_BT1886(L)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
eotf_reverse_BT1886(L * factor), V * factor, decimal=7)
def test_domain_range_scale_log_decoding_PivotedLog(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.pivoted_log.\
log_decoding_PivotedLog` definition domain and range scale support.
"""
y = 0.434995112414467
x = log_decoding_PivotedLog(y)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
log_decoding_PivotedLog(y * factor), x * factor, decimal=7)
def test_domain_range_scale_log_decoding_DLog(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.dji_dlog.\
log_decoding_DJIDLog` definition domain and range scale support.
"""
y = 0.398764556189331
x = log_decoding_DJIDLog(y)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
log_decoding_DJIDLog(y * factor), x * factor, decimal=7)
def test_domain_range_scale_log_encoding_Protune(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.gopro.\
log_encoding_Protune` definition domain and range scale support.
"""
x = 0.18
y = log_encoding_Protune(x)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
log_encoding_Protune(x * factor), y * factor, decimal=7)
def test_domain_range_scale_eotf_RIMMRGB(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.rimm_romm_rgb.\
eotf_RIMMRGB` definition domain and range scale support.
"""
X_p = 0.291673732475746
X = eotf_RIMMRGB(X_p)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
eotf_RIMMRGB(X_p * factor), X * factor, decimal=7)
def test_domain_range_scale_IPT_hue_angle(self):
"""
Tests :func:`colour.models.ipt.IPT_hue_angle` definition domain and
range scale support.
"""
IPT = np.array([0.20654008, 0.12197225, 0.05136952])
hue = IPT_hue_angle(IPT)
d_r = (('reference', 1, 1), (1, 1, 1 / 360), (100, 100, 1 / 3.6))
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
IPT_hue_angle(IPT * factor_a), hue * factor_b, decimal=7)
def test_domain_range_scale_oetf_BT601(self):
"""
Tests :func:`colour.models.rgb.transfer_functions.itur_bt_601.\
oetf_BT601` definition domain and range scale support.
"""
L = 0.18
E = oetf_BT601(L)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
oetf_BT601(L * factor), E * factor, decimal=7)
def test_domain_range_scale_Luv_to_uv(self):
"""
Tests :func:`colour.models.cie_luv.Luv_to_uv` definition
domain and range scale support.
"""
Luv = np.array([41.52787529, 96.83626054, 17.75210149])
illuminant = np.array([0.31270, 0.32900])
uv = Luv_to_uv(Luv, illuminant)
d_r = (('reference', 1), (1, 0.01), (100, 1))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(Luv_to_uv(
Luv * factor, illuminant),
uv,
decimal=7)
def test_domain_range_scale_oetf_inverse_ARIBSTDB67(self):
"""
Test :func:`colour.models.rgb.transfer_functions.arib_std_b67.\
oetf_inverse_ARIBSTDB67` definition domain and range scale support.
"""
E_p = 0.212132034355964
E = oetf_inverse_ARIBSTDB67(E_p)
d_r = (("reference", 1), ("1", 1), ("100", 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
oetf_inverse_ARIBSTDB67(E_p * factor),
E * factor,
decimal=7,
)
def test_domain_range_scale_whiteness_Ganz1979(self):
"""
Tests :func:`colour.colorimetry.whiteness.whiteness_Ganz1979`
definition domain and range scale support.
"""
xy = np.array([0.3167, 0.3334])
Y = 100
WT = whiteness_Ganz1979(xy, Y)
d_r = (('reference', 1), (1, 0.01), (100, 1))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(whiteness_Ganz1979(
xy, Y * factor),
WT * factor,
decimal=7)
def test_domain_range_scale_delta_E_CMC(self):
"""
Tests :func:`colour.difference.delta_e.delta_E_CMC` definition
domain and range scale support.
"""
Lab_1 = np.array([100.00000000, 21.57210357, 272.22819350])
Lab_2 = np.array([100.00000000, 426.67945353, 72.39590835])
delta_E = delta_E_CMC(Lab_1, Lab_2)
d_r = (('reference', 1), (1, 0.01), (100, 1))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(delta_E_CMC(
Lab_1 * factor, Lab_2 * factor),
delta_E,
decimal=7)
def test_domain_range_scale_whiteness_Berger1959(self):
"""
Tests :func:`colour.colorimetry.whiteness.whiteness_Berger1959`
definition domain and range scale support.
"""
XYZ = np.array([95.00000000, 100.00000000, 105.00000000])
XYZ_0 = np.array([94.80966767, 100.00000000, 107.30513595])
W = whiteness_Berger1959(XYZ, XYZ_0)
d_r = (('reference', 1), (1, 0.01), (100, 1))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
whiteness_Berger1959(XYZ * factor, XYZ_0 * factor),
W * factor,
decimal=7)
def test_domain_range_scale_XYZ_to_Luv(self):
"""
Tests :func:`colour.models.cie_luv.XYZ_to_Luv` definition
domain and range scale support.
"""
XYZ = np.array([0.20654008, 0.12197225, 0.05136952])
illuminant = np.array([0.31270, 0.32900])
Luv = XYZ_to_Luv(XYZ, illuminant)
d_r = (('reference', 1, 1), (1, 1, 0.01), (100, 100, 1))
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(XYZ_to_Luv(
XYZ * factor_a, illuminant),
Luv * factor_b,
decimal=7)
def test_domain_range_scale_chromatic_adaptation(self):
"""
Tests :func:`colour.adaptation.chromatic_adaptation` definition domain
and range scale support.
"""
XYZ = np.array([0.20654008, 0.12197225, 0.05136952])
XYZ_w = np.array([0.95045593, 1.00000000, 1.08905775])
XYZ_wr = np.array([0.96429568, 1.00000000, 0.82510460])
Y_o = 0.2
E_o = 1000
L_A = 200
Y_n = 200
m = ('Von Kries', 'CIE 1994', 'CMCCAT2000', 'Fairchild 1990')
v = [
chromatic_adaptation(XYZ,
XYZ_w,
XYZ_wr,
method=method,
Y_o=Y_o,
E_o1=E_o,
E_o2=E_o,
L_A1=L_A,
L_A2=L_A,
Y_n=Y_n) for method in m
]
d_r = (('reference', 1), (1, 1), (100, 100))
for method, value in zip(m, v):
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(chromatic_adaptation(
XYZ * factor,
XYZ_w * factor,
XYZ_wr * factor,
method=method,
Y_o=Y_o * factor,
E_o1=E_o,
E_o2=E_o,
L_A1=L_A,
L_A2=L_A,
Y_n=Y_n),
value * factor,
decimal=7)
def test_domain_range_scale_JMh_CIECAM02_to_UCS_Luo2006(self):
"""
Tests :func:`colour.models.cam02_ucs.JMh_CIECAM02_to_UCS_Luo2006`
definition domain and range scale support.
"""
JMh = self._JMh
Jpapbp = JMh_CIECAM02_to_UCS_Luo2006(
JMh, COEFFICIENTS_UCS_LUO2006['CAM02-LCD'])
d_r = (('reference', 1, 1), (1, np.array([0.01, 0.01, 1 / 360]), 0.01),
(100, np.array([1, 1, 1 / 3.6]), 1))
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(JMh_CIECAM02_to_UCS_Luo2006(
JMh * factor_a, COEFFICIENTS_UCS_LUO2006['CAM02-LCD']),
Jpapbp * factor_b,
decimal=7)
def test_domain_range_scale_whiteness_Taube1960(self):
"""
Test :func:`colour.colorimetry.whiteness.whiteness_Taube1960`
definition domain and range scale support.
"""
XYZ = np.array([95.00000000, 100.00000000, 105.00000000])
XYZ_0 = np.array([94.80966767, 100.00000000, 107.30513595])
WI = whiteness_Taube1960(XYZ, XYZ_0)
d_r = (("reference", 1), ("1", 0.01), ("100", 1))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
whiteness_Taube1960(XYZ * factor, XYZ_0 * factor),
WI * factor,
decimal=7,
)
def test_domain_range_scale_chromatic_adaptation_VonKries(self):
"""
Tests :func:`colour.adaptation.vonkries.chromatic_adaptation_VonKries`
definition domain and range scale support.
"""
XYZ = np.array([0.20654008, 0.12197225, 0.05136952])
XYZ_w = np.array([0.95045593, 1.00000000, 1.08905775])
XYZ_wr = np.array([0.96429568, 1.00000000, 0.82510460])
XYZ_a = chromatic_adaptation_VonKries(XYZ, XYZ_w, XYZ_wr)
d_r = (('reference', 1), (1, 1), (100, 0.01))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(chromatic_adaptation_VonKries(
XYZ * factor, XYZ_w * factor, XYZ_wr * factor),
XYZ_a * factor,
decimal=7)
def test_domain_range_scale_Lab_to_XYZ(self):
"""
Test :func:`colour.models.cie_lab.Lab_to_XYZ` definition
domain and range scale support.
"""
Lab = np.array([41.52787529, 52.63858304, 26.92317922])
illuminant = np.array([0.31270, 0.32900])
XYZ = Lab_to_XYZ(Lab, illuminant)
d_r = (("reference", 1, 1), ("1", 0.01, 1), ("100", 1, 100))
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
Lab_to_XYZ(Lab * factor_a, illuminant),
XYZ * factor_b,
decimal=7,
)
def test_domain_range_scale_lightness(self):
"""
Tests :func:`colour.colorimetry.lightness.lightness` definition domain
and range scale support.
"""
m = ('Glasser 1958', 'Wyszecki 1963', 'CIE 1976', 'Fairchild 2010',
'Fairchild 2011')
v = [lightness(12.19722535, method, Y_n=100) for method in m]
d_r = (('reference', 1), (1, 0.01), (100, 1))
for method, value in zip(m, v):
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
lightness(12.19722535 * factor, method, Y_n=100),
value * factor,
decimal=7)
def test_domain_range_scale_delta_E_DIN99(self):
"""
Test :func:`colour.difference.din99.delta_E_DIN99` definition
domain and range scale support.
"""
Lab_1 = np.array([60.25740000, -34.00990000, 36.26770000])
Lab_2 = np.array([60.46260000, -34.17510000, 39.43870000])
delta_E = delta_E_DIN99(Lab_1, Lab_2)
d_r = (("reference", 1), ("1", 0.01), ("100", 1))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
delta_E_DIN99(Lab_1 * factor, Lab_2 * factor),
delta_E,
decimal=7,
)
def test_domain_range_scale_Oklab_to_XYZ(self):
"""
Test :func:`colour.models.oklab.Oklab_to_XYZ` definition domain and
range scale support.
"""
Oklab = np.array([0.51634019, 0.15469500, 0.06289579])
XYZ = Oklab_to_XYZ(Oklab)
d_r = (("reference", 1), ("1", 1), ("100", 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_allclose(
Oklab_to_XYZ(Oklab * factor),
XYZ * factor,
rtol=0.000001,
atol=0.000001,
)
def test_domain_range_scale_hdr_IPT_to_XYZ(self):
"""
Tests :func:`colour.models.hdr_ipt.hdr_IPT_to_XYZ` definition domain
and range scale support.
"""
IPT_hdr = np.array([24.88927680, -11.44574144, 1.63147707])
Y_s = 0.2
Y_abs = 100
XYZ = hdr_IPT_to_XYZ(IPT_hdr, Y_s, Y_abs)
d_r = (('reference', 1, 1, 1), (1, 0.01, 1, 1), (100, 1, 100, 100))
for scale, factor_a, factor_b, factor_c in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(hdr_IPT_to_XYZ(
IPT_hdr * factor_a, Y_s * factor_b, Y_abs),
XYZ * factor_c,
decimal=7)
def test_domain_range_scale_sd_to_XYZ_integration(self):
"""
Test :func:`colour.colorimetry.tristimulus_values.\
sd_to_XYZ_integration` definition domain and range scale support.
"""
cmfs = MSDS_CMFS["CIE 1931 2 Degree Standard Observer"]
XYZ = sd_to_XYZ_integration(SD_SAMPLE, cmfs, SDS_ILLUMINANTS["A"])
d_r = (("reference", 1), ("1", 0.01), ("100", 1))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
sd_to_XYZ_integration(SD_SAMPLE, cmfs,
SDS_ILLUMINANTS["A"]),
XYZ * factor,
decimal=7,
)
def test_domain_range_scale_XYZ_to_sd(self):
"""
Tests :func:`colour.recovery.XYZ_to_sd` definition domain
and range scale support.
"""
XYZ = np.array([0.20654008, 0.12197225, 0.05136952])
m = ('Smits 1999', 'Meng 2015')
v = [sd_to_XYZ_integration(XYZ_to_sd(XYZ, method)) for method in m]
d_r = (('reference', 1, 1), (1, 1, 0.01), (100, 100, 1))
for method, value in zip(m, v):
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(sd_to_XYZ_integration(
XYZ_to_sd(XYZ * factor_a, method=method)),
value * factor_b,
decimal=7)
def test_domain_range_scale_XYZ_to_RGB(self):
"""
Tests :func:`colour.models.rgb.rgb_colourspace.RGB_to_RGB` definition
domain and range scale support.
"""
aces_2065_1_colourspace = RGB_COLOURSPACES['ACES2065-1']
sRGB_colourspace = RGB_COLOURSPACES['sRGB']
RGB_i = np.array([0.21931722, 0.06950287, 0.04694832])
RGB_o = RGB_to_RGB(RGB_i, aces_2065_1_colourspace, sRGB_colourspace)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(RGB_to_RGB(
RGB_i * factor, aces_2065_1_colourspace, sRGB_colourspace),
RGB_o * factor,
decimal=7)
def test_domain_range_scale_exponent_hdr_CIELab(self):
"""
Test :func:`colour.models.hdr_cie_lab.exponent_hdr_CIELab` definition
domain and range scale support.
"""
Y_s = 0.2
Y_abs = 100
epsilon = exponent_hdr_CIELab(Y_s, Y_abs)
d_r = (("reference", 1), ("1", 1), ("100", 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
exponent_hdr_CIELab(Y_s * factor, Y_abs),
epsilon,
decimal=7,
)
def test_domain_range_scale_oetf_BlackmagicFilmGeneration5(self):
"""
Test :func:`colour.models.rgb.transfer_functions.\
blackmagic_design.oetf_BlackmagicFilmGeneration5` definition domain and range
scale support.
"""
L = 0.18
V = oetf_BlackmagicFilmGeneration5(L)
d_r = (("reference", 1), ("1", 1), ("100", 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
oetf_BlackmagicFilmGeneration5(L * factor),
V * factor,
decimal=7,
)
def test_domain_range_scale_UCS_Luo2006_to_JMh_CIECAM02(self):
"""
Tests :func:`colour.models.cam02_ucs.UCS_Luo2006_to_JMh_CIECAM02`
definition domain and range scale support.
"""
Jpapbp = np.array([54.90433134, -0.08442362, -0.06848314])
JMh = UCS_Luo2006_to_JMh_CIECAM02(
Jpapbp, COEFFICIENTS_UCS_LUO2006['CAM02-LCD'])
d_r = (('reference', 1, 1), (1, 0.01, np.array([0.01, 0.01, 1 / 360])),
(100, 1, np.array([1, 1, 1 / 3.6])))
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(UCS_Luo2006_to_JMh_CIECAM02(
Jpapbp * factor_a, COEFFICIENTS_UCS_LUO2006['CAM02-LCD']),
JMh * factor_b,
decimal=7)
def test_domain_range_scale_oetf_inverse_DaVinciIntermediate(self):
"""
Test :func:`colour.models.rgb.transfer_functions.\
davinci_intermediate.oetf_inverse_DaVinciIntermediate` definition domain and
range scale support.
"""
V = 0.336043272384855
L = oetf_inverse_DaVinciIntermediate(V)
d_r = (("reference", 1), ("1", 1), ("100", 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
oetf_inverse_DaVinciIntermediate(V * factor),
L * factor,
decimal=7,
)
def test_domain_range_scale_Jzazbz_to_XYZ(self):
"""
Test :func:`colour.models.jzazbz.Jzazbz_to_XYZ` definition domain and
range scale support.
"""
Jzazbz = np.array([0.00535048, 0.00924302, 0.00526007])
XYZ = Jzazbz_to_XYZ(Jzazbz)
d_r = (("reference", 1), ("1", 1), ("100", 1))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_allclose(
Jzazbz_to_XYZ(Jzazbz * factor),
XYZ * factor,
rtol=0.000001,
atol=0.000001,
)
def test_domain_range_scale_RGB_to_sd_Smits1999(self):
"""
Tests :func:`colour.recovery.smits1999.RGB_to_sd_Smits1999`
definition domain and range scale support.
"""
XYZ_i = np.array([0.20654008, 0.12197225, 0.05136952])
RGB_i = XYZ_to_RGB_Smits1999(XYZ_i)
XYZ_o = sd_to_XYZ_integration(RGB_to_sd_Smits1999(RGB_i))
d_r = (('reference', 1, 1), (1, 1, 0.01), (100, 100, 1))
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
sd_to_XYZ_integration(
RGB_to_sd_Smits1999(RGB_i * factor_a)),
XYZ_o * factor_b,
decimal=7)
def test_domain_range_scale_luminance(self):
"""
Tests :func:`colour.colorimetry.luminance.luminance` definition
domain and range scale support.
"""
m = ('Newhall 1943', 'ASTM D1535-08', 'CIE 1976', 'Fairchild 2010',
'Fairchild 2011')
v = [luminance(41.527875844653451, method, Y_n=100) for method in m]
d_r = (('reference', 1), (1, 0.01), (100, 1))
for method, value in zip(m, v):
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(luminance(
41.527875844653451 * factor, method, Y_n=100),
value * factor,
decimal=7)
def test_domain_range_scale_uv_to_Luv(self):
"""
Tests :func:`colour.models.cie_luv.uv_to_Luv` definition
domain and range scale support.
"""
uv = np.array([0.37720213, 0.50120264])
illuminant = np.array([0.31270, 0.32900])
Y = 1
Luv = uv_to_Luv(uv, illuminant, Y)
d_r = (('reference', 1, 1), (1, 1, 0.01), (100, 100, 1))
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(uv_to_Luv(
uv, illuminant, Y * factor_a),
Luv * factor_b,
decimal=7)
def test_domain_range_scale_XYZ_to_hdr_IPT(self):
"""
Tests :func:`colour.models.hdr_ipt.XYZ_to_hdr_IPT` definition domain
and range scale support.
"""
XYZ = np.array([0.20654008, 0.12197225, 0.05136952])
Y_s = 0.2
Y_abs = 100
IPT_hdr = XYZ_to_hdr_IPT(XYZ, Y_s, Y_abs)
d_r = (('reference', 1, 1), (1, 1, 0.01), (100, 100, 1))
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(XYZ_to_hdr_IPT(
XYZ * factor_a, Y_s * factor_a, Y_abs),
IPT_hdr * factor_b,
decimal=7)
def test_domain_range_scale_XYZ_to_hdr_CIELab(self):
"""
Tests :func:`colour.models.hdr_cie_lab.XYZ_to_hdr_CIELab` definition
domain and range scale support.
"""
XYZ = np.array([0.20654008, 0.12197225, 0.05136952])
illuminant = np.array([0.31270, 0.32900])
Y_s = 0.2
Y_abs = 100
Lab_hdr = XYZ_to_hdr_CIELab(XYZ, illuminant, Y_s, Y_abs)
d_r = (('reference', 1, 1), (1, 1, 0.01), (100, 100, 1))
for scale, factor_a, factor_b in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(XYZ_to_hdr_CIELab(
XYZ * factor_a, illuminant, Y_s * factor_a, Y_abs),
Lab_hdr * factor_b,
decimal=7)
def test_domain_range_scale_hdr_CIELab_to_XYZ(self):
"""
Tests :func:`colour.models.hdr_cie_lab.hdr_CIELab_to_XYZ` definition
domain and range scale support.
"""
Lab_hdr = np.array([26.46461067, -24.61332600, -4.84796811])
illuminant = np.array([0.31270, 0.32900])
Y_s = 0.2
Y_abs = 100
XYZ = hdr_CIELab_to_XYZ(Lab_hdr, illuminant, Y_s, Y_abs)
d_r = (('reference', 1, 1, 1), (1, 0.01, 1, 1), (100, 1, 100, 100))
for scale, factor_a, factor_b, factor_c in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(hdr_CIELab_to_XYZ(
Lab_hdr * factor_a, illuminant, Y_s * factor_b, Y_abs),
XYZ * factor_c,
decimal=7)
def test_domain_range_scale_spectral_to_aces_relative_exposure_values(
self):
"""
Tests :func:`colour.models.rgb.aces_it.
sd_to_aces_relative_exposure_values` definition domain and range scale
support.
"""
shape = ACES_RICD.shape
grey_reflector = sd_constant(0.18, shape)
RGB = sd_to_aces_relative_exposure_values(grey_reflector)
d_r = (('reference', 1), (1, 1), (100, 100))
for scale, factor in d_r:
with domain_range_scale(scale):
np.testing.assert_almost_equal(
sd_to_aces_relative_exposure_values(grey_reflector),
RGB * factor,
decimal=7)
