def plot_spectra_ANSIIESTM3018(specification, **kwargs):
"""
Plots a comparison of the spectral distributions of a test emission source
and a reference illuminant for *ANSI/IES TM-30-18 Colour Rendition Report*.
Parameters
----------
specification : ColourQuality_Specification_ANSIIESTM3018
*ANSI/IES TM-30-18 Colour Rendition Report* specification.
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
--------
>>> from colour import SDS_ILLUMINANTS
>>> from colour.quality import colour_fidelity_index_ANSIIESTM3018
>>> sd = SDS_ILLUMINANTS['FL2']
>>> specification = colour_fidelity_index_ANSIIESTM3018(sd, True)
>>> plot_spectra_ANSIIESTM3018(specification)
... # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, <...AxesSubplot...>)
"""
settings = kwargs.copy()
_figure, axes = artist(**settings)
Y_reference = sd_to_XYZ(specification.sd_reference)[1]
Y_test = sd_to_XYZ(specification.sd_test)[1]
axes.plot(specification.sd_reference.wavelengths,
specification.sd_reference.values / Y_reference,
'black',
label='Reference')
axes.plot(specification.sd_test.wavelengths,
specification.sd_test.values / Y_test,
'#F05046',
label='Test')
axes.tick_params(axis='y', which='both', length=0)
axes.set_yticklabels([])
settings = {
'axes': axes,
'legend': True,
'legend_columns': 2,
'x_label': 'Wavelength (nm)',
'y_label': 'Radiant Power\n(Equal Luminous Flux)',
}
settings.update(kwargs)
return render(**settings)
def plot_colour_fidelity_indexes(
specification: ColourQuality_Specification_ANSIIESTM3018,
**kwargs: Any) -> Tuple[plt.Figure, plt.Axes]:
"""
Plot the local chroma shifts according to
*ANSI/IES TM-30-18 Colour Rendition Report*.
Parameters
----------
specification
*ANSI/IES TM-30-18 Colour Rendition Report* specification.
Other Parameters
----------------
kwargs
{:func:`colour.plotting.artist`, :func:`colour.plotting.render`},
See the documentation of the previously listed definitions.
Returns
-------
:class:`tuple`
Current figure and axes
Examples
--------
>>> from colour import SDS_ILLUMINANTS
>>> from colour.quality import colour_fidelity_index_ANSIIESTM3018
>>> sd = SDS_ILLUMINANTS['FL2']
>>> specification = colour_fidelity_index_ANSIIESTM3018(sd, True)
>>> plot_colour_fidelity_indexes(specification)
... # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, <...AxesSubplot...>)
"""
_figure, axes = artist(**kwargs)
bar_count = len(_COLOURS_TCS_BAR)
axes.bar(
np.arange(bar_count) + 1,
specification.R_s,
color=_COLOURS_TCS_BAR,
width=1,
edgecolor="black",
linewidth=CONSTANTS_COLOUR_STYLE.geometry.short / 3,
zorder=CONSTANTS_COLOUR_STYLE.zorder.background_polygon,
)
axes.set_xlim(0.5, bar_count + 0.5)
axes.set_ylim(0, 100)
axes.set_yticks(np.arange(0, 110, 10))
axes.set_ylabel("Color Sample Fidelity ($R_{f,CESi}$)")
ticks = list(range(1, bar_count + 1, 1))
axes.set_xticks(ticks)
labels = [
f"CES{i:02d}" if i % 3 == 1 else "" for i in range(1, bar_count + 1)
]
axes.set_xticklabels(labels, rotation=90)
return render(**kwargs)
def multi_spd_colour_quality_scale_bars_plot(spds, **kwargs):
"""
Plots the *Colour Quality Scale* (CQS) of given illuminants or light
sources spectral power distributions.
Parameters
----------
spds : array_like
Array of illuminants or light sources spectral power distributions to
plot the *Colour Quality Scale* (CQS).
Other Parameters
----------------
\**kwargs : dict, optional
{:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definition.
labels : bool, optional
{:func:`colour.plotting.quality.colour_quality_bars_plot`},
Add labels above bars.
hatching : bool or None, optional
{:func:`colour.plotting.quality.colour_quality_bars_plot`},
Use hatching for the bars.
hatching_repeat : int, optional
{:func:`colour.plotting.quality.colour_quality_bars_plot`},
Hatching pattern repeat.
Returns
-------
Figure
Current figure or None.
Examples
--------
>>> from colour import (ILLUMINANTS_RELATIVE_SPDS,
... LIGHT_SOURCES_RELATIVE_SPDS)
>>> illuminant = ILLUMINANTS_RELATIVE_SPDS['F2']
>>> light_source = LIGHT_SOURCES_RELATIVE_SPDS['Kinoton 75P']
>>> multi_spd_colour_quality_scale_bars_plot([illuminant, light_source])
... # doctest: +SKIP
"""
settings = {}
settings.update(kwargs)
settings.update({'standalone': False})
specifications = [
colour_quality_scale(spd, additional_data=True) for spd in spds
]
colour_quality_bars_plot(specifications, **settings)
settings = {
'title':
'Colour Quality Scale - {0}'.format(', '.join(
[spd.strict_name for spd in spds]))
}
settings.update(kwargs)
return render(with_boundaries=False, **settings)
def spcs_in_one_diagram(*specs):
"""传入多个光谱数据，将他们画在同一张 CIE1931图上
:: specs (instances of spectrum class): 该程序定义的类的实例
:: re: None
"""
num = len(specs)
x = []
y = []
for spec in specs:
x.append(spec.x)
y.append(spec.y)
cpt.chromaticity_diagram_plot_CIE1931(standalone=False)
pylab.plot(x, y, 'o', color='k', mew=1, mec='k', alpha=0.5)
# displaying the plot
cpt.render(standalong=True,
limits=(-0.1, 0.9, -0.1, 0.9),
x_tighten=True,
y_tighten=True)
def plot_colour_fidelity_indexes(specification, **kwargs):
"""
Plots the local chroma shifts according to
*ANSI/IES TM-30-18 Colour Rendition Report*.
Parameters
----------
specification : ColourQuality_Specification_ANSIIESTM3018
*ANSI/IES TM-30-18 Colour Rendition Report* specification.
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
--------
>>> from colour import SDS_ILLUMINANTS
>>> from colour.quality import colour_fidelity_index_ANSIIESTM3018
>>> sd = SDS_ILLUMINANTS['FL2']
>>> specification = colour_fidelity_index_ANSIIESTM3018(sd, True)
>>> plot_colour_fidelity_indexes(specification)
... # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, <...AxesSubplot...>)
"""
_figure, axes = artist(**kwargs)
bar_count = len(_TCS_BAR_COLOURS)
axes.bar(np.arange(bar_count) + 1,
specification.R_s,
color=_TCS_BAR_COLOURS,
width=1,
edgecolor='black',
linewidth=CONSTANTS_COLOUR_STYLE.geometry.short / 3)
axes.set_xlim(0.5, bar_count + 0.5)
axes.set_ylim(0, 100)
axes.set_yticks(np.arange(0, 110, 10))
axes.set_ylabel('Color Sample Fidelity ($R_{f,CESi}$)')
ticks = list(range(1, bar_count + 1, 1))
axes.set_xticks(ticks)
labels = [
'CES{0:02d}'.format(i) if i % 3 == 1 else ''
for i in range(1, bar_count + 1)
]
axes.set_xticklabels(labels, rotation=90)
return render(**kwargs)
def plot_local_chroma_shifts(
specification: ColourQuality_Specification_ANSIIESTM3018,
x_ticker: Boolean = False,
**kwargs: Any,
) -> Tuple[plt.Figure, plt.Axes]:
"""
Plot the local chroma shifts according to
*ANSI/IES TM-30-18 Colour Rendition Report*.
Parameters
----------
specification
*ANSI/IES TM-30-18 Colour Rendition Report* specification.
x_ticker
Whether to show the *X* axis ticker and the associated label.
Other Parameters
----------------
kwargs
{:func:`colour.plotting.artist`, :func:`colour.plotting.render`},
See the documentation of the previously listed definitions.
Returns
-------
:class:`tuple`
Current figure and axes
Examples
--------
>>> from colour import SDS_ILLUMINANTS
>>> from colour.quality import colour_fidelity_index_ANSIIESTM3018
>>> sd = SDS_ILLUMINANTS['FL2']
>>> specification = colour_fidelity_index_ANSIIESTM3018(sd, True)
>>> plot_local_chroma_shifts(specification)
... # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, <...AxesSubplot...>)
"""
settings: Dict[str, Any] = dict(kwargs)
settings["standalone"] = False
_figure, axes = plot_16_bin_bars(specification.R_cs, "{0:.0f}%", x_ticker,
**settings)
axes.set_ylim(-40, 40)
axes.set_ylabel("Local Chroma Shift ($R_{cs,hj}$)")
ticks = np.arange(-40, 41, 10)
axes.set_yticks(ticks)
axes.set_yticklabels([f"{value}%" for value in ticks])
settings = {"standalone": True}
settings.update(kwargs)
return render(**settings)
def visible_spectrum_plot(cmfs='CIE 1931 2 Degree Standard Observer',
out_of_gamut_clipping=True,
**kwargs):
"""
Plots the visible colours spectrum using given standard observer *CIE XYZ*
colour matching functions.
Parameters
----------
cmfs : unicode, optional
Standard observer colour matching functions used for spectrum creation.
out_of_gamut_clipping : bool, optional
Whether to clip out of gamut colours otherwise, the colours will be
offset by the absolute minimal colour leading to a rendering on
gray background, less saturated and smoother.
Other Parameters
----------------
\**kwargs : dict, optional
{:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definition.
Returns
-------
Figure
Current figure or None.
References
----------
- :cite:`Spiker2015a`
Examples
--------
>>> visible_spectrum_plot() # doctest: +SKIP
"""
settings = {'y_label': None, 'y_ticker': False, 'standalone': False}
single_spd_plot(ones_spd(DEFAULT_SPECTRAL_SHAPE),
cmfs=cmfs,
out_of_gamut_clipping=out_of_gamut_clipping,
**settings)
cmfs = get_cmfs(cmfs)
settings = {
'title': 'The Visible Spectrum - {0}'.format(cmfs.strict_name),
'x_label': 'Wavelength $\\lambda$ (nm)',
'standalone': True
}
settings.update(kwargs)
return render(**settings)
def plot_radiance_image_strip(
image,
count=5,
ev_steps=-2,
cctf_encoding=COLOUR_STYLE_CONSTANTS.colour.colourspace.cctf_encoding,
**kwargs):
"""
Plots given HDRI / radiance image as strip of images of varying exposure.
Parameters
----------
image : array_like
HDRI / radiance image to plot.
count : int, optional
Strip images count.
ev_steps : numeric, optional
Exposure variation for each image of the strip.
cctf_encoding : callable, optional
Encoding colour component transfer function / opto-electronic
transfer function used for plotting.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.display`},
Please refer to the documentation of the previously listed definition.
Returns
-------
tuple
Current figure and axes.
"""
image = as_float_array(image)
grid = matplotlib.gridspec.GridSpec(1, count)
grid.update(wspace=0, hspace=0)
height, width, _channel = image.shape
for i in range(count):
ev = i * ev_steps
axis = plt.subplot(grid[i])
axis.imshow(np.clip(cctf_encoding(adjust_exposure(image, ev)), 0, 1))
axis.text(
width * 0.05,
height - height * 0.05,
'EV {0}'.format(ev),
color=(1, 1, 1))
axis.set_xticks([])
axis.set_yticks([])
axis.set_aspect('equal')
return render(**kwargs)
def saveCIE (xy, id1):
#plotting x,y
plot_chromaticity_diagram_CIE1931(standalone=False)
# Plotting the *CIE xy* chromaticity coordinates
x, y = xy
plt.plot(x, y, 'o-', color='white')
# Annotating the plot.
plt.annotate('FEM',
xy=xy,
xytext=(-50, 30),
textcoords='offset points',
arrowprops=dict(arrowstyle='->', connectionstyle='arc3, rad=-0.2'))
# Displaying the plot.
render(
filename = '%s.png' %id1,
limits=(-0.1, 0.9, -0.1, 0.9),
x_tighten=True,
y_tighten=True)
def test_render(self):
"""
Tests :func:`colour.plotting.common.render` definition.
"""
figure, axes = artist()
render(
figure=figure,
axes=axes,
standalone=False,
aspect='equal',
axes_visible=True,
bounding_box=[0, 1, 0, 1],
tight_layout=False,
legend=True,
legend_columns=2,
transparent_background=False,
title='Render Unit Test',
wrap_title=True,
x_label='x Label',
y_label='y Label',
x_ticker=False,
y_ticker=False,
)
render(standalone=True)
render(filename=os.path.join(self._temporary_directory, 'render.png'),
axes_visible=False)
def plot_local_chroma_shifts(specification, x_ticker=False, **kwargs):
"""
Plots the local chroma shifts according to
*ANSI/IES TM-30-18 Colour Rendition Report*.
Parameters
----------
specification : ColourQuality_Specification_ANSIIESTM3018
*ANSI/IES TM-30-18 Colour Rendition Report* specification.
x_ticker : bool, optional
Whether to show the *X* axis ticker and the associated label.
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
--------
>>> from colour import SDS_ILLUMINANTS
>>> from colour.quality import colour_fidelity_index_ANSIIESTM3018
>>> sd = SDS_ILLUMINANTS['FL2']
>>> specification = colour_fidelity_index_ANSIIESTM3018(sd, True)
>>> plot_local_chroma_shifts(specification)
... # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, <...AxesSubplot...>)
"""
settings = kwargs.copy()
settings['standalone'] = False
_figure, axes = plot_16_bin_bars(specification.R_cs, '{0:.0f}%', x_ticker,
**settings)
axes.set_ylim(-40, 40)
axes.set_ylabel('Local Chroma Shift ($R_{cs,hj}$)')
ticks = np.arange(-40, 41, 10)
axes.set_yticks(ticks)
axes.set_yticklabels(['{0}%'.format(value) for value in ticks])
settings = {'standalone': True}
settings.update(kwargs)
return render(**settings)
def plot_visible_spectrum(cmfs='CIE 1931 2 Degree Standard Observer',
out_of_gamut_clipping=True,
**kwargs):
"""
Plots the visible colours spectrum using given standard observer *CIE XYZ*
colour matching functions.
Parameters
----------
cmfs : unicode, optional
Standard observer colour matching functions used for spectrum creation.
out_of_gamut_clipping : bool, optional
Whether to clip out of gamut colours otherwise, the colours will be
offset by the absolute minimal colour leading to a rendering on
gray background, less saturated and smoother.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.plot_single_sd`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
References
----------
:cite:`Spiker2015a`
Examples
--------
>>> plot_visible_spectrum() # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_Visible_Spectrum.png
:align: center
:alt: plot_visible_spectrum
"""
cmfs = first_item(filter_cmfs(cmfs).values())
bounding_box = (min(cmfs.wavelengths), max(cmfs.wavelengths), 0, 1)
settings = {'bounding_box': bounding_box, 'y_label': None}
settings.update(kwargs)
settings['standalone'] = False
_figure, axes = plot_single_sd(
sd_ones(cmfs.shape),
cmfs=cmfs,
out_of_gamut_clipping=out_of_gamut_clipping,
**settings)
# Removing wavelength line as it doubles with the axes spine.
axes.lines.pop(0)
settings = {
'axes': axes,
'standalone': True,
'title': 'The Visible Spectrum - {0}'.format(cmfs.strict_name),
'x_label': 'Wavelength $\\lambda$ (nm)',
}
settings.update(kwargs)
return render(**settings)
def plot_multi_sds(sds,
cmfs='CIE 1931 2 Degree Standard Observer',
use_sds_colours=False,
normalise_sds_colours=False,
**kwargs):
"""
Plots given spectral distributions.
Parameters
----------
sds : array_like or MultiSpectralDistribution
Spectral distributions or multi-spectral distributions to
plot. `sds` can be a single
:class:`colour.MultiSpectralDistribution` class instance, a list
of :class:`colour.MultiSpectralDistribution` class instances or a
list of :class:`colour.SpectralDistribution` class instances.
cmfs : unicode, optional
Standard observer colour matching functions used for spectrum creation.
use_sds_colours : bool, optional
Whether to use spectral distributions colours.
normalise_sds_colours : bool
Whether to normalise spectral distributions colours.
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
--------
>>> from colour import SpectralDistribution
>>> data_1 = {
... 500: 0.004900,
... 510: 0.009300,
... 520: 0.063270,
... 530: 0.165500,
... 540: 0.290400,
... 550: 0.433450,
... 560: 0.594500
... }
>>> data_2 = {
... 500: 0.323000,
... 510: 0.503000,
... 520: 0.710000,
... 530: 0.862000,
... 540: 0.954000,
... 550: 0.994950,
... 560: 0.995000
... }
>>> spd1 = SpectralDistribution(data_1, name='Custom 1')
>>> spd2 = SpectralDistribution(data_2, name='Custom 2')
>>> plot_multi_sds([spd1, spd2]) # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_Multi_SDs.png
:align: center
:alt: plot_multi_sds
"""
_figure, axes = artist(**kwargs)
if isinstance(sds, MultiSpectralDistribution):
sds = sds.to_sds()
else:
sds = list(sds)
for i, sd in enumerate(sds[:]):
if isinstance(sd, MultiSpectralDistribution):
sds.remove(sd)
sds[i:i] = sd.to_sds()
cmfs = first_item(filter_cmfs(cmfs).values())
illuminant = ILLUMINANTS_SDS[
COLOUR_STYLE_CONSTANTS.colour.colourspace.illuminant]
x_limit_min, x_limit_max, y_limit_min, y_limit_max = [], [], [], []
for sd in sds:
wavelengths, values = sd.wavelengths, sd.values
shape = sd.shape
x_limit_min.append(shape.start)
x_limit_max.append(shape.end)
y_limit_min.append(min(values))
y_limit_max.append(max(values))
if use_sds_colours:
with domain_range_scale('1'):
XYZ = sd_to_XYZ(sd, cmfs, illuminant)
if normalise_sds_colours:
XYZ = normalise_maximum(XYZ, clip=False)
RGB = np.clip(XYZ_to_plotting_colourspace(XYZ), 0, 1)
axes.plot(wavelengths, values, color=RGB, label=sd.strict_name)
else:
axes.plot(wavelengths, values, label=sd.strict_name)
bounding_box = (min(x_limit_min), max(x_limit_max), min(y_limit_min),
max(y_limit_max) + max(y_limit_max) * 0.05)
settings = {
'axes': axes,
'bounding_box': bounding_box,
'legend': True,
'x_label': 'Wavelength $\\lambda$ (nm)',
'y_label': 'Spectral Distribution',
}
settings.update(kwargs)
return render(**settings)
def plot_hull_section_colours(
hull: trimesh.Trimesh, # type: ignore[name-defined] # noqa
model: Union[Literal["CAM02LCD", "CAM02SCD", "CAM02UCS", "CAM16LCD",
"CAM16SCD", "CAM16UCS", "CIE XYZ", "CIE xyY",
"CIE Lab", "CIE Luv", "CIE UCS", "CIE UVW", "DIN99",
"Hunter Lab", "Hunter Rdab", "ICaCb", "ICtCp", "IPT",
"IgPgTg", "Jzazbz", "OSA UCS", "Oklab", "hdr-CIELAB",
"hdr-IPT", ], str, ] = "CIE xyY",
axis: Union[Literal["+z", "+x", "+y"], str] = "+z",
origin: Floating = 0.5,
normalise: Boolean = True,
section_colours: Optional[Union[ArrayLike, str]] = None,
section_opacity: Floating = 1,
convert_kwargs: Optional[Dict] = None,
samples: Integer = 256,
**kwargs: Any,
) -> Tuple[plt.Figure, plt.Axes]:
"""
Plot the section colours of given *trimesh* hull along given axis and
origin.
Parameters
----------
hull
*Trimesh* hull.
model
Colourspace model, see :attr:`colour.COLOURSPACE_MODELS` attribute for
the list of supported colourspace models.
axis
Axis the hull section will be normal to.
origin
Coordinate along ``axis`` at which to plot the hull section.
normalise
Whether to normalise ``axis`` to the extent of the hull along it.
section_colours
Colours of the hull section, if ``section_colours`` is set to *RGB*,
the colours will be computed according to the corresponding
coordinates.
section_opacity
Opacity of the hull section colours.
convert_kwargs
Keyword arguments for the :func:`colour.convert` definition.
samples
Samples count on one axis when computing the hull section colours.
Other Parameters
----------------
kwargs
{:func:`colour.plotting.artist`,
:func:`colour.plotting.render`},
See the documentation of the previously listed definitions.
Returns
-------
:class:`tuple`
Current figure and axes.
Examples
--------
>>> from colour.models import RGB_COLOURSPACE_sRGB
>>> from colour.utilities import is_trimesh_installed
>>> vertices, faces, _outline = primitive_cube(1, 1, 1, 64, 64, 64)
>>> XYZ_vertices = RGB_to_XYZ(
... vertices['position'] + 0.5,
... RGB_COLOURSPACE_sRGB.whitepoint,
... RGB_COLOURSPACE_sRGB.whitepoint,
... RGB_COLOURSPACE_sRGB.matrix_RGB_to_XYZ,
... )
>>> if is_trimesh_installed:
... import trimesh
... hull = trimesh.Trimesh(XYZ_vertices, faces, process=False)
... plot_hull_section_colours(hull, section_colours='RGB')
... # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, <...AxesSubplot...>)
.. image:: ../_static/Plotting_Plot_Hull_Section_Colours.png
:align: center
:alt: plot_hull_section_colours
"""
axis = validate_method(
axis,
["+z", "+x", "+y"],
'"{0}" axis is invalid, it must be one of {1}!',
)
hull = hull.copy()
settings: Dict[str, Any] = {"uniform": True}
settings.update(kwargs)
_figure, axes = artist(**settings)
section_colours = cast(
ArrayLike,
optional(section_colours,
HEX_to_RGB(CONSTANTS_COLOUR_STYLE.colour.average)),
)
convert_kwargs = optional(convert_kwargs, {})
# Luminance / Lightness reordered along "z" axis.
with suppress_warnings(python_warnings=True):
ijk_vertices = colourspace_model_axis_reorder(
convert(hull.vertices, "CIE XYZ", model, **convert_kwargs), model)
ijk_vertices = np.nan_to_num(ijk_vertices)
ijk_vertices *= COLOURSPACE_MODELS_DOMAIN_RANGE_SCALE_1_TO_REFERENCE[
model]
hull.vertices = ijk_vertices
if axis == "+x":
index_origin = 0
elif axis == "+y":
index_origin = 1
elif axis == "+z":
index_origin = 2
plane = MAPPING_AXIS_TO_PLANE[axis]
section = hull_section(hull, axis, origin, normalise)
padding = 0.1 * np.mean(
COLOURSPACE_MODELS_DOMAIN_RANGE_SCALE_1_TO_REFERENCE[model])
min_x = np.min(ijk_vertices[..., plane[0]]) - padding
max_x = np.max(ijk_vertices[..., plane[0]]) + padding
min_y = np.min(ijk_vertices[..., plane[1]]) - padding
max_y = np.max(ijk_vertices[..., plane[1]]) + padding
extent = (min_x, max_x, min_y, max_y)
use_RGB_section_colours = str(section_colours).upper() == "RGB"
if use_RGB_section_colours:
ii, jj = np.meshgrid(
np.linspace(min_x, max_x, samples),
np.linspace(max_y, min_y, samples),
)
ij = tstack([ii, jj])
ijk_section = full((samples, samples, 3),
np.median(section[..., index_origin]))
ijk_section[..., plane] = ij
ijk_section /= COLOURSPACE_MODELS_DOMAIN_RANGE_SCALE_1_TO_REFERENCE[
model]
XYZ_section = convert(
colourspace_model_axis_reorder(ijk_section, model, "Inverse"),
model,
"CIE XYZ",
**convert_kwargs,
)
RGB_section = XYZ_to_plotting_colourspace(XYZ_section)
else:
section_colours = np.hstack([section_colours, section_opacity])
facecolor = "none" if use_RGB_section_colours else section_colours
polygon = Polygon(
section[..., plane],
facecolor=facecolor,
edgecolor="none",
zorder=CONSTANTS_COLOUR_STYLE.zorder.background_polygon,
)
axes.add_patch(polygon)
if use_RGB_section_colours:
image = axes.imshow(
np.clip(RGB_section, 0, 1),
interpolation="bilinear",
extent=extent,
clip_path=None,
alpha=section_opacity,
zorder=CONSTANTS_COLOUR_STYLE.zorder.background_polygon,
)
image.set_clip_path(polygon)
settings = {
"axes": axes,
"bounding_box": extent,
}
settings.update(kwargs)
return render(**settings)
def plot_visible_spectrum_section(
cmfs: Union[MultiSpectralDistributions, str, Sequence[Union[
MultiSpectralDistributions,
str]], ] = "CIE 1931 2 Degree Standard Observer",
illuminant: Union[SpectralDistribution, str] = "D65",
model: Union[Literal["CAM02LCD", "CAM02SCD", "CAM02UCS", "CAM16LCD",
"CAM16SCD", "CAM16UCS", "CIE XYZ", "CIE xyY",
"CIE Lab", "CIE Luv", "CIE UCS", "CIE UVW", "DIN99",
"Hunter Lab", "Hunter Rdab", "ICaCb", "ICtCp", "IPT",
"IgPgTg", "Jzazbz", "OSA UCS", "Oklab", "hdr-CIELAB",
"hdr-IPT", ], str, ] = "CIE xyY",
axis: Union[Literal["+z", "+x", "+y"], str] = "+z",
origin: Floating = 0.5,
normalise: Boolean = True,
show_section_colours: Boolean = True,
show_section_contour: Boolean = True,
**kwargs: Any,
) -> Tuple[plt.Figure, plt.Axes]:
"""
Plot the visible spectrum volume, i.e. *Rösch-MacAdam* colour solid,
section colours along given axis and origin.
Parameters
----------
cmfs
Standard observer colour matching functions, default to the
*CIE 1931 2 Degree Standard Observer*. ``cmfs`` can be of any type or
form supported by the :func:`colour.plotting.filter_cmfs` definition.
illuminant
Illuminant spectral distribution, default to *CIE Illuminant D65*.
``illuminant`` can be of any type or form supported by the
:func:`colour.plotting.filter_illuminants` definition.
model
Colourspace model, see :attr:`colour.COLOURSPACE_MODELS` attribute for
the list of supported colourspace models.
axis
Axis the hull section will be normal to.
origin
Coordinate along ``axis`` at which to plot the hull section.
normalise
Whether to normalise ``axis`` to the extent of the hull along it.
show_section_colours
Whether to show the hull section colours.
show_section_contour
Whether to show the hull section contour.
Other Parameters
----------------
kwargs
{:func:`colour.plotting.artist`,
:func:`colour.plotting.render`,
:func:`colour.plotting.section.plot_hull_section_colours`
:func:`colour.plotting.section.plot_hull_section_contour`},
See the documentation of the previously listed definitions.
Returns
-------
:class:`tuple`
Current figure and axes.
Examples
--------
>>> from colour.utilities import is_trimesh_installed
>>> if is_trimesh_installed:
... plot_visible_spectrum_section(
... section_colours='RGB', section_opacity=0.15)
... # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, <...AxesSubplot...>)
.. image:: ../_static/Plotting_Plot_Visible_Spectrum_Section.png
:align: center
:alt: plot_visible_spectrum_section
"""
import trimesh
settings: Dict[str, Any] = {"uniform": True}
settings.update(kwargs)
_figure, axes = artist(**settings)
# pylint: disable=E1102
cmfs = reshape_msds(first_item(filter_cmfs(cmfs).values()),
SpectralShape(360, 780, 1))
illuminant = cast(
SpectralDistribution,
first_item(filter_illuminants(illuminant).values()),
)
vertices = solid_RoschMacAdam(
cmfs,
illuminant,
point_order="Pulse Wave Width",
filter_jagged_points=True,
)
mesh = trimesh.Trimesh(vertices)
hull = trimesh.convex.convex_hull(mesh)
if show_section_colours:
settings = {"axes": axes}
settings.update(kwargs)
settings["standalone"] = False
plot_hull_section_colours(hull, model, axis, origin, normalise,
**settings)
if show_section_contour:
settings = {"axes": axes}
settings.update(kwargs)
settings["standalone"] = False
plot_hull_section_contour(hull, model, axis, origin, normalise,
**settings)
title = (f"Visible Spectrum Section - "
f"{f'{origin * 100}%' if normalise else origin} - "
f"{model} - "
f"{cmfs.strict_name}")
plane = MAPPING_AXIS_TO_PLANE[axis]
labels = np.array(COLOURSPACE_MODELS_AXIS_LABELS[model])[as_int_array(
colourspace_model_axis_reorder([0, 1, 2], model))]
x_label, y_label = labels[plane[0]], labels[plane[1]]
settings.update({
"axes": axes,
"standalone": True,
"title": title,
"x_label": x_label,
"y_label": y_label,
})
settings.update(kwargs)
return render(**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: +SKIP
.. 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])
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 plot_visible_spectrum(cmfs='CIE 1931 2 Degree Standard Observer',
out_of_gamut_clipping=True,
**kwargs):
"""
Plots the visible colours spectrum using given standard observer *CIE XYZ*
colour matching functions.
Parameters
----------
cmfs : unicode, optional
Standard observer colour matching functions used for spectrum creation.
out_of_gamut_clipping : bool, optional
Whether to clip out of gamut colours otherwise, the colours will be
offset by the absolute minimal colour leading to a rendering on
gray background, less saturated and smoother.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.plot_single_sd`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
References
----------
:cite:`Spiker2015a`
Examples
--------
>>> plot_visible_spectrum() # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, \
<matplotlib.axes._subplots.AxesSubplot object at 0x...>)
.. image:: ../_static/Plotting_Plot_Visible_Spectrum.png
:align: center
:alt: plot_visible_spectrum
"""
cmfs = first_item(filter_cmfs(cmfs).values())
bounding_box = (min(cmfs.wavelengths), max(cmfs.wavelengths), 0, 1)
settings = {'bounding_box': bounding_box, 'y_label': None}
settings.update(kwargs)
settings['standalone'] = False
_figure, axes = plot_single_sd(sd_ones(cmfs.shape),
cmfs=cmfs,
out_of_gamut_clipping=out_of_gamut_clipping,
**settings)
# Removing wavelength line as it doubles with the axes spine.
axes.lines.pop(0)
settings = {
'axes': axes,
'standalone': True,
'title': 'The Visible Spectrum - {0}'.format(cmfs.strict_name),
'x_label': 'Wavelength $\\lambda$ (nm)',
}
settings.update(kwargs)
return render(**settings)
def plot_pointer_gamut(method='CIE 1931', **kwargs):
"""
Plots *Pointer's Gamut* according to given method.
Parameters
----------
method : unicode, optional
**{'CIE 1931', 'CIE 1960 UCS', 'CIE 1976 UCS'}**,
Plotting 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_pointer_gamut() # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_Pointer_Gamut.png
:align: center
:alt: plot_pointer_gamut
"""
settings = {'uniform': True}
settings.update(kwargs)
_figure, axes = artist(**settings)
method = method.upper()
if method == 'CIE 1931':
def XYZ_to_ij(XYZ, *args):
"""
Converts given *CIE XYZ* tristimulus values to *ij* chromaticity
coordinates.
"""
return XYZ_to_xy(XYZ, *args)
def xy_to_ij(xy):
"""
Converts given *xy* chromaticity coordinates to *ij* chromaticity
coordinates.
"""
return xy
elif method == 'CIE 1960 UCS':
def XYZ_to_ij(XYZ, *args):
"""
Converts given *CIE XYZ* tristimulus values to *ij* chromaticity
coordinates.
"""
return UCS_to_uv(XYZ_to_UCS(XYZ))
def xy_to_ij(xy):
"""
Converts given *xy* chromaticity coordinates to *ij* chromaticity
coordinates.
"""
return xy_to_UCS_uv(xy)
elif method == 'CIE 1976 UCS':
def XYZ_to_ij(XYZ, *args):
"""
Converts given *CIE XYZ* tristimulus values to *ij* chromaticity
coordinates.
"""
return Luv_to_uv(XYZ_to_Luv(XYZ, *args), *args)
def xy_to_ij(xy):
"""
Converts given *xy* chromaticity coordinates to *ij* chromaticity
coordinates.
"""
return xy_to_Luv_uv(xy)
else:
raise ValueError(
'Invalid method: "{0}", must be one of '
'{{\'CIE 1931\', \'CIE 1960 UCS\', \'CIE 1976 UCS\'}}'.format(
method))
ij = xy_to_ij(as_float_array(POINTER_GAMUT_BOUNDARIES))
alpha_p = COLOUR_STYLE_CONSTANTS.opacity.high
colour_p = COLOUR_STYLE_CONSTANTS.colour.darkest
axes.plot(
ij[..., 0],
ij[..., 1],
label='Pointer\'s Gamut',
color=colour_p,
alpha=alpha_p)
axes.plot(
(ij[-1][0], ij[0][0]), (ij[-1][1], ij[0][1]),
color=colour_p,
alpha=alpha_p)
XYZ = Lab_to_XYZ(
LCHab_to_Lab(POINTER_GAMUT_DATA), POINTER_GAMUT_ILLUMINANT)
ij = XYZ_to_ij(XYZ, POINTER_GAMUT_ILLUMINANT)
axes.scatter(
ij[..., 0], ij[..., 1], alpha=alpha_p / 2, color=colour_p, marker='+')
settings.update({'axes': axes})
settings.update(kwargs)
return render(**settings)
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 plot_RGB_colourspaces_in_chromaticity_diagram(
colourspaces=None,
cmfs='CIE 1931 2 Degree Standard Observer',
chromaticity_diagram_callable=plot_chromaticity_diagram,
method='CIE 1931',
show_whitepoints=True,
show_pointer_gamut=False,
**kwargs):
"""
Plots given *RGB* colourspaces in the *Chromaticity Diagram* according
to given method.
Parameters
----------
colourspaces : array_like, optional
*RGB* colourspaces to plot.
cmfs : unicode, optional
Standard observer colour matching functions used for
*Chromaticity Diagram* bounds.
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.
show_whitepoints : bool, optional
Whether to display the *RGB* colourspaces whitepoints.
show_pointer_gamut : bool, optional
Whether to display the *Pointer's Gamut*.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.diagrams.plot_chromaticity_diagram`,
:func:`colour.plotting.plot_pointer_gamut`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> plot_RGB_colourspaces_in_chromaticity_diagram(
... ['ITU-R BT.709', 'ACEScg', 'S-Gamut'])
... # doctest: +SKIP
.. image:: ../_static/Plotting_\
Plot_RGB_Colourspaces_In_Chromaticity_Diagram.png
:align: center
:alt: plot_RGB_colourspaces_in_chromaticity_diagram
"""
if colourspaces is None:
colourspaces = ['ITU-R BT.709', 'ACEScg', 'S-Gamut']
colourspaces = filter_RGB_colourspaces(colourspaces).values()
settings = {'uniform': True}
settings.update(kwargs)
_figure, axes = artist(**settings)
method = method.upper()
cmfs = first_item(filter_cmfs(cmfs).values())
title = '{0}\n{1} - {2} Chromaticity Diagram'.format(
', '.join([colourspace.name for colourspace in colourspaces]),
cmfs.name, method)
settings = {'axes': axes, 'title': title, 'method': method}
settings.update(kwargs)
settings['standalone'] = False
chromaticity_diagram_callable(**settings)
if show_pointer_gamut:
settings = {'axes': axes, 'method': method}
settings.update(kwargs)
settings['standalone'] = False
plot_pointer_gamut(**settings)
if method == 'CIE 1931':
def xy_to_ij(xy):
"""
Converts given *xy* chromaticity coordinates to *ij* chromaticity
coordinates.
"""
return xy
x_limit_min, x_limit_max = [-0.1], [0.9]
y_limit_min, y_limit_max = [-0.1], [0.9]
elif method == 'CIE 1960 UCS':
def xy_to_ij(xy):
"""
Converts given *xy* chromaticity coordinates to *ij* chromaticity
coordinates.
"""
return xy_to_UCS_uv(xy)
x_limit_min, x_limit_max = [-0.1], [0.7]
y_limit_min, y_limit_max = [-0.2], [0.6]
elif method == 'CIE 1976 UCS':
def xy_to_ij(xy):
"""
Converts given *xy* chromaticity coordinates to *ij* chromaticity
coordinates.
"""
return xy_to_Luv_uv(xy)
x_limit_min, x_limit_max = [-0.1], [0.7]
y_limit_min, y_limit_max = [-0.1], [0.7]
else:
raise ValueError(
'Invalid method: "{0}", must be one of '
'{{\'CIE 1931\', \'CIE 1960 UCS\', \'CIE 1976 UCS\'}}'.format(
method))
settings = {'colour_cycle_count': len(colourspaces)}
settings.update(kwargs)
cycle = colour_cycle(**settings)
for colourspace in colourspaces:
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.
P = np.where(
colourspace.primaries == 0,
EPSILON,
colourspace.primaries,
)
P = xy_to_ij(P)
W = xy_to_ij(colourspace.whitepoint)
axes.plot(
(W[0], W[0]), (W[1], W[1]),
color=(R, G, B),
label=colourspace.name)
if show_whitepoints:
axes.plot((W[0], W[0]), (W[1], W[1]), 'o', color=(R, G, B))
axes.plot(
(P[0, 0], P[1, 0]), (P[0, 1], P[1, 1]), 'o-', color=(R, G, B))
axes.plot(
(P[1, 0], P[2, 0]), (P[1, 1], P[2, 1]), 'o-', color=(R, G, B))
axes.plot(
(P[2, 0], P[0, 0]), (P[2, 1], P[0, 1]), 'o-', color=(R, G, B))
x_limit_min.append(np.amin(P[..., 0]) - 0.1)
y_limit_min.append(np.amin(P[..., 1]) - 0.1)
x_limit_max.append(np.amax(P[..., 0]) + 0.1)
y_limit_max.append(np.amax(P[..., 1]) + 0.1)
bounding_box = (
min(x_limit_min),
max(x_limit_max),
min(y_limit_min),
max(y_limit_max),
)
settings.update({
'standalone': True,
'legend': True,
'bounding_box': bounding_box,
})
settings.update(kwargs)
return render(**settings)
def plot_colour_quality_bars(specifications,
labels=True,
hatching=None,
hatching_repeat=2,
**kwargs):
"""
Plots the colour quality data of given illuminants or light sources colour
quality specifications.
Parameters
----------
specifications : array_like
Array of illuminants or light sources colour quality specifications.
labels : bool, optional
Add labels above bars.
hatching : bool or None, optional
Use hatching for the bars.
hatching_repeat : int, optional
Hatching pattern repeat.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.quality.plot_colour_quality_bars`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> from colour import (ILLUMINANTS_SDS,
... LIGHT_SOURCES_SDS, SpectralShape)
>>> illuminant = ILLUMINANTS_SDS['FL2']
>>> light_source = LIGHT_SOURCES_SDS['Kinoton 75P']
>>> light_source = light_source.copy().align(SpectralShape(360, 830, 1))
>>> cqs_i = colour_quality_scale(illuminant, additional_data=True)
>>> cqs_l = colour_quality_scale(light_source, additional_data=True)
>>> plot_colour_quality_bars([cqs_i, cqs_l]) # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_Colour_Quality_Bars.png
:align: center
:alt: plot_colour_quality_bars
"""
settings = {'uniform': True}
settings.update(kwargs)
_figure, axes = artist(**settings)
bar_width = 0.5
y_ticks_interval = 10
count_s, count_Q_as = len(specifications), 0
patterns = cycle(COLOUR_STYLE_CONSTANTS.hatch.patterns)
if hatching is None:
hatching = False if count_s == 1 else True
for i, specification in enumerate(specifications):
Q_a, Q_as, colorimetry_data = (specification.Q_a, specification.Q_as,
specification.colorimetry_data)
count_Q_as = len(Q_as)
colours = ([[1] * 3] + [
np.clip(XYZ_to_plotting_colourspace(x.XYZ), 0, 1)
for x in colorimetry_data[0]
])
x = (i + np.arange(
0, (count_Q_as + 1) * (count_s + 1), (count_s + 1),
dtype=DEFAULT_FLOAT_DTYPE)) * bar_width
y = [s[1].Q_a for s in sorted(Q_as.items(), key=lambda s: s[0])]
y = np.array([Q_a] + list(y))
bars = plt.bar(
x,
np.abs(y),
color=colours,
width=bar_width,
edgecolor=COLOUR_STYLE_CONSTANTS.colour.dark,
label=specification.name)
hatches = ([next(patterns) * hatching_repeat] * (count_Q_as + 1)
if hatching else np.where(y < 0, next(patterns),
None).tolist())
for j, bar in enumerate(bars.patches):
bar.set_hatch(hatches[j])
if labels:
label_rectangles(
y,
bars,
rotation='horizontal' if count_s == 1 else 'vertical',
offset=(0 if count_s == 1 else 3 / 100 * count_s + 65 / 1000,
0.025),
text_size=-5 / 7 * count_s + 12.5)
axes.axhline(
y=100, color=COLOUR_STYLE_CONSTANTS.colour.dark, linestyle='--')
axes.set_xticks((np.arange(
0, (count_Q_as + 1) * (count_s + 1), (count_s + 1),
dtype=DEFAULT_FLOAT_DTYPE) * bar_width + (count_s * bar_width / 2)),
['Qa'] + [
'Q{0}'.format(index + 1)
for index in range(0, count_Q_as + 1, 1)
])
axes.set_yticks(range(0, 100 + y_ticks_interval, y_ticks_interval))
aspect = 1 / (120 / (bar_width + len(Q_as) + bar_width * 2))
bounding_box = (-bar_width, ((count_Q_as + 1) * (count_s + 1)) / 2, 0, 120)
settings = {
'axes': axes,
'aspect': aspect,
'bounding_box': bounding_box,
'legend': hatching,
'title': 'Colour Quality',
}
settings.update(kwargs)
return render(**settings)
def plot_planckian_locus_in_chromaticity_diagram(
illuminants=None,
annotate_parameters=None,
chromaticity_diagram_callable=plot_chromaticity_diagram,
method='CIE 1931',
**kwargs):
"""
Plots the *Planckian Locus* and given illuminants in the
*Chromaticity Diagram* according to given method.
Parameters
----------
illuminants : array_like, optional
Factory illuminants to plot.
annotate_parameters : dict or array_like, optional
Parameters for the :func:`plt.annotate` definition, used to annotate
the resulting chromaticity coordinates with their respective illuminant
names if ``annotate`` is set to *True*. ``annotate_parameters`` can be
either a single dictionary applied to all the arrows with same settings
or a sequence of dictionaries with different settings for each
illuminant.
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.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.diagrams.plot_chromaticity_diagram`,
:func:`colour.plotting.temperature.plot_planckian_locus`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> plot_planckian_locus_in_chromaticity_diagram(['A', 'B', 'C'])
... # doctest: +SKIP
.. image:: ../_static/Plotting_\
Plot_Planckian_Locus_In_Chromaticity_Diagram.png
:align: center
:alt: plot_planckian_locus_in_chromaticity_diagram
"""
cmfs = CMFS['CIE 1931 2 Degree Standard Observer']
if illuminants is None:
illuminants = ('A', 'B', 'C')
illuminants = filter_passthrough(ILLUMINANTS.get(cmfs.name), illuminants)
settings = {'uniform': True}
settings.update(kwargs)
_figure, axes = artist(**settings)
method = method.upper()
settings = {'axes': axes, 'method': method}
settings.update(kwargs)
settings['standalone'] = False
chromaticity_diagram_callable(**settings)
plot_planckian_locus(**settings)
if method == 'CIE 1931':
def xy_to_ij(xy):
"""
Converts given *xy* chromaticity coordinates to *ij* chromaticity
coordinates.
"""
return xy
bounding_box = (-0.1, 0.9, -0.1, 0.9)
elif method == 'CIE 1960 UCS':
def xy_to_ij(xy):
"""
Converts given *xy* chromaticity coordinates to *ij* chromaticity
coordinates.
"""
return UCS_to_uv(XYZ_to_UCS(xy_to_XYZ(xy)))
bounding_box = (-0.1, 0.7, -0.2, 0.6)
else:
raise ValueError('Invalid method: "{0}", must be one of '
'{{\'CIE 1931\', \'CIE 1960 UCS\'}}'.format(method))
annotate_settings_collection = [{
'annotate': True,
'xytext': (-50, 30),
'textcoords': 'offset points',
'arrowprops': COLOUR_ARROW_STYLE,
} for _ in range(len(illuminants))]
if annotate_parameters is not None:
if not isinstance(annotate_parameters, dict):
assert len(annotate_parameters) == len(illuminants), (
'Multiple annotate parameters defined, but they do not match '
'the illuminants count!')
for i, annotate_settings in enumerate(annotate_settings_collection):
if isinstance(annotate_parameters, dict):
annotate_settings.update(annotate_parameters)
else:
annotate_settings.update(annotate_parameters[i])
for i, (illuminant, xy) in enumerate(illuminants.items()):
ij = xy_to_ij(xy)
axes.plot(
ij[0],
ij[1],
'o',
color=COLOUR_STYLE_CONSTANTS.colour.brightest,
markeredgecolor=COLOUR_STYLE_CONSTANTS.colour.dark,
markersize=(COLOUR_STYLE_CONSTANTS.geometry.short * 6 +
COLOUR_STYLE_CONSTANTS.geometry.short * 0.75),
markeredgewidth=COLOUR_STYLE_CONSTANTS.geometry.short * 0.75,
label=illuminant)
if annotate_settings_collection[i]['annotate']:
annotate_settings = annotate_settings_collection[i]
annotate_settings.pop('annotate')
plt.annotate(illuminant, xy=ij, **annotate_settings)
title = (('{0} Illuminants - Planckian Locus\n'
'{1} Chromaticity Diagram - '
'CIE 1931 2 Degree Standard Observer').format(
', '.join(illuminants), method) if illuminants else
('Planckian Locus\n{0} Chromaticity Diagram - '
'CIE 1931 2 Degree Standard Observer'.format(method)))
settings.update({
'axes': axes,
'standalone': True,
'bounding_box': bounding_box,
'title': title,
})
settings.update(kwargs)
return render(**settings)
def plot_planckian_locus(planckian_locus_colours=None,
method='CIE 1931',
**kwargs):
"""
Plots the *Planckian Locus* according to given method.
Parameters
----------
planckian_locus_colours : array_like or unicode, optional
*Planckian Locus* colours.
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_planckian_locus() # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_Planckian_Locus.png
:align: center
:alt: plot_planckian_locus
"""
if planckian_locus_colours is None:
planckian_locus_colours = COLOUR_STYLE_CONSTANTS.colour.dark
settings = {'uniform': True}
settings.update(kwargs)
_figure, axes = artist(**settings)
if method == 'CIE 1931':
def uv_to_ij(uv):
"""
Converts given *uv* chromaticity coordinates to *ij* chromaticity
coordinates.
"""
return UCS_uv_to_xy(uv)
D_uv = 0.025
elif method == 'CIE 1960 UCS':
def uv_to_ij(uv):
"""
Converts given *uv* chromaticity coordinates to *ij* chromaticity
coordinates.
"""
return uv
D_uv = 0.025
else:
raise ValueError('Invalid method: "{0}", must be one of '
'{{\'CIE 1931\', \'CIE 1960 UCS\'}}'.format(method))
start, end = 1667, 100000
CCT = np.arange(start, end + 250, 250)
CCT_D_uv = tstack([CCT, np.zeros(CCT.shape)])
ij = uv_to_ij(CCT_to_uv(CCT_D_uv, 'Robertson 1968'))
axes.plot(ij[..., 0], ij[..., 1], color=planckian_locus_colours)
for i in (1667, 2000, 2500, 3000, 4000, 6000, 10000):
i0, j0 = uv_to_ij(CCT_to_uv(np.array([i, -D_uv]), 'Robertson 1968'))
i1, j1 = uv_to_ij(CCT_to_uv(np.array([i, D_uv]), 'Robertson 1968'))
axes.plot((i0, i1), (j0, j1), color=planckian_locus_colours)
axes.annotate(
'{0}K'.format(i),
xy=(i0, j0),
xytext=(0, -10),
textcoords='offset points',
size='x-small')
settings = {'axes': axes}
settings.update(kwargs)
return render(**settings)
def plot_blackbody_spectral_radiance(
temperature=3500,
cmfs='CIE 1931 2 Degree Standard Observer',
blackbody='VY Canis Major',
**kwargs):
"""
Plots given blackbody spectral radiance.
Parameters
----------
temperature : numeric, optional
Blackbody temperature.
cmfs : unicode, optional
Standard observer colour matching functions.
blackbody : unicode, optional
Blackbody name.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.plot_single_sd`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> plot_blackbody_spectral_radiance(3500, blackbody='VY Canis Major')
... # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_Blackbody_Spectral_Radiance.png
:align: center
:alt: plot_blackbody_spectral_radiance
"""
figure = plt.figure()
figure.subplots_adjust(hspace=COLOUR_STYLE_CONSTANTS.geometry.short / 2)
cmfs = first_item(filter_cmfs(cmfs).values())
sd = sd_blackbody(temperature, cmfs.shape)
axes = figure.add_subplot(211)
settings = {
'axes': axes,
'title': '{0} - Spectral Radiance'.format(blackbody),
'y_label': 'W / (sr m$^2$) / m',
}
settings.update(kwargs)
settings['standalone'] = False
plot_single_sd(sd, cmfs.name, **settings)
axes = figure.add_subplot(212)
with domain_range_scale('1'):
XYZ = sd_to_XYZ(sd, cmfs)
RGB = normalise_maximum(XYZ_to_plotting_colourspace(XYZ))
settings = {
'axes': axes,
'aspect': None,
'title': '{0} - Colour'.format(blackbody),
'x_label': '{0}K'.format(temperature),
'y_label': '',
'x_ticker': False,
'y_ticker': False,
}
settings.update(kwargs)
settings['standalone'] = False
figure, axes = plot_single_colour_swatch(
ColourSwatch(name='', RGB=RGB), **settings)
settings = {'axes': axes, 'standalone': True}
settings.update(kwargs)
return render(**settings)
def plot_multi_sds(sds,
cmfs='CIE 1931 2 Degree Standard Observer',
use_sds_colours=False,
normalise_sds_colours=False,
**kwargs):
"""
Plots given spectral distributions.
Parameters
----------
sds : array_like or MultiSpectralDistributions
Spectral distributions or multi-spectral distributions to
plot. `sds` can be a single
:class:`colour.MultiSpectralDistributions` class instance, a list
of :class:`colour.MultiSpectralDistributions` class instances or a
list of :class:`colour.SpectralDistribution` class instances.
cmfs : unicode, optional
Standard observer colour matching functions used for spectrum creation.
use_sds_colours : bool, optional
Whether to use spectral distributions colours.
normalise_sds_colours : bool
Whether to normalise spectral distributions colours.
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
--------
>>> from colour import SpectralDistribution
>>> data_1 = {
... 500: 0.004900,
... 510: 0.009300,
... 520: 0.063270,
... 530: 0.165500,
... 540: 0.290400,
... 550: 0.433450,
... 560: 0.594500
... }
>>> data_2 = {
... 500: 0.323000,
... 510: 0.503000,
... 520: 0.710000,
... 530: 0.862000,
... 540: 0.954000,
... 550: 0.994950,
... 560: 0.995000
... }
>>> sd_1 = SpectralDistribution(data_1, name='Custom 1')
>>> sd_2 = SpectralDistribution(data_2, name='Custom 2')
>>> plot_multi_sds([sd_1, sd_2]) # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, \
<matplotlib.axes._subplots.AxesSubplot object at 0x...>)
.. image:: ../_static/Plotting_Plot_Multi_SDS.png
:align: center
:alt: plot_multi_sds
"""
_figure, axes = artist(**kwargs)
sds = sds_and_multi_sds_to_sds(sds)
cmfs = first_item(filter_cmfs(cmfs).values())
illuminant = ILLUMINANTS_SDS[
COLOUR_STYLE_CONSTANTS.colour.colourspace.illuminant]
x_limit_min, x_limit_max, y_limit_min, y_limit_max = [], [], [], []
for sd in sds:
wavelengths, values = sd.wavelengths, sd.values
shape = sd.shape
x_limit_min.append(shape.start)
x_limit_max.append(shape.end)
y_limit_min.append(min(values))
y_limit_max.append(max(values))
if use_sds_colours:
with domain_range_scale('1'):
XYZ = sd_to_XYZ(sd, cmfs, illuminant)
if normalise_sds_colours:
XYZ = normalise_maximum(XYZ, clip=False)
RGB = np.clip(XYZ_to_plotting_colourspace(XYZ), 0, 1)
axes.plot(wavelengths, values, color=RGB, label=sd.strict_name)
else:
axes.plot(wavelengths, values, label=sd.strict_name)
bounding_box = (min(x_limit_min), max(x_limit_max), min(y_limit_min),
max(y_limit_max) + max(y_limit_max) * 0.05)
settings = {
'axes': axes,
'bounding_box': bounding_box,
'legend': True,
'x_label': 'Wavelength $\\lambda$ (nm)',
'y_label': 'Spectral Distribution',
}
settings.update(kwargs)
return render(**settings)
def plot_ellipses_MacAdam1942_in_chromaticity_diagram(
chromaticity_diagram_callable=plot_chromaticity_diagram,
method='CIE 1931',
chromaticity_diagram_clipping=False,
ellipse_parameters=None,
**kwargs):
"""
Plots *MacAdam (1942) Ellipses (Observer PGN)* in the
*Chromaticity Diagram* according to given method.
Parameters
----------
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.
chromaticity_diagram_clipping : bool, optional,
Whether to clip the *Chromaticity Diagram* colours with the ellipses.
ellipse_parameters : dict or array_like, optional
Parameters for the :class:`Ellipse` class, ``ellipse_parameters`` can
be either a single dictionary applied to all the ellipses with same
settings or a sequence of dictionaries with different settings for each
ellipse.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.diagrams.plot_chromaticity_diagram`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> plot_ellipses_MacAdam1942_in_chromaticity_diagram() # doctest: +SKIP
.. image:: ../_static/\
Plotting_Plot_Ellipses_MacAdam1942_In_Chromaticity_Diagram.png
:align: center
:alt: plot_ellipses_MacAdam1942_in_chromaticity_diagram
"""
settings = {'uniform': True}
settings.update(kwargs)
_figure, axes = artist(**settings)
settings = dict(kwargs)
settings.update({'axes': axes, 'standalone': False})
ellipses_coefficients = ellipses_MacAdam1942(method=method)
if chromaticity_diagram_clipping:
diagram_clipping_path_x = []
diagram_clipping_path_y = []
for coefficients in ellipses_coefficients:
coefficients = np.copy(coefficients)
coefficients[2:4] /= 2
x, y = tsplit(
point_at_angle_on_ellipse(
np.linspace(0, 360, 36),
coefficients,
))
diagram_clipping_path_x.append(x)
diagram_clipping_path_y.append(y)
diagram_clipping_path = np.rollaxis(
np.array([diagram_clipping_path_x, diagram_clipping_path_y]), 0, 3)
diagram_clipping_path = Path.make_compound_path_from_polys(
diagram_clipping_path).vertices
settings.update({'diagram_clipping_path': diagram_clipping_path})
chromaticity_diagram_callable(**settings)
ellipse_settings_collection = [{
'color': COLOUR_STYLE_CONSTANTS.colour.cycle[4],
'alpha': 0.4,
'edgecolor': COLOUR_STYLE_CONSTANTS.colour.cycle[1],
'linewidth': colour_style()['lines.linewidth']
} for _ellipses_coefficient in ellipses_coefficients]
if ellipse_parameters is not None:
if not isinstance(ellipse_parameters, dict):
assert len(ellipse_parameters) == len(ellipses_coefficients), (
'Multiple ellipse parameters defined, but they do not match '
'the ellipses count!')
for i, ellipse_settings in enumerate(ellipse_settings_collection):
if isinstance(ellipse_parameters, dict):
ellipse_settings.update(ellipse_parameters)
else:
ellipse_settings.update(ellipse_parameters[i])
for i, coefficients in enumerate(ellipses_coefficients):
x_c, y_c, a_a, a_b, theta_e = coefficients
ellipse = Ellipse((x_c, y_c), a_a, a_b, theta_e,
**ellipse_settings_collection[i])
axes.add_artist(ellipse)
settings.update({'standalone': True})
settings.update(kwargs)
return render(**settings)
def plot_blackbody_spectral_radiance(
temperature=3500,
cmfs='CIE 1931 2 Degree Standard Observer',
blackbody='VY Canis Major',
**kwargs):
"""
Plots given blackbody spectral radiance.
Parameters
----------
temperature : numeric, optional
Blackbody temperature.
cmfs : unicode, optional
Standard observer colour matching functions.
blackbody : unicode, optional
Blackbody name.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.plot_single_sd`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> plot_blackbody_spectral_radiance(3500, blackbody='VY Canis Major')
... # doctest: +ELLIPSIS
(<Figure size ... with 2 Axes>, \
<matplotlib.axes._subplots.AxesSubplot object at 0x...>)
.. image:: ../_static/Plotting_Plot_Blackbody_Spectral_Radiance.png
:align: center
:alt: plot_blackbody_spectral_radiance
"""
figure = plt.figure()
figure.subplots_adjust(hspace=COLOUR_STYLE_CONSTANTS.geometry.short / 2)
cmfs = first_item(filter_cmfs(cmfs).values())
sd = sd_blackbody(temperature, cmfs.shape)
axes = figure.add_subplot(211)
settings = {
'axes': axes,
'title': '{0} - Spectral Radiance'.format(blackbody),
'y_label': 'W / (sr m$^2$) / m',
}
settings.update(kwargs)
settings['standalone'] = False
plot_single_sd(sd, cmfs.name, **settings)
axes = figure.add_subplot(212)
with domain_range_scale('1'):
XYZ = sd_to_XYZ(sd, cmfs)
RGB = normalise_maximum(XYZ_to_plotting_colourspace(XYZ))
settings = {
'axes': axes,
'aspect': None,
'title': '{0} - Colour'.format(blackbody),
'x_label': '{0}K'.format(temperature),
'y_label': '',
'x_ticker': False,
'y_ticker': False,
}
settings.update(kwargs)
settings['standalone'] = False
figure, axes = plot_single_colour_swatch(ColourSwatch(name='', RGB=RGB),
**settings)
settings = {'axes': axes, 'standalone': True}
settings.update(kwargs)
return render(**settings)
'Wavelength $\\lambda$ (nm)',
'y_label':
'Spectral Distribution',
'legend':
True,
'legend_location':
'upper left',
'x_ticker':
True,
'y_ticker':
True,
'bounding_box': (min(x_limit_min), max(x_limit_max), min(y_limit_min),
max(y_limit_max))
}
render(**settings)
print('\n')
V_xyz = np.random.random((6, 3))
message_box(('Performing "trilinear" interpolation of given "xyz" values:\n'
'\n{0}\n'
'\nusing given interpolation table.'.format(V_xyz)))
path = os.path.join(
os.path.dirname(__file__), '..', '..', 'io', 'luts', 'tests', 'resources',
'iridas_cube', 'ColourCorrect.cube')
table = colour.read_LUT(path).table
print(colour.table_interpolation(V_xyz, table, method='Trilinear'))
print(colour.algebra.table_interpolation_trilinear(V_xyz, table))
print('\n')
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: +SKIP
.. 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 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: +SKIP
.. 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])
# Avoiding zero division in later colour transformations.
ij = np.where(ij == 0, EPSILON, ij)
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 plot_hull_section_contour(
hull: trimesh.Trimesh, # type: ignore[name-defined] # noqa
model: Union[Literal["CAM02LCD", "CAM02SCD", "CAM02UCS", "CAM16LCD",
"CAM16SCD", "CAM16UCS", "CIE XYZ", "CIE xyY",
"CIE Lab", "CIE Luv", "CIE UCS", "CIE UVW", "DIN99",
"Hunter Lab", "Hunter Rdab", "ICaCb", "ICtCp", "IPT",
"IgPgTg", "Jzazbz", "OSA UCS", "Oklab", "hdr-CIELAB",
"hdr-IPT", ], str, ] = "CIE xyY",
axis: Union[Literal["+z", "+x", "+y"], str] = "+z",
origin: Floating = 0.5,
normalise: Boolean = True,
contour_colours: Optional[Union[ArrayLike, str]] = None,
contour_opacity: Floating = 1,
convert_kwargs: Optional[Dict] = None,
**kwargs: Any,
) -> Tuple[plt.Figure, plt.Axes]:
"""
Plot the section contour of given *trimesh* hull along given axis and
origin.
Parameters
----------
hull
*Trimesh* hull.
model
Colourspace model, see :attr:`colour.COLOURSPACE_MODELS` attribute for
the list of supported colourspace models.
axis
Axis the hull section will be normal to.
origin
Coordinate along ``axis`` at which to plot the hull section.
normalise
Whether to normalise ``axis`` to the extent of the hull along it.
contour_colours
Colours of the hull section contour, if ``contour_colours`` is set to
*RGB*, the colours will be computed according to the corresponding
coordinates.
contour_opacity
Opacity of the hull section contour.
convert_kwargs
Keyword arguments for the :func:`colour.convert` definition.
Other Parameters
----------------
kwargs
{:func:`colour.plotting.artist`,
:func:`colour.plotting.render`},
See the documentation of the previously listed definitions.
Returns
-------
:class:`tuple`
Current figure and axes.
Examples
--------
>>> from colour.models import RGB_COLOURSPACE_sRGB
>>> from colour.utilities import is_trimesh_installed
>>> vertices, faces, _outline = primitive_cube(1, 1, 1, 64, 64, 64)
>>> XYZ_vertices = RGB_to_XYZ(
... vertices['position'] + 0.5,
... RGB_COLOURSPACE_sRGB.whitepoint,
... RGB_COLOURSPACE_sRGB.whitepoint,
... RGB_COLOURSPACE_sRGB.matrix_RGB_to_XYZ,
... )
>>> if is_trimesh_installed:
... import trimesh
... hull = trimesh.Trimesh(XYZ_vertices, faces, process=False)
... plot_hull_section_contour(hull, contour_colours='RGB')
... # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, <...AxesSubplot...>)
.. image:: ../_static/Plotting_Plot_Hull_Section_Contour.png
:align: center
:alt: plot_hull_section_contour
"""
hull = hull.copy()
contour_colours = cast(
Union[ArrayLike, str],
optional(contour_colours, CONSTANTS_COLOUR_STYLE.colour.dark),
)
settings: Dict[str, Any] = {"uniform": True}
settings.update(kwargs)
_figure, axes = artist(**settings)
convert_kwargs = optional(convert_kwargs, {})
# Luminance / Lightness is re-ordered along "z-up" axis.
with suppress_warnings(python_warnings=True):
ijk_vertices = colourspace_model_axis_reorder(
convert(hull.vertices, "CIE XYZ", model, **convert_kwargs), model)
ijk_vertices = np.nan_to_num(ijk_vertices)
ijk_vertices *= COLOURSPACE_MODELS_DOMAIN_RANGE_SCALE_1_TO_REFERENCE[
model]
hull.vertices = ijk_vertices
plane = MAPPING_AXIS_TO_PLANE[axis]
padding = 0.1 * np.mean(
COLOURSPACE_MODELS_DOMAIN_RANGE_SCALE_1_TO_REFERENCE[model])
min_x = np.min(ijk_vertices[..., plane[0]]) - padding
max_x = np.max(ijk_vertices[..., plane[0]]) + padding
min_y = np.min(ijk_vertices[..., plane[1]]) - padding
max_y = np.max(ijk_vertices[..., plane[1]]) + padding
extent = (min_x, max_x, min_y, max_y)
use_RGB_contour_colours = str(contour_colours).upper() == "RGB"
section = hull_section(hull, axis, origin, normalise)
if use_RGB_contour_colours:
ijk_section = section / (
COLOURSPACE_MODELS_DOMAIN_RANGE_SCALE_1_TO_REFERENCE[model])
XYZ_section = convert(
colourspace_model_axis_reorder(ijk_section, model, "Inverse"),
model,
"CIE XYZ",
**convert_kwargs,
)
contour_colours = np.clip(XYZ_to_plotting_colourspace(XYZ_section), 0,
1)
section = np.reshape(section[..., plane], (-1, 1, 2))
line_collection = LineCollection(
np.concatenate([section[:-1], section[1:]], axis=1),
colors=contour_colours,
alpha=contour_opacity,
zorder=CONSTANTS_COLOUR_STYLE.zorder.background_line,
)
axes.add_collection(line_collection)
settings = {
"axes": axes,
"bounding_box": extent,
}
settings.update(kwargs)
return render(**settings)
def plot_chromaticity_diagram(cmfs='CIE 1931 2 Degree Standard Observer',
show_diagram_colours=True,
show_spectral_locus=True,
method='CIE 1931',
**kwargs):
"""
Plots the *Chromaticity Diagram* according to given method.
Parameters
----------
cmfs : unicode, optional
Standard observer colour matching functions used for
*Chromaticity Diagram* bounds.
show_diagram_colours : bool, optional
Whether to display the *Chromaticity Diagram* background colours.
show_spectral_locus : bool, optional
Whether to display the *Spectral Locus*.
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.diagrams.plot_spectral_locus`,
:func:`colour.plotting.diagrams.plot_chromaticity_diagram_colours`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> plot_chromaticity_diagram() # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_Chromaticity_Diagram.png
:align: center
:alt: plot_chromaticity_diagram
"""
settings = {'uniform': True}
settings.update(kwargs)
_figure, axes = artist(**settings)
method = method.upper()
cmfs = first_item(filter_cmfs(cmfs).values())
if show_diagram_colours:
settings = {'axes': axes, 'method': method}
settings.update(kwargs)
settings['standalone'] = False
plot_chromaticity_diagram_colours(**settings)
if show_spectral_locus:
settings = {'axes': axes, 'method': method}
settings.update(kwargs)
settings['standalone'] = False
plot_spectral_locus(**settings)
if method == 'CIE 1931':
x_label, y_label = 'CIE x', 'CIE y'
elif method == 'CIE 1960 UCS':
x_label, y_label = 'CIE u', 'CIE v'
elif method == 'CIE 1976 UCS':
x_label, y_label = 'CIE u\'', 'CIE v\'',
else:
raise ValueError(
'Invalid method: "{0}", must be one of '
'{{\'CIE 1931\', \'CIE 1960 UCS\', \'CIE 1976 UCS\'}}'.format(
method))
title = '{0} Chromaticity Diagram - {1}'.format(method, cmfs.strict_name)
settings.update({
'axes': axes,
'standalone': True,
'bounding_box': (0, 1, 0, 1),
'title': title,
'x_label': x_label,
'y_label': y_label,
})
settings.update(kwargs)
return render(**settings)
def plot_RGB_colourspace_section(
colourspace: Union[RGB_Colourspace, str, Sequence[Union[RGB_Colourspace,
str]]],
model: Union[Literal["CAM02LCD", "CAM02SCD", "CAM02UCS", "CAM16LCD",
"CAM16SCD", "CAM16UCS", "CIE XYZ", "CIE xyY",
"CIE Lab", "CIE Luv", "CIE UCS", "CIE UVW", "DIN99",
"Hunter Lab", "Hunter Rdab", "ICaCb", "ICtCp", "IPT",
"IgPgTg", "Jzazbz", "OSA UCS", "Oklab", "hdr-CIELAB",
"hdr-IPT", ], str, ] = "CIE xyY",
axis: Union[Literal["+z", "+x", "+y"], str] = "+z",
origin: Floating = 0.5,
normalise: Boolean = True,
show_section_colours: Boolean = True,
show_section_contour: Boolean = True,
**kwargs: Any,
) -> Tuple[plt.Figure, plt.Axes]:
"""
Plot given *RGB* colourspace section colours along given axis and origin.
Parameters
----------
colourspace
*RGB* colourspace of the *RGB* array. ``colourspace`` can be of any
type or form supported by the
:func:`colour.plotting.filter_RGB_colourspaces` definition.
model
Colourspace model, see :attr:`colour.COLOURSPACE_MODELS` attribute for
the list of supported colourspace models.
axis
Axis the hull section will be normal to.
origin
Coordinate along ``axis`` at which to plot the hull section.
normalise
Whether to normalise ``axis`` to the extent of the hull along it.
show_section_colours
Whether to show the hull section colours.
show_section_contour
Whether to show the hull section contour.
Other Parameters
----------------
kwargs
{:func:`colour.plotting.artist`,
:func:`colour.plotting.render`,
:func:`colour.plotting.section.plot_hull_section_colours`
:func:`colour.plotting.section.plot_hull_section_contour`},
See the documentation of the previously listed definitions.
Returns
-------
:class:`tuple`
Current figure and axes.
Examples
--------
>>> from colour.utilities import is_trimesh_installed
>>> if is_trimesh_installed:
... plot_RGB_colourspace_section(
... 'sRGB', section_colours='RGB', section_opacity=0.15)
... # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, <...AxesSubplot...>)
.. image:: ../_static/Plotting_Plot_RGB_Colourspace_Section.png
:align: center
:alt: plot_RGB_colourspace_section
"""
import trimesh
settings: Dict[str, Any] = {"uniform": True}
settings.update(kwargs)
_figure, axes = artist(**settings)
colourspace = cast(
RGB_Colourspace,
first_item(filter_RGB_colourspaces(colourspace).values()),
)
vertices, faces, _outline = primitive_cube(1, 1, 1, 64, 64, 64)
XYZ_vertices = RGB_to_XYZ(
vertices["position"] + 0.5,
colourspace.whitepoint,
colourspace.whitepoint,
colourspace.matrix_RGB_to_XYZ,
)
hull = trimesh.Trimesh(XYZ_vertices, faces, process=False)
if show_section_colours:
settings = {"axes": axes}
settings.update(kwargs)
settings["standalone"] = False
plot_hull_section_colours(hull, model, axis, origin, normalise,
**settings)
if show_section_contour:
settings = {"axes": axes}
settings.update(kwargs)
settings["standalone"] = False
plot_hull_section_contour(hull, model, axis, origin, normalise,
**settings)
title = (f"{colourspace.name} Section - "
f"{f'{origin * 100}%' if normalise else origin} - "
f"{model}")
plane = MAPPING_AXIS_TO_PLANE[axis]
labels = np.array(COLOURSPACE_MODELS_AXIS_LABELS[model])[as_int_array(
colourspace_model_axis_reorder([0, 1, 2], model))]
x_label, y_label = labels[plane[0]], labels[plane[1]]
settings.update({
"axes": axes,
"standalone": True,
"title": title,
"x_label": x_label,
"y_label": y_label,
})
settings.update(kwargs)
return render(**settings)
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: +SKIP
.. 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 plot_sds_in_chromaticity_diagram(
sds,
cmfs='CIE 1931 2 Degree Standard Observer',
annotate_parameters=None,
chromaticity_diagram_callable=plot_chromaticity_diagram,
method='CIE 1931',
**kwargs):
"""
Plots given spectral distribution chromaticity coordinates into the
*Chromaticity Diagram* using given method.
Parameters
----------
sds : array_like, optional
Spectral distributions to plot.
cmfs : unicode, optional
Standard observer colour matching functions used for
*Chromaticity Diagram* bounds.
annotate_parameters : dict or array_like, optional
Parameters for the :func:`plt.annotate` definition, used to annotate
the resulting chromaticity coordinates with their respective spectral
distribution names if ``annotate`` is set to *True*.
``annotate_parameters`` can be either a single dictionary applied to
all the arrows with same settings or a sequence of dictionaries with
different settings for each spectral distribution.
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.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.diagrams.plot_chromaticity_diagram`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> from colour import ILLUMINANTS_SDS
>>> A = ILLUMINANTS_SDS['A']
>>> D65 = ILLUMINANTS_SDS['D65']
>>> plot_sds_in_chromaticity_diagram([A, D65]) # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_SDs_In_Chromaticity_Diagram.png
:align: center
:alt: plot_sds_in_chromaticity_diagram
"""
settings = {'uniform': True}
settings.update(kwargs)
_figure, axes = artist(**settings)
method = method.upper()
settings.update({
'axes': axes,
'standalone': False,
'method': method,
'cmfs': cmfs,
})
chromaticity_diagram_callable(**settings)
if method == 'CIE 1931':
def XYZ_to_ij(XYZ):
"""
Converts given *CIE XYZ* tristimulus values to *ij* chromaticity
coordinates.
"""
return XYZ_to_xy(XYZ)
bounding_box = (-0.1, 0.9, -0.1, 0.9)
elif method == 'CIE 1960 UCS':
def XYZ_to_ij(XYZ):
"""
Converts given *CIE XYZ* tristimulus values to *ij* chromaticity
coordinates.
"""
return UCS_to_uv(XYZ_to_UCS(XYZ))
bounding_box = (-0.1, 0.7, -0.2, 0.6)
elif method == 'CIE 1976 UCS':
def XYZ_to_ij(XYZ):
"""
Converts given *CIE XYZ* tristimulus values to *ij* chromaticity
coordinates.
"""
return Luv_to_uv(XYZ_to_Luv(XYZ))
bounding_box = (-0.1, 0.7, -0.1, 0.7)
else:
raise ValueError(
'Invalid method: "{0}", must be one of '
'{{\'CIE 1931\', \'CIE 1960 UCS\', \'CIE 1976 UCS\'}}'.format(
method))
annotate_settings_collection = [{
'annotate': True,
'xytext': (-50, 30),
'textcoords': 'offset points',
'arrowprops': COLOUR_ARROW_STYLE,
} for _ in range(len(sds))]
if annotate_parameters is not None:
if not isinstance(annotate_parameters, dict):
assert len(annotate_parameters) == len(sds), (
'Multiple annotate parameters defined, but they do not match '
'the spectral distributions count!')
for i, annotate_settings in enumerate(annotate_settings_collection):
if isinstance(annotate_parameters, dict):
annotate_settings.update(annotate_parameters)
else:
annotate_settings.update(annotate_parameters[i])
for i, sd in enumerate(sds):
with domain_range_scale('1'):
XYZ = sd_to_XYZ(sd)
ij = XYZ_to_ij(XYZ)
axes.plot(
ij[0],
ij[1],
'o',
color=COLOUR_STYLE_CONSTANTS.colour.brightest,
markeredgecolor=COLOUR_STYLE_CONSTANTS.colour.dark,
markersize=(COLOUR_STYLE_CONSTANTS.geometry.short * 6 +
COLOUR_STYLE_CONSTANTS.geometry.short * 0.75),
markeredgewidth=COLOUR_STYLE_CONSTANTS.geometry.short * 0.75,
label=sd.strict_name)
if (sd.name is not None and
annotate_settings_collection[i]['annotate']):
annotate_settings = annotate_settings_collection[i]
annotate_settings.pop('annotate')
axes.annotate(sd.name, xy=ij, **annotate_settings)
settings.update({'standalone': True, 'bounding_box': bounding_box})
settings.update(kwargs)
return render(**settings)
def plot_the_blue_sky(cmfs='CIE 1931 2 Degree Standard Observer', **kwargs):
"""
Plots the blue sky.
Parameters
----------
cmfs : unicode, optional
Standard observer colour matching functions.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.plot_single_sd`,
:func:`colour.plotting.plot_multi_colour_swatches`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> plot_the_blue_sky() # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_The_Blue_Sky.png
:align: center
:alt: plot_the_blue_sky
"""
figure = plt.figure()
figure.subplots_adjust(hspace=COLOUR_STYLE_CONSTANTS.geometry.short / 2)
cmfs = first_item(filter_cmfs(cmfs).values())
ASTM_G_173_sd = ASTM_G_173_ETR.copy()
rayleigh_sd = sd_rayleigh_scattering()
ASTM_G_173_sd.align(rayleigh_sd.shape)
sd = rayleigh_sd * ASTM_G_173_sd
axes = figure.add_subplot(211)
settings = {
'axes': axes,
'title': 'The Blue Sky - Synthetic Spectral Distribution',
'y_label': u'W / m-2 / nm-1',
}
settings.update(kwargs)
settings['standalone'] = False
plot_single_sd(sd, cmfs, **settings)
axes = figure.add_subplot(212)
x_label = ('The sky is blue because molecules in the atmosphere '
'scatter shorter wavelengths more than longer ones.\n'
'The synthetic spectral distribution is computed as '
'follows: '
'(ASTM G-173 ETR * Standard Air Rayleigh Scattering).')
settings = {
'axes': axes,
'aspect': None,
'title': 'The Blue Sky - Colour',
'x_label': x_label,
'y_label': '',
'x_ticker': False,
'y_ticker': False,
}
settings.update(kwargs)
settings['standalone'] = False
blue_sky_color = XYZ_to_plotting_colourspace(sd_to_XYZ(sd))
figure, axes = plot_single_colour_swatch(
ColourSwatch('', normalise_maximum(blue_sky_color)), **settings)
settings = {'axes': axes, 'standalone': True}
settings.update(kwargs)
return render(**settings)
def plot_multi_cmfs(cmfs=None, **kwargs):
"""
Plots given colour matching functions.
Parameters
----------
cmfs : array_like, optional
Colour matching functions to plot.
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
--------
>>> cmfs = ('CIE 1931 2 Degree Standard Observer',
... 'CIE 1964 10 Degree Standard Observer')
>>> plot_multi_cmfs(cmfs) # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_Multi_CMFS.png
:align: center
:alt: plot_multi_cmfs
"""
if cmfs is None:
cmfs = ('CIE 1931 2 Degree Standard Observer',
'CIE 1964 10 Degree Standard Observer')
cmfs = filter_cmfs(cmfs).values()
_figure, axes = artist(**kwargs)
axes.axhline(color=COLOUR_STYLE_CONSTANTS.colour.dark, linestyle='--')
x_limit_min, x_limit_max, y_limit_min, y_limit_max = [], [], [], []
for i, cmfs_i in enumerate(cmfs):
for j, RGB in enumerate([(1, 0, 0), (0, 1, 0), (0, 0, 1)]):
RGB = [reduce(lambda y, _: y * 0.5, range(i), x) for x in RGB]
values = cmfs_i.values[:, j]
shape = cmfs_i.shape
x_limit_min.append(shape.start)
x_limit_max.append(shape.end)
y_limit_min.append(min(values))
y_limit_max.append(max(values))
axes.plot(
cmfs_i.wavelengths,
values,
color=RGB,
label='{0} - {1}'.format(cmfs_i.strict_labels[j],
cmfs_i.strict_name))
bounding_box = (min(x_limit_min), max(x_limit_max),
min(y_limit_min) - abs(min(y_limit_min)) * 0.05,
max(y_limit_max) + abs(max(y_limit_max)) * 0.05)
title = '{0} - Colour Matching Functions'.format(', '.join(
[cmfs_i.strict_name for cmfs_i in cmfs]))
settings = {
'axes': axes,
'bounding_box': bounding_box,
'legend': True,
'title': title,
'x_label': 'Wavelength $\\lambda$ (nm)',
'y_label': 'Tristimulus Values',
}
settings.update(kwargs)
return render(**settings)
def plot_multi_colour_checkers(colour_checkers=None, **kwargs):
"""
Plots and compares given colour checkers.
Parameters
----------
colour_checkers : array_like, optional
Color checker names, must be less than or equal to 2 names.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.plot_multi_colour_swatches`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> plot_multi_colour_checkers(['ColorChecker 1976', 'ColorChecker 2005'])
... # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_Multi_Colour_Checkers.png
:align: center
:alt: plot_multi_colour_checkers
"""
if colour_checkers is None:
colour_checkers = ['ColorChecker 1976', 'ColorChecker 2005']
else:
assert len(colour_checkers) <= 2, (
'Only two colour checkers can be compared at a time!')
colour_checkers = filter_colour_checkers(colour_checkers).values()
_figure, axes = artist(**kwargs)
compare_swatches = len(colour_checkers) == 2
colour_swatches = []
colour_checker_names = []
for colour_checker in colour_checkers:
colour_checker_names.append(colour_checker.name)
for label, xyY in colour_checker.data.items():
XYZ = xyY_to_XYZ(xyY)
RGB = XYZ_to_plotting_colourspace(XYZ, colour_checker.illuminant)
colour_swatches.append(
ColourSwatch(label.title(), np.clip(np.ravel(RGB), 0, 1)))
if compare_swatches:
colour_swatches = [
swatch
for pairs in zip(colour_swatches[0:len(colour_swatches) // 2],
colour_swatches[len(colour_swatches) // 2:])
for swatch in pairs
]
background_colour = '0.1'
width = height = 1.0
spacing = 0.25
columns = 6
settings = {
'axes': axes,
'width': width,
'height': height,
'spacing': spacing,
'columns': columns,
'text_parameters': {
'size': 8
},
'background_colour': background_colour,
'compare_swatches': 'Stacked' if compare_swatches else None,
}
settings.update(kwargs)
settings['standalone'] = False
plot_multi_colour_swatches(colour_swatches, **settings)
axes.text(
0.5,
0.005,
'{0} - {1} - Colour Rendition Chart'.format(
', '.join(colour_checker_names),
COLOUR_STYLE_CONSTANTS.colour.colourspace.name),
transform=axes.transAxes,
color=COLOUR_STYLE_CONSTANTS.colour.bright,
ha='center',
va='bottom')
settings.update({
'axes': axes,
'standalone': True,
'title': ', '.join(colour_checker_names),
})
return render(**settings)
def plot_single_sd(sd,
cmfs='CIE 1931 2 Degree Standard Observer',
out_of_gamut_clipping=True,
modulate_colours_with_sd_amplitude=False,
equalize_sd_amplitude=False,
**kwargs):
"""
Plots given spectral distribution.
Parameters
----------
sd : SpectralDistribution
Spectral distribution to plot.
out_of_gamut_clipping : bool, optional
Whether to clip out of gamut colours otherwise, the colours will be
offset by the absolute minimal colour leading to a rendering on
gray background, less saturated and smoother.
modulate_colours_with_sd_amplitude : bool, optional
Whether to modulate the colours with the spectral distribution
amplitude.
equalize_sd_amplitude : bool, optional
Whether to equalize the spectral distribution amplitude.
Equalization occurs after the colours modulation thus setting both
arguments to *True* will generate a spectrum strip where each
wavelength colour is modulated by the spectral distribution amplitude.
The usual 5% margin above the spectral distribution is also omitted.
cmfs : unicode
Standard observer colour matching functions used for spectrum creation.
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.
References
----------
:cite:`Spiker2015a`
Examples
--------
>>> from colour import SpectralDistribution
>>> data = {
... 500: 0.0651,
... 520: 0.0705,
... 540: 0.0772,
... 560: 0.0870,
... 580: 0.1128,
... 600: 0.1360
... }
>>> sd = SpectralDistribution(data, name='Custom')
>>> plot_single_sd(sd) # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_Single_SD.png
:align: center
:alt: plot_single_sd
"""
_figure, axes = artist(**kwargs)
cmfs = first_item(filter_cmfs(cmfs).values())
sd = sd.copy()
sd.interpolator = LinearInterpolator
wavelengths = cmfs.wavelengths[np.logical_and(
cmfs.wavelengths >= max(min(cmfs.wavelengths), min(sd.wavelengths)),
cmfs.wavelengths <= min(max(cmfs.wavelengths), max(sd.wavelengths)),
)]
values = sd[wavelengths]
colours = XYZ_to_plotting_colourspace(
wavelength_to_XYZ(wavelengths, cmfs),
ILLUMINANTS['CIE 1931 2 Degree Standard Observer']['E'],
apply_encoding_cctf=False)
if not out_of_gamut_clipping:
colours += np.abs(np.min(colours))
colours = normalise_maximum(colours)
if modulate_colours_with_sd_amplitude:
colours *= (values / np.max(values))[..., np.newaxis]
colours = COLOUR_STYLE_CONSTANTS.colour.colourspace.encoding_cctf(colours)
if equalize_sd_amplitude:
values = np.ones(values.shape)
margin = 0 if equalize_sd_amplitude else 0.05
x_min, x_max = min(wavelengths), max(wavelengths)
y_min, y_max = 0, max(values) + max(values) * margin
polygon = Polygon(
np.vstack([
(x_min, 0),
tstack([wavelengths, values]),
(x_max, 0),
]),
facecolor='none',
edgecolor='none')
axes.add_patch(polygon)
padding = 0.1
axes.bar(
x=wavelengths - padding,
height=max(values),
width=1 + padding,
color=colours,
align='edge',
clip_path=polygon)
axes.plot(wavelengths, values, color=COLOUR_STYLE_CONSTANTS.colour.dark)
settings = {
'axes': axes,
'bounding_box': (x_min, x_max, y_min, y_max),
'title': '{0} - {1}'.format(sd.strict_name, cmfs.strict_name),
'x_label': 'Wavelength $\\lambda$ (nm)',
'y_label': 'Spectral Distribution',
}
settings.update(kwargs)
return render(**settings)
def plot_multi_sds_colour_quality_scales_bars(sds,
method='NIST CQS 7.4',
**kwargs):
"""
Plots the *Colour Quality Scale* (CQS) of given illuminants or light
sources spectral distributions.
Parameters
----------
sds : array_like
Array of illuminants or light sources spectral distributions to
plot the *Colour Quality Scale* (CQS).
method : unicode, optional
**{NIST CQS 7.4'}**,
*Colour Quality Scale* (CQS) computation method.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.quality.plot_colour_quality_bars`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
labels : bool, optional
{:func:`colour.plotting.quality.plot_colour_quality_bars`},
Add labels above bars.
hatching : bool or None, optional
{:func:`colour.plotting.quality.plot_colour_quality_bars`},
Use hatching for the bars.
hatching_repeat : int, optional
{:func:`colour.plotting.quality.plot_colour_quality_bars`},
Hatching pattern repeat.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> from colour import (ILLUMINANTS_SDS,
... LIGHT_SOURCES_SDS)
>>> illuminant = ILLUMINANTS_SDS['FL2']
>>> light_source = LIGHT_SOURCES_SDS['Kinoton 75P']
>>> plot_multi_sds_colour_quality_scales_bars([illuminant, light_source])
... # doctest: +SKIP
.. image:: ../_static/Plotting_\
Plot_Multi_SDs_Colour_Quality_Scales_Bars.png
:align: center
:alt: plot_multi_sds_colour_quality_scales_bars
"""
settings = dict(kwargs)
settings.update({'standalone': False})
specifications = [colour_quality_scale(sd, True, method) for sd in sds]
_figure, axes = plot_colour_quality_bars(specifications, **settings)
title = 'Colour Quality Scale - {0}'.format(', '.join(
[sd.strict_name for sd in sds]))
settings = {'axes': axes, 'title': title}
settings.update(kwargs)
return render(**settings)
def plot_blackbody_colours(
shape=SpectralShape(150, 12500, 50),
cmfs='CIE 1931 2 Degree Standard Observer',
**kwargs):
"""
Plots blackbody colours.
Parameters
----------
shape : SpectralShape, optional
Spectral shape to use as plot boundaries.
cmfs : unicode, optional
Standard observer colour matching functions.
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_blackbody_colours(SpectralShape(150, 12500, 50)) # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_Blackbody_Colours.png
:align: center
:alt: plot_blackbody_colours
"""
_figure, axes = artist(**kwargs)
cmfs = first_item(filter_cmfs(cmfs).values())
colours = []
temperatures = []
for temperature in shape:
sd = sd_blackbody(temperature, cmfs.shape)
with domain_range_scale('1'):
XYZ = sd_to_XYZ(sd, cmfs)
RGB = normalise_maximum(XYZ_to_plotting_colourspace(XYZ))
colours.append(RGB)
temperatures.append(temperature)
x_min, x_max = min(temperatures), max(temperatures)
y_min, y_max = 0, 1
padding = 0.1
axes.bar(
x=np.array(temperatures) - padding,
height=1,
width=shape.interval + (padding * shape.interval),
color=colours,
align='edge')
settings = {
'axes': axes,
'bounding_box': (x_min, x_max, y_min, y_max),
'title': 'Blackbody Colours',
'x_label': 'Temperature K',
'y_label': None,
}
settings.update(kwargs)
return render(**settings)
def plot_RGB_colourspaces_gamuts(colourspaces=None,
reference_colourspace='CIE xyY',
segments=8,
show_grid=True,
grid_segments=10,
show_spectral_locus=False,
spectral_locus_colour=None,
cmfs='CIE 1931 2 Degree Standard Observer',
**kwargs):
"""
Plots given *RGB* colourspaces gamuts in given reference colourspace.
Parameters
----------
colourspaces : array_like, optional
*RGB* colourspaces to plot the gamuts.
reference_colourspace : unicode, optional
**{'CIE XYZ', 'CIE xyY', 'CIE xy', 'CIE Lab', 'CIE LCHab', 'CIE Luv',
'CIE Luv uv', 'CIE LCHuv', 'CIE UCS', 'CIE UCS uv', 'CIE UVW',
'DIN 99', 'Hunter Lab', 'Hunter Rdab', 'IPT', 'JzAzBz', 'OSA UCS',
'hdr-CIELAB', 'hdr-IPT'}**,
Reference colourspace to plot the gamuts into.
segments : int, optional
Edge segments count for each *RGB* colourspace cubes.
show_grid : bool, optional
Whether to show a grid at the bottom of the *RGB* colourspace cubes.
grid_segments : bool, optional
Edge segments count for the grid.
show_spectral_locus : bool, optional
Whether to show the spectral locus.
spectral_locus_colour : array_like, optional
Spectral locus colour.
cmfs : unicode, optional
Standard observer colour matching functions used for spectral locus.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.volume.nadir_grid`},
Please refer to the documentation of the previously listed definitions.
face_colours : array_like, optional
Face colours array such as `face_colours = (None, (0.5, 0.5, 1.0))`.
edge_colours : array_like, optional
Edge colours array such as `edge_colours = (None, (0.5, 0.5, 1.0))`.
face_alpha : numeric, optional
Face opacity value such as `face_alpha = (0.5, 1.0)`.
edge_alpha : numeric, optional
Edge opacity value such as `edge_alpha = (0.0, 1.0)`.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> plot_RGB_colourspaces_gamuts(['ITU-R BT.709', 'ACEScg', 'S-Gamut'])
... # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_RGB_Colourspaces_Gamuts.png
:align: center
:alt: plot_RGB_colourspaces_gamuts
"""
if colourspaces is None:
colourspaces = ('ITU-R BT.709', 'ACEScg')
colourspaces = filter_RGB_colourspaces(colourspaces).values()
count_c = len(colourspaces)
title = '{0} - {1} Reference Colourspace'.format(
', '.join([colourspace.name for colourspace in colourspaces]),
reference_colourspace,
)
settings = Structure(
**{
'face_colours': [None] * count_c,
'edge_colours': [None] * count_c,
'face_alpha': [1] * count_c,
'edge_alpha': [1] * count_c,
'title': title,
})
settings.update(kwargs)
figure = plt.figure()
axes = figure.add_subplot(111, projection='3d')
illuminant = COLOUR_STYLE_CONSTANTS.colour.colourspace.whitepoint
points = np.zeros((4, 3))
if show_spectral_locus:
cmfs = first_item(filter_cmfs(cmfs).values())
XYZ = cmfs.values
points = common_colourspace_model_axis_reorder(
XYZ_to_colourspace_model(XYZ, illuminant, reference_colourspace),
reference_colourspace)
points[np.isnan(points)] = 0
c = ((0.0, 0.0, 0.0, 0.5)
if spectral_locus_colour is None else spectral_locus_colour)
axes.plot(
points[..., 0], points[..., 1], points[..., 2], color=c, zorder=1)
axes.plot(
(points[-1][0], points[0][0]), (points[-1][1], points[0][1]),
(points[-1][2], points[0][2]),
color=c,
zorder=1)
quads, RGB_f, RGB_e = [], [], []
for i, colourspace in enumerate(colourspaces):
quads_c, RGB = RGB_identity_cube(
width_segments=segments,
height_segments=segments,
depth_segments=segments)
XYZ = RGB_to_XYZ(
quads_c,
colourspace.whitepoint,
colourspace.whitepoint,
colourspace.RGB_to_XYZ_matrix,
)
quads.extend(
common_colourspace_model_axis_reorder(
XYZ_to_colourspace_model(
XYZ,
colourspace.whitepoint,
reference_colourspace,
), reference_colourspace))
if settings.face_colours[i] is not None:
RGB = np.ones(RGB.shape) * settings.face_colours[i]
RGB_f.extend(
np.hstack([
RGB,
np.full((RGB.shape[0], 1), settings.face_alpha[i],
DEFAULT_FLOAT_DTYPE)
]))
if settings.edge_colours[i] is not None:
RGB = np.ones(RGB.shape) * settings.edge_colours[i]
RGB_e.extend(
np.hstack([
RGB,
np.full((RGB.shape[0], 1), settings.edge_alpha[i],
DEFAULT_FLOAT_DTYPE)
]))
quads = as_float_array(quads)
quads[np.isnan(quads)] = 0
if quads.size != 0:
for i, axis in enumerate('xyz'):
min_a = min(np.min(quads[..., i]), np.min(points[..., i]))
max_a = max(np.max(quads[..., i]), np.max(points[..., i]))
getattr(axes, 'set_{}lim'.format(axis))((min_a, max_a))
labels = COLOURSPACE_MODELS_LABELS[reference_colourspace]
for i, axis in enumerate('xyz'):
getattr(axes, 'set_{}label'.format(axis))(labels[i])
if show_grid:
if reference_colourspace == 'CIE Lab':
limits = np.array([[-450, 450], [-450, 450]])
elif reference_colourspace == 'CIE Luv':
limits = np.array([[-650, 650], [-650, 650]])
elif reference_colourspace == 'CIE UVW':
limits = np.array([[-850, 850], [-850, 850]])
elif reference_colourspace in ('Hunter Lab', 'Hunter Rdab'):
limits = np.array([[-250, 250], [-250, 250]])
else:
limits = np.array([[-1.5, 1.5], [-1.5, 1.5]])
quads_g, RGB_gf, RGB_ge = nadir_grid(limits, grid_segments, labels,
axes, **settings)
quads = np.vstack([quads_g, quads])
RGB_f = np.vstack([RGB_gf, RGB_f])
RGB_e = np.vstack([RGB_ge, RGB_e])
collection = Poly3DCollection(quads)
collection.set_facecolors(RGB_f)
collection.set_edgecolors(RGB_e)
axes.add_collection3d(collection)
settings.update({
'axes': axes,
'axes_visible': False,
'camera_aspect': 'equal'
})
settings.update(kwargs)
return render(**settings)
def plot_multi_cmfs(cmfs=None, **kwargs):
"""
Plots given colour matching functions.
Parameters
----------
cmfs : array_like, optional
Colour matching functions to plot.
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
--------
>>> cmfs = ('CIE 1931 2 Degree Standard Observer',
... 'CIE 1964 10 Degree Standard Observer')
>>> plot_multi_cmfs(cmfs) # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, \
<matplotlib.axes._subplots.AxesSubplot object at 0x...>)
.. image:: ../_static/Plotting_Plot_Multi_CMFS.png
:align: center
:alt: plot_multi_cmfs
"""
if cmfs is None:
cmfs = ('CIE 1931 2 Degree Standard Observer',
'CIE 1964 10 Degree Standard Observer')
cmfs = filter_cmfs(cmfs).values()
_figure, axes = artist(**kwargs)
axes.axhline(color=COLOUR_STYLE_CONSTANTS.colour.dark, linestyle='--')
x_limit_min, x_limit_max, y_limit_min, y_limit_max = [], [], [], []
for i, cmfs_i in enumerate(cmfs):
for j, RGB in enumerate([(1, 0, 0), (0, 1, 0), (0, 0, 1)]):
RGB = [reduce(lambda y, _: y * 0.5, range(i), x) for x in RGB]
values = cmfs_i.values[:, j]
shape = cmfs_i.shape
x_limit_min.append(shape.start)
x_limit_max.append(shape.end)
y_limit_min.append(min(values))
y_limit_max.append(max(values))
axes.plot(cmfs_i.wavelengths,
values,
color=RGB,
label='{0} - {1}'.format(cmfs_i.strict_labels[j],
cmfs_i.strict_name))
bounding_box = (min(x_limit_min), max(x_limit_max),
min(y_limit_min) - abs(min(y_limit_min)) * 0.05,
max(y_limit_max) + abs(max(y_limit_max)) * 0.05)
title = '{0} - Colour Matching Functions'.format(', '.join(
[cmfs_i.strict_name for cmfs_i in cmfs]))
settings = {
'axes': axes,
'bounding_box': bounding_box,
'legend': True,
'title': title,
'x_label': 'Wavelength $\\lambda$ (nm)',
'y_label': 'Tristimulus Values',
}
settings.update(kwargs)
return render(**settings)
def plot_multi_sds_colour_rendering_indexes_bars(sds, **kwargs):
"""
Plots the *Colour Rendering Index* (CRI) of given illuminants or light
sources spectral distributions.
Parameters
----------
sds : array_like
Array of illuminants or light sources spectral distributions to
plot the *Colour Rendering Index* (CRI).
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.quality.plot_colour_quality_bars`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
labels : bool, optional
{:func:`colour.plotting.quality.plot_colour_quality_bars`},
Add labels above bars.
hatching : bool or None, optional
{:func:`colour.plotting.quality.plot_colour_quality_bars`},
Use hatching for the bars.
hatching_repeat : int, optional
{:func:`colour.plotting.quality.plot_colour_quality_bars`},
Hatching pattern repeat.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> from colour import (ILLUMINANTS_SDS,
... LIGHT_SOURCES_SDS)
>>> illuminant = ILLUMINANTS_SDS['FL2']
>>> light_source = LIGHT_SOURCES_SDS['Kinoton 75P']
>>> plot_multi_sds_colour_rendering_indexes_bars(
... [illuminant, light_source]) # doctest: +SKIP
.. image:: ../_static/Plotting_\
Plot_Multi_SDs_Colour_Rendering_Indexes_Bars.png
:align: center
:alt: plot_multi_sds_colour_rendering_indexes_bars
"""
settings = dict(kwargs)
settings.update({'standalone': False})
specifications = [
colour_rendering_index(sd, additional_data=True) for sd in sds
]
# *colour rendering index* colorimetry data tristimulus values are
# computed in [0, 100] domain however `plot_colour_quality_bars` expects
# [0, 1] domain. As we want to keep `plot_colour_quality_bars` definition
# agnostic from the colour quality data, we update the test sd
# colorimetry data tristimulus values domain.
for specification in specifications:
colorimetry_data = specification.colorimetry_data
for i, c_d in enumerate(colorimetry_data[0]):
colorimetry_data[0][i] = TCS_ColorimetryData(
c_d.name, c_d.XYZ / 100, c_d.uv, c_d.UVW)
_figure, axes = plot_colour_quality_bars(specifications, **settings)
title = 'Colour Rendering Index - {0}'.format(', '.join(
[sd.strict_name for sd in sds]))
settings = {'axes': axes, 'title': title}
settings.update(kwargs)
return render(**settings)
def plot_single_sd(sd,
cmfs='CIE 1931 2 Degree Standard Observer',
out_of_gamut_clipping=True,
modulate_colours_with_sd_amplitude=False,
equalize_sd_amplitude=False,
**kwargs):
"""
Plots given spectral distribution.
Parameters
----------
sd : SpectralDistribution
Spectral distribution to plot.
out_of_gamut_clipping : bool, optional
Whether to clip out of gamut colours otherwise, the colours will be
offset by the absolute minimal colour leading to a rendering on
gray background, less saturated and smoother.
modulate_colours_with_sd_amplitude : bool, optional
Whether to modulate the colours with the spectral distribution
amplitude.
equalize_sd_amplitude : bool, optional
Whether to equalize the spectral distribution amplitude.
Equalization occurs after the colours modulation thus setting both
arguments to *True* will generate a spectrum strip where each
wavelength colour is modulated by the spectral distribution amplitude.
The usual 5% margin above the spectral distribution is also omitted.
cmfs : unicode
Standard observer colour matching functions used for spectrum creation.
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.
References
----------
:cite:`Spiker2015a`
Examples
--------
>>> from colour import SpectralDistribution
>>> data = {
... 500: 0.0651,
... 520: 0.0705,
... 540: 0.0772,
... 560: 0.0870,
... 580: 0.1128,
... 600: 0.1360
... }
>>> sd = SpectralDistribution(data, name='Custom')
>>> plot_single_sd(sd) # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, \
<matplotlib.axes._subplots.AxesSubplot object at 0x...>)
.. image:: ../_static/Plotting_Plot_Single_SD.png
:align: center
:alt: plot_single_sd
"""
_figure, axes = artist(**kwargs)
cmfs = first_item(filter_cmfs(cmfs).values())
sd = sd.copy()
sd.interpolator = LinearInterpolator
wavelengths = cmfs.wavelengths[np.logical_and(
cmfs.wavelengths >= max(min(cmfs.wavelengths), min(sd.wavelengths)),
cmfs.wavelengths <= min(max(cmfs.wavelengths), max(sd.wavelengths)),
)]
values = sd[wavelengths]
colours = XYZ_to_plotting_colourspace(
wavelength_to_XYZ(wavelengths, cmfs),
ILLUMINANTS['CIE 1931 2 Degree Standard Observer']['E'],
apply_cctf_encoding=False)
if not out_of_gamut_clipping:
colours += np.abs(np.min(colours))
colours = normalise_maximum(colours)
if modulate_colours_with_sd_amplitude:
colours *= (values / np.max(values))[..., np.newaxis]
colours = COLOUR_STYLE_CONSTANTS.colour.colourspace.cctf_encoding(colours)
if equalize_sd_amplitude:
values = np.ones(values.shape)
margin = 0 if equalize_sd_amplitude else 0.05
x_min, x_max = min(wavelengths), max(wavelengths)
y_min, y_max = 0, max(values) + max(values) * margin
polygon = Polygon(np.vstack([
(x_min, 0),
tstack([wavelengths, values]),
(x_max, 0),
]),
facecolor='none',
edgecolor='none')
axes.add_patch(polygon)
padding = 0.1
axes.bar(x=wavelengths - padding,
height=max(values),
width=1 + padding,
color=colours,
align='edge',
clip_path=polygon)
axes.plot(wavelengths, values, color=COLOUR_STYLE_CONSTANTS.colour.dark)
settings = {
'axes': axes,
'bounding_box': (x_min, x_max, y_min, y_max),
'title': '{0} - {1}'.format(sd.strict_name, cmfs.strict_name),
'x_label': 'Wavelength $\\lambda$ (nm)',
'y_label': 'Spectral Distribution',
}
settings.update(kwargs)
return render(**settings)
def plot_multi_sds_colour_rendering_indexes_bars(
sds: Union[
Sequence[Union[SpectralDistribution, MultiSpectralDistributions]],
MultiSpectralDistributions,
],
**kwargs: Any,
) -> Tuple[plt.Figure, plt.Axes]:
"""
Plot the *Colour Rendering Index* (CRI) of given illuminants or light
sources spectral distributions.
Parameters
----------
sds
Spectral distributions or multi-spectral distributions to
plot. `sds` can be a single
:class:`colour.MultiSpectralDistributions` class instance, a list
of :class:`colour.MultiSpectralDistributions` class instances or a
list of :class:`colour.SpectralDistribution` class instances.
Other Parameters
----------------
kwargs
{:func:`colour.plotting.artist`,
:func:`colour.plotting.quality.plot_colour_quality_bars`,
:func:`colour.plotting.render`},
See the documentation of the previously listed definitions.
Returns
-------
:class:`tuple`
Current figure and axes.
Examples
--------
>>> from colour import (SDS_ILLUMINANTS,
... SDS_LIGHT_SOURCES)
>>> illuminant = SDS_ILLUMINANTS['FL2']
>>> light_source = SDS_LIGHT_SOURCES['Kinoton 75P']
>>> plot_multi_sds_colour_rendering_indexes_bars(
... [illuminant, light_source]) # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, <...AxesSubplot...>)
.. image:: ../_static/Plotting_\
Plot_Multi_SDS_Colour_Rendering_Indexes_Bars.png
:align: center
:alt: plot_multi_sds_colour_rendering_indexes_bars
"""
sds_converted = sds_and_msds_to_sds(sds)
settings: Dict[str, Any] = dict(kwargs)
settings.update({"standalone": False})
specifications = cast(
List[ColourRendering_Specification_CRI],
[
colour_rendering_index(sd, additional_data=True)
for sd in sds_converted
],
)
# *colour rendering index* colorimetry data tristimulus values are
# computed in [0, 100] domain however `plot_colour_quality_bars` expects
# [0, 1] domain. As we want to keep `plot_colour_quality_bars` definition
# agnostic from the colour quality data, we update the test sd
# colorimetry data tristimulus values domain.
for specification in specifications:
colorimetry_data = specification.colorimetry_data
for i in range(len(colorimetry_data[0])):
colorimetry_data[0][i].XYZ /= 100
_figure, axes = plot_colour_quality_bars(specifications, **settings)
title = (
f"Colour Rendering Index - "
f"{', '.join([sd.strict_name for sd in sds_converted])}"
)
settings = {"axes": axes, "title": title}
settings.update(kwargs)
return render(**settings)
def plot_blackbody_colours(shape=SpectralShape(150, 12500, 50),
cmfs='CIE 1931 2 Degree Standard Observer',
**kwargs):
"""
Plots blackbody colours.
Parameters
----------
shape : SpectralShape, optional
Spectral shape to use as plot boundaries.
cmfs : unicode, optional
Standard observer colour matching functions.
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_blackbody_colours(SpectralShape(150, 12500, 50))
... # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, \
<matplotlib.axes._subplots.AxesSubplot object at 0x...>)
.. image:: ../_static/Plotting_Plot_Blackbody_Colours.png
:align: center
:alt: plot_blackbody_colours
"""
_figure, axes = artist(**kwargs)
cmfs = first_item(filter_cmfs(cmfs).values())
colours = []
temperatures = []
for temperature in shape:
sd = sd_blackbody(temperature, cmfs.shape)
with domain_range_scale('1'):
XYZ = sd_to_XYZ(sd, cmfs)
RGB = normalise_maximum(XYZ_to_plotting_colourspace(XYZ))
colours.append(RGB)
temperatures.append(temperature)
x_min, x_max = min(temperatures), max(temperatures)
y_min, y_max = 0, 1
padding = 0.1
axes.bar(x=np.array(temperatures) - padding,
height=1,
width=shape.interval + (padding * shape.interval),
color=colours,
align='edge')
settings = {
'axes': axes,
'bounding_box': (x_min, x_max, y_min, y_max),
'title': 'Blackbody Colours',
'x_label': 'Temperature K',
'y_label': None,
}
settings.update(kwargs)
return render(**settings)
def plot_multi_sds_colour_quality_scales_bars(
sds: Union[
Sequence[Union[SpectralDistribution, MultiSpectralDistributions]],
MultiSpectralDistributions,
],
method: Union[
Literal["NIST CQS 7.4", "NIST CQS 9.0"], str
] = "NIST CQS 9.0",
**kwargs: Any,
) -> Tuple[plt.Figure, plt.Axes]:
"""
Plot the *Colour Quality Scale* (CQS) of given illuminants or light
sources spectral distributions.
Parameters
----------
sds
Spectral distributions or multi-spectral distributions to
plot. `sds` can be a single
:class:`colour.MultiSpectralDistributions` class instance, a list
of :class:`colour.MultiSpectralDistributions` class instances or a
list of :class:`colour.SpectralDistribution` class instances.
method
*Colour Quality Scale* (CQS) computation method.
Other Parameters
----------------
kwargs
{:func:`colour.plotting.artist`,
:func:`colour.plotting.quality.plot_colour_quality_bars`,
:func:`colour.plotting.render`},
See the documentation of the previously listed definitions.
Returns
-------
:class:`tuple`
Current figure and axes.
Examples
--------
>>> from colour import (SDS_ILLUMINANTS,
... SDS_LIGHT_SOURCES)
>>> illuminant = SDS_ILLUMINANTS['FL2']
>>> light_source = SDS_LIGHT_SOURCES['Kinoton 75P']
>>> plot_multi_sds_colour_quality_scales_bars([illuminant, light_source])
... # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, <...AxesSubplot...>)
.. image:: ../_static/Plotting_\
Plot_Multi_SDS_Colour_Quality_Scales_Bars.png
:align: center
:alt: plot_multi_sds_colour_quality_scales_bars
"""
method = validate_method(method, COLOUR_QUALITY_SCALE_METHODS)
sds_converted = sds_and_msds_to_sds(sds)
settings: Dict[str, Any] = dict(kwargs)
settings.update({"standalone": False})
specifications = cast(
List[ColourRendering_Specification_CQS],
[colour_quality_scale(sd, True, method) for sd in sds_converted],
)
_figure, axes = plot_colour_quality_bars(specifications, **settings)
title = (
f"Colour Quality Scale - "
f"{', '.join([sd.strict_name for sd in sds_converted])}"
)
settings = {"axes": axes, "title": title}
settings.update(kwargs)
return render(**settings)
def plot_chromaticity_diagram(cmfs='CIE 1931 2 Degree Standard Observer',
show_diagram_colours=True,
show_spectral_locus=True,
method='CIE 1931',
**kwargs):
"""
Plots the *Chromaticity Diagram* according to given method.
Parameters
----------
cmfs : unicode, optional
Standard observer colour matching functions used for
*Chromaticity Diagram* bounds.
show_diagram_colours : bool, optional
Whether to display the *Chromaticity Diagram* background colours.
show_spectral_locus : bool, optional
Whether to display the *Spectral Locus*.
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.diagrams.plot_spectral_locus`,
:func:`colour.plotting.diagrams.plot_chromaticity_diagram_colours`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> plot_chromaticity_diagram() # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_Chromaticity_Diagram.png
:align: center
:alt: plot_chromaticity_diagram
"""
settings = {'uniform': True}
settings.update(kwargs)
figure, axes = artist(**settings)
method = method.upper()
cmfs = first_item(filter_cmfs(cmfs).values())
if show_diagram_colours:
settings = {'axes': axes, 'method': method}
settings.update(kwargs)
settings['standalone'] = False
plot_chromaticity_diagram_colours(**settings)
if show_spectral_locus:
settings = {'axes': axes, 'method': method}
settings.update(kwargs)
settings['standalone'] = False
plot_spectral_locus(**settings)
if method == 'CIE 1931':
x_label, y_label = 'CIE x', 'CIE y'
elif method == 'CIE 1960 UCS':
x_label, y_label = 'CIE u', 'CIE v'
elif method == 'CIE 1976 UCS':
x_label, y_label = 'CIE u\'', 'CIE v\'',
else:
raise ValueError(
'Invalid method: "{0}", must be one of '
'{\'CIE 1931\', \'CIE 1960 UCS\', \'CIE 1976 UCS\'}'.format(
method))
title = '{0} Chromaticity Diagram - {1}'.format(method, cmfs.strict_name)
settings.update({
'axes': axes,
'standalone': True,
'bounding_box': (0, 1, 0, 1),
'title': title,
'x_label': x_label,
'y_label': y_label,
})
settings.update(kwargs)
return render(**settings)
def plot_colour_quality_bars(
specifications: Sequence[
Union[
ColourRendering_Specification_CQS,
ColourRendering_Specification_CRI,
]
],
labels: Boolean = True,
hatching: Optional[Boolean] = None,
hatching_repeat: Integer = 2,
**kwargs: Any,
) -> Tuple[plt.Figure, plt.Axes]:
"""
Plot the colour quality data of given illuminants or light sources colour
quality specifications.
Parameters
----------
specifications
Array of illuminants or light sources colour quality specifications.
labels
Add labels above bars.
hatching
Use hatching for the bars.
hatching_repeat
Hatching pattern repeat.
Other Parameters
----------------
kwargs
{:func:`colour.plotting.artist`,
:func:`colour.plotting.quality.plot_colour_quality_bars`,
:func:`colour.plotting.render`},
See the documentation of the previously listed definitions.
Returns
-------
:class:`tuple`
Current figure and axes.
Examples
--------
>>> from colour import (SDS_ILLUMINANTS,
... SDS_LIGHT_SOURCES, SpectralShape)
>>> illuminant = SDS_ILLUMINANTS['FL2']
>>> light_source = SDS_LIGHT_SOURCES['Kinoton 75P']
>>> light_source = light_source.copy().align(SpectralShape(360, 830, 1))
>>> cqs_i = colour_quality_scale(illuminant, additional_data=True)
>>> cqs_l = colour_quality_scale(light_source, additional_data=True)
>>> plot_colour_quality_bars([cqs_i, cqs_l]) # doctest: +ELLIPSIS
(<Figure size ... with 1 Axes>, <...AxesSubplot...>)
.. image:: ../_static/Plotting_Plot_Colour_Quality_Bars.png
:align: center
:alt: plot_colour_quality_bars
"""
settings: Dict[str, Any] = {"uniform": True}
settings.update(kwargs)
_figure, axes = artist(**settings)
bar_width = 0.5
y_ticks_interval = 10
count_s, count_Q_as = len(specifications), 0
patterns = cycle(CONSTANTS_COLOUR_STYLE.hatch.patterns)
if hatching is None:
hatching = False if count_s == 1 else True
for i, specification in enumerate(specifications):
Q_a, Q_as, colorimetry_data = (
specification.Q_a,
specification.Q_as,
specification.colorimetry_data,
)
count_Q_as = len(Q_as)
RGB = [[1] * 3] + [
np.clip(XYZ_to_plotting_colourspace(x.XYZ), 0, 1)
for x in colorimetry_data[0]
]
x = (
as_float_array(
i
+ np.arange(
0,
(count_Q_as + 1) * (count_s + 1),
(count_s + 1),
dtype=DEFAULT_FLOAT_DTYPE,
)
)
* bar_width
)
y = as_float_array(
[Q_a]
+ [
s[1].Q_a # type: ignore[attr-defined]
for s in sorted(Q_as.items(), key=lambda s: s[0])
]
)
bars = axes.bar(
x,
np.abs(y),
color=RGB,
width=bar_width,
edgecolor=CONSTANTS_COLOUR_STYLE.colour.dark,
label=specification.name,
zorder=CONSTANTS_COLOUR_STYLE.zorder.background_polygon,
)
hatches = (
[next(patterns) * hatching_repeat] * (count_Q_as + 1)
if hatching
else list(
np.where(y < 0, next(patterns), None) # type: ignore[call-overload]
)
)
for j, bar in enumerate(bars.patches):
bar.set_hatch(hatches[j])
if labels:
label_rectangles(
[f"{y_v:.1f}" for y_v in y],
bars,
rotation="horizontal" if count_s == 1 else "vertical",
offset=(
0 if count_s == 1 else 3 / 100 * count_s + 65 / 1000,
0.025,
),
text_size=-5 / 7 * count_s + 12.5,
axes=axes,
)
axes.axhline(
y=100,
color=CONSTANTS_COLOUR_STYLE.colour.dark,
linestyle="--",
zorder=CONSTANTS_COLOUR_STYLE.zorder.midground_line,
)
axes.set_xticks(
(
np.arange(
0,
(count_Q_as + 1) * (count_s + 1),
(count_s + 1),
dtype=DEFAULT_FLOAT_DTYPE,
)
- bar_width
)
* bar_width
+ (count_s * bar_width / 2)
)
axes.set_xticklabels(
["Qa"] + [f"Q{index + 1}" for index in range(0, count_Q_as, 1)]
)
axes.set_yticks(range(0, 100 + y_ticks_interval, y_ticks_interval))
aspect = 1 / (120 / (bar_width + len(Q_as) + bar_width * 2))
bounding_box = (
-bar_width,
((count_Q_as + 1) * (count_s + 1)) / 2 - bar_width,
0,
120,
)
settings = {
"axes": axes,
"aspect": aspect,
"bounding_box": bounding_box,
"legend": hatching,
"title": "Colour Quality",
}
settings.update(kwargs)
return render(**settings)
def plot_sds_in_chromaticity_diagram(
sds,
cmfs='CIE 1931 2 Degree Standard Observer',
annotate_parameters=None,
chromaticity_diagram_callable=plot_chromaticity_diagram,
method='CIE 1931',
**kwargs):
"""
Plots given spectral distribution chromaticity coordinates into the
*Chromaticity Diagram* using given method.
Parameters
----------
sds : array_like, optional
Spectral distributions to plot.
cmfs : unicode, optional
Standard observer colour matching functions used for
*Chromaticity Diagram* bounds.
annotate_parameters : dict or array_like, optional
Parameters for the :func:`plt.annotate` definition, used to annotate
the resulting chromaticity coordinates with their respective spectral
distribution names if ``annotate`` is set to *True*.
``annotate_parameters`` can be either a single dictionary applied to
all the arrows with same settings or a sequence of dictionaries with
different settings for each spectral distribution.
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.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.diagrams.plot_chromaticity_diagram`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> from colour import ILLUMINANTS_SDS
>>> A = ILLUMINANTS_SDS['A']
>>> D65 = ILLUMINANTS_SDS['D65']
>>> plot_sds_in_chromaticity_diagram([A, D65]) # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_SDs_In_Chromaticity_Diagram.png
:align: center
:alt: plot_sds_in_chromaticity_diagram
"""
settings = {'uniform': True}
settings.update(kwargs)
figure, axes = artist(**settings)
method = method.upper()
settings.update({
'axes': axes,
'standalone': False,
'method': method,
'cmfs': cmfs,
})
chromaticity_diagram_callable(**settings)
if method == 'CIE 1931':
def XYZ_to_ij(XYZ):
"""
Converts given *CIE XYZ* tristimulus values to *ij* chromaticity
coordinates.
"""
return XYZ_to_xy(XYZ)
bounding_box = (-0.1, 0.9, -0.1, 0.9)
elif method == 'CIE 1960 UCS':
def XYZ_to_ij(XYZ):
"""
Converts given *CIE XYZ* tristimulus values to *ij* chromaticity
coordinates.
"""
return UCS_to_uv(XYZ_to_UCS(XYZ))
bounding_box = (-0.1, 0.7, -0.2, 0.6)
elif method == 'CIE 1976 UCS':
def XYZ_to_ij(XYZ):
"""
Converts given *CIE XYZ* tristimulus values to *ij* chromaticity
coordinates.
"""
return Luv_to_uv(XYZ_to_Luv(XYZ))
bounding_box = (-0.1, 0.7, -0.1, 0.7)
else:
raise ValueError(
'Invalid method: "{0}", must be one of '
'{\'CIE 1931\', \'CIE 1960 UCS\', \'CIE 1976 UCS\'}'.format(
method))
annotate_settings_collection = [{
'annotate': True,
'xytext': (-50, 30),
'textcoords': 'offset points',
'arrowprops': COLOUR_ARROW_STYLE,
} for _ in range(len(sds))]
if annotate_parameters is not None:
if not isinstance(annotate_parameters, dict):
assert len(annotate_parameters) == len(sds), (
'Multiple annotate parameters defined, but they do not match '
'the spectral distributions count!')
for i, annotate_settings in enumerate(annotate_settings_collection):
if isinstance(annotate_parameters, dict):
annotate_settings.update(annotate_parameters)
else:
annotate_settings.update(annotate_parameters[i])
for i, sd in enumerate(sds):
with domain_range_scale('1'):
XYZ = sd_to_XYZ(sd)
ij = XYZ_to_ij(XYZ)
axes.plot(
ij[0],
ij[1],
'o',
color=COLOUR_STYLE_CONSTANTS.colour.brightest,
markeredgecolor=COLOUR_STYLE_CONSTANTS.colour.dark,
markersize=(COLOUR_STYLE_CONSTANTS.geometry.short * 6 +
COLOUR_STYLE_CONSTANTS.geometry.short * 0.75),
markeredgewidth=COLOUR_STYLE_CONSTANTS.geometry.short * 0.75,
label=sd.strict_name)
if (sd.name is not None and
annotate_settings_collection[i]['annotate']):
annotate_settings = annotate_settings_collection[i]
annotate_settings.pop('annotate')
axes.annotate(sd.name, xy=ij, **annotate_settings)
settings.update({'standalone': True, 'bounding_box': bounding_box})
settings.update(kwargs)
return render(**settings)
def plot_corresponding_chromaticities_prediction(experiment=1,
model='Von Kries',
transform='CAT02',
**kwargs):
"""
Plots given chromatic adaptation model corresponding chromaticities
prediction.
Parameters
----------
experiment : int, optional
Corresponding chromaticities prediction experiment number.
model : unicode, optional
Corresponding chromaticities prediction model name.
transform : unicode, optional
Transformation to use with *Von Kries* chromatic adaptation model.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.diagrams.plot_chromaticity_diagram`,
:func:`colour.plotting.render`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
tuple
Current figure and axes.
Examples
--------
>>> plot_corresponding_chromaticities_prediction(1, 'Von Kries', 'CAT02')
... # doctest: +SKIP
.. image:: ../_static/Plotting_\
Plot_Corresponding_Chromaticities_Prediction.png
:align: center
:alt: plot_corresponding_chromaticities_prediction
"""
settings = {'uniform': True}
settings.update(kwargs)
_figure, axes = artist(**settings)
title = (('Corresponding Chromaticities Prediction\n{0} ({1}) - '
'Experiment {2}\nCIE 1976 UCS Chromaticity Diagram').format(
model, transform, experiment)
if model.lower() in ('von kries', 'vonkries') else
('Corresponding Chromaticities Prediction\n{0} - '
'Experiment {1}\nCIE 1976 UCS Chromaticity Diagram').format(
model, experiment))
settings = {'axes': axes, 'title': title}
settings.update(kwargs)
settings['standalone'] = False
plot_chromaticity_diagram_CIE1976UCS(**settings)
results = corresponding_chromaticities_prediction(
experiment, transform=transform)
for result in results:
_name, uvp_t, uvp_m, uvp_p = result
axes.arrow(
uvp_t[0],
uvp_t[1],
uvp_p[0] - uvp_t[0] - 0.1 * (uvp_p[0] - uvp_t[0]),
uvp_p[1] - uvp_t[1] - 0.1 * (uvp_p[1] - uvp_t[1]),
color=COLOUR_STYLE_CONSTANTS.colour.dark,
head_width=0.005,
head_length=0.005)
axes.plot(
uvp_t[0],
uvp_t[1],
'o',
color=COLOUR_STYLE_CONSTANTS.colour.brightest,
markeredgecolor=COLOUR_STYLE_CONSTANTS.colour.dark,
markersize=(COLOUR_STYLE_CONSTANTS.geometry.short * 6 +
COLOUR_STYLE_CONSTANTS.geometry.short * 0.75),
markeredgewidth=COLOUR_STYLE_CONSTANTS.geometry.short * 0.75)
axes.plot(
uvp_m[0],
uvp_m[1],
'^',
color=COLOUR_STYLE_CONSTANTS.colour.brightest,
markeredgecolor=COLOUR_STYLE_CONSTANTS.colour.dark,
markersize=(COLOUR_STYLE_CONSTANTS.geometry.short * 6 +
COLOUR_STYLE_CONSTANTS.geometry.short * 0.75),
markeredgewidth=COLOUR_STYLE_CONSTANTS.geometry.short * 0.75)
axes.plot(
uvp_p[0], uvp_p[1], '^', color=COLOUR_STYLE_CONSTANTS.colour.dark)
settings.update({
'standalone': True,
'bounding_box': (-0.1, 0.7, -0.1, 0.7),
})
settings.update(kwargs)
return render(**settings)
def plot_RGB_scatter(RGB,
colourspace,
reference_colourspace='CIE xyY',
colourspaces=None,
segments=8,
show_grid=True,
grid_segments=10,
show_spectral_locus=False,
spectral_locus_colour=None,
points_size=12,
cmfs='CIE 1931 2 Degree Standard Observer',
**kwargs):
"""
Plots given *RGB* colourspace array in a scatter plot.
Parameters
----------
RGB : array_like
*RGB* colourspace array.
colourspace : RGB_Colourspace
*RGB* colourspace of the *RGB* array.
reference_colourspace : unicode, optional
**{'CIE XYZ', 'CIE xyY', 'CIE xy', 'CIE Lab', 'CIE LCHab', 'CIE Luv',
'CIE Luv uv', 'CIE LCHuv', 'CIE UCS', 'CIE UCS uv', 'CIE UVW',
'DIN 99', 'Hunter Lab', 'Hunter Rdab', 'IPT', 'JzAzBz', 'OSA UCS',
'hdr-CIELAB', 'hdr-IPT'}**,
Reference colourspace for colour conversion.
colourspaces : array_like, optional
*RGB* colourspaces to plot the gamuts.
segments : int, optional
Edge segments count for each *RGB* colourspace cubes.
show_grid : bool, optional
Whether to show a grid at the bottom of the *RGB* colourspace cubes.
grid_segments : bool, optional
Edge segments count for the grid.
show_spectral_locus : bool, optional
Whether to show the spectral locus.
spectral_locus_colour : array_like, optional
Spectral locus colour.
points_size : numeric, optional
Scatter points size.
cmfs : unicode, optional
Standard observer colour matching functions used for spectral locus.
Other Parameters
----------------
\\**kwargs : dict, optional
{:func:`colour.plotting.artist`,
:func:`colour.plotting.plot_RGB_colourspaces_gamuts`},
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_scatter(RGB, 'ITU-R BT.709') # doctest: +SKIP
.. image:: ../_static/Plotting_Plot_RGB_Scatter.png
:align: center
:alt: plot_RGB_scatter
"""
colourspace = first_item(filter_RGB_colourspaces(colourspace).values())
if colourspaces is None:
colourspaces = (colourspace.name, )
count_c = len(colourspaces)
settings = Structure(
**{
'face_colours': [None] * count_c,
'edge_colours': [(0.25, 0.25, 0.25)] * count_c,
'face_alpha': [0.0] * count_c,
'edge_alpha': [0.1] * count_c,
})
settings.update(kwargs)
settings['standalone'] = False
plot_RGB_colourspaces_gamuts(
colourspaces=colourspaces,
reference_colourspace=reference_colourspace,
segments=segments,
show_grid=show_grid,
grid_segments=grid_segments,
show_spectral_locus=show_spectral_locus,
spectral_locus_colour=spectral_locus_colour,
cmfs=cmfs,
**settings)
XYZ = RGB_to_XYZ(RGB, colourspace.whitepoint, colourspace.whitepoint,
colourspace.RGB_to_XYZ_matrix)
points = common_colourspace_model_axis_reorder(
XYZ_to_colourspace_model(XYZ, colourspace.whitepoint,
reference_colourspace), reference_colourspace)
axes = plt.gca()
axes.scatter(
points[..., 0],
points[..., 1],
points[..., 2],
color=np.reshape(RGB, (-1, 3)),
s=points_size)
settings.update({'axes': axes, 'standalone': True})
settings.update(kwargs)
return render(**settings)
def fraunhofer_lines_plot(image,
measured_Fraunhofer_lines,
show_luminance_spd=True,
**kwargs):
"""
Plots the *Fraunhofer* lines of given image.
Parameters
----------
image : unicode
Path to read the image from.
measured_Fraunhofer_lines : dict, optional
Measured *Fraunhofer* lines locations.
show_luminance_spd : bool, optional
Whether to show the *Luminance* sd for given image.
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.
"""
settings = {}
settings.update(kwargs)
figure, axes = artist(**settings)
spectrum = calibrated_RGB_spectrum(image, FRAUNHOFER_LINES_PUBLISHED,
measured_Fraunhofer_lines)
wavelengths = spectrum.wavelengths
input, output = wavelengths[0], wavelengths[-1]
width, height = figure.get_size_inches()
ratio = width / height
height = (output - input) * (1 / ratio)
axes.imshow(
COLOUR_STYLE_CONSTANTS.colour.colourspace.encoding_cctf(
np.clip(spectrum.values[np.newaxis, ...], 0, 1)),
extent=[input, output, 0, height])
sd = luminance_sd(spectrum).normalise(height - height * 0.05)
if show_luminance_spd:
axes.plot(sd.wavelengths, sd.values, color='black', linewidth=1)
fraunhofer_wavelengths = np.array(
sorted(FRAUNHOFER_LINES_PUBLISHED.values()))
fraunhofer_wavelengths = fraunhofer_wavelengths[np.where(
np.logical_and(fraunhofer_wavelengths >= input,
fraunhofer_wavelengths <= output))]
fraunhofer_lines_labels = [
tuple(FRAUNHOFER_LINES_PUBLISHED.keys())[tuple(
FRAUNHOFER_LINES_PUBLISHED.values()).index(i)]
for i in fraunhofer_wavelengths
]
y0, y1 = 0, height * .5
for i, label in enumerate(fraunhofer_lines_labels):
# Trick to cluster siblings *Fraunhofer* lines.
from_siblings = False
for pattern, (first, siblings,
specific_label) in FRAUNHOFER_LINES_CLUSTERED.items():
if re.match(pattern, label):
if label in siblings:
from_siblings = True
label = specific_label
break
power = bisect.bisect_left(wavelengths, fraunhofer_wavelengths[i])
scale = (sd[wavelengths[power]] / height)
is_large_line = label in FRAUNHOFER_LINES_NOTABLE
axes.vlines(
fraunhofer_wavelengths[i],
y0,
y1 * scale,
linewidth=1 if is_large_line else 1)
axes.vlines(
fraunhofer_wavelengths[i],
y0,
height,
linewidth=1 if is_large_line else 1,
alpha=0.075)
if not from_siblings:
axes.text(
fraunhofer_wavelengths[i],
y1 * scale + (y1 * 0.025),
label,
clip_on=True,
ha='center',
va='bottom',
fontdict={'size': 'large' if is_large_line else 'small'})
r = lambda x: int(x / 100) * 100
plt.xticks(np.arange(r(input), r(output * 1.5), 20))
plt.yticks([])
settings = {
'title': 'The Solar Spectrum - Fraunhofer Lines',
'bounding_box': [input, output, 0, height],
'x_label': u'Wavelength λ (nm)',
'y_label': False,
}
settings.update(**kwargs)
return render(**settings)
