def find_colour(spectrum, col_map_f='CIE 1931 2 Degree Standard Observer'):
import colour
cmfs = colour.MSDS_CMFS[col_map_f]
illuminant = colour.SDS_ILLUMINANTS['D65']
wavs = spectrum.wavelengths
try:
XYZ = colour.sd_to_XYZ(spectrum, cmfs, illuminant)
except:
XYZ = colour.sd_to_XYZ(
spectrum.interpolate(colour.SpectralShape(min(wavs), max(wavs),
1)), cmfs, illuminant)
RGB = colour.XYZ_to_sRGB(XYZ / 100)
for i in range(0, 3, 1):
if RGB[i] < 0:
RGB[i] = 0
if RGB[i] > 1:
RGB[i] = 1
return RGB
def XYZ_to_sd_Otsu2018(
XYZ,
cmfs=STANDARD_OBSERVER_CMFS['CIE 1931 2 Degree Standard Observer'].
copy().align(OTSU_2018_SPECTRAL_SHAPE),
illuminant=ILLUMINANT_SDS['D65'].copy().align(
OTSU_2018_SPECTRAL_SHAPE),
clip=True):
XYZ = as_float_array(XYZ)
xy = XYZ_to_xy(XYZ)
cluster = select_cluster_Otsu2018(xy)
basis_functions = OTSU_2018_BASIS_FUNCTIONS[cluster]
mean = OTSU_2018_MEANS[cluster]
M = np.empty((3, 3))
for i in range(3):
sd = SpectralDistribution(
basis_functions[i, :],
OTSU_2018_SPECTRAL_SHAPE.range(),
)
M[:, i] = sd_to_XYZ(sd, illuminant=illuminant) / 100
M_inverse = np.linalg.inv(M)
sd = SpectralDistribution(mean, OTSU_2018_SPECTRAL_SHAPE.range())
XYZ_mu = sd_to_XYZ(sd, illuminant=illuminant) / 100
weights = np.dot(M_inverse, XYZ - XYZ_mu)
recovered_sd = np.dot(weights, basis_functions) + mean
if clip:
recovered_sd = np.clip(recovered_sd, 0, 1)
return SpectralDistribution(recovered_sd, OTSU_2018_SPECTRAL_SHAPE.range())
def sp2xy(sp):
spd = colour.SpectralDistribution(sp, name='Sample')
cmfs = colour.colorimetry.MSDS_CMFS_STANDARD_OBSERVER[
'CIE 1931 2 Degree Standard Observer']
illuminant = colour.SDS_ILLUMINANTS['D65']
XYZ = colour.sd_to_XYZ(spd, cmfs, illuminant)
return colour.XYZ_to_xy(XYZ)
def __init__(
self,
sds,
shape,
cmfs=STANDARD_OBSERVER_CMFS['CIE 1931 2 Degree Standard Observer'],
illuminant=sd_ones()):
"""
Parameters
----------
sds : ndarray (n,m)
Reflectances of the ``n`` reference colours to be used for
optimisation.
shape : SpectralShape
Spectral shape of ``sds``.
cmfs : XYZ_ColourMatchingFunctions, optional
Standard observer colour matching functions.
illuminant : SpectralDistribution, optional
Illuminant spectral distribution.
"""
self.shape = shape
self.wl = shape.range()
self.dw = self.wl[1] - self.wl[0]
self.cmfs = cmfs.copy().align(shape)
self.illuminant = illuminant.copy().align(shape)
self.xy_w = XYZ_to_xy(sd_to_XYZ(illuminant, cmfs=cmfs))
# The normalising constant used in sd_to_XYZ.
self.k = 1 / (np.sum(self.cmfs.values[:, 1] * self.illuminant.values) *
self.dw)
# Python 3: super().__init__(...)
super(Otsu2018Tree, self).__init__(self, Colours(self, sds))
def spectral2rgb(s):
sd = colour.SpectralDistribution(s)
cmfs = colour.STANDARD_OBSERVERS_CMFS[
'CIE 1931 2 Degree Standard Observer']
illuminant = colour.ILLUMINANTS_SDS['D65']
XYZ = colour.sd_to_XYZ(sd, cmfs, illuminant)
RGB = colour.XYZ_to_sRGB(XYZ / 100)
return RGB
def compute_color(self):
self.sample_spd_data = dict(zip(self.raw_wl, self.raw_spec))
self.spd = colour.SpectralDistribution(self.sample_spd_data,
name=self.label)
# Cloning the sample spectral power distribution.
self.spd_interpolated = self.spd.clone()
# Interpolating the cloned sample spectral power distribution.
# Indeed, the algorithm for colour identification needs a spectra with a point each nanometer
self.spd_interpolated.interpolate(colour.SpectralShape(370, 680, 1))
self.cmfs = colour.STANDARD_OBSERVERS_CMFS[
'CIE 1931 2 Degree Standard Observer']
self.illuminant = colour.ILLUMINANTS_SDS['D65']
self.XYZ = colour.sd_to_XYZ(self.spd_interpolated, self.cmfs,
self.illuminant)
self.RGB = colour.XYZ_to_sRGB(self.XYZ / 100)
"""
We then come to the next obstacle... The RGB values that we get from this process are often out of range -
meaning that they are either greater than 1.0, or even that they are negative! The first case is fairly
straightforward, it means that the color is too bright for the display. The second case means that the color
is too saturated and vivid for the display. The display must compose all colors from some combination of
positive amounts of the colors of its red, green and blue phosphors. The colors of these phosphors are not
perfectly saturated, they are washed out, mixed with white, to some extent. So not all colors can be displayed
accurately. As an example, the colors of pure spectral lines, all have some negative component.
Something must be done to put these values into the 0.0 - 1.0 range that can actually be displayed,
known as color clipping.
In the first case, values larger than 1.0, ColorPy scales the color so that the maximum component is 1.0.
This reduces the brightness without changing the chromaticity. The second case requires some change in
chromaticity. By default, ColorPy will add white to the color, just enough to make all of the components
non-negative. (You can also have ColorPy clamp the negative values to zero. My personal, qualitative,
assessment is that adding white produces somewhat better results. There is also the potential to develop a
better clipping function.)
"""
if min(self.RGB) < 0:
self.RGB += min(self.RGB)
if max(self.RGB) > 1:
self.RGB /= max(self.RGB)
# TODO why can we get negative values and values > 1 ?
self.RGB = np.abs(self.RGB)
self.RGB = np.clip(self.RGB, 0, 1)
self.xy = colour.XYZ_to_xy(self.XYZ)
def get_tristimulus_XYZs(Theta_I, Phi_I, Polarization, Data, observer,
illuminant):
u_wls = np.array(Data['Wavelengths'])
u_theta_Is = np.array(Data['thetaIs'])
u_phi_Is = np.array(Data['phiIs'])
u_pols = np.array(Data['Polarization'])
u_theta_Vs = np.array(Data['thetaVs'])
u_phi_Vs = np.array(Data['phiVs'])
data = np.array(Data['data'])
cmfs = clr.STANDARD_OBSERVERS_CMFS[observer]
illuminant = clr.ILLUMINANTS_SDS[illuminant]
tristimulus_XYZ_values = []
color_values = []
for theta_V in u_theta_Vs:
tristimulus_XYZ_row = []
color_values_row = []
for phi_V in u_phi_Vs:
spectrum = data[u_pols == Polarization, u_theta_Is == Theta_I,
u_phi_Is == Phi_I, :, u_theta_Vs == theta_V,
u_phi_Vs == phi_V]
# spectrum = spectrum[0]/np.max(spectrum)
spectrum = np.array([u_wls, spectrum[0]]).T
spectrum = spectrum.tolist()
spectrum = {line[0]: line[1] for line in spectrum}
sd = clr.SpectralDistribution(spectrum)
sd = sd.interpolate(clr.SpectralShape(380, 830, 1))
# print(sd)
XYZ = clr.sd_to_XYZ(sd, cmfs, illuminant)
sRGB = clr.XYZ_to_sRGB(XYZ / 100)
sRGB = sRGBColor(sRGB[0], sRGB[1], sRGB[2])
RGB = list(sRGB.get_upscaled_value_tuple())
for i in range(len(RGB)):
if RGB[i] < 0:
RGB[i] = 0
elif RGB[i] > 255:
RGB[i] = 255
tristimulus_XYZ_row.append(XYZ)
color_values_row.append(RGB)
tristimulus_XYZ_values.append(tristimulus_XYZ_row)
color_values.append(color_values_row)
return tristimulus_XYZ_values, color_values
def spectrum_to_XYZ(
wavelength,
spectrum,
# cmfs=None,
illuminant=None,
):
"""
Calculate the rgb color given a wavelength and spectrum
Parameters
----------
wavelength
spectrum
cmfs
illuminant
Returns
-------
"""
# if cmfs is None:
# cmfs = colour.STANDARD_OBSERVERS_CMFS['CIE 1931 2 Degree Standard Observer']
if illuminant is None:
# illuminant = ILLUMINANTS_SDS['CIE 1931 2 Degree Standard Observer']['D65']
illuminant = sd_ones()
elif type(illuminant) == type(''):
illuminant = SDS_ILLUMINANTS[illuminant]
# # Get illuminant
# if type(illuminant) == type(''):
# illuminant = colour.ILLUMINANTS_SDS[illuminant]
# Build spectral distribution object
sd = SpectralDistribution(pd.Series(spectrum, index=wavelength),
interpolator=CubicSplineInterpolator,
extrapolator=Extrapolator)
# Calculate xyz color coordinates.
xyz = sd_to_XYZ(sd=sd, illuminant=illuminant)
return xyz
def copute_color(self):
self.sample_spd_data = dict(zip(self.raw_wl, self.raw_spec))
self.spd = colour.SpectralDistribution(self.sample_spd_data,
name=self.label)
# Cloning the sample spectral power distribution.
self.spd_interpolated = self.spd.clone()
# Interpolating the cloned sample spectral power distribution.
# Indeed, the algorithm for colour identification needs a spectra with a point each nanometer
self.spd_interpolated.interpolate(colour.SpectralShape(400, 820, 1))
self.cmfs = colour.STANDARD_OBSERVERS_CMFS[
'CIE 1931 2 Degree Standard Observer']
self.illuminant = colour.ILLUMINANTS_SDS['D65']
self.XYZ = colour.sd_to_XYZ(self.spd_interpolated, self.cmfs,
self.illuminant)
self.RGB = colour.XYZ_to_sRGB(self.XYZ / 100)
# TODO why can we get negative values and values > 1 ?
self.RGB = np.abs(self.RGB)
self.RGB = np.clip(self.RGB, 0, 1)
self.xy = colour.XYZ_to_xy(self.XYZ)
def __init__(self, tree, reflectances):
"""
Parameters
==========
tree : tree
The parent tree. This determines what cmfs and illuminant
are used in colourimetric calculations.
reflectances : ndarray (n,m)
Reflectances of the ``n`` colours to be stored in this class.
The shape must match ``tree.shape`` with ``m`` points for
each colour.
"""
self.reflectances = reflectances
self.XYZ = np.empty((reflectances.shape[0], 3))
self.xy = np.empty((reflectances.shape[0], 2))
for i in range(len(self)):
sd = SpectralDistribution(reflectances[i, :], tree.wl)
XYZ = sd_to_XYZ(sd, illuminant=tree.illuminant) / 100
self.XYZ[i, :] = XYZ
self.xy[i, :] = XYZ_to_xy(XYZ)
def sd_to_XYZ(
sd: Union[ArrayLike, SpectralDistribution, MultiSpectralDistributions],
cmfs: Optional[MultiSpectralDistributions] = None,
illuminant: Optional[SpectralDistribution] = None,
k: Optional[Number] = None,
method: Union[Literal["ASTM E308", "Integration"], str] = "ASTM E308",
**kwargs: Any,
) -> NDArray:
"""
Convert given spectral distribution to *CIE XYZ* tristimulus values using
given colour matching functions, illuminant and method.
This placeholder docstring is replaced with the modified
:func:`colour.sd_to_XYZ` definition docstring.
"""
illuminant = cast(
SpectralDistribution,
optional(illuminant, SDS_ILLUMINANTS[_ILLUMINANT_DEFAULT]),
)
return colour.sd_to_XYZ(sd, cmfs, illuminant, k, method, **kwargs)
def to_color(self):
"""
Determine the RGB color of this spectrum.
Returns
-------
rgb : numpy.ndarray
3-element array containing RGB values
that can be fed into matplotlib.
"""
with warnings.catch_warnings():
warnings.simplefilter(action="ignore", category=ColourRuntimeWarning)
# create a colour SpectralDistribution
sd = self.to_sd()
# convert to XYZ
# (maybe use `k=` option for relative scaling between sources?)
XYZ = colour.sd_to_XYZ(sd)
if (np.min(XYZ) < 0) or np.max(XYZ) > 100:
print(f"XYZ={XYZ} is outside of [0, 100]!")
# convert to RGB
RGB = colour.XYZ_to_sRGB(XYZ / 100)
if (np.min(RGB) < 0) or np.max(RGB) > 1:
pass
# print(f'RGB={RGB} is outside of [0, 1]!')
# trim out underenderable colors (this is sneaky!)
# clipped_RGB = np.maximum(0, np.minimum(1, RGB))
clipped_RGB = np.maximum(0, RGB)
# instead of clip, should we add to everything until we get to zero?
# kludge to maximize brightness, for every color!
clipped_RGB /= np.max(clipped_RGB)
return clipped_RGB
# -*- coding: utf-8 -*-
"""
Showcases correlated colour temperature computations.
"""
import colour
from colour.utilities import message_box
message_box('Correlated Colour Temperature Computations')
cmfs = colour.CMFS['CIE 1931 2 Degree Standard Observer']
illuminant = colour.ILLUMINANTS_SDS['D65']
xy = colour.XYZ_to_xy(colour.sd_to_XYZ(illuminant, cmfs) / 100)
uv = colour.UCS_to_uv(colour.XYZ_to_UCS(colour.xy_to_XYZ(xy)))
message_box(('Converting to "CCT" and "D_uv" from given "CIE UCS" colourspace '
'"uv" chromaticity coordinates using "Ohno (2013)" method:\n'
'\n\t{0}'.format(uv)))
print(colour.uv_to_CCT(uv, cmfs=cmfs))
print(colour.temperature.uv_to_CCT_Ohno2013(uv, cmfs=cmfs))
print('\n')
message_box('Faster computation with 3 iterations but a lot less precise.')
print(colour.uv_to_CCT(uv, cmfs=cmfs, iterations=3))
print(colour.temperature.uv_to_CCT_Ohno2013(uv, cmfs=cmfs, iterations=3))
print('\n')
message_box(('Converting to "CCT" and "D_uv" from given "CIE UCS" colourspace '
'"uv" chromaticity coordinates using "Robertson (1968)" method:\n'
'\n\t{0}'.format(uv)))
for i in range(data.shape[0])
]
for name, colourchecker in COLOURCHECKER_SDS.items():
print('Adding %s...' % name)
sds += colourchecker.values()
D65 = ILLUMINANT_SDS['D65']
xy_w = ILLUMINANTS['CIE 1931 2 Degree Standard Observer']['D65']
x = []
y = []
errors = []
above_JND = 0
for i, sd in tqdm.tqdm(enumerate(sds), total=len(sds)):
XYZ = sd_to_XYZ(sd, illuminant=D65) / 100
xy = XYZ_to_xy(XYZ)
x.append(xy[0])
y.append(xy[1])
Lab = XYZ_to_Lab(XYZ, xy_w)
recovered_sd = XYZ_to_sd_Otsu2018(XYZ)
recovered_XYZ = sd_to_XYZ(recovered_sd, illuminant=D65) / 100
recovered_Lab = XYZ_to_Lab(recovered_XYZ, xy_w)
error = delta_E_CIE1976(Lab, recovered_Lab)
errors.append(error)
if error > 2.4:
above_JND += 1
print('Min. error: %g' % min(errors))
# -*- coding: utf-8 -*-
"""
Showcases blackbody / planckian radiator computations.
"""
import colour
from colour.utilities import message_box
message_box('Blackbody / Planckian Radiator Computations')
message_box(('Computing the spectral distribution of a blackbody at '
'temperature 5500 kelvin degrees and converting to "CIE XYZ" '
'tristimulus values.'))
cmfs = colour.MSDS_CMFS['CIE 1931 2 Degree Standard Observer']
sd_blackbody = colour.sd_blackbody(5500, cmfs.shape)
print(sd_blackbody)
XYZ = colour.sd_to_XYZ(sd_blackbody, cmfs)
print(XYZ)
print('\n')
message_box(('Computing the spectral radiance of a blackbody at wavelength '
'500 nm and temperature 5500 kelvin degrees.'))
print(colour.colorimetry.blackbody_spectral_radiance(500 * 1e-9, 5500))
print(colour.colorimetry.planck_law(500 * 1e-9, 5500))
760: 0.462,
765: 0.465,
770: 0.448,
775: 0.432,
780: 0.421,
}
sd_sample = colour.SpectralDistribution(data_sample, name="Sample")
cmfs = colour.MSDS_CMFS["CIE 1931 2 Degree Standard Observer"]
illuminant = colour.SDS_ILLUMINANTS["A"]
message_box(
"Computing *CIE XYZ* tristimulus values for sample spectral distribution "
'and "CIE Standard Illuminant A".')
print(colour.sd_to_XYZ(sd_sample, cmfs, illuminant))
print("\n")
message_box(
'Computing "CIE Standard Illuminant A" chromaticity coordinates from its '
"spectral distribution.")
print(colour.XYZ_to_xy(colour.sd_to_XYZ(illuminant, cmfs) / 100))
print("\n")
message_box(
"Computing *CIE XYZ* tristimulus values for a single given wavelength in "
"nm.")
print(
colour.wavelength_to_XYZ(
if not os.path.exists('datasets'):
os.makedirs('datasets')
data = tree.to_dataset()
data.to_file('datasets/otsu2018.npz')
data.to_Python_file('datasets/otsu2018.py')
print('Plotting...')
tree.visualise()
plt.figure()
examples = COLOURCHECKER_SDS['ColorChecker N Ohta'].items()
for i, (name, sd) in enumerate(examples):
plt.subplot(2, 3, 1 + i)
plt.title(name)
plt.plot(sd.wavelengths, sd.values, label='Original')
XYZ = sd_to_XYZ(sd) / 100
recovered_sd = tree.reconstruct(XYZ)
plt.plot(recovered_sd.wavelengths,
recovered_sd.values,
label='Recovered')
plt.legend()
if i + 1 == 6:
break
plt.show()
blackbody='VY Canis Majoris')
plot_blackbody_spectral_radiance(temperature=5778, blackbody='The Sun')
plot_blackbody_spectral_radiance(temperature=12130, blackbody='Rigel')
print('\n')
message_box('Comparing theoretical and measured "Sun" spectral distributions.')
sd_ASTMG173 = SD_ASTMG173_ETR.copy()
sd_ASTMG173.interpolate(colour.SpectralShape(interval=5),
interpolator=colour.LinearInterpolator)
sd_blackbody = colour.sd_blackbody(5778, sd_ASTMG173.shape)
sd_blackbody.name = 'The Sun - 5778K'
sd_blackbody /= colour.sd_to_XYZ(sd_blackbody)[1]
sd_blackbody *= colour.sd_to_XYZ(sd_ASTMG173)[1]
plot_multi_sds([sd_ASTMG173, sd_blackbody], y_label='W / (sr m$^2$) / m')
print('\n')
message_box('Plotting various "blackbody" spectral distributions.')
sds_blackbody = [
colour.sd_blackbody(i, colour.SpectralShape(100, 1500, 10))
for i in range(1000, 11000, 1000)
]
plot_multi_sds(sds_blackbody,
y_label='W / (sr m$^2$) / m',
plot_kwargs={
# -*- coding: utf-8 -*-
"""
Showcases correlated colour temperature computations.
"""
import colour
from colour.utilities import message_box
message_box('Correlated Colour Temperature Computations')
cmfs = colour.CMFS['CIE 1931 2 Degree Standard Observer']
illuminant = colour.ILLUMINANTS_SDS['D65']
xy = colour.XYZ_to_xy(colour.sd_to_XYZ(illuminant, cmfs) / 100)
uv = colour.UCS_to_uv(colour.XYZ_to_UCS(colour.xy_to_XYZ(xy)))
message_box(('Converting to "CCT" and "D_uv" from given "CIE UCS" colourspace '
'"uv" chromaticity coordinates using "Ohno (2013)" method:\n'
'\n\t{0}'.format(uv)))
print(colour.uv_to_CCT(uv, cmfs=cmfs))
print(colour.temperature.uv_to_CCT_Ohno2013(uv, cmfs=cmfs))
print('\n')
message_box('Faster computation with 3 iterations but a lot less precise.')
print(colour.uv_to_CCT(uv, cmfs=cmfs, iterations=3))
print(colour.temperature.uv_to_CCT_Ohno2013(uv, cmfs=cmfs, iterations=3))
print('\n')
message_box(('Converting to "CCT" and "D_uv" from given "CIE UCS" colourspace '
'"uv" chromaticity coordinates using "Robertson (1968)" method:\n'
'\n\t{0}'.format(uv)))
import numpy as np
import colour
from colour.utilities import message_box
message_box('Automatic Colour Conversion Graph')
message_box('Converting a "ColorChecker" "dark skin" sample spectral '
'distribution to "Output-Referred" "sRGB" colourspace.')
sd = colour.COLOURCHECKERS_SDS['ColorChecker N Ohta']['dark skin']
print(colour.convert(sd, 'Spectral Distribution', 'sRGB'))
print(
colour.XYZ_to_sRGB(
colour.sd_to_XYZ(sd, illuminant=colour.ILLUMINANTS_SDS['D65']) / 100))
print('\n')
RGB = np.array([0.45675795, 0.30986982, 0.24861924])
message_box(('Converting to "CAM16-UCS" colourspace from given '
'"Output-Referred" "sRGB" colourspace values:\n'
'\n\t{0}'.format(RGB)))
print(colour.convert(RGB, 'Output-Referred RGB', 'CAM16UCS'))
specification = colour.XYZ_to_CAM16(
colour.sRGB_to_XYZ(RGB) * 100,
XYZ_w=colour.xy_to_XYZ(
colour.ILLUMINANTS['CIE 1931 2 Degree Standard Observer']['D65']) *
100,
L_A=64 / np.pi * 0.2,
Y_b=20)
# -*- coding: utf-8 -*-
"""
Showcases reflectance recovery computations using *Meng et al. (2015)* method.
"""
import numpy as np
import colour
from colour.utilities import message_box
message_box('"Meng et al. (2015)" - Reflectance Recovery Computations')
illuminant = colour.SDS_ILLUMINANTS['D65']
XYZ = np.array([0.20654008, 0.12197225, 0.05136952])
message_box('Recovering reflectance using "Meng et al. (2015)" method from '
'given "XYZ" tristimulus values:\n'
'\n\tXYZ: {0}'.format(XYZ))
sd = colour.XYZ_to_sd(XYZ, method='Meng 2015')
print(sd)
print(colour.recovery.XYZ_to_sd_Meng2015(XYZ))
print(colour.sd_to_XYZ(sd, illuminant=illuminant) / 100)
import numpy as np
import colour
from colour.utilities import message_box
message_box('Automatic Colour Conversion Graph')
message_box('Converting a "ColorChecker" "dark skin" sample spectral '
'distribution to "Output-Referred" "sRGB" colourspace.')
sd_dark_skin = colour.SDS_COLOURCHECKERS['ColorChecker N Ohta']['dark skin']
print(colour.convert(sd_dark_skin, 'Spectral Distribution', 'sRGB'))
print(
colour.XYZ_to_sRGB(
colour.sd_to_XYZ(sd_dark_skin,
illuminant=colour.SDS_ILLUMINANTS['D65']) / 100))
print('\n')
RGB = np.array([0.45675795, 0.30986982, 0.24861924])
message_box(('Converting to "CAM16-UCS" colourspace from given '
'"Output-Referred" "sRGB" colourspace values:\n'
'\n\t{0}'.format(RGB)))
print(colour.convert(RGB, 'Output-Referred RGB', 'CAM16UCS'))
specification = colour.XYZ_to_CAM16(
colour.sRGB_to_XYZ(RGB) * 100,
XYZ_w=colour.xy_to_XYZ(
colour.CCS_ILLUMINANTS['CIE 1931 2 Degree Standard Observer']['D65']) *
100,
L_A=64 / np.pi * 0.2,
Y_b=20)
#Thanks colour for making this a PITA. Just have a stupid array instead of hiding
#this like it's something incredibly special.
subset_of_blackbody_sd = {}
for k in black_body_sd.wavelengths:
s = black_body_sd[k]
#print("s: {}, k: {}".format(s, k))
if spetral_f_initial <= k and k <= spetral_f_final:
subset_of_blackbody_sd[
k] = s * intensity_normalization_factor
else:
subset_of_blackbody_sd[k] = 0.0
subset_of_blackbody_sd = colour.SpectralDistribution(
subset_of_blackbody_sd)
#Convert our spectrum into a color
star_xyz_color = colour.sd_to_XYZ(subset_of_blackbody_sd,
cmfs)
star_rgb_color = [
min(max(int(c), 0), 255)
for c in colour.XYZ_to_sRGB(star_xyz_color / 100)
]
y_position = j * 16 + 1 + y
x_position = i * 32 + 1 + x
for c in range(3):
output_texture[y_position][x_position][
c] = star_rgb_color[c]
output_texture[y_position][x_position][3] = 255
progress_bar_status += 1
bar.update(progress_bar_status)
#Write this into a texture
# -*- coding: utf-8 -*-
"""
Showcases blackbody / planckian radiator computations.
"""
import colour
from colour.utilities import message_box
message_box('Blackbody / Planckian Radiator Computations')
message_box(('Computing the spectral distribution of a blackbody at '
'temperature 5500 kelvin degrees and converting to "CIE XYZ" '
'tristimulus values.'))
cmfs = colour.STANDARD_OBSERVERS_CMFS['CIE 1931 2 Degree Standard Observer']
blackbody_sd = colour.sd_blackbody(5500, cmfs.shape)
print(blackbody_sd)
XYZ = colour.sd_to_XYZ(blackbody_sd, cmfs)
print(XYZ)
print('\n')
message_box(('Computing the spectral radiance of a blackbody at wavelength '
'500 nm and temperature 5500 kelvin degrees.'))
print(colour.colorimetry.blackbody_spectral_radiance(500 * 1e-9, 5500))
print(colour.colorimetry.planck_law(500 * 1e-9, 5500))
u'neutral 8 (.23 D)': 'neutral_80',
u'orange': 'orange',
u'orange yellow': 'orange_yellow',
u'purple': 'purple',
u'purplish blue': 'purplish_blue',
u'red': 'red',
u'white 9.5 (.05 D)': 'white_95',
u'yellow': 'yellow',
u'yellow green': 'yellow_green'
}
cmfs = colour.CMFS[u'cie_2_1931']
illum = colour.ILLUMINANTS_SDS[u'D65']
babelcolor_sds = colour.characterisation.COLOURCHECKERS_SDS[
u'BabelColor Average']
dark_skin_sd = babelcolor_sds[u'dark skin']
xyz = colour.sd_to_XYZ(dark_skin_sd, cmfs, illum)
print(xyz / 100)
rgb = colour.XYZ_to_sRGB(xyz / 100)
print(rgb)
print('let ref_xyz = HashMap::new();')
print('let ref_srgb = HashMap::new();')
for name in name_map.keys():
sd = babelcolor_sds[name]
xyz = colour.sd_to_XYZ(sd, cmfs, illum) / 100
srgb = colour.XYZ_to_sRGB(xyz)
print('ref_xyz.insert("%s", xyz(%f, %f, %f));' %
(name_map[name], xyz[0], xyz[1], xyz[2]))
print('ref_srgb.insert("%s", rgbf32(%f, %f, %f));' %
(name_map[name], srgb[0], srgb[1], srgb[2]))
import colour
from colour.utilities import message_box
message_box("Automatic Colour Conversion Graph")
message_box(
'Converting a "ColorChecker" "dark skin" sample spectral distribution to '
'"Output-Referred" "sRGB" colourspace.'
)
sd_dark_skin = colour.SDS_COLOURCHECKERS["ColorChecker N Ohta"]["dark skin"]
print(colour.convert(sd_dark_skin, "Spectral Distribution", "sRGB"))
print(
colour.XYZ_to_sRGB(
colour.sd_to_XYZ(
sd_dark_skin, illuminant=colour.SDS_ILLUMINANTS["D65"]
)
/ 100
)
)
print("\n")
RGB = np.array([0.45675795, 0.30986982, 0.24861924])
message_box(
f'Converting to the "CAM16-UCS" colourspace from given "Output-Referred" '
f'"sRGB" colourspace values:\n\n\t{RGB}'
)
print(colour.convert(RGB, "Output-Referred RGB", "CAM16UCS"))
specification = colour.XYZ_to_CAM16(
colour.sRGB_to_XYZ(RGB) * 100,
"""Showcases reflectance recovery computations using *Smits (1999)* method."""
import numpy as np
import colour
from colour.recovery.smits1999 import XYZ_to_RGB_Smits1999
from colour.utilities import message_box
message_box('"Smits (1999)" - Reflectance Recovery Computations')
XYZ = np.array([0.20654008, 0.12197225, 0.05136952])
RGB = XYZ_to_RGB_Smits1999(XYZ)
message_box(
f'Recovering reflectance using "Smits (1999)" method from given "RGB" '
f"colourspace array:\n\n\tRGB: {RGB}")
sd = colour.XYZ_to_sd(XYZ, method="Smits 1999")
print(sd)
print(colour.recovery.RGB_to_sd_Smits1999(XYZ))
print(colour.sd_to_XYZ(sd.align(colour.SPECTRAL_SHAPE_DEFAULT)) / 100)
print("\n")
message_box('An analysis of "Smits (1999)" method is available at the '
"following url : "
"http://nbviewer.jupyter.org/github/colour-science/colour-website/"
"blob/master/ipython/about_reflectance_recovery.ipynb")
def generate_documentation_plots(output_directory):
"""
Generates documentation plots.
Parameters
----------
output_directory : unicode
Output directory.
"""
colour.utilities.filter_warnings()
colour_style()
np.random.seed(0)
# *************************************************************************
# "README.rst"
# *************************************************************************
arguments = {
'tight_layout':
True,
'transparent_background':
True,
'filename':
os.path.join(output_directory,
'Examples_Plotting_Visible_Spectrum.png')
}
plot_visible_spectrum('CIE 1931 2 Degree Standard Observer', **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Examples_Plotting_Illuminant_F1_SD.png')
plot_single_illuminant_sd('FL1', **arguments)
arguments['filename'] = os.path.join(output_directory,
'Examples_Plotting_Blackbodies.png')
blackbody_sds = [
colour.sd_blackbody(i, colour.SpectralShape(0, 10000, 10))
for i in range(1000, 15000, 1000)
]
plot_multi_sds(
blackbody_sds,
y_label='W / (sr m$^2$) / m',
use_sds_colours=True,
normalise_sds_colours=True,
legend_location='upper right',
bounding_box=(0, 1250, 0, 2.5e15),
**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Examples_Plotting_Cone_Fundamentals.png')
plot_single_cmfs(
'Stockman & Sharpe 2 Degree Cone Fundamentals',
y_label='Sensitivity',
bounding_box=(390, 870, 0, 1.1),
**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Examples_Plotting_Luminous_Efficiency.png')
sd_mesopic_luminous_efficiency_function = (
colour.sd_mesopic_luminous_efficiency_function(0.2))
plot_multi_sds(
(sd_mesopic_luminous_efficiency_function,
colour.PHOTOPIC_LEFS['CIE 1924 Photopic Standard Observer'],
colour.SCOTOPIC_LEFS['CIE 1951 Scotopic Standard Observer']),
y_label='Luminous Efficiency',
legend_location='upper right',
y_tighten=True,
margins=(0, 0, 0, .1),
**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Examples_Plotting_BabelColor_Average.png')
plot_multi_sds(
colour.COLOURCHECKERS_SDS['BabelColor Average'].values(),
use_sds_colours=True,
title=('BabelColor Average - '
'Spectral Distributions'),
**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Examples_Plotting_ColorChecker_2005.png')
plot_single_colour_checker(
'ColorChecker 2005', text_parameters={'visible': False}, **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Examples_Plotting_Chromaticities_Prediction.png')
plot_corresponding_chromaticities_prediction(2, 'Von Kries', 'Bianco',
**arguments)
arguments['filename'] = os.path.join(
output_directory,
'Examples_Plotting_CCT_CIE_1960_UCS_Chromaticity_Diagram.png')
plot_planckian_locus_in_chromaticity_diagram_CIE1960UCS(['A', 'B', 'C'],
**arguments)
arguments['filename'] = os.path.join(
output_directory,
'Examples_Plotting_Chromaticities_CIE_1931_Chromaticity_Diagram.png')
RGB = np.random.random((32, 32, 3))
plot_RGB_chromaticities_in_chromaticity_diagram_CIE1931(
RGB,
'ITU-R BT.709',
colourspaces=['ACEScg', 'S-Gamut'],
show_pointer_gamut=True,
**arguments)
arguments['filename'] = os.path.join(output_directory,
'Examples_Plotting_CRI.png')
plot_single_sd_colour_rendering_index_bars(colour.ILLUMINANTS_SDS['FL2'],
**arguments)
# *************************************************************************
# Documentation
# *************************************************************************
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_CVD_Simulation_Machado2009.png')
plot_cvd_simulation_Machado2009(RGB, **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Single_Colour_Checker.png')
plot_single_colour_checker('ColorChecker 2005', **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Multi_Colour_Checkers.png')
plot_multi_colour_checkers(['ColorChecker 1976', 'ColorChecker 2005'],
**arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_Single_SD.png')
data = {
500: 0.0651,
520: 0.0705,
540: 0.0772,
560: 0.0870,
580: 0.1128,
600: 0.1360
}
sd = colour.SpectralDistribution(data, name='Custom')
plot_single_sd(sd, **arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_Multi_SDs.png')
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 = colour.SpectralDistribution(data_1, name='Custom 1')
spd2 = colour.SpectralDistribution(data_2, name='Custom 2')
plot_multi_sds([spd1, spd2], **arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_Single_CMFS.png')
plot_single_cmfs('CIE 1931 2 Degree Standard Observer', **arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_Multi_CMFS.png')
cmfs = ('CIE 1931 2 Degree Standard Observer',
'CIE 1964 10 Degree Standard Observer')
plot_multi_cmfs(cmfs, **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Single_Illuminant_SD.png')
plot_single_illuminant_sd('A', **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Multi_Illuminant_SDs.png')
plot_multi_illuminant_sds(['A', 'B', 'C'], **arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_Visible_Spectrum.png')
plot_visible_spectrum(**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Single_Lightness_Function.png')
plot_single_lightness_function('CIE 1976', **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Multi_Lightness_Functions.png')
plot_multi_lightness_functions(['CIE 1976', 'Wyszecki 1963'], **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Single_Luminance_Function.png')
plot_single_luminance_function('CIE 1976', **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Multi_Luminance_Functions.png')
plot_multi_luminance_functions(['CIE 1976', 'Newhall 1943'], **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Blackbody_Spectral_Radiance.png')
plot_blackbody_spectral_radiance(
3500, blackbody='VY Canis Major', **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Blackbody_Colours.png')
plot_blackbody_colours(colour.SpectralShape(150, 12500, 50), **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Single_Colour_Swatch.png')
RGB = ColourSwatch(RGB=(0.32315746, 0.32983556, 0.33640183))
plot_single_colour_swatch(RGB, **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Multi_Colour_Swatches.png')
RGB_1 = ColourSwatch(RGB=(0.45293517, 0.31732158, 0.26414773))
RGB_2 = ColourSwatch(RGB=(0.77875824, 0.57726450, 0.50453169))
plot_multi_colour_swatches([RGB_1, RGB_2], **arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_Single_Function.png')
plot_single_function(lambda x: x ** (1 / 2.2), **arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_Multi_Functions.png')
functions = {
'Gamma 2.2': lambda x: x ** (1 / 2.2),
'Gamma 2.4': lambda x: x ** (1 / 2.4),
'Gamma 2.6': lambda x: x ** (1 / 2.6),
}
plot_multi_functions(functions, **arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_Image.png')
path = os.path.join(colour.__path__[0], '..', 'docs', '_static',
'Logo_Medium_001.png')
plot_image(colour.read_image(str(path)), **arguments)
arguments['filename'] = os.path.join(
output_directory,
'Plotting_Plot_Corresponding_Chromaticities_Prediction.png')
plot_corresponding_chromaticities_prediction(1, 'Von Kries', 'CAT02',
**arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_Spectral_Locus.png')
plot_spectral_locus(spectral_locus_colours='RGB', **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Chromaticity_Diagram_Colours.png')
plot_chromaticity_diagram_colours(**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Chromaticity_Diagram.png')
plot_chromaticity_diagram(**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Chromaticity_Diagram_CIE1931.png')
plot_chromaticity_diagram_CIE1931(**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Chromaticity_Diagram_CIE1960UCS.png')
plot_chromaticity_diagram_CIE1960UCS(**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Chromaticity_Diagram_CIE1976UCS.png')
plot_chromaticity_diagram_CIE1976UCS(**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_SDs_In_Chromaticity_Diagram.png')
A = colour.ILLUMINANTS_SDS['A']
D65 = colour.ILLUMINANTS_SDS['D65']
plot_sds_in_chromaticity_diagram([A, D65], **arguments)
arguments['filename'] = os.path.join(
output_directory,
'Plotting_Plot_SDs_In_Chromaticity_Diagram_CIE1931.png')
plot_sds_in_chromaticity_diagram_CIE1931([A, D65], **arguments)
arguments['filename'] = os.path.join(
output_directory,
'Plotting_Plot_SDs_In_Chromaticity_Diagram_CIE1960UCS.png')
plot_sds_in_chromaticity_diagram_CIE1960UCS([A, D65], **arguments)
arguments['filename'] = os.path.join(
output_directory,
'Plotting_Plot_SDs_In_Chromaticity_Diagram_CIE1976UCS.png')
plot_sds_in_chromaticity_diagram_CIE1976UCS([A, D65], **arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_Pointer_Gamut.png')
plot_pointer_gamut(**arguments)
arguments['filename'] = os.path.join(
output_directory,
'Plotting_Plot_RGB_Colourspaces_In_Chromaticity_Diagram.png')
plot_RGB_colourspaces_in_chromaticity_diagram(
['ITU-R BT.709', 'ACEScg', 'S-Gamut'], **arguments)
arguments['filename'] = os.path.join(
output_directory,
'Plotting_Plot_RGB_Colourspaces_In_Chromaticity_Diagram_CIE1931.png')
plot_RGB_colourspaces_in_chromaticity_diagram_CIE1931(
['ITU-R BT.709', 'ACEScg', 'S-Gamut'], **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_RGB_Colourspaces_In_'
'Chromaticity_Diagram_CIE1960UCS.png')
plot_RGB_colourspaces_in_chromaticity_diagram_CIE1960UCS(
['ITU-R BT.709', 'ACEScg', 'S-Gamut'], **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_RGB_Colourspaces_In_'
'Chromaticity_Diagram_CIE1976UCS.png')
plot_RGB_colourspaces_in_chromaticity_diagram_CIE1976UCS(
['ITU-R BT.709', 'ACEScg', 'S-Gamut'], **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_RGB_Chromaticities_In_'
'Chromaticity_Diagram_Plot.png')
RGB = np.random.random((128, 128, 3))
plot_RGB_chromaticities_in_chromaticity_diagram(RGB, 'ITU-R BT.709',
**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_RGB_Chromaticities_In_'
'Chromaticity_Diagram_CIE1931.png')
plot_RGB_chromaticities_in_chromaticity_diagram_CIE1931(
RGB, 'ITU-R BT.709', **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_RGB_Chromaticities_In_'
'Chromaticity_Diagram_CIE1960UCS.png')
plot_RGB_chromaticities_in_chromaticity_diagram_CIE1960UCS(
RGB, 'ITU-R BT.709', **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_RGB_Chromaticities_In_'
'Chromaticity_Diagram_CIE1976UCS.png')
plot_RGB_chromaticities_in_chromaticity_diagram_CIE1976UCS(
RGB, 'ITU-R BT.709', **arguments)
arguments['filename'] = os.path.join(
output_directory,
'Plotting_Plot_Ellipses_MacAdam1942_In_Chromaticity_Diagram.png')
plot_ellipses_MacAdam1942_in_chromaticity_diagram(**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Ellipses_MacAdam1942_In_'
'Chromaticity_Diagram_CIE1931.png')
plot_ellipses_MacAdam1942_in_chromaticity_diagram_CIE1931(**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Ellipses_MacAdam1942_In_'
'Chromaticity_Diagram_CIE1960UCS.png')
plot_ellipses_MacAdam1942_in_chromaticity_diagram_CIE1960UCS(**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Ellipses_MacAdam1942_In_'
'Chromaticity_Diagram_CIE1976UCS.png')
plot_ellipses_MacAdam1942_in_chromaticity_diagram_CIE1976UCS(**arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_Single_CCTF.png')
plot_single_cctf('ITU-R BT.709', **arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_Multi_CCTFs.png')
plot_multi_cctfs(['ITU-R BT.709', 'sRGB'], **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Single_Munsell_Value_Function.png')
plot_single_munsell_value_function('ASTM D1535-08', **arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Multi_Munsell_Value_Functions.png')
plot_multi_munsell_value_functions(['ASTM D1535-08', 'McCamy 1987'],
**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Single_SD_Rayleigh_Scattering.png')
plot_single_sd_rayleigh_scattering(**arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_The_Blue_Sky.png')
plot_the_blue_sky(**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_Colour_Quality_Bars.png')
illuminant = colour.ILLUMINANTS_SDS['FL2']
light_source = colour.LIGHT_SOURCES_SDS['Kinoton 75P']
light_source = light_source.copy().align(colour.SpectralShape(360, 830, 1))
cqs_i = colour.colour_quality_scale(illuminant, additional_data=True)
cqs_l = colour.colour_quality_scale(light_source, additional_data=True)
plot_colour_quality_bars([cqs_i, cqs_l], **arguments)
arguments['filename'] = os.path.join(
output_directory,
'Plotting_Plot_Single_SD_Colour_Rendering_Index_Bars.png')
illuminant = colour.ILLUMINANTS_SDS['FL2']
plot_single_sd_colour_rendering_index_bars(illuminant, **arguments)
arguments['filename'] = os.path.join(
output_directory,
'Plotting_Plot_Multi_SDs_Colour_Rendering_Indexes_Bars.png')
light_source = colour.LIGHT_SOURCES_SDS['Kinoton 75P']
plot_multi_sds_colour_rendering_indexes_bars([illuminant, light_source],
**arguments)
arguments['filename'] = os.path.join(
output_directory,
'Plotting_Plot_Single_SD_Colour_Quality_Scale_Bars.png')
illuminant = colour.ILLUMINANTS_SDS['FL2']
plot_single_sd_colour_quality_scale_bars(illuminant, **arguments)
arguments['filename'] = os.path.join(
output_directory,
'Plotting_Plot_Multi_SDs_Colour_Quality_Scales_Bars.png')
light_source = colour.LIGHT_SOURCES_SDS['Kinoton 75P']
plot_multi_sds_colour_quality_scales_bars([illuminant, light_source],
**arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_Planckian_Locus.png')
plot_planckian_locus(**arguments)
arguments['filename'] = os.path.join(
output_directory,
'Plotting_Plot_Planckian_Locus_In_Chromaticity_Diagram.png')
plot_planckian_locus_in_chromaticity_diagram(['A', 'B', 'C'], **arguments)
arguments['filename'] = os.path.join(
output_directory,
'Plotting_Plot_Planckian_Locus_In_Chromaticity_Diagram_CIE1931.png')
plot_planckian_locus_in_chromaticity_diagram_CIE1931(['A', 'B', 'C'],
**arguments)
arguments['filename'] = os.path.join(
output_directory,
'Plotting_Plot_Planckian_Locus_In_Chromaticity_Diagram_CIE1960UCS.png')
plot_planckian_locus_in_chromaticity_diagram_CIE1960UCS(['A', 'B', 'C'],
**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_RGB_Colourspaces_Gamuts.png')
plot_RGB_colourspaces_gamuts(['ITU-R BT.709', 'ACEScg', 'S-Gamut'],
**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Plotting_Plot_RGB_Colourspaces_Gamuts.png')
plot_RGB_colourspaces_gamuts(['ITU-R BT.709', 'ACEScg', 'S-Gamut'],
**arguments)
arguments['filename'] = os.path.join(output_directory,
'Plotting_Plot_RGB_Scatter.png')
plot_RGB_scatter(RGB, 'ITU-R BT.709', **arguments)
# *************************************************************************
# "tutorial.rst"
# *************************************************************************
arguments['filename'] = os.path.join(output_directory,
'Tutorial_Visible_Spectrum.png')
plot_visible_spectrum(**arguments)
arguments['filename'] = os.path.join(output_directory,
'Tutorial_Sample_SD.png')
sample_sd_data = {
380: 0.048,
385: 0.051,
390: 0.055,
395: 0.060,
400: 0.065,
405: 0.068,
410: 0.068,
415: 0.067,
420: 0.064,
425: 0.062,
430: 0.059,
435: 0.057,
440: 0.055,
445: 0.054,
450: 0.053,
455: 0.053,
460: 0.052,
465: 0.052,
470: 0.052,
475: 0.053,
480: 0.054,
485: 0.055,
490: 0.057,
495: 0.059,
500: 0.061,
505: 0.062,
510: 0.065,
515: 0.067,
520: 0.070,
525: 0.072,
530: 0.074,
535: 0.075,
540: 0.076,
545: 0.078,
550: 0.079,
555: 0.082,
560: 0.087,
565: 0.092,
570: 0.100,
575: 0.107,
580: 0.115,
585: 0.122,
590: 0.129,
595: 0.134,
600: 0.138,
605: 0.142,
610: 0.146,
615: 0.150,
620: 0.154,
625: 0.158,
630: 0.163,
635: 0.167,
640: 0.173,
645: 0.180,
650: 0.188,
655: 0.196,
660: 0.204,
665: 0.213,
670: 0.222,
675: 0.231,
680: 0.242,
685: 0.251,
690: 0.261,
695: 0.271,
700: 0.282,
705: 0.294,
710: 0.305,
715: 0.318,
720: 0.334,
725: 0.354,
730: 0.372,
735: 0.392,
740: 0.409,
745: 0.420,
750: 0.436,
755: 0.450,
760: 0.462,
765: 0.465,
770: 0.448,
775: 0.432,
780: 0.421
}
sd = colour.SpectralDistribution(sample_sd_data, name='Sample')
plot_single_sd(sd, **arguments)
arguments['filename'] = os.path.join(output_directory,
'Tutorial_SD_Interpolation.png')
sd_copy = sd.copy()
sd_copy.interpolate(colour.SpectralShape(400, 770, 1))
plot_multi_sds(
[sd, sd_copy], bounding_box=[730, 780, 0.25, 0.5], **arguments)
arguments['filename'] = os.path.join(output_directory,
'Tutorial_Sample_Swatch.png')
sd = colour.SpectralDistribution(sample_sd_data)
cmfs = colour.STANDARD_OBSERVERS_CMFS[
'CIE 1931 2 Degree Standard Observer']
illuminant = colour.ILLUMINANTS_SDS['D65']
with domain_range_scale('1'):
XYZ = colour.sd_to_XYZ(sd, cmfs, illuminant)
RGB = colour.XYZ_to_sRGB(XYZ)
plot_single_colour_swatch(
ColourSwatch('Sample', RGB),
text_parameters={'size': 'x-large'},
**arguments)
arguments['filename'] = os.path.join(output_directory,
'Tutorial_Neutral5.png')
patch_name = 'neutral 5 (.70 D)'
patch_sd = colour.COLOURCHECKERS_SDS['ColorChecker N Ohta'][patch_name]
with domain_range_scale('1'):
XYZ = colour.sd_to_XYZ(patch_sd, cmfs, illuminant)
RGB = colour.XYZ_to_sRGB(XYZ)
plot_single_colour_swatch(
ColourSwatch(patch_name.title(), RGB),
text_parameters={'size': 'x-large'},
**arguments)
arguments['filename'] = os.path.join(output_directory,
'Tutorial_Colour_Checker.png')
plot_single_colour_checker(
colour_checker='ColorChecker 2005',
text_parameters={'visible': False},
**arguments)
arguments['filename'] = os.path.join(
output_directory, 'Tutorial_CIE_1931_Chromaticity_Diagram.png')
xy = colour.XYZ_to_xy(XYZ)
plot_chromaticity_diagram_CIE1931(standalone=False)
x, y = xy
plt.plot(x, y, 'o-', color='white')
# Annotating the plot.
plt.annotate(
patch_sd.name.title(),
xy=xy,
xytext=(-50, 30),
textcoords='offset points',
arrowprops=dict(arrowstyle='->', connectionstyle='arc3, rad=-0.2'))
render(
standalone=True,
limits=(-0.1, 0.9, -0.1, 0.9),
x_tighten=True,
y_tighten=True,
**arguments)
# *************************************************************************
# "basics.rst"
# *************************************************************************
arguments['filename'] = os.path.join(output_directory,
'Basics_Logo_Small_001_CIE_XYZ.png')
RGB = colour.read_image(
os.path.join(output_directory, 'Logo_Small_001.png'))[..., 0:3]
XYZ = colour.sRGB_to_XYZ(RGB)
colour.plotting.plot_image(
XYZ, text_parameters={'text': 'sRGB to XYZ'}, **arguments)
755: 0.450,
760: 0.462,
765: 0.465,
770: 0.448,
775: 0.432,
780: 0.421
}
sd = colour.SpectralDistribution(sample_sd_data, name='Sample')
cmfs = colour.CMFS['CIE 1931 2 Degree Standard Observer']
illuminant = colour.ILLUMINANTS_SDS['A']
message_box(('Computing *CIE XYZ* tristimulus values for sample spectral '
'distribution and "CIE Standard Illuminant A".'))
print(colour.sd_to_XYZ(sd, cmfs, illuminant))
print('\n')
message_box(('Computing "CIE Standard Illuminant A" chromaticity coordinates '
'from its spectral distribution.'))
print(colour.XYZ_to_xy(colour.sd_to_XYZ(illuminant, cmfs) / 100))
print('\n')
message_box(('Computing *CIE XYZ* tristimulus values for a single given '
'wavelength in nm.'))
print(
colour.wavelength_to_XYZ(
546.1, colour.CMFS['CIE 1931 2 Degree Standard Observer']))
