def test_camera(self):
"""Test :func:`colour.plotting.common.camera` definition."""
figure, _axes = artist()
axes = figure.add_subplot(111, projection="3d")
_figure, axes = camera(axes=axes, elevation=45, azimuth=90)
self.assertEqual(axes.elev, 45)
self.assertEqual(axes.azim, 90)
def RGB_scatter_plot(RGB,
colourspace,
reference_colourspace='CIE xyY',
colourspaces=None,
segments=8,
display_grid=True,
grid_segments=10,
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 Lab', 'CIE Luv', 'CIE UCS', 'CIE UVW',
'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.
display_grid : bool, optional
Display a grid at the bottom of the *RGB* colourspace cubes.
grid_segments : bool, optional
Edge segments count for the grid.
spectral_locus : bool, optional
Is spectral locus line plotted.
spectral_locus_colour : array_like, optional
Spectral locus line colour.
points_size : numeric, optional
Scatter points size.
cmfs : unicode, optional
Standard observer colour matching functions used for spectral locus.
\**kwargs : dict, optional
**{'face_colours', 'edge_colours', 'edge_alpha', 'face_alpha'}**,
Arguments for each given colourspace where each key has an array_like
value such as: ``{ 'face_colours': (None, (0.5, 0.5, 1.0)),
'edge_colours': (None, (0.5, 0.5, 1.0)), 'edge_alpha': (0.5, 1.0),
'face_alpha': (0.0, 1.0)}``
**{'grid_face_colours', 'grid_edge_colours', 'grid_face_alpha',
'grid_edge_alpha', 'x_axis_colour', 'y_axis_colour', 'x_ticks_colour',
'y_ticks_colour', 'x_label_colour', 'y_label_colour',
'ticks_and_label_location'}**,
Arguments for the nadir grid such as ``{'grid_face_colours':
(0.25, 0.25, 0.25), 'grid_edge_colours': (0.50, 0.50, 0.50),
'grid_face_alpha': 0.1, 'grid_edge_alpha': 0.5, 'x_axis_colour':
(0.0, 0.0, 0.0, 1.0), 'y_axis_colour': (0.0, 0.0, 0.0, 1.0),
'x_ticks_colour': (0.0, 0.0, 0.0, 0.85), 'y_ticks_colour':
(0.0, 0.0, 0.0, 0.85), 'x_label_colour': (0.0, 0.0, 0.0, 0.85),
'y_label_colour': (0.0, 0.0, 0.0, 0.85), 'ticks_and_label_location':
('-x', '-y')}``
Returns
-------
bool
Definition success.
Examples
--------
>>> c = 'Rec. 709'
>>> RGB_scatter_plot(c) # doctest: +SKIP
True
"""
colourspace = get_RGB_colourspace(colourspace)
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,
'standalone': False})
settings.update(kwargs)
RGB_colourspaces_gamuts_plot(
colourspaces=colourspaces,
reference_colourspace=reference_colourspace,
segments=segments,
display_grid=display_grid,
grid_segments=grid_segments,
spectral_locus=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 = XYZ_to_reference_colourspace(XYZ,
colourspace.whitepoint,
reference_colourspace)
axes = matplotlib.pyplot.gca()
axes.scatter(points[..., 0],
points[..., 1],
points[..., 2],
color=np.reshape(RGB, (-1, 3)),
s=points_size)
settings.update({'standalone': True})
settings.update(kwargs)
camera(**settings)
decorate(**settings)
return display(**settings)
def RGB_colourspaces_gamuts_plot(colourspaces=None,
reference_colourspace='CIE xyY',
segments=8,
display_grid=True,
grid_segments=10,
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 Lab', 'CIE Luv', 'CIE UCS', 'CIE UVW',
'IPT'}**,
Reference colourspace to plot the gamuts into.
segments : int, optional
Edge segments count for each *RGB* colourspace cubes.
display_grid : bool, optional
Display a grid at the bottom of the *RGB* colourspace cubes.
grid_segments : bool, optional
Edge segments count for the grid.
spectral_locus : bool, optional
Is spectral locus line plotted.
spectral_locus_colour : array_like, optional
Spectral locus line colour.
cmfs : unicode, optional
Standard observer colour matching functions used for spectral locus.
\**kwargs : dict, optional
**{'face_colours', 'edge_colours', 'edge_alpha', 'face_alpha'}**,
Arguments for each given colourspace where each key has an array_like
value such as: ``{ 'face_colours': (None, (0.5, 0.5, 1.0)),
'edge_colours': (None, (0.5, 0.5, 1.0)), 'edge_alpha': (0.5, 1.0),
'face_alpha': (0.0, 1.0)}``
**{'grid_face_colours', 'grid_edge_colours', 'grid_face_alpha',
'grid_edge_alpha', 'x_axis_colour', 'y_axis_colour', 'x_ticks_colour',
'y_ticks_colour', 'x_label_colour', 'y_label_colour',
'ticks_and_label_location'}**,
Arguments for the nadir grid such as ``{'grid_face_colours':
(0.25, 0.25, 0.25), 'grid_edge_colours': (0.50, 0.50, 0.50),
'grid_face_alpha': 0.1, 'grid_edge_alpha': 0.5, 'x_axis_colour':
(0.0, 0.0, 0.0, 1.0), 'y_axis_colour': (0.0, 0.0, 0.0, 1.0),
'x_ticks_colour': (0.0, 0.0, 0.0, 0.85), 'y_ticks_colour':
(0.0, 0.0, 0.0, 0.85), 'x_label_colour': (0.0, 0.0, 0.0, 0.85),
'y_label_colour': (0.0, 0.0, 0.0, 0.85), 'ticks_and_label_location':
('-x', '-y')}``
Returns
-------
bool
Definition success.
Examples
--------
>>> c = ['Rec. 709', 'ACEScg', 'S-Gamut']
>>> RGB_colourspaces_gamuts_plot(c) # doctest: +SKIP
True
"""
if colourspaces is None:
colourspaces = ('Rec. 709', 'ACEScg')
count_c = len(colourspaces)
settings = Structure(
**{'face_colours': [None] * count_c,
'edge_colours': [None] * count_c,
'face_alpha': [1] * count_c,
'edge_alpha': [1] * count_c,
'title': '{0} - {1} Reference Colourspace'.format(
', '.join(colourspaces), reference_colourspace)})
settings.update(kwargs)
figure = matplotlib.pyplot.figure()
axes = figure.add_subplot(111, projection='3d')
illuminant = DEFAULT_PLOTTING_ILLUMINANT
points = np.zeros((4, 3))
if spectral_locus:
cmfs = get_cmfs(cmfs)
XYZ = cmfs.values
points = XYZ_to_reference_colourspace(XYZ,
illuminant,
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)
pylab.plot(points[..., 0],
points[..., 1],
points[..., 2],
color=c,
linewidth=2,
zorder=1)
pylab.plot((points[-1][0], points[0][0]),
(points[-1][1], points[0][1]),
(points[-1][2], points[0][2]),
color=c,
linewidth=2,
zorder=1)
quads, RGB_f, RGB_e = [], [], []
for i, colourspace in enumerate(colourspaces):
colourspace = get_RGB_colourspace(colourspace)
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(XYZ_to_reference_colourspace(XYZ,
colourspace.whitepoint,
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, np.float_),
settings.face_alpha[i]))))
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, np.float_),
settings.edge_alpha[i]))))
quads = np.asarray(quads)
quads[np.isnan(quads)] = 0
if quads.size != 0:
for i, axis in enumerate('xyz'):
min_a = np.min(np.vstack((quads[..., i], points[..., i])))
max_a = np.max(np.vstack((quads[..., i], points[..., i])))
getattr(axes, 'set_{}lim'.format(axis))((min_a, max_a))
labels = REFERENCE_COLOURSPACES_TO_LABELS[reference_colourspace]
for i, axis in enumerate('xyz'):
getattr(axes, 'set_{}label'.format(axis))(labels[i])
if display_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]])
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({
'camera_aspect': 'equal',
'no_axes3d': True})
settings.update(kwargs)
camera(**settings)
decorate(**settings)
return display(**settings)
def RGB_scatter_plot(RGB,
colourspace,
reference_colourspace='CIE xyY',
colourspaces=None,
segments=8,
display_grid=True,
grid_segments=10,
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 Lab', 'CIE Luv', 'CIE UCS', 'CIE UVW',
'IPT', 'Hunter Lab', 'Hunter Rdab'}**,
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.
display_grid : bool, optional
Display a grid at the bottom of the *RGB* colourspace cubes.
grid_segments : bool, optional
Edge segments count for the grid.
spectral_locus : bool, optional
Is spectral locus line plotted.
spectral_locus_colour : array_like, optional
Spectral locus line 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:`RGB_colourspaces_gamuts_plot`},
Please refer to the documentation of the previously listed definitions.
Returns
-------
Figure
Current figure or None.
Examples
--------
>>> c = 'Rec. 709'
>>> RGB_scatter_plot(c) # doctest: +SKIP
"""
colourspace = get_RGB_colourspace(colourspace)
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,
'standalone': False
})
settings.update(kwargs)
RGB_colourspaces_gamuts_plot(colourspaces=colourspaces,
reference_colourspace=reference_colourspace,
segments=segments,
display_grid=display_grid,
grid_segments=grid_segments,
spectral_locus=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 = matplotlib.pyplot.gca()
axes.scatter(points[..., 0],
points[..., 1],
points[..., 2],
color=np.reshape(RGB, (-1, 3)),
s=points_size)
settings.update({'standalone': True})
settings.update(kwargs)
camera(**settings)
decorate(**settings)
return display(**settings)
def RGB_colourspaces_gamuts_plot(colourspaces=None,
reference_colourspace='CIE xyY',
segments=8,
display_grid=True,
grid_segments=10,
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 Lab', 'CIE Luv', 'CIE UCS', 'CIE UVW',
'IPT', 'Hunter Lab', 'Hunter Rdab'}**,
Reference colourspace to plot the gamuts into.
segments : int, optional
Edge segments count for each *RGB* colourspace cubes.
display_grid : bool, optional
Display a grid at the bottom of the *RGB* colourspace cubes.
grid_segments : bool, optional
Edge segments count for the grid.
spectral_locus : bool, optional
Is spectral locus line plotted.
spectral_locus_colour : array_like, optional
Spectral locus line colour.
cmfs : unicode, optional
Standard observer colour matching functions used for spectral locus.
Other Parameters
----------------
\**kwargs : dict, optional
{:func:`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
-------
Figure
Current figure or None.
Examples
--------
>>> c = ['Rec. 709', 'ACEScg', 'S-Gamut']
>>> RGB_colourspaces_gamuts_plot(c) # doctest: +SKIP
"""
if colourspaces is None:
colourspaces = ('Rec. 709', 'ACEScg')
count_c = len(colourspaces)
settings = Structure(
**{
'face_colours': [None] * count_c,
'edge_colours': [None] * count_c,
'face_alpha': [1] * count_c,
'edge_alpha': [1] * count_c,
'title':
'{0} - {1} Reference Colourspace'.format(', '.join(colourspaces),
reference_colourspace)
})
settings.update(kwargs)
figure = matplotlib.pyplot.figure()
axes = figure.add_subplot(111, projection='3d')
illuminant = DEFAULT_PLOTTING_ILLUMINANT
points = np.zeros((4, 3))
if spectral_locus:
cmfs = get_cmfs(cmfs)
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)
pylab.plot(points[..., 0],
points[..., 1],
points[..., 2],
color=c,
linewidth=2,
zorder=1)
pylab.plot((points[-1][0], points[0][0]),
(points[-1][1], points[0][1]),
(points[-1][2], points[0][2]),
color=c,
linewidth=2,
zorder=1)
quads, RGB_f, RGB_e = [], [], []
for i, colourspace in enumerate(colourspaces):
colourspace = get_RGB_colourspace(colourspace)
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],
np.float_))))
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],
np.float_))))
quads = np.asarray(quads)
quads[np.isnan(quads)] = 0
if quads.size != 0:
for i, axis in enumerate('xyz'):
min_a = np.min(np.vstack((quads[..., i], points[..., i])))
max_a = np.max(np.vstack((quads[..., i], 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 display_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({'camera_aspect': 'equal', 'no_axes': True})
settings.update(kwargs)
camera(**settings)
decorate(**settings)
return display(**settings)
def RGB_scatter_plot(RGB,
colourspace,
reference_colourspace='CIE xyY',
colourspaces=None,
segments=8,
display_grid=True,
grid_segments=10,
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 Lab', 'CIE Luv', 'CIE UCS', 'CIE UVW',
'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.
display_grid : bool, optional
Display a grid at the bottom of the *RGB* colourspace cubes.
grid_segments : bool, optional
Edge segments count for the grid.
spectral_locus : bool, optional
Is spectral locus line plotted.
spectral_locus_colour : array_like, optional
Spectral locus line colour.
points_size : numeric, optional
Scatter points size.
cmfs : unicode, optional
Standard observer colour matching functions used for spectral locus.
\**kwargs : dict, optional
**{'face_colours', 'edge_colours', 'edge_alpha', 'face_alpha'}**,
Arguments for each given colourspace where each key has an array_like
value such as: ``{ 'face_colours': (None, (0.5, 0.5, 1.0)),
'edge_colours': (None, (0.5, 0.5, 1.0)), 'edge_alpha': (0.5, 1.0),
'face_alpha': (0.0, 1.0)}``
**{'grid_face_colours', 'grid_edge_colours', 'grid_face_alpha',
'grid_edge_alpha', 'x_axis_colour', 'y_axis_colour', 'x_ticks_colour',
'y_ticks_colour', 'x_label_colour', 'y_label_colour',
'ticks_and_label_location'}**,
Arguments for the nadir grid such as ``{'grid_face_colours':
(0.25, 0.25, 0.25), 'grid_edge_colours': (0.50, 0.50, 0.50),
'grid_face_alpha': 0.1, 'grid_edge_alpha': 0.5, 'x_axis_colour':
(0.0, 0.0, 0.0, 1.0), 'y_axis_colour': (0.0, 0.0, 0.0, 1.0),
'x_ticks_colour': (0.0, 0.0, 0.0, 0.85), 'y_ticks_colour':
(0.0, 0.0, 0.0, 0.85), 'x_label_colour': (0.0, 0.0, 0.0, 0.85),
'y_label_colour': (0.0, 0.0, 0.0, 0.85), 'ticks_and_label_location':
('-x', '-y')}``
Returns
-------
bool
Definition success.
Examples
--------
>>> c = 'Rec. 709'
>>> RGB_scatter_plot(c) # doctest: +SKIP
True
"""
colourspace = get_RGB_colourspace(colourspace)
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,
'standalone': False
})
settings.update(kwargs)
RGB_colourspaces_gamuts_plot(colourspaces=colourspaces,
reference_colourspace=reference_colourspace,
segments=segments,
display_grid=display_grid,
grid_segments=grid_segments,
spectral_locus=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 = XYZ_to_reference_colourspace(XYZ, colourspace.whitepoint,
reference_colourspace)
axes = matplotlib.pyplot.gca()
axes.scatter(points[..., 0],
points[..., 1],
points[..., 2],
color=np.reshape(RGB, (-1, 3)),
s=points_size)
settings.update({'standalone': True})
settings.update(kwargs)
camera(**settings)
decorate(**settings)
return display(**settings)
