def tcs_colorimetry_data(
sd_t: SpectralDistribution,
sd_r: SpectralDistribution,
sds_tcs: Dict[str, SpectralDistribution],
cmfs: MultiSpectralDistributions,
chromatic_adaptation: Boolean = False,
) -> Tuple[TCS_ColorimetryData, ...]:
"""
Return the *test colour samples* colorimetry data.
Parameters
----------
sd_t
Test spectral distribution.
sd_r
Reference spectral distribution.
sds_tcs
*Test colour samples* spectral distributions.
cmfs
Standard observer colour matching functions.
chromatic_adaptation
Perform chromatic adaptation.
Returns
-------
:class:`tuple`
*Test colour samples* colorimetry data.
"""
XYZ_t = sd_to_XYZ(sd_t, cmfs)
uv_t = UCS_to_uv(XYZ_to_UCS(XYZ_t))
u_t, v_t = uv_t[0], uv_t[1]
XYZ_r = sd_to_XYZ(sd_r, cmfs)
uv_r = UCS_to_uv(XYZ_to_UCS(XYZ_r))
u_r, v_r = uv_r[0], uv_r[1]
tcs_data = []
for _key, value in sorted(INDEXES_TO_NAMES_TCS.items()):
sd_tcs = sds_tcs[value]
XYZ_tcs = sd_to_XYZ(sd_tcs, cmfs, sd_t)
xyY_tcs = XYZ_to_xyY(XYZ_tcs)
uv_tcs = UCS_to_uv(XYZ_to_UCS(XYZ_tcs))
u_tcs, v_tcs = uv_tcs[0], uv_tcs[1]
if chromatic_adaptation:
def c(
x: FloatingOrNDArray, y: FloatingOrNDArray
) -> FloatingOrNDArray:
"""Compute the :math:`c` term."""
return (4 - x - 10 * y) / y
def d(
x: FloatingOrNDArray, y: FloatingOrNDArray
) -> FloatingOrNDArray:
"""Compute the :math:`d` term."""
return (1.708 * y + 0.404 - 1.481 * x) / y
c_t, d_t = c(u_t, v_t), d(u_t, v_t)
c_r, d_r = c(u_r, v_r), d(u_r, v_r)
tcs_c, tcs_d = c(u_tcs, v_tcs), d(u_tcs, v_tcs)
u_tcs = (
10.872 + 0.404 * c_r / c_t * tcs_c - 4 * d_r / d_t * tcs_d
) / (16.518 + 1.481 * c_r / c_t * tcs_c - d_r / d_t * tcs_d)
v_tcs = 5.52 / (
16.518 + 1.481 * c_r / c_t * tcs_c - d_r / d_t * tcs_d
)
W_tcs = 25 * spow(xyY_tcs[-1], 1 / 3) - 17
U_tcs = 13 * W_tcs * (u_tcs - u_r)
V_tcs = 13 * W_tcs * (v_tcs - v_r)
tcs_data.append(
TCS_ColorimetryData(
sd_tcs.name, XYZ_tcs, uv_tcs, np.array([U_tcs, V_tcs, W_tcs])
)
)
return tuple(tcs_data)
def XYZ_to_UVW(
XYZ,
illuminant=ILLUMINANTS['CIE 1931 2 Degree Standard Observer']['D65']):
"""
Converts from *CIE XYZ* tristimulus values to *CIE 1964 U\\*V\\*W\\**
colourspace.
Parameters
----------
XYZ : array_like
*CIE XYZ* tristimulus values.
illuminant : array_like, optional
Reference *illuminant* *CIE xy* chromaticity coordinates or *CIE xyY*
colourspace array.
Returns
-------
ndarray
*CIE 1964 U\\*V\\*W\\** colourspace array.
Warning
-------
The input domain and output range of that definition are non standard!
Notes
-----
+----------------+-----------------------+-----------------+
| **Domain** | **Scale - Reference** | **Scale - 1** |
+================+=======================+=================+
| ``XYZ`` | [0, 1] | [0, 1] |
+----------------+-----------------------+-----------------+
| ``illuminant`` | [0, 1] | [0, 1] |
+----------------+-----------------------+-----------------+
+----------------+-----------------------+-----------------+
| **Range** | **Scale - Reference** | **Scale - 1** |
+================+=======================+=================+
| ``UVW`` | ``U`` : [-100, 100] | ``U`` : [-1, 1] |
| | | |
| | ``V`` : [-100, 100] | ``V`` : [-1, 1] |
| | | |
| | ``W`` : [0, 100] | ``W`` : [0, 1] |
+----------------+-----------------------+-----------------+
References
----------
:cite:`Wikipedia2008a`
Examples
--------
>>> import numpy as np
>>> XYZ = np.array([0.20654008, 0.12197225, 0.05136952]) * 100
>>> XYZ_to_UVW(XYZ) # doctest: +ELLIPSIS
array([ 94.5503572..., 11.5553652..., 40.5475740...])
"""
XYZ = to_domain_100(XYZ)
xy = xyY_to_xy(illuminant)
xyY = XYZ_to_xyY(XYZ, xy)
_x, _y, Y = tsplit(xyY)
u, v = tsplit(UCS_to_uv(XYZ_to_UCS(XYZ)))
u_0, v_0 = tsplit(xy_to_UCS_uv(xy))
W = 25 * spow(Y, 1 / 3) - 17
U = 13 * W * (u - u_0)
V = 13 * W * (v - v_0)
UVW = tstack([U, V, W])
return from_range_100(UVW)
def colour_quality_scale(sd_test,
additional_data=False,
method='NIST CQS 9.0'):
"""
Returns the *Colour Quality Scale* (CQS) of given spectral distribution
using given method.
Parameters
----------
sd_test : SpectralDistribution
Test spectral distribution.
additional_data : bool, optional
Whether to output additional data.
method : unicode, optional
**{'NIST CQS 9.0', 'NIST CQS 7.4'}**,
Computation method.
Returns
-------
numeric or ColourRendering_Specification_CQS
Color quality scale.
References
----------
:cite:`Davis2010a`, :cite:`Ohno2008a`, :cite:`Ohno2013`
Examples
--------
>>> from colour import SDS_ILLUMINANTS
>>> sd = SDS_ILLUMINANTS['FL2']
>>> colour_quality_scale(sd) # doctest: +ELLIPSIS
64.1117031...
"""
method = method.lower()
assert method.lower() in [
m.lower() for m in COLOUR_QUALITY_SCALE_METHODS
], ('"{0}" method is invalid, must be one of {1}!'.format(
method, COLOUR_QUALITY_SCALE_METHODS))
cmfs = MSDS_CMFS_STANDARD_OBSERVER[
'CIE 1931 2 Degree Standard Observer'].copy().trim(
SPECTRAL_SHAPE_DEFAULT)
shape = cmfs.shape
sd_test = sd_test.copy().align(shape)
vs_sds = {
sd.name: sd.copy().align(shape)
for sd in SDS_VS[method].values()
}
with domain_range_scale('1'):
XYZ = sd_to_XYZ(sd_test, cmfs)
uv = UCS_to_uv(XYZ_to_UCS(XYZ))
CCT, _D_uv = uv_to_CCT_Ohno2013(uv)
if CCT < 5000:
sd_reference = sd_blackbody(CCT, shape)
else:
xy = CCT_to_xy_CIE_D(CCT)
sd_reference = sd_CIE_illuminant_D_series(xy)
sd_reference.align(shape)
test_vs_colorimetry_data = vs_colorimetry_data(sd_test,
sd_reference,
vs_sds,
cmfs,
chromatic_adaptation=True)
reference_vs_colorimetry_data = vs_colorimetry_data(
sd_reference, sd_reference, vs_sds, cmfs)
if method == 'nist cqs 9.0':
CCT_f = 1
scaling_f = 3.2
else:
XYZ_r = sd_to_XYZ(sd_reference, cmfs)
XYZ_r /= XYZ_r[1]
CCT_f = CCT_factor(reference_vs_colorimetry_data, XYZ_r)
scaling_f = 3.104
Q_as = colour_quality_scales(test_vs_colorimetry_data,
reference_vs_colorimetry_data, scaling_f,
CCT_f)
D_E_RMS = delta_E_RMS(Q_as, 'D_E_ab')
D_Ep_RMS = delta_E_RMS(Q_as, 'D_Ep_ab')
Q_a = scale_conversion(D_Ep_RMS, CCT_f, scaling_f)
if method == 'nist cqs 9.0':
scaling_f = 2.93 * 1.0343
else:
scaling_f = 2.928
Q_f = scale_conversion(D_E_RMS, CCT_f, scaling_f)
G_t = gamut_area(
[vs_CQS_data.Lab for vs_CQS_data in test_vs_colorimetry_data])
G_r = gamut_area(
[vs_CQS_data.Lab for vs_CQS_data in reference_vs_colorimetry_data])
Q_g = G_t / GAMUT_AREA_D65 * 100
if method == 'nist cqs 9.0':
Q_d = Q_p = None
else:
p_delta_C = np.average([
sample_data.D_C_ab if sample_data.D_C_ab > 0 else 0
for sample_data in Q_as.values()
])
Q_p = 100 - 3.6 * (D_Ep_RMS - p_delta_C)
Q_d = G_t / G_r * CCT_f * 100
if additional_data:
return ColourRendering_Specification_CQS(
sd_test.name, Q_a, Q_f, Q_p, Q_g, Q_d, Q_as,
(test_vs_colorimetry_data, reference_vs_colorimetry_data))
else:
return Q_a
def colour_rendering_index(
sd_test: SpectralDistribution, additional_data: Boolean = False
) -> Union[Floating, ColourRendering_Specification_CRI]:
"""
Return the *Colour Rendering Index* (CRI) :math:`Q_a` of given spectral
distribution.
Parameters
----------
sd_test
Test spectral distribution.
additional_data
Whether to output additional data.
Returns
-------
:class:`numpy.floating` or \
:class:`colour.quality.ColourRendering_Specification_CRI`
*Colour Rendering Index* (CRI).
References
----------
:cite:`Ohno2008a`
Examples
--------
>>> from colour import SDS_ILLUMINANTS
>>> sd = SDS_ILLUMINANTS['FL2']
>>> colour_rendering_index(sd) # doctest: +ELLIPSIS
64.2337241...
"""
# pylint: disable=E1102
cmfs = reshape_msds(
MSDS_CMFS["CIE 1931 2 Degree Standard Observer"],
SPECTRAL_SHAPE_DEFAULT,
)
shape = cmfs.shape
sd_test = reshape_sd(sd_test, shape)
tcs_sds = {sd.name: reshape_sd(sd, shape) for sd in SDS_TCS.values()}
with domain_range_scale("1"):
XYZ = sd_to_XYZ(sd_test, cmfs)
uv = UCS_to_uv(XYZ_to_UCS(XYZ))
CCT, _D_uv = uv_to_CCT_Robertson1968(uv)
if CCT < 5000:
sd_reference = sd_blackbody(CCT, shape)
else:
xy = CCT_to_xy_CIE_D(CCT)
sd_reference = sd_CIE_illuminant_D_series(xy)
sd_reference.align(shape)
test_tcs_colorimetry_data = tcs_colorimetry_data(
sd_test, sd_reference, tcs_sds, cmfs, chromatic_adaptation=True
)
reference_tcs_colorimetry_data = tcs_colorimetry_data(
sd_reference, sd_reference, tcs_sds, cmfs
)
Q_as = colour_rendering_indexes(
test_tcs_colorimetry_data, reference_tcs_colorimetry_data
)
Q_a = as_float_scalar(
np.average(
[v.Q_a for k, v in Q_as.items() if k in (1, 2, 3, 4, 5, 6, 7, 8)]
)
)
if additional_data:
return ColourRendering_Specification_CRI(
sd_test.name,
Q_a,
Q_as,
(test_tcs_colorimetry_data, reference_tcs_colorimetry_data),
)
else:
return Q_a
def RGB_colourspaces_CIE_1960_UCS_chromaticity_diagram_plot(
colourspaces=None,
cmfs='CIE 1931 2 Degree Standard Observer',
**kwargs):
"""
Plots given *RGB* colourspaces in *CIE 1960 UCS Chromaticity Diagram*.
Parameters
----------
colourspaces : array_like, optional
*RGB* colourspaces to plot.
cmfs : unicode, optional
Standard observer colour matching functions used for diagram bounds.
\**kwargs : dict, optional
Keywords arguments.
Returns
-------
Figure
Current figure or None.
Examples
--------
>>> c = ['Rec. 709', 'ACEScg', 'S-Gamut']
>>> RGB_colourspaces_CIE_1960_UCS_chromaticity_diagram_plot(
... c) # doctest: +SKIP
"""
settings = {'figure_size': (DEFAULT_FIGURE_WIDTH, DEFAULT_FIGURE_WIDTH)}
settings.update(kwargs)
canvas(**settings)
if colourspaces is None:
colourspaces = ('Rec. 709', 'ACEScg', 'S-Gamut', 'Pointer Gamut')
cmfs, name = get_cmfs(cmfs), cmfs
settings = {
'title':
'{0} - {1} - CIE 1960 UCS Chromaticity Diagram'.format(
', '.join(colourspaces), name),
'standalone':
False
}
settings.update(kwargs)
CIE_1960_UCS_chromaticity_diagram_plot(**settings)
x_limit_min, x_limit_max = [-0.1], [0.7]
y_limit_min, y_limit_max = [-0.2], [0.6]
settings = {
'colour_cycle_map': 'rainbow',
'colour_cycle_count': len(colourspaces)
}
settings.update(kwargs)
cycle = colour_cycle(**settings)
for colourspace in colourspaces:
if colourspace == 'Pointer Gamut':
uv = UCS_to_uv(XYZ_to_UCS(xy_to_XYZ(POINTER_GAMUT_BOUNDARIES)))
alpha_p, colour_p = 0.85, '0.95'
pylab.plot(uv[..., 0],
uv[..., 1],
label='Pointer\'s Gamut',
color=colour_p,
alpha=alpha_p,
linewidth=2)
pylab.plot((uv[-1][0], uv[0][0]), (uv[-1][1], uv[0][1]),
color=colour_p,
alpha=alpha_p,
linewidth=2)
XYZ = Lab_to_XYZ(LCHab_to_Lab(POINTER_GAMUT_DATA),
POINTER_GAMUT_ILLUMINANT)
uv = UCS_to_uv(XYZ_to_UCS(XYZ))
pylab.scatter(uv[..., 0],
uv[..., 1],
alpha=alpha_p / 2,
color=colour_p,
marker='+')
else:
colourspace, name = get_RGB_colourspace(colourspace), colourspace
r, g, b, _a = next(cycle)
# RGB colourspaces such as *ACES2065-1* have primaries with
# chromaticity coordinates set to 0 thus we prevent nan from being
# yield by zero division in later colour transformations.
primaries = np.where(colourspace.primaries == 0, EPSILON,
colourspace.primaries)
primaries = UCS_to_uv(XYZ_to_UCS(xy_to_XYZ(primaries)))
whitepoint = UCS_to_uv(
XYZ_to_UCS(xy_to_XYZ(colourspace.whitepoint)))
pylab.plot((whitepoint[0], whitepoint[0]),
(whitepoint[1], whitepoint[1]),
color=(r, g, b),
label=colourspace.name,
linewidth=2)
pylab.plot((whitepoint[0], whitepoint[0]),
(whitepoint[1], whitepoint[1]),
'o',
color=(r, g, b),
linewidth=2)
pylab.plot((primaries[0, 0], primaries[1, 0]),
(primaries[0, 1], primaries[1, 1]),
'o-',
color=(r, g, b),
linewidth=2)
pylab.plot((primaries[1, 0], primaries[2, 0]),
(primaries[1, 1], primaries[2, 1]),
'o-',
color=(r, g, b),
linewidth=2)
pylab.plot((primaries[2, 0], primaries[0, 0]),
(primaries[2, 1], primaries[0, 1]),
'o-',
color=(r, g, b),
linewidth=2)
x_limit_min.append(np.amin(primaries[..., 0]) - 0.1)
y_limit_min.append(np.amin(primaries[..., 1]) - 0.1)
x_limit_max.append(np.amax(primaries[..., 0]) + 0.1)
y_limit_max.append(np.amax(primaries[..., 1]) + 0.1)
settings.update({
'legend':
True,
'legend_location':
'upper right',
'x_tighten':
True,
'y_tighten':
True,
'limits': (min(x_limit_min), max(x_limit_max), min(y_limit_min),
max(y_limit_max)),
'standalone':
True
})
settings.update(kwargs)
boundaries(**settings)
decorate(**settings)
return display(**settings)
def plot_chromaticity_diagram_colours(
samples=256,
diagram_opacity=1.0,
diagram_clipping_path=None,
cmfs='CIE 1931 2 Degree Standard Observer',
method='CIE 1931',
**kwargs):
"""
Plots the *Chromaticity Diagram* colours according to given method.
Parameters
----------
samples : numeric, optional
Samples count on one axis.
diagram_opacity : numeric, optional
Opacity of the *Chromaticity Diagram* colours.
diagram_clipping_path : array_like, optional
Path of points used to clip the *Chromaticity Diagram* colours.
cmfs : unicode, optional
Standard observer colour matching functions used for
*Chromaticity Diagram* bounds.
method : unicode, optional
**{'CIE 1931', 'CIE 1960 UCS', 'CIE 1976 UCS'}**,
*Chromaticity Diagram* method.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`, :func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> plot_chromaticity_diagram_colours() # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, \
<matplotlib.axes._subplots.AxesSubplot object at 0x...>)
.. image:: ../_static/Plotting_Plot_Chromaticity_Diagram_Colours.png
:align: center
:alt: plot_chromaticity_diagram_colours
"""
settings = {'uniform': True}
settings.update(kwargs)
_figure, axes = artist(**settings)
method = method.upper()
cmfs = first_item(filter_cmfs(cmfs).values())
illuminant = COLOUR_STYLE_CONSTANTS.colour.colourspace.whitepoint
ii, jj = np.meshgrid(np.linspace(0, 1, samples),
np.linspace(1, 0, samples))
ij = tstack([ii, jj])
# NOTE: Various values in the grid have potential to generate
# zero-divisions, they could be avoided by perturbing the grid, e.g. adding
# a small epsilon. It was decided instead to disable warnings.
with suppress_warnings(python_warnings=True):
if method == 'CIE 1931':
XYZ = xy_to_XYZ(ij)
spectral_locus = XYZ_to_xy(cmfs.values, illuminant)
elif method == 'CIE 1960 UCS':
XYZ = xy_to_XYZ(UCS_uv_to_xy(ij))
spectral_locus = UCS_to_uv(XYZ_to_UCS(cmfs.values))
elif method == 'CIE 1976 UCS':
XYZ = xy_to_XYZ(Luv_uv_to_xy(ij))
spectral_locus = Luv_to_uv(XYZ_to_Luv(cmfs.values, illuminant),
illuminant)
else:
raise ValueError(
'Invalid method: "{0}", must be one of '
'{{\'CIE 1931\', \'CIE 1960 UCS\', \'CIE 1976 UCS\'}}'.format(
method))
RGB = normalise_maximum(XYZ_to_plotting_colourspace(XYZ, illuminant),
axis=-1)
polygon = Polygon(spectral_locus if diagram_clipping_path is None else
diagram_clipping_path,
facecolor='none',
edgecolor='none')
axes.add_patch(polygon)
# Preventing bounding box related issues as per
# https://github.com/matplotlib/matplotlib/issues/10529
image = axes.imshow(RGB,
interpolation='bilinear',
extent=(0, 1, 0, 1),
clip_path=None,
alpha=diagram_opacity)
image.set_clip_path(polygon)
settings = {'axes': axes}
settings.update(kwargs)
return render(**kwargs)
def CIE_1960_UCS_chromaticity_diagram_colours_plot(
surface=1.25,
spacing=0.00075,
cmfs='CIE 1931 2 Degree Standard Observer',
**kwargs):
"""
Plots the *CIE 1960 UCS Chromaticity Diagram* colours.
Parameters
----------
surface : numeric, optional
Generated markers surface.
spacing : numeric, optional
Spacing between markers.
cmfs : unicode, optional
Standard observer colour matching functions used for diagram bounds.
\*\*kwargs : \*\*
Keywords arguments.
Returns
-------
bool
Definition success.
Examples
--------
>>> CIE_1960_UCS_chromaticity_diagram_colours_plot() # doctest: +SKIP
True
"""
cmfs, name = get_cmfs(cmfs), cmfs
illuminant = ILLUMINANTS.get('CIE 1931 2 Degree Standard Observer').get(
'E')
UVWs = [XYZ_to_UCS(value) for key, value in cmfs]
u, v = tuple(zip(*([UCS_to_uv(x) for x in UVWs])))
path = matplotlib.path.Path(tuple(zip(u, v)))
x_dot, y_dot, colours = [], [], []
for i in np.arange(0, 1, spacing):
for j in np.arange(0, 1, spacing):
if path.contains_path(matplotlib.path.Path([[i, j], [i, j]])):
x_dot.append(i)
y_dot.append(j)
XYZ = xy_to_XYZ(UCS_uv_to_xy((i, j)))
RGB = normalise(XYZ_to_sRGB(XYZ, illuminant))
colours.append(RGB)
pylab.scatter(x_dot, y_dot, color=colours, s=surface)
settings = {
'no_ticks': True,
'bounding_box': [0, 1, 0, 1],
'bbox_inches': 'tight',
'pad_inches': 0
}
settings.update(kwargs)
bounding_box(**settings)
aspect(**settings)
return display(**settings)
def colour_rendering_index(spd_test, additional_data=False):
"""
Returns the *Colour Rendering Index* (CRI) :math:`Q_a` of given spectral
power distribution.
Parameters
----------
spd_test : SpectralPowerDistribution
Test spectral power distribution.
additional_data : bool, optional
Output additional data.
Returns
-------
numeric or CRI_Specification
*Colour Rendering Index* (CRI).
Examples
--------
>>> from colour import ILLUMINANTS_RELATIVE_SPDS
>>> spd = ILLUMINANTS_RELATIVE_SPDS['F2']
>>> colour_rendering_index(spd) # doctest: +ELLIPSIS
64.1515202...
"""
cmfs = STANDARD_OBSERVERS_CMFS[
'CIE 1931 2 Degree Standard Observer'].clone().trim_wavelengths(
ASTME30815_PRACTISE_SHAPE)
shape = cmfs.shape
spd_test = spd_test.clone().align(shape)
tcs_spds = {
spd.name: spd.clone().align(shape)
for spd in TCS_SPDS.values()
}
XYZ = spectral_to_XYZ(spd_test, cmfs)
uv = UCS_to_uv(XYZ_to_UCS(XYZ))
CCT, _D_uv = uv_to_CCT_Robertson1968(uv)
if CCT < 5000:
spd_reference = blackbody_spd(CCT, shape)
else:
xy = CCT_to_xy_CIE_D(CCT)
spd_reference = D_illuminant_relative_spd(xy)
spd_reference.align(shape)
test_tcs_colorimetry_data = tcs_colorimetry_data(spd_test,
spd_reference,
tcs_spds,
cmfs,
chromatic_adaptation=True)
reference_tcs_colorimetry_data = tcs_colorimetry_data(
spd_reference, spd_reference, tcs_spds, cmfs)
Q_as = colour_rendering_indexes(test_tcs_colorimetry_data,
reference_tcs_colorimetry_data)
Q_a = np.average(
[v.Q_a for k, v in Q_as.items() if k in (1, 2, 3, 4, 5, 6, 7, 8)])
if additional_data:
return CRI_Specification(
spd_test.name, Q_a, Q_as,
(test_tcs_colorimetry_data, reference_tcs_colorimetry_data))
else:
return Q_a
def XYZ_to_colourspace_model(XYZ, illuminant, model):
"""
Converts from *CIE XYZ* tristimulus values to given colourspace model.
Parameters
----------
XYZ : array_like
*CIE XYZ* tristimulus values.
illuminant : array_like
*CIE XYZ* tristimulus values *illuminant* *xy* chromaticity
coordinates.
model : unicode
**{'CIE XYZ', 'CIE xyY', 'CIE xy', 'CIE Lab', 'CIE LCHab', 'CIE Luv',
'CIE Luv uv', 'CIE LCHuv', 'CIE UCS', 'CIE UCS uv', 'CIE UVW', 'IPT',
'Hunter Lab', 'Hunter Rdab'}**,
Colourspace model to convert the *CIE XYZ* tristimulus values to.
Returns
-------
ndarray
Colourspace model values.
Examples
--------
>>> import numpy as np
>>> XYZ = np.array([0.07049534, 0.10080000, 0.09558313])
>>> W = np.array([0.34570, 0.35850])
>>> XYZ_to_colourspace_model( # doctest: +ELLIPSIS
... XYZ, W, 'CIE XYZ')
array([ 0.0704953..., 0.1008 , 0.0955831...])
>>> XYZ_to_colourspace_model( # doctest: +ELLIPSIS
... XYZ, W, 'CIE xyY')
array([ 0.2641477..., 0.3777000..., 0.1008 ])
>>> XYZ_to_colourspace_model( # doctest: +ELLIPSIS
... XYZ, W, 'CIE xy')
array([ 0.2641477..., 0.3777000...])
>>> XYZ_to_colourspace_model( # doctest: +ELLIPSIS
... XYZ, W, 'CIE Lab')
array([ 37.9856291..., -23.6290768..., -4.4174661...])
>>> XYZ_to_colourspace_model( # doctest: +ELLIPSIS
... XYZ, W, 'CIE LCHab')
array([ 37.9856291..., 24.0384542..., 190.5892337...])
>>> XYZ_to_colourspace_model( # doctest: +ELLIPSIS
... XYZ, W, 'CIE Luv')
array([ 37.9856291..., -28.8021959..., -1.3580070...])
>>> XYZ_to_colourspace_model( # doctest: +ELLIPSIS
... XYZ, W, 'CIE Luv uv')
array([ 0.1508531..., 0.4853297...])
>>> XYZ_to_colourspace_model( # doctest: +ELLIPSIS
... XYZ, W, 'CIE LCHuv')
array([ 37.9856291..., 28.8341927..., 182.6994640...])
>>> XYZ_to_colourspace_model( # doctest: +ELLIPSIS
... XYZ, W, 'CIE UCS uv')
array([ 0.1508531..., 0.32355314...])
>>> XYZ_to_colourspace_model( # doctest: +ELLIPSIS
... XYZ, W, 'CIE UVW')
array([-28.0579733..., -0.8819449..., 37.0041149...])
>>> XYZ_to_colourspace_model( # doctest: +ELLIPSIS
... XYZ, W, 'IPT')
array([ 0.3657112..., -0.1111479..., 0.0159474...])
>>> XYZ_to_colourspace_model( # doctest: +ELLIPSIS
... XYZ, W, 'Hunter Lab')
array([ 31.7490157..., -15.1351736..., -2.7709606...])
>>> XYZ_to_colourspace_model( # doctest: +ELLIPSIS
... XYZ, W, 'Hunter Rdab')
array([ 10.08..., -18.7019271..., -3.4239649...])
"""
values = None
if model == 'CIE XYZ':
values = XYZ
elif model == 'CIE xyY':
values = XYZ_to_xyY(XYZ, illuminant)
elif model == 'CIE xy':
values = XYZ_to_xy(XYZ, illuminant)
elif model == 'CIE Lab':
values = XYZ_to_Lab(XYZ, illuminant)
elif model == 'CIE LCHab':
values = Lab_to_LCHab(XYZ_to_Lab(XYZ, illuminant))
elif model == 'CIE Luv':
values = XYZ_to_Luv(XYZ, illuminant)
elif model == 'CIE Luv uv':
values = Luv_to_uv(XYZ_to_Luv(XYZ, illuminant), illuminant)
elif model == 'CIE LCHuv':
values = Luv_to_LCHuv(XYZ_to_Luv(XYZ, illuminant))
elif model == 'CIE UCS':
values = XYZ_to_UCS(XYZ)
elif model == 'CIE UCS uv':
values = UCS_to_uv(XYZ_to_UCS(XYZ))
elif model == 'CIE UVW':
values = XYZ_to_UVW(XYZ * 100, illuminant)
elif model == 'IPT':
values = XYZ_to_IPT(XYZ)
elif model == 'Hunter Lab':
values = XYZ_to_Hunter_Lab(XYZ * 100, xy_to_XYZ(illuminant) * 100)
elif model == 'Hunter Rdab':
values = XYZ_to_Hunter_Rdab(XYZ * 100, xy_to_XYZ(illuminant) * 100)
if values is None:
raise ValueError(
'"{0}" not found in colourspace models: "{1}".'.format(
model, ', '.join(COLOURSPACE_MODELS)))
return values
def colour_quality_scale(
sd_test: SpectralDistribution,
additional_data: Boolean = False,
method: Union[Literal["NIST CQS 7.4", "NIST CQS 9.0"],
str] = "NIST CQS 9.0",
) -> Union[Floating, ColourRendering_Specification_CQS]:
"""
Return the *Colour Quality Scale* (CQS) of given spectral distribution
using given method.
Parameters
----------
sd_test
Test spectral distribution.
additional_data
Whether to output additional data.
method
Computation method.
Returns
-------
:class:`numpy.floating` or \
:class:`colour.quality.ColourRendering_Specification_CQS`
*Colour Quality Scale* (CQS).
References
----------
:cite:`Davis2010a`, :cite:`Ohno2008a`, :cite:`Ohno2013`
Examples
--------
>>> from colour import SDS_ILLUMINANTS
>>> sd = SDS_ILLUMINANTS['FL2']
>>> colour_quality_scale(sd) # doctest: +ELLIPSIS
64.1117031...
"""
method = validate_method(method, COLOUR_QUALITY_SCALE_METHODS)
# pylint: disable=E1102
cmfs = reshape_msds(
MSDS_CMFS["CIE 1931 2 Degree Standard Observer"],
SPECTRAL_SHAPE_DEFAULT,
)
shape = cmfs.shape
sd_test = reshape_sd(sd_test, shape)
vs_sds = {sd.name: reshape_sd(sd, shape) for sd in SDS_VS[method].values()}
with domain_range_scale("1"):
XYZ = sd_to_XYZ(sd_test, cmfs)
uv = UCS_to_uv(XYZ_to_UCS(XYZ))
CCT, _D_uv = uv_to_CCT_Ohno2013(uv)
if CCT < 5000:
sd_reference = sd_blackbody(CCT, shape)
else:
xy = CCT_to_xy_CIE_D(CCT)
sd_reference = sd_CIE_illuminant_D_series(xy)
sd_reference.align(shape)
test_vs_colorimetry_data = vs_colorimetry_data(sd_test,
sd_reference,
vs_sds,
cmfs,
chromatic_adaptation=True)
reference_vs_colorimetry_data = vs_colorimetry_data(
sd_reference, sd_reference, vs_sds, cmfs)
CCT_f: Floating
if method == "nist cqs 9.0":
CCT_f = 1
scaling_f = 3.2
else:
XYZ_r = sd_to_XYZ(sd_reference, cmfs)
XYZ_r /= XYZ_r[1]
CCT_f = CCT_factor(reference_vs_colorimetry_data, XYZ_r)
scaling_f = 3.104
Q_as = colour_quality_scales(
test_vs_colorimetry_data,
reference_vs_colorimetry_data,
scaling_f,
CCT_f,
)
D_E_RMS = delta_E_RMS(Q_as, "D_E_ab")
D_Ep_RMS = delta_E_RMS(Q_as, "D_Ep_ab")
Q_a = scale_conversion(D_Ep_RMS, CCT_f, scaling_f)
if method == "nist cqs 9.0":
scaling_f = 2.93 * 1.0343
else:
scaling_f = 2.928
Q_f = scale_conversion(D_E_RMS, CCT_f, scaling_f)
G_t = gamut_area(
[vs_CQS_data.Lab for vs_CQS_data in test_vs_colorimetry_data])
G_r = gamut_area(
[vs_CQS_data.Lab for vs_CQS_data in reference_vs_colorimetry_data])
Q_g = G_t / GAMUT_AREA_D65 * 100
if method == "nist cqs 9.0":
Q_p = Q_d = None
else:
p_delta_C = np.average([
sample_data.D_C_ab if sample_data.D_C_ab > 0 else 0
for sample_data in Q_as.values()
])
Q_p = as_float_scalar(100 - 3.6 * (D_Ep_RMS - p_delta_C))
Q_d = as_float_scalar(G_t / G_r * CCT_f * 100)
if additional_data:
return ColourRendering_Specification_CQS(
sd_test.name,
Q_a,
Q_f,
Q_p,
Q_g,
Q_d,
Q_as,
(test_vs_colorimetry_data, reference_vs_colorimetry_data),
)
else:
return Q_a
def planckian_locus_chromaticity_diagram_plot_CIE1960UCS(
illuminants=None,
chromaticity_diagram_callable_CIE1960UCS=(
chromaticity_diagram_plot_CIE1960UCS),
**kwargs):
"""
Plots the planckian locus and given illuminants in
*CIE 1960 UCS Chromaticity Diagram*.
Parameters
----------
illuminants : array_like, optional
Factory illuminants to plot.
chromaticity_diagram_callable_CIE1960UCS : callable, optional
Callable responsible for drawing the
*CIE 1960 UCS Chromaticity Diagram*.
Other Parameters
----------------
\**kwargs : dict, optional
{:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definition.
show_diagram_colours : bool, optional
{:func:`colour.plotting.chromaticity_diagram_plot_CIE1960UCS`},
Whether to display the chromaticity diagram background colours.
use_cached_diagram_colours : bool, optional
{:func:`colour.plotting.chromaticity_diagram_plot_CIE1960UCS`},
Whether to used the cached chromaticity diagram background colours
image.
Returns
-------
Figure
Current figure or None.
Raises
------
KeyError
If one of the given illuminant is not found in the factory illuminants.
Examples
--------
>>> planckian_locus_chromaticity_diagram_plot_CIE1960UCS(['A', 'C', 'E'])
... # doctest: +SKIP
"""
if illuminants is None:
illuminants = ('A', 'C', 'E')
cmfs = CMFS['CIE 1931 2 Degree Standard Observer']
settings = {
'title': ('{0} Illuminants - Planckian Locus\n'
'CIE 1960 UCS Chromaticity Diagram - '
'CIE 1931 2 Degree Standard Observer').format(
', '.join(illuminants)) if illuminants else
('Planckian Locus\nCIE 1960 UCS Chromaticity Diagram - '
'CIE 1931 2 Degree Standard Observer'),
'standalone':
False
}
settings.update(kwargs)
chromaticity_diagram_callable_CIE1960UCS(**settings)
start, end = 1667, 100000
uv = np.array(
[CCT_to_uv(x, 'Robertson 1968', D_uv=0)
for x in np.arange(start, end + 250, 250)]) # yapf: disable
pylab.plot(uv[..., 0], uv[..., 1], color='black', linewidth=1)
for i in (1667, 2000, 2500, 3000, 4000, 6000, 10000):
u0, v0 = CCT_to_uv(i, 'Robertson 1968', D_uv=-0.05)
u1, v1 = CCT_to_uv(i, 'Robertson 1968', D_uv=0.05)
pylab.plot((u0, u1), (v0, v1), color='black', linewidth=1)
pylab.annotate('{0}K'.format(i),
xy=(u0, v0),
xytext=(0, -10),
color='black',
textcoords='offset points',
size='x-small')
for illuminant in illuminants:
xy = ILLUMINANTS.get(cmfs.name).get(illuminant)
if xy is None:
raise KeyError(
('Illuminant "{0}" not found in factory illuminants: '
'"{1}".').format(illuminant,
sorted(ILLUMINANTS[cmfs.name].keys())))
uv = UCS_to_uv(XYZ_to_UCS(xy_to_XYZ(xy)))
pylab.plot(uv[0], uv[1], 'o', color='white', linewidth=1)
pylab.annotate(illuminant,
xy=(uv[0], uv[1]),
xytext=(-50, 30),
color='black',
textcoords='offset points',
arrowprops=dict(arrowstyle='->',
connectionstyle='arc3, rad=-0.2'))
settings.update({
'x_tighten': True,
'y_tighten': True,
'limits': (-0.1, 0.7, -0.2, 0.6),
'standalone': True
})
settings.update(kwargs)
return render(**settings)
def CCT_to_uv_Ohno2013(
CCT,
D_uv=0,
cmfs=STANDARD_OBSERVERS_CMFS['CIE 1931 2 Degree Standard Observer']):
"""
Returns the *CIE UCS* colourspace *uv* chromaticity coordinates from given
correlated colour temperature :math:`T_{cp}`, :math:`\\Delta_{uv}` and
colour matching functions using *Ohno (2013)* method.
Parameters
----------
CCT : numeric
Correlated colour temperature :math:`T_{cp}`.
D_uv : numeric, optional
:math:`\\Delta_{uv}`.
cmfs : XYZ_ColourMatchingFunctions, optional
Standard observer colour matching functions.
Returns
-------
ndarray
*CIE UCS* colourspace *uv* chromaticity coordinates.
References
----------
:cite:`Ohno2014a`
Examples
--------
>>> from colour import STANDARD_OBSERVERS_CMFS
>>> cmfs = STANDARD_OBSERVERS_CMFS['CIE 1931 2 Degree Standard Observer']
>>> CCT = 6507.4342201047066
>>> D_uv = 0.003223690901513
>>> CCT_to_uv_Ohno2013(CCT, D_uv, cmfs) # doctest: +ELLIPSIS
array([ 0.1977999..., 0.3122004...])
"""
cmfs = cmfs.copy().trim(ASTME30815_PRACTISE_SHAPE)
shape = cmfs.shape
delta = 0.01
sd = sd_blackbody(CCT, shape)
XYZ = sd_to_XYZ(sd, cmfs)
XYZ *= 1 / np.max(XYZ)
UVW = XYZ_to_UCS(XYZ)
u0, v0 = UCS_to_uv(UVW)
if D_uv == 0:
return np.array([u0, v0])
else:
sd = sd_blackbody(CCT + delta, shape)
XYZ = sd_to_XYZ(sd, cmfs)
XYZ *= 1 / np.max(XYZ)
UVW = XYZ_to_UCS(XYZ)
u1, v1 = UCS_to_uv(UVW)
du = u0 - u1
dv = v0 - v1
u = u0 - D_uv * (dv / np.hypot(du, dv))
v = v0 + D_uv * (du / np.hypot(du, dv))
return np.array([u, v])
def plot_spectral_locus(cmfs='CIE 1931 2 Degree Standard Observer',
spectral_locus_colours=None,
spectral_locus_labels=None,
method='CIE 1931',
**kwargs):
"""
Plots the *Spectral Locus* according to given method.
Parameters
----------
cmfs : unicode, optional
Standard observer colour matching functions defining the
*Spectral Locus*.
spectral_locus_colours : array_like or unicode, optional
*Spectral Locus* colours, if ``spectral_locus_colours`` is set to
*RGB*, the colours will be computed according to the corresponding
chromaticity coordinates.
spectral_locus_labels : array_like, optional
Array of wavelength labels used to customise which labels will be drawn
around the spectral locus. Passing an empty array will result in no
wavelength labels being drawn.
method : unicode, optional
**{'CIE 1931', 'CIE 1960 UCS', 'CIE 1976 UCS'}**,
*Chromaticity Diagram* method.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`, :func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> plot_spectral_locus(spectral_locus_colours='RGB') # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, \
<matplotlib.axes._subplots.AxesSubplot object at 0x...>)
.. image:: ../_static/Plotting_Plot_Spectral_Locus.png
:align: center
:alt: plot_spectral_locus
"""
if spectral_locus_colours is None:
spectral_locus_colours = COLOUR_STYLE_CONSTANTS.colour.dark
settings = {'uniform': True}
settings.update(kwargs)
_figure, axes = artist(**settings)
method = method.upper()
cmfs = first_item(filter_cmfs(cmfs).values())
illuminant = COLOUR_STYLE_CONSTANTS.colour.colourspace.whitepoint
wavelengths = cmfs.wavelengths
equal_energy = np.array([1 / 3] * 2)
if method == 'CIE 1931':
ij = XYZ_to_xy(cmfs.values, illuminant)
labels = ((390, 460, 470, 480, 490, 500, 510, 520, 540, 560, 580, 600,
620, 700)
if spectral_locus_labels is None else spectral_locus_labels)
elif method == 'CIE 1960 UCS':
ij = UCS_to_uv(XYZ_to_UCS(cmfs.values))
labels = ((420, 440, 450, 460, 470, 480, 490, 500, 510, 520, 530, 540,
550, 560, 570, 580, 590, 600, 610, 620, 630, 645, 680)
if spectral_locus_labels is None else spectral_locus_labels)
elif method == 'CIE 1976 UCS':
ij = Luv_to_uv(XYZ_to_Luv(cmfs.values, illuminant), illuminant)
labels = ((420, 440, 450, 460, 470, 480, 490, 500, 510, 520, 530, 540,
550, 560, 570, 580, 590, 600, 610, 620, 630, 645, 680)
if spectral_locus_labels is None else spectral_locus_labels)
else:
raise ValueError(
'Invalid method: "{0}", must be one of '
'{{\'CIE 1931\', \'CIE 1960 UCS\', \'CIE 1976 UCS\'}}'.format(
method))
pl_ij = tstack([
np.linspace(ij[0][0], ij[-1][0], 20),
np.linspace(ij[0][1], ij[-1][1], 20)
]).reshape(-1, 1, 2)
sl_ij = np.copy(ij).reshape(-1, 1, 2)
if spectral_locus_colours.upper() == 'RGB':
spectral_locus_colours = normalise_maximum(XYZ_to_plotting_colourspace(
cmfs.values),
axis=-1)
if method == 'CIE 1931':
XYZ = xy_to_XYZ(pl_ij)
elif method == 'CIE 1960 UCS':
XYZ = xy_to_XYZ(UCS_uv_to_xy(pl_ij))
elif method == 'CIE 1976 UCS':
XYZ = xy_to_XYZ(Luv_uv_to_xy(pl_ij))
purple_line_colours = normalise_maximum(XYZ_to_plotting_colourspace(
XYZ.reshape(-1, 3)),
axis=-1)
else:
purple_line_colours = spectral_locus_colours
for slp_ij, slp_colours in ((pl_ij, purple_line_colours),
(sl_ij, spectral_locus_colours)):
line_collection = LineCollection(np.concatenate(
[slp_ij[:-1], slp_ij[1:]], axis=1),
colors=slp_colours)
axes.add_collection(line_collection)
wl_ij = dict(tuple(zip(wavelengths, ij)))
for label in labels:
i, j = wl_ij[label]
index = bisect.bisect(wavelengths, label)
left = wavelengths[index - 1] if index >= 0 else wavelengths[index]
right = (wavelengths[index]
if index < len(wavelengths) else wavelengths[-1])
dx = wl_ij[right][0] - wl_ij[left][0]
dy = wl_ij[right][1] - wl_ij[left][1]
ij = np.array([i, j])
direction = np.array([-dy, dx])
normal = (np.array([
-dy, dx
]) if np.dot(normalise_vector(ij - equal_energy),
normalise_vector(direction)) > 0 else np.array([dy, -dx]))
normal = normalise_vector(normal) / 30
label_colour = (spectral_locus_colours
if is_string(spectral_locus_colours) else
spectral_locus_colours[index])
axes.plot((i, i + normal[0] * 0.75), (j, j + normal[1] * 0.75),
color=label_colour)
axes.plot(i, j, 'o', color=label_colour)
axes.text(i + normal[0],
j + normal[1],
label,
clip_on=True,
ha='left' if normal[0] >= 0 else 'right',
va='center',
fontdict={'size': 'small'})
settings = {'axes': axes}
settings.update(kwargs)
return render(**kwargs)
def CCT_to_uv_Ohno2013(
CCT,
D_uv=0,
cmfs=STANDARD_OBSERVERS_CMFS['CIE 1931 2 Degree Standard Observer']):
"""
Returns the *CIE UCS* colourspace *uv* chromaticity coordinates from given
correlated colour temperature :math:`T_{cp}`, :math:`\Delta_{uv}` and
colour matching functions using *Ohno (2013)* method.
Parameters
----------
CCT : numeric
Correlated colour temperature :math:`T_{cp}`.
D_uv : numeric, optional
:math:`\Delta_{uv}`.
cmfs : XYZ_ColourMatchingFunctions, optional
Standard observer colour matching functions.
Returns
-------
ndarray
*CIE UCS* colourspace *uv* chromaticity coordinates.
References
----------
.. [4] Ohno, Y. (2014). Practical Use and Calculation of CCT and Duv.
LEUKOS, 10(1), 47–55. doi:10.1080/15502724.2014.839020
Examples
--------
>>> from colour import STANDARD_OBSERVERS_CMFS
>>> cmfs = STANDARD_OBSERVERS_CMFS['CIE 1931 2 Degree Standard Observer']
>>> CCT = 6507.4342201047066
>>> D_uv = 0.003223690901513
>>> CCT_to_uv_Ohno2013(CCT, D_uv, cmfs) # doctest: +ELLIPSIS
array([ 0.1977999..., 0.3122004...])
"""
cmfs = cmfs.clone().trim_wavelengths(ASTME30815_PRACTISE_SHAPE)
shape = cmfs.shape
delta = 0.01
spd = blackbody_spd(CCT, shape)
XYZ = spectral_to_XYZ(spd, cmfs)
XYZ *= 1 / np.max(XYZ)
UVW = XYZ_to_UCS(XYZ)
u0, v0 = UCS_to_uv(UVW)
if D_uv == 0:
return np.array([u0, v0])
else:
spd = blackbody_spd(CCT + delta, shape)
XYZ = spectral_to_XYZ(spd, cmfs)
XYZ *= 1 / np.max(XYZ)
UVW = XYZ_to_UCS(XYZ)
u1, v1 = UCS_to_uv(UVW)
du = u0 - u1
dv = v0 - v1
u = u0 - D_uv * (dv / np.hypot(du, dv))
v = v0 + D_uv * (du / np.hypot(du, dv))
return np.array([u, v])
def CIE_1960_UCS_chromaticity_diagram_plot(
cmfs='CIE 1931 2 Degree Standard Observer', **kwargs):
"""
Plots the *CIE 1960 UCS Chromaticity Diagram*.
Parameters
----------
cmfs : unicode, optional
Standard observer colour matching functions used for diagram bounds.
\*\*kwargs : \*\*
Keywords arguments.
Returns
-------
bool
Definition success.
Examples
--------
>>> CIE_1960_UCS_chromaticity_diagram_plot() # doctest: +SKIP
True
"""
cmfs, name = get_cmfs(cmfs), cmfs
image = matplotlib.image.imread(
os.path.join(
PLOTTING_RESOURCES_DIRECTORY,
'CIE_1960_UCS_Chromaticity_Diagram_{0}_Small.png'.format(
cmfs.name.replace(' ', '_'))))
pylab.imshow(image, interpolation='nearest', extent=(0, 1, 0, 1))
labels = [
420, 430, 440, 450, 460, 470, 480, 490, 500, 510, 520, 530, 540, 550,
560, 570, 580, 590, 600, 610, 620, 630, 640, 680
]
wavelengths = cmfs.wavelengths
equal_energy = np.array([1 / 3] * 2)
UVWs = [XYZ_to_UCS(value) for key, value in cmfs]
u, v = tuple(zip(*([UCS_to_uv(x) for x in UVWs])))
wavelengths_chromaticity_coordinates = dict(
tuple(zip(wavelengths, tuple(zip(u, v)))))
pylab.plot(u, v, color='black', linewidth=2)
pylab.plot((u[-1], u[0]), (v[-1], v[0]), color='black', linewidth=2)
for label in labels:
u, v = wavelengths_chromaticity_coordinates.get(label)
pylab.plot(u, v, 'o', color='black', linewidth=2)
index = bisect.bisect(wavelengths, label)
left = wavelengths[index - 1] if index >= 0 else wavelengths[index]
right = (wavelengths[index]
if index < len(wavelengths) else wavelengths[-1])
dx = (wavelengths_chromaticity_coordinates.get(right)[0] -
wavelengths_chromaticity_coordinates.get(left)[0])
dy = (wavelengths_chromaticity_coordinates.get(right)[1] -
wavelengths_chromaticity_coordinates.get(left)[1])
norme = lambda x: x / np.linalg.norm(x)
uv = np.array([u, v])
direction = np.array((-dy, dx))
normal = (np.array(
(-dy,
dx)) if np.dot(norme(uv - equal_energy), norme(direction)) > 0
else np.array((dy, -dx)))
normal = norme(normal)
normal /= 25
pylab.plot([u, u + normal[0] * 0.75], [v, v + normal[1] * 0.75],
color='black',
linewidth=1.5)
pylab.text(u + normal[0],
v + normal[1],
label,
clip_on=True,
ha='left' if normal[0] >= 0 else 'right',
va='center',
fontdict={'size': 'small'})
settings = {
'title': 'CIE 1960 UCS Chromaticity Diagram - {0}'.format(name),
'x_label': 'CIE u',
'y_label': 'CIE v',
'x_ticker': True,
'y_ticker': True,
'grid': True,
'bounding_box': [-0.075, 0.675, -0.15, 0.6],
'bbox_inches': 'tight',
'pad_inches': 0
}
settings.update(kwargs)
bounding_box(**settings)
aspect(**settings)
return display(**settings)
def tcs_colorimetry_data(spd_t,
spd_r,
spds_tcs,
cmfs,
chromatic_adaptation=False):
"""
Returns the *test colour samples* colorimetry data.
Parameters
----------
spd_t : SpectralPowerDistribution
Test spectral power distribution.
spd_r : SpectralPowerDistribution
Reference spectral power distribution.
spds_tcs : dict
*Test colour samples* spectral power distributions.
cmfs : XYZ_ColourMatchingFunctions
Standard observer colour matching functions.
chromatic_adaptation : bool, optional
Perform chromatic adaptation.
Returns
-------
list
*Test colour samples* colorimetry data.
"""
XYZ_t = spectral_to_XYZ(spd_t, cmfs)
uv_t = UCS_to_uv(XYZ_to_UCS(XYZ_t))
u_t, v_t = uv_t[0], uv_t[1]
XYZ_r = spectral_to_XYZ(spd_r, cmfs)
uv_r = UCS_to_uv(XYZ_to_UCS(XYZ_r))
u_r, v_r = uv_r[0], uv_r[1]
tcs_data = []
for _key, value in sorted(TCS_INDEXES_TO_NAMES.items()):
spd_tcs = spds_tcs[value]
XYZ_tcs = spectral_to_XYZ(spd_tcs, cmfs, spd_t)
xyY_tcs = XYZ_to_xyY(XYZ_tcs)
uv_tcs = UCS_to_uv(XYZ_to_UCS(XYZ_tcs))
u_tcs, v_tcs = uv_tcs[0], uv_tcs[1]
if chromatic_adaptation:
def c(x, y):
"""
Computes the :math:`c` term.
"""
return (4 - x - 10 * y) / y
def d(x, y):
"""
Computes the :math:`d` term.
"""
return (1.708 * y + 0.404 - 1.481 * x) / y
c_t, d_t = c(u_t, v_t), d(u_t, v_t)
c_r, d_r = c(u_r, v_r), d(u_r, v_r)
tcs_c, tcs_d = c(u_tcs, v_tcs), d(u_tcs, v_tcs)
u_tcs = (
(10.872 + 0.404 * c_r / c_t * tcs_c - 4 * d_r / d_t * tcs_d) /
(16.518 + 1.481 * c_r / c_t * tcs_c - d_r / d_t * tcs_d))
v_tcs = (5.52 /
(16.518 + 1.481 * c_r / c_t * tcs_c - d_r / d_t * tcs_d))
W_tcs = 25 * xyY_tcs[-1]**(1 / 3) - 17
U_tcs = 13 * W_tcs * (u_tcs - u_r)
V_tcs = 13 * W_tcs * (v_tcs - v_r)
tcs_data.append(
TCS_ColorimetryData(spd_tcs.name, XYZ_tcs, uv_tcs,
np.array([U_tcs, V_tcs, W_tcs])))
return tcs_data
def plot_RGB_chromaticities_in_chromaticity_diagram(
RGB,
colourspace='sRGB',
chromaticity_diagram_callable=(
plot_RGB_colourspaces_in_chromaticity_diagram),
method='CIE 1931',
scatter_parameters=None,
**kwargs):
"""
Plots given *RGB* colourspace array in the *Chromaticity Diagram* according
to given method.
Parameters
----------
RGB : array_like
*RGB* colourspace array.
colourspace : optional, unicode
*RGB* colourspace of the *RGB* array.
chromaticity_diagram_callable : callable, optional
Callable responsible for drawing the *Chromaticity Diagram*.
method : unicode, optional
**{'CIE 1931', 'CIE 1960 UCS', 'CIE 1976 UCS'}**,
*Chromaticity Diagram* method.
scatter_parameters : dict, optional
Parameters for the :func:`plt.scatter` definition, if ``c`` is set to
*RGB*, the scatter will use given ``RGB`` colours.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.diagrams.plot_chromaticity_diagram`,
:func:`colour.plotting.diagrams.\
plot_RGB_colourspaces_in_chromaticity_diagram`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> RGB = np.random.random((128, 128, 3))
>>> plot_RGB_chromaticities_in_chromaticity_diagram(
... RGB, 'ITU-R BT.709')
... # doctest: +SKIP
.. image:: ../_static/Plotting_\
Plot_RGB_Chromaticities_In_Chromaticity_Diagram_Plot.png
:align: center
:alt: plot_RGB_chromaticities_in_chromaticity_diagram
"""
RGB = as_float_array(RGB).reshape(-1, 3)
settings = {'uniform': True}
settings.update(kwargs)
_figure, axes = artist(**settings)
method = method.upper()
scatter_settings = {
's': 40,
'c': 'RGB',
'marker': 'o',
'alpha': 0.85,
}
if scatter_parameters is not None:
scatter_settings.update(scatter_parameters)
settings = dict(kwargs)
settings.update({'axes': axes, 'standalone': False})
colourspace = first_item(filter_RGB_colourspaces(colourspace).values())
settings['colourspaces'] = (['^{0}$'.format(colourspace.name)] +
settings.get('colourspaces', []))
chromaticity_diagram_callable(**settings)
use_RGB_colours = scatter_settings['c'].upper() == 'RGB'
if use_RGB_colours:
RGB = RGB[RGB[:, 1].argsort()]
scatter_settings['c'] = np.clip(
RGB_to_RGB(RGB,
colourspace,
COLOUR_STYLE_CONSTANTS.colour.colourspace,
apply_encoding_cctf=True).reshape(-1, 3), 0, 1)
XYZ = RGB_to_XYZ(RGB, colourspace.whitepoint, colourspace.whitepoint,
colourspace.RGB_to_XYZ_matrix)
if method == 'CIE 1931':
ij = XYZ_to_xy(XYZ, colourspace.whitepoint)
elif method == 'CIE 1960 UCS':
ij = UCS_to_uv(XYZ_to_UCS(XYZ))
elif method == 'CIE 1976 UCS':
ij = Luv_to_uv(XYZ_to_Luv(XYZ, colourspace.whitepoint),
colourspace.whitepoint)
axes.scatter(ij[..., 0], ij[..., 1], **scatter_settings)
settings.update({'standalone': True})
settings.update(kwargs)
return render(**settings)
def planckian_table(uv, cmfs, start, end, count):
"""
Returns a planckian table from given *CIE UCS* colourspace *uv*
chromaticity coordinates, colour matching functions and temperature range
using *Ohno (2013)* method.
Parameters
----------
uv : array_like
*uv* chromaticity coordinates.
cmfs : XYZ_ColourMatchingFunctions
Standard observer colour matching functions.
start : numeric
Temperature range start in kelvins.
end : numeric
Temperature range end in kelvins.
count : int
Temperatures count in the planckian table.
Returns
-------
list
Planckian table.
Examples
--------
>>> from colour import STANDARD_OBSERVERS_CMFS
>>> from pprint import pprint
>>> cmfs = STANDARD_OBSERVERS_CMFS['CIE 1931 2 Degree Standard Observer']
>>> uv = np.array([0.1978, 0.3122])
>>> pprint(planckian_table(uv, cmfs, 1000, 1010, 10))
... # doctest: +ELLIPSIS
[PlanckianTable_Tuvdi(Ti=1000.0, \
ui=0.4479628..., vi=0.3546296..., di=0.2537355...),
PlanckianTable_Tuvdi(Ti=1001.1111111..., \
ui=0.4477030..., vi=0.3546521..., di=0.2534831...),
PlanckianTable_Tuvdi(Ti=1002.2222222..., \
ui=0.4474434..., vi=0.3546746..., di=0.2532310...),
PlanckianTable_Tuvdi(Ti=1003.3333333..., \
ui=0.4471842..., vi=0.3546970..., di=0.2529792...),
PlanckianTable_Tuvdi(Ti=1004.4444444..., \
ui=0.4469252..., vi=0.3547194..., di=0.2527277...),
PlanckianTable_Tuvdi(Ti=1005.5555555..., \
ui=0.4466666..., vi=0.3547417..., di=0.2524765...),
PlanckianTable_Tuvdi(Ti=1006.6666666..., \
ui=0.4464083..., vi=0.3547640..., di=0.2522256...),
PlanckianTable_Tuvdi(Ti=1007.7777777..., \
ui=0.4461502..., vi=0.3547862..., di=0.2519751...),
PlanckianTable_Tuvdi(Ti=1008.8888888..., \
ui=0.4458925..., vi=0.3548084..., di=0.2517248...),
PlanckianTable_Tuvdi(Ti=1010.0, \
ui=0.4456351..., vi=0.3548306..., di=0.2514749...)]
"""
ux, vx = uv
cmfs = cmfs.copy().trim(ASTME30815_PRACTISE_SHAPE)
shape = cmfs.shape
table = []
for Ti in np.linspace(start, end, count):
sd = sd_blackbody(Ti, shape)
XYZ = sd_to_XYZ(sd, cmfs)
XYZ /= np.max(XYZ)
UVW = XYZ_to_UCS(XYZ)
ui, vi = UCS_to_uv(UVW)
di = np.hypot(ux - ui, vx - vi)
table.append(PLANCKIAN_TABLE_TUVD(Ti, ui, vi, di))
return table
def colour_rendering_index(sd_test, additional_data=False):
"""
Returns the *Colour Rendering Index* (CRI) :math:`Q_a` of given spectral
distribution.
Parameters
----------
sd_test : SpectralDistribution
Test spectral distribution.
additional_data : bool, optional
Whether to output additional data.
Returns
-------
numeric or ColourRendering_Specification_CRI
*Colour Rendering Index* (CRI).
References
----------
:cite:`Ohno2008a`
Examples
--------
>>> from colour import SDS_ILLUMINANTS
>>> sd = SDS_ILLUMINANTS['FL2']
>>> colour_rendering_index(sd) # doctest: +ELLIPSIS
64.2337241...
"""
cmfs = MSDS_CMFS_STANDARD_OBSERVER[
'CIE 1931 2 Degree Standard Observer'].copy().trim(
SPECTRAL_SHAPE_DEFAULT)
shape = cmfs.shape
sd_test = sd_test.copy().align(shape)
tcs_sds = {sd.name: sd.copy().align(shape) for sd in SDS_TCS.values()}
with domain_range_scale('1'):
XYZ = sd_to_XYZ(sd_test, cmfs)
uv = UCS_to_uv(XYZ_to_UCS(XYZ))
CCT, _D_uv = uv_to_CCT_Robertson1968(uv)
if CCT < 5000:
sd_reference = sd_blackbody(CCT, shape)
else:
xy = CCT_to_xy_CIE_D(CCT)
sd_reference = sd_CIE_illuminant_D_series(xy)
sd_reference.align(shape)
test_tcs_colorimetry_data = tcs_colorimetry_data(sd_test,
sd_reference,
tcs_sds,
cmfs,
chromatic_adaptation=True)
reference_tcs_colorimetry_data = tcs_colorimetry_data(
sd_reference, sd_reference, tcs_sds, cmfs)
Q_as = colour_rendering_indexes(test_tcs_colorimetry_data,
reference_tcs_colorimetry_data)
Q_a = np.average(
[v.Q_a for k, v in Q_as.items() if k in (1, 2, 3, 4, 5, 6, 7, 8)])
if additional_data:
return ColourRendering_Specification_CRI(
sd_test.name, Q_a, Q_as,
(test_tcs_colorimetry_data, reference_tcs_colorimetry_data))
else:
return Q_a
def CIE_1960_UCS_chromaticity_diagram_colours_plot(
surface=1,
samples=4096,
cmfs='CIE 1931 2 Degree Standard Observer',
**kwargs):
"""
Plots the *CIE 1960 UCS Chromaticity Diagram* colours.
Parameters
----------
surface : numeric, optional
Generated markers surface.
samples : numeric, optional
Samples count on one axis.
cmfs : unicode, optional
Standard observer colour matching functions used for diagram bounds.
\**kwargs : dict, optional
Keywords arguments.
Returns
-------
bool
Definition success.
Examples
--------
>>> CIE_1960_UCS_chromaticity_diagram_colours_plot() # doctest: +SKIP
True
"""
if is_scipy_installed(raise_exception=True):
from scipy.spatial import Delaunay
settings = {'figure_size': (64, 64)}
settings.update(kwargs)
canvas(**settings)
cmfs = get_cmfs(cmfs)
illuminant = DEFAULT_PLOTTING_ILLUMINANT
triangulation = Delaunay(UCS_to_uv(XYZ_to_UCS(cmfs.values)),
qhull_options='QJ')
xx, yy = np.meshgrid(np.linspace(0, 1, samples),
np.linspace(0, 1, samples))
xy = tstack((xx, yy))
xy = xy[triangulation.find_simplex(xy) > 0]
XYZ = xy_to_XYZ(UCS_uv_to_xy(xy))
RGB = normalise(XYZ_to_sRGB(XYZ, illuminant), axis=-1)
x_dot, y_dot = tsplit(xy)
pylab.scatter(x_dot, y_dot, color=RGB, s=surface)
settings.update({
'x_ticker': False,
'y_ticker': False,
'bounding_box': (0, 1, 0, 1),
'bbox_inches': 'tight',
'pad_inches': 0
})
settings.update(kwargs)
ax = matplotlib.pyplot.gca()
matplotlib.pyplot.setp(ax, frame_on=False)
boundaries(**settings)
decorate(**settings)
return display(**settings)
def colour_quality_scale(sd_test, additional_data=False):
"""
Returns the *Colour Quality Scale* (CQS) of given spectral
distribution.
Parameters
----------
sd_test : SpectralDistribution
Test spectral distribution.
additional_data : bool, optional
Whether to output additional data.
Returns
-------
numeric or CQS_Specification
Color quality scale.
References
----------
:cite:`Davis2010a`, :cite:`Ohno2008a`
Examples
--------
>>> from colour import ILLUMINANTS_SDS
>>> sd = ILLUMINANTS_SDS['F2']
>>> colour_quality_scale(sd) # doctest: +ELLIPSIS
64.6863391...
"""
cmfs = STANDARD_OBSERVERS_CMFS['CIE 1931 2 Degree Standard Observer'].copy(
).trim(ASTME30815_PRACTISE_SHAPE)
shape = cmfs.shape
sd_test = sd_test.copy().align(shape)
vs_sds = {sd.name: sd.copy().align(shape) for sd in VS_SDS.values()}
with domain_range_scale('1'):
XYZ = sd_to_XYZ(sd_test, cmfs)
uv = UCS_to_uv(XYZ_to_UCS(XYZ))
CCT, _D_uv = uv_to_CCT_Ohno2013(uv)
if CCT < 5000:
sd_reference = sd_blackbody(CCT, shape)
else:
xy = CCT_to_xy_CIE_D(CCT)
sd_reference = sd_CIE_illuminant_D_series(xy)
sd_reference.align(shape)
test_vs_colorimetry_data = vs_colorimetry_data(sd_test,
sd_reference,
vs_sds,
cmfs,
chromatic_adaptation=True)
reference_vs_colorimetry_data = vs_colorimetry_data(
sd_reference, sd_reference, vs_sds, cmfs)
XYZ_r = sd_to_XYZ(sd_reference, cmfs)
XYZ_r /= XYZ_r[1]
CCT_f = CCT_factor(reference_vs_colorimetry_data, XYZ_r)
Q_as = colour_quality_scales(test_vs_colorimetry_data,
reference_vs_colorimetry_data, CCT_f)
D_E_RMS = delta_E_RMS(Q_as, 'D_E_ab')
D_Ep_RMS = delta_E_RMS(Q_as, 'D_Ep_ab')
Q_a = scale_conversion(D_Ep_RMS, CCT_f)
Q_f = scale_conversion(D_E_RMS, CCT_f, 2.928)
p_delta_C = np.average(
[sample_data.D_C_ab if sample_data.D_C_ab > 0 else 0
for sample_data in Q_as.values()]) # yapf: disable
Q_p = 100 - 3.6 * (D_Ep_RMS - p_delta_C)
G_t = gamut_area(
[vs_CQS_data.Lab for vs_CQS_data in test_vs_colorimetry_data])
G_r = gamut_area(
[vs_CQS_data.Lab for vs_CQS_data in reference_vs_colorimetry_data])
Q_g = G_t / D65_GAMUT_AREA * 100
Q_d = G_t / G_r * CCT_f * 100
if additional_data:
return CQS_Specification(
sd_test.name, Q_a, Q_f, Q_p, Q_g, Q_d, Q_as,
(test_vs_colorimetry_data, reference_vs_colorimetry_data))
else:
return Q_a