def test_nan_oetf_BT2020(self): """ Tests :func:`colour.models.rgb.transfer_functions.bt_2020.\ oetf_BT2020` definition nan support. """ oetf_BT2020(np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
def test_nan_oetf_BT2020(self): """ Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2020.\ oetf_BT2020` definition nan support. """ oetf_BT2020(np.array([-1.0, 0.0, 1.0, -np.inf, np.inf, np.nan]))
def test_oetf_BT2020(self): """ Tests :func:`colour.models.rgb.transfer_functions.bt_2020.\ oetf_BT2020` definition. """ self.assertAlmostEqual(oetf_BT2020(0.0), 0.0, places=7) self.assertAlmostEqual(oetf_BT2020(0.18), 0.409007728864150, places=7) self.assertAlmostEqual(oetf_BT2020(1.0), 1.0, places=7)
def test_oetf_BT2020(self): """ Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2020.\ oetf_BT2020` definition. """ self.assertAlmostEqual(oetf_BT2020(0.0), 0.0, places=7) self.assertAlmostEqual(oetf_BT2020(0.18), 0.409007728864150, places=7) self.assertAlmostEqual(oetf_BT2020(1.0), 1.0, places=7)
def test_domain_range_scale_oetf_BT2020(self): """ Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2020.\ oetf_BT2020` definition domain and range scale support. """ E = 0.18 E_p = oetf_BT2020(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_BT2020(E * factor), E_p * factor, decimal=7)
def test_domain_range_scale_oetf_BT2020(self): """ Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2020.\ oetf_BT2020` definition domain and range scale support. """ E = 0.18 E_p = oetf_BT2020(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_BT2020(E * factor), E_p * factor, decimal=7)
def test_n_dimensional_oetf_BT2020(self): """ Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2020.\ oetf_BT2020` definition n-dimensional arrays support. """ E = 0.18 E_p = oetf_BT2020(E) E = np.tile(E, 6) E_p = np.tile(E_p, 6) np.testing.assert_almost_equal(oetf_BT2020(E), E_p, decimal=7) E = np.reshape(E, (2, 3)) E_p = np.reshape(E_p, (2, 3)) np.testing.assert_almost_equal(oetf_BT2020(E), E_p, decimal=7) E = np.reshape(E, (2, 3, 1)) E_p = np.reshape(E_p, (2, 3, 1)) np.testing.assert_almost_equal(oetf_BT2020(E), E_p, decimal=7)
def test_n_dimensional_oetf_BT2020(self): """ Tests :func:`colour.models.rgb.transfer_functions.itur_bt_2020.\ oetf_BT2020` definition n-dimensional arrays support. """ E = 0.18 E_p = oetf_BT2020(E) E = np.tile(E, 6) E_p = np.tile(E_p, 6) np.testing.assert_almost_equal(oetf_BT2020(E), E_p, decimal=7) E = np.reshape(E, (2, 3)) E_p = np.reshape(E_p, (2, 3)) np.testing.assert_almost_equal(oetf_BT2020(E), E_p, decimal=7) E = np.reshape(E, (2, 3, 1)) E_p = np.reshape(E_p, (2, 3, 1)) np.testing.assert_almost_equal(oetf_BT2020(E), E_p, decimal=7)
def test_n_dimensional_oetf_BT2020(self): """ Tests :func:`colour.models.rgb.transfer_functions.bt_2020.\ oetf_BT2020` definition n-dimensional arrays support. """ L = 0.18 V = 0.409007728864150 np.testing.assert_almost_equal(oetf_BT2020(L), V, decimal=7) L = np.tile(L, 6) V = np.tile(V, 6) np.testing.assert_almost_equal(oetf_BT2020(L), V, decimal=7) L = np.reshape(L, (2, 3)) V = np.reshape(V, (2, 3)) np.testing.assert_almost_equal(oetf_BT2020(L), V, decimal=7) L = np.reshape(L, (2, 3, 1)) V = np.reshape(V, (2, 3, 1)) np.testing.assert_almost_equal(oetf_BT2020(L), V, decimal=7)
def RGB_to_YcCbcCrc(RGB, out_bits=10, out_legal=True, out_int=False, is_12_bits_system=False, **kwargs): """ Converts an array of *RGB* linear values to the corresponding *Yc'Cbc'Crc'* colour encoding values array. Parameters ---------- RGB : array_like Input *RGB* array of linear float values. out_bits : int, optional Bit depth for integer output, or used in the calculation of the denominator for legal range float values, i.e. 8-bit means the float value for legal white is `235 / 255`. Ignored if `out_legal` and `out_int` are both False. Default is `10`. out_legal : bool, optional Whether to return legal range values. Default is `True`. out_int : bool, optional Whether to return values as `out_bits` integer code values. Default is `False`. is_12_bits_system : bool, optional *Recommendation ITU-R BT.2020* OETF (OECF) adopts different parameters for 10 and 12 bit systems. Default is `False`. Other Parameters ---------------- out_range : array_like, optional Array overriding the computed range such as `out_range = (Y_min, Y_max, C_min, C_max)`. If `out_range` is undefined, `Y_min`, `Y_max`, `C_min` and `C_max` will be computed using :func:`YCbCr_ranges` definition. Returns ------- ndarray *Yc'Cbc'Crc'* colour encoding array of integer or float values. Warning ------- This definition is specifically for usage with *Recommendation ITU-R BT.2020* [3]_ when adopting the constant luminance implementation. Examples -------- >>> RGB = np.array([0.18, 0.18, 0.18]) >>> RGB_to_YcCbcCrc( ... RGB, ... out_legal=True, ... out_bits=10, ... out_int=True, ... is_12_bits_system=False) array([422, 512, 512]) """ RGB = np.asarray(RGB) R, G, B = tsplit(RGB) Y_min, Y_max, C_min, C_max = kwargs.get( 'out_range', YCbCr_ranges(out_bits, out_legal, out_int)) Yc = 0.2627 * R + 0.6780 * G + 0.0593 * B Yc = oetf_BT2020(Yc, is_12_bits_system=is_12_bits_system) R = oetf_BT2020(R, is_12_bits_system=is_12_bits_system) B = oetf_BT2020(B, is_12_bits_system=is_12_bits_system) Cbc = np.where((B - Yc) <= 0, (B - Yc) / 1.9404, (B - Yc) / 1.5816) Crc = np.where((R - Yc) <= 0, (R - Yc) / 1.7184, (R - Yc) / 0.9936) Yc *= Y_max - Y_min Yc += Y_min Cbc *= C_max - C_min Crc *= C_max - C_min Cbc += (C_max + C_min) / 2 Crc += (C_max + C_min) / 2 YcCbcCrc = tstack((Yc, Cbc, Crc)) YcCbcCrc = np.round(YcCbcCrc).astype(np.int_) if out_int else YcCbcCrc return YcCbcCrc
def RGB_to_YcCbcCrc(RGB, out_bits=10, out_legal=True, out_int=False, is_12_bits_system=False, **kwargs): """ Converts an array of *RGB* linear values to the corresponding *Yc'Cbc'Crc'* colour encoding values array. Parameters ---------- RGB : array_like Input *RGB* array of linear float values. out_bits : int, optional Bit depth for integer output, or used in the calculation of the denominator for legal range float values, i.e. 8-bit means the float value for legal white is *235 / 255*. Ignored if ``out_legal`` and ``out_int`` are both *False*. Default is *10*. out_legal : bool, optional Whether to return legal range values. Default is *True*. out_int : bool, optional Whether to return values as ``out_bits`` integer code values. Default is *False*. is_12_bits_system : bool, optional *Recommendation ITU-R BT.2020* OETF (OECF) adopts different parameters for 10 and 12 bit systems. Default is *False*. Other Parameters ---------------- out_range : array_like, optional Array overriding the computed range such as *out_range = (Y_min, Y_max, C_min, C_max)*. If ``out_range`` is undefined, *Y_min*, *Y_max*, *C_min* and *C_max* will be computed using :func:`colour.models.rgb.ycbcr.YCbCr_ranges` definition. Returns ------- ndarray *Yc'Cbc'Crc'* colour encoding array of integer or float values. Notes ----- +----------------+-----------------------+---------------+ | **Domain \\*** | **Scale - Reference** | **Scale - 1** | +================+=======================+===============+ | ``RGB`` | [0, 1] | [0, 1] | +----------------+-----------------------+---------------+ +----------------+-----------------------+---------------+ | **Range \\*** | **Scale - Reference** | **Scale - 1** | +================+=======================+===============+ | ``YcCbcCrc`` | [0, 1] | [0, 1] | +----------------+-----------------------+---------------+ - \\* This definition has input and output integer switches, thus the domain-range scale information is only given for the floating point mode. Warning ------- This definition is specifically for usage with *Recommendation ITU-R BT.2020* when adopting the constant luminance implementation. References ---------- :cite:`InternationalTelecommunicationUnion2015h`, :cite:`Wikipedia2004d` Examples -------- >>> RGB = np.array([0.18, 0.18, 0.18]) >>> RGB_to_YcCbcCrc(RGB, out_legal=True, out_bits=10, out_int=True, ... is_12_bits_system=False) array([422, 512, 512]) """ R, G, B = tsplit(to_domain_1(RGB)) Y_min, Y_max, C_min, C_max = kwargs.get( 'out_range', YCbCr_ranges(out_bits, out_legal, out_int)) Yc = 0.2627 * R + 0.6780 * G + 0.0593 * B with domain_range_scale('ignore'): Yc = oetf_BT2020(Yc, is_12_bits_system=is_12_bits_system) R = oetf_BT2020(R, is_12_bits_system=is_12_bits_system) B = oetf_BT2020(B, is_12_bits_system=is_12_bits_system) Cbc = np.where((B - Yc) <= 0, (B - Yc) / 1.9404, (B - Yc) / 1.5816) Crc = np.where((R - Yc) <= 0, (R - Yc) / 1.7184, (R - Yc) / 0.9936) Yc *= Y_max - Y_min Yc += Y_min Cbc *= C_max - C_min Crc *= C_max - C_min Cbc += (C_max + C_min) / 2 Crc += (C_max + C_min) / 2 YcCbcCrc = tstack([Yc, Cbc, Crc]) YcCbcCrc = (np.round(YcCbcCrc).astype(DEFAULT_INT_DTYPE) if out_int else from_range_1(YcCbcCrc)) return YcCbcCrc
def RGB_to_YcCbcCrc(RGB, out_bits=10, out_legal=True, out_int=False, is_12_bits_system=False, **kwargs): """ Converts an array of *RGB* linear values to the corresponding *Yc'Cbc'Crc'* colour encoding values array. Parameters ---------- RGB : array_like Input *RGB* array of linear float values. out_bits : int, optional Bit depth for integer output, or used in the calculation of the denominator for legal range float values, i.e. 8-bit means the float value for legal white is *235 / 255*. Ignored if ``out_legal`` and ``out_int`` are both *False*. Default is *10*. out_legal : bool, optional Whether to return legal range values. Default is *True*. out_int : bool, optional Whether to return values as ``out_bits`` integer code values. Default is *False*. is_12_bits_system : bool, optional *Recommendation ITU-R BT.2020* OETF (OECF) adopts different parameters for 10 and 12 bit systems. Default is *False*. Other Parameters ---------------- out_range : array_like, optional Array overriding the computed range such as *out_range = (Y_min, Y_max, C_min, C_max)*. If ``out_range`` is undefined, *Y_min*, *Y_max*, *C_min* and *C_max* will be computed using :func:`colour.models.rgb.ycbcr.YCbCr_ranges` definition. Returns ------- ndarray *Yc'Cbc'Crc'* colour encoding array of integer or float values. Notes ----- +----------------+-----------------------+---------------+ | **Domain \\*** | **Scale - Reference** | **Scale - 1** | +================+=======================+===============+ | ``RGB`` | [0, 1] | [0, 1] | +----------------+-----------------------+---------------+ +----------------+-----------------------+---------------+ | **Range \\*** | **Scale - Reference** | **Scale - 1** | +================+=======================+===============+ | ``YcCbcCrc`` | [0, 1] | [0, 1] | +----------------+-----------------------+---------------+ - \\* This definition has input and output integer switches, thus the domain-range scale information is only given for the floating point mode. Warning ------- This definition is specifically for usage with *Recommendation ITU-R BT.2020* when adopting the constant luminance implementation. References ---------- :cite:`InternationalTelecommunicationUnion2015h`, :cite:`Wikipedia2004d` Examples -------- >>> RGB = np.array([0.18, 0.18, 0.18]) >>> RGB_to_YcCbcCrc(RGB, out_legal=True, out_bits=10, out_int=True, ... is_12_bits_system=False) array([422, 512, 512]) """ R, G, B = tsplit(to_domain_1(RGB)) Y_min, Y_max, C_min, C_max = kwargs.get( 'out_range', YCbCr_ranges(out_bits, out_legal, out_int)) Yc = 0.2627 * R + 0.6780 * G + 0.0593 * B with domain_range_scale('ignore'): Yc = oetf_BT2020(Yc, is_12_bits_system=is_12_bits_system) R = oetf_BT2020(R, is_12_bits_system=is_12_bits_system) B = oetf_BT2020(B, is_12_bits_system=is_12_bits_system) Cbc = np.where((B - Yc) <= 0, (B - Yc) / 1.9404, (B - Yc) / 1.5816) Crc = np.where((R - Yc) <= 0, (R - Yc) / 1.7184, (R - Yc) / 0.9936) Yc *= Y_max - Y_min Yc += Y_min Cbc *= C_max - C_min Crc *= C_max - C_min Cbc += (C_max + C_min) / 2 Crc += (C_max + C_min) / 2 YcCbcCrc = tstack([Yc, Cbc, Crc]) YcCbcCrc = (np.round(YcCbcCrc).astype(DEFAULT_INT_DTYPE) if out_int else from_range_1(YcCbcCrc)) return YcCbcCrc
def RGB_to_YcCbcCrc(RGB, out_bits=10, out_legal=True, out_int=False, is_12_bits_system=False, **kwargs): """ Converts an array of *RGB* linear values to the corresponding *Yc'Cbc'Crc'* colour encoding values array. Parameters ---------- RGB : array_like Input *RGB* array of linear float values. out_bits : int, optional Bit depth for integer output, or used in the calculation of the denominator for legal range float values, i.e. 8-bit means the float value for legal white is `235 / 255`. Ignored if `out_legal` and `out_int` are both False. Default is `10`. out_legal : bool, optional Whether to return legal range values. Default is `True`. out_int : bool, optional Whether to return values as `out_bits` integer code values. Default is `False`. is_12_bits_system : bool, optional *Recommendation ITU-R BT.2020* OETF (OECF) adopts different parameters for 10 and 12 bit systems. Default is `False`. \**kwargs : dict, optional **{'out_range'}** Keyword arguments to override the calculated ranges such as ``{'out_range' : array_like (Y_min, Y_max, C_min, C_max)}`` Returns ------- ndarray *Yc'Cbc'Crc'* colour encoding array of integer or float values. Warning ------- This definition is specifically for usage with *Recommendation ITU-R BT.2020* [3]_ when adopting the constant luminance implementation. Examples -------- >>> RGB = np.array([0.18, 0.18, 0.18]) >>> RGB_to_YcCbcCrc( ... RGB, ... out_legal=True, ... out_bits=10, ... out_int=True, ... is_12_bits_system=False) array([422, 512, 512]) """ RGB = np.asarray(RGB) R, G, B = tsplit(RGB) Y_min, Y_max, C_min, C_max = kwargs.get( 'out_range', YCbCr_ranges(out_bits, out_legal, out_int)) Yc = 0.2627 * R + 0.6780 * G + 0.0593 * B Yc = oetf_BT2020(Yc, is_12_bits_system=is_12_bits_system) R = oetf_BT2020(R, is_12_bits_system=is_12_bits_system) B = oetf_BT2020(B, is_12_bits_system=is_12_bits_system) Cbc = np.where((B - Yc) <= 0, (B - Yc) / 1.9404, (B - Yc) / 1.5816) Crc = np.where((R - Yc) <= 0, (R - Yc) / 1.7184, (R - Yc) / 0.9936) Yc *= Y_max - Y_min Yc += Y_min Cbc *= C_max - C_min Crc *= C_max - C_min Cbc += (C_max + C_min) / 2 Crc += (C_max + C_min) / 2 YcCbcCrc = tstack((Yc, Cbc, Crc)) YcCbcCrc = np.round(YcCbcCrc).astype(np.int_) if out_int else YcCbcCrc return YcCbcCrc