def run(data,
xyzw=_DEFAULT_WHITE_POINT,
Yw=None,
outin='J,aM,bM',
conditions=None,
forward=True,
yellowbluepurplecorrect=False,
mcat='cat02'):
"""
Run CIECAM02 color appearance model in forward or backward modes.
Args:
:data:
| ndarray with relative sample xyz values (forward mode) or J'a'b' coordinates (inverse mode)
:xyzw:
| ndarray with relative white point tristimulus values
:Yw:
| None, optional
| Luminance factor of white point.
| If None: xyz (in data) and xyzw are entered as relative tristimulus values
| (normalized to Yw = 100).
| If not None: input tristimulus are absolute and Yw is used to
| rescale the absolute values to relative ones
| (relative to a reference perfect white diffuser
| with Ywr = 100).
| Yw can be < 100 for e.g. paper as white point. If Yw is None, it
| is assumed that the relative Y-tristimulus value in xyzw
| represents the luminance factor Yw.
:conditions:
| None, optional
| Dictionary with viewing condition parameters for:
| La, Yb, D and surround.
| surround can contain:
| - str (options: 'avg','dim','dark') or
| - dict with keys c, Nc, F.
| None results in:
| {'La':100, 'Yb':20, 'D':1, 'surround':'avg'}
:forward:
| True, optional
| If True: run in CAM in forward mode, else: inverse mode.
:outin:
| 'J,aM,bM', optional
| String with requested output (e.g. "J,aM,bM,M,h") [Forward mode]
| - attributes: 'J': lightness,'Q': brightness,
| 'M': colorfulness,'C': chroma, 's': saturation,
| 'h': hue angle, 'H': hue quadrature/composition,
| String with inputs in data [inverse mode].
| Input must have data.shape[-1]==3 and last dim of data must have
| the following structure for inverse mode:
| * data[...,0] = J or Q,
| * data[...,1:] = (aM,bM) or (aC,bC) or (aS,bS) or (M,h) or (C, h), ...
:yellowbluepurplecorrect:
| False, optional
| If False: don't correct for yellow-blue and purple problems in ciecam02.
| If 'brill-suss':
| for yellow-blue problem, see:
| - Brill [Color Res Appl, 2006; 31, 142-145] and
| - Brill and Süsstrunk [Color Res Appl, 2008; 33, 424-426]
| If 'jiang-luo':
| for yellow-blue problem + purple line problem, see:
| - Jiang, Jun et al. [Color Res Appl 2015: 40(5), 491-503]
:mcat:
| 'cat02', optional
| Specifies CAT sensor space.
| - options:
| - None defaults to 'cat02'
| (others e.g. 'cat02-bs', 'cat02-jiang',
| all trying to correct gamut problems of original cat02 matrix)
| - str: see see luxpy.cat._MCATS.keys() for options
| (details on type, ?luxpy.cat)
| - ndarray: matrix with sensor primaries
Returns:
:camout:
| ndarray with color appearance correlates (forward mode)
| or
| XYZ tristimulus values (inverse mode)
References:
1. `N. Moroney, M. D. Fairchild, R. W. G. Hunt, C. Li, M. R. Luo, and T. Newman, (2002),
"The CIECAM02 color appearance model,”
IS&T/SID Tenth Color Imaging Conference. p. 23, 2002.
<http://rit-mcsl.org/fairchild/PDFs/PRO19.pdf>`_
"""
outin = outin.split(',') if isinstance(outin, str) else outin
#--------------------------------------------
# Get condition parameters:
if conditions is None:
conditions = _DEFAULT_CONDITIONS
D, Dtype, La, Yb, surround = (conditions[x]
for x in sorted(conditions.keys()))
surround_parameters = _SURROUND_PARAMETERS
if isinstance(surround, str):
surround = surround_parameters[conditions['surround']]
F, FLL, Nc, c = [surround[x] for x in sorted(surround.keys())]
#--------------------------------------------
# Define sensor space and cat matrices:
# Hunt-Pointer-Estevez sensors (cone fundamentals)
mhpe = cat._MCATS['hpe']
# chromatic adaptation sensors:
if (mcat is None) | (mcat == 'cat02'):
mcat = cat._MCATS['cat02']
if yellowbluepurplecorrect == 'brill-suss':
mcat = cat._MCATS[
'cat02-bs'] # for yellow-blue problem, Brill [Color Res Appl 2006;31:142-145] and Brill and Süsstrunk [Color Res Appl 2008;33:424-426]
elif yellowbluepurplecorrect == 'jiang-luo':
mcat = cat._MCATS[
'cat02-jiang-luo'] # for yellow-blue problem + purple line problem
elif isinstance(mcat, str):
mcat = cat._MCATS[mcat]
#--------------------------------------------
# pre-calculate some matrices:
invmcat = np.linalg.inv(mcat)
mhpe_x_invmcat = np.dot(mhpe, invmcat)
if not forward: mcat_x_invmhpe = np.dot(mcat, np.linalg.inv(mhpe))
#--------------------------------------------
# Set Yw:
if Yw is not None:
Yw = (Yw * np.ones_like(xyzw2[..., 1:2]).T)
else:
Yw = xyzw[..., 1:2].T
#--------------------------------------------
# calculate condition dependent parameters:
k = 1.0 / (5.0 * La + 1.0)
FL = 0.2 * (k**4.0) * (5.0 * La) + 0.1 * ((1.0 - k**4.0)**2.0) * (
(5.0 * La)**(1.0 / 3.0)) # luminance adaptation factor
n = Yb / Yw
Nbb = 0.725 * (1 / n)**0.2
Ncb = Nbb
z = 1.48 + FLL * n**0.5
yw = xyzw[..., 1:2].T # original Y in xyzw (pre-transposed)
#--------------------------------------------
# Calculate degree of chromatic adaptation:
if D is None:
D = F * (1.0 - (1.0 / 3.6) * np.exp((-La - 42.0) / 92.0))
#===================================================================
# WHITE POINT transformations (common to forward and inverse modes):
#--------------------------------------------
# Normalize white point (keep transpose for next step):
xyzw = Yw * xyzw.T / yw
#--------------------------------------------
# transform from xyzw to cat sensor space:
rgbw = math.dot23(mcat, xyzw)
#--------------------------------------------
# apply von Kries cat:
rgbwc = (
(D * Yw / rgbw) + (1 - D)
) * rgbw # factor 100 from ciecam02 is replaced with Yw[i] in ciecam16, but see 'note' in Fairchild's "Color Appearance Models" (p291 ni 3ed.)
#--------------------------------------------
# convert from cat02 sensor space to cone sensors (hpe):
rgbwp = math.dot23(mhpe_x_invmcat, rgbwc).T
#--------------------------------------------
# apply Naka_rushton repsonse compression to white:
NK = lambda x, forward: naka_rushton(x,
scaling=400,
n=0.42,
sig=27.13**(1 / 0.42),
noise=0.1,
forward=forward)
pw = np.where(rgbwp < 0)
# if requested apply yellow-blue correction:
if (yellowbluepurplecorrect == 'brill-suss'
): # Brill & Susstrunck approach, for purple line problem
rgbwp[pw] = 0.0
rgbwpa = NK(FL * rgbwp / 100.0, True)
rgbwpa[pw] = 0.1 - (NK(FL * np.abs(rgbwp[pw]) / 100.0, True) - 0.1)
#--------------------------------------------
# Calculate achromatic signal of white:
Aw = (2.0 * rgbwpa[..., 0] + rgbwpa[..., 1] +
(1.0 / 20.0) * rgbwpa[..., 2] - 0.305) * Nbb
# massage shape of data for broadcasting:
original_ndim = data.ndim
if data.ndim == 2: data = data[:, None]
#===================================================================
# STIMULUS transformations
if forward:
#--------------------------------------------
# Normalize xyz (keep transpose for matrix multiplication in next step):
xyz = (Yw / yw)[..., None] * data.T
#--------------------------------------------
# transform from xyz to cat sensor space:
rgb = math.dot23(mcat, xyz)
#--------------------------------------------
# apply von Kries cat:
rgbc = (
(D * Yw / rgbw)[..., None] + (1 - D)
) * rgb # factor 100 from ciecam02 is replaced with Yw[i] in ciecam16, but see 'note' in Fairchild's "Color Appearance Models" (p291 ni 3ed.)
#--------------------------------------------
# convert from cat02 sensor space to cone sensors (hpe):
rgbp = math.dot23(mhpe_x_invmcat, rgbc).T
#--------------------------------------------
# apply Naka_rushton repsonse compression:
p = np.where(rgbp < 0)
if (yellowbluepurplecorrect == 'brill-suss'
): # Brill & Susstrunck approach, for purple line problem
rgbp[p] = 0.0
rgbpa = NK(FL * rgbp / 100.0, forward)
rgbpa[p] = 0.1 - (NK(FL * np.abs(rgbp[p]) / 100.0, forward) - 0.1)
#--------------------------------------------
# Calculate achromatic signal:
A = (2.0 * rgbpa[..., 0] + rgbpa[..., 1] +
(1.0 / 20.0) * rgbpa[..., 2] - 0.305) * Nbb
#--------------------------------------------
# calculate initial opponent channels:
a = rgbpa[..., 0] - 12.0 * rgbpa[..., 1] / 11.0 + rgbpa[..., 2] / 11.0
b = (1.0 / 9.0) * (rgbpa[..., 0] + rgbpa[..., 1] - 2.0 * rgbpa[..., 2])
#--------------------------------------------
# calculate hue h and eccentricity factor, et:
h = hue_angle(a, b, htype='deg')
et = (1.0 / 4.0) * (np.cos(h * np.pi / 180 + 2.0) + 3.8)
#--------------------------------------------
# calculate Hue quadrature (if requested in 'out'):
if 'H' in outin:
H = hue_quadrature(h, unique_hue_data=_UNIQUE_HUE_DATA)
else:
H = None
#--------------------------------------------
# calculate lightness, J:
J = 100.0 * (A / Aw)**(c * z)
#--------------------------------------------
# calculate brightness, Q:
Q = (4.0 / c) * ((J / 100.0)**0.5) * (Aw + 4.0) * (FL**0.25)
#--------------------------------------------
# calculate chroma, C:
t = ((50000.0 / 13.0) * Nc * Ncb * et *
((a**2.0 + b**2.0)**0.5)) / (rgbpa[..., 0] + rgbpa[..., 1] +
(21.0 / 20.0 * rgbpa[..., 2]))
C = (t**0.9) * ((J / 100.0)**0.5) * (1.64 - 0.29**n)**0.73
#--------------------------------------------
# calculate colorfulness, M:
M = C * FL**0.25
#--------------------------------------------
# calculate saturation, s:
s = 100.0 * (M / Q)**0.5
S = s # make extra variable, jsut in case 'S' is called
#--------------------------------------------
# calculate cartesian coordinates:
if ('aS' in outin):
aS = s * np.cos(h * np.pi / 180.0)
bS = s * np.sin(h * np.pi / 180.0)
if ('aC' in outin):
aC = C * np.cos(h * np.pi / 180.0)
bC = C * np.sin(h * np.pi / 180.0)
if ('aM' in outin):
aM = M * np.cos(h * np.pi / 180.0)
bM = M * np.sin(h * np.pi / 180.0)
#--------------------------------------------
if outin != ['J', 'aM', 'bM']:
camout = eval('ajoin((' + ','.join(outin) + '))')
else:
camout = ajoin((J, aM, bM))
if (camout.shape[1] == 1) & (original_ndim < 3):
camout = camout[:, 0, :]
return camout
elif forward == False:
#--------------------------------------------
# Get Lightness J from data:
if ('J' in outin[0]):
J = data[..., 0].copy()
elif ('Q' in outin[0]):
Q = data[..., 0].copy()
J = 100.0 * (Q / ((Aw + 4.0) * (FL**0.25) * (4.0 / c)))**2.0
else:
raise Exception(
'No lightness or brightness values in data. Inverse CAM-transform not possible!'
)
#--------------------------------------------
if 'a' in outin[1]:
# calculate hue h:
h = hue_angle(data[..., 1], data[..., 2], htype='deg')
#--------------------------------------------
# calculate Colorfulness M or Chroma C or Saturation s from a,b:
MCs = (data[..., 1]**2.0 + data[..., 2]**2.0)**0.5
else:
h = data[..., 2]
MCs = data[..., 1]
if ('S' in outin[1]):
Q = (4.0 / c) * ((J / 100.0)**0.5) * (Aw + 4.0) * (FL**0.25)
M = Q * (MCs / 100.0)**2.0
C = M / (FL**0.25)
if ('M' in outin[1]): # convert M to C:
C = MCs / (FL**0.25)
if ('C' in outin[1]):
C = MCs
#--------------------------------------------
# calculate t from J, C:
t = (C / ((J / 100.0)**(1.0 / 2.0) * (1.64 - 0.29**n)**0.73))**(1.0 /
0.9)
#--------------------------------------------
# calculate eccentricity factor, et:
et = (np.cos(h * np.pi / 180.0 + 2.0) + 3.8) / 4.0
#--------------------------------------------
# calculate achromatic signal, A:
A = Aw * (J / 100.0)**(1.0 / (c * z))
#--------------------------------------------
# calculate temporary cart. co. at, bt and p1,p2,p3,p4,p5:
at = np.cos(h * np.pi / 180.0)
bt = np.sin(h * np.pi / 180.0)
p1 = (50000.0 / 13.0) * Nc * Ncb * et / t
p2 = A / Nbb + 0.305
p3 = 21.0 / 20.0
p4 = p1 / bt
p5 = p1 / at
#--------------------------------------------
#q = np.where(np.abs(bt) < np.abs(at))[0]
q = (np.abs(bt) < np.abs(at))
b = p2 * (2.0 + p3) * (460.0 / 1403.0) / (p4 + (2.0 + p3) *
(220.0 / 1403.0) *
(at / bt) -
(27.0 / 1403.0) + p3 *
(6300.0 / 1403.0))
a = b * (at / bt)
a[q] = p2[q] * (2.0 + p3) * (460.0 / 1403.0) / (p5[q] + (2.0 + p3) *
(220.0 / 1403.0) -
((27.0 / 1403.0) - p3 *
(6300.0 / 1403.0)) *
(bt[q] / at[q]))
b[q] = a[q] * (bt[q] / at[q])
#--------------------------------------------
# calculate post-adaptation values
rpa = (460.0 * p2 + 451.0 * a + 288.0 * b) / 1403.0
gpa = (460.0 * p2 - 891.0 * a - 261.0 * b) / 1403.0
bpa = (460.0 * p2 - 220.0 * a - 6300.0 * b) / 1403.0
#--------------------------------------------
# join values:
rgbpa = ajoin((rpa, gpa, bpa))
#--------------------------------------------
# decompress signals:
rgbp = (100.0 / FL) * NK(rgbpa, forward)
# apply yellow-blue correction:
if (yellowbluepurplecorrect == 'brill-suss'
): # Brill & Susstrunck approach, for purple line problem
p = np.where(rgbp < 0.0)
rgbp[p] = 0.0
#--------------------------------------------
# convert from to cone sensors (hpe) cat02 sensor space:
rgbc = math.dot23(mcat_x_invmhpe, rgbp.T)
#--------------------------------------------
# apply inverse von Kries cat:
rgb = rgbc / ((D * Yw / rgbw)[..., None] + (1.0 - D))
#--------------------------------------------
# transform from cat sensor space to xyz:
xyz = math.dot23(invmcat, rgb)
#--------------------------------------------
# unnormalize xyz:
xyz = ((yw / Yw)[..., None] * xyz).T
return xyz
def run(data,
xyzw=None,
outin='J,aM,bM',
cieobs=_CIEOBS,
conditions=None,
forward=True,
mcat='cat16',
**kwargs):
"""
Run the Jz,az,bz based color appearance model in forward or backward modes.
Args:
:data:
| ndarray with relative sample xyz values (forward mode) or J'a'b' coordinates (inverse mode)
:xyzw:
| ndarray with relative white point tristimulus values
| None defaults to D65
:cieobs:
| _CIEOBS, optional
| CMF set to use when calculating :xyzw: if this is None.
:conditions:
| None, optional
| Dictionary with viewing condition parameters for:
| La, Yb, D and surround.
| surround can contain:
| - str (options: 'avg','dim','dark') or
| - dict with keys c, Nc, F.
| None results in:
| {'La':100, 'Yb':20, 'D':1, 'surround':'avg'}
:forward:
| True, optional
| If True: run in CAM in forward mode, else: inverse mode.
:outin:
| 'J,aM,bM', optional
| String with requested output (e.g. "J,aM,bM,M,h") [Forward mode]
| String with inputs in data.
| Input must have data.shape[-1]==3 and last dim of data must have
| the following structure:
| * data[...,0] = J or Q,
| * data[...,1:] = (aM,bM) or (aC,bC) or (aS,bS)
:mcat:
| 'cat16', optional
| Specifies CAT sensor space.
| - options:
| - None defaults to 'cat16'
| - str: see see luxpy.cat._MCATS.keys() for options
| (details on type, ?luxpy.cat)
| - ndarray: matrix with sensor primaries
Returns:
:camout:
| ndarray with color appearance correlates (forward mode)
| or
| XYZ tristimulus values (inverse mode)
References:
1. `Safdar, M., Cui, G., Kim,Y. J., and Luo, M. R.(2017).
Perceptually uniform color space for image signals including high dynamic range and wide gamut.
Opt. Express, vol. 25, no. 13, pp. 15131–15151, Jun. 2017.
<https://www.opticsexpress.org/abstract.cfm?URI=oe-25-13-15131>`_
2. `Safdar, M., Hardeberg, J., Cui, G., Kim, Y. J., and Luo, M. R.(2018).
A Colour Appearance Model based on Jzazbz Colour Space,
26th Color and Imaging Conference (2018), Vancouver, Canada, November 12-16, 2018, pp96-101.
<https://doi.org/10.2352/ISSN.2169-2629.2018.26.96>`_
"""
outin = outin.split(',') if isinstance(outin, str) else outin
#--------------------------------------------
# Get condition parameters:
if conditions is None:
conditions = _DEFAULT_CONDITIONS
D, Dtype, La, Yb, surround = (conditions[x]
for x in sorted(conditions.keys()))
surround_parameters = _SURROUND_PARAMETERS
if isinstance(surround, str):
surround = surround_parameters[conditions['surround']]
F, FLL, Nc, c = [surround[x] for x in sorted(surround.keys())]
# Define cone/chromatic adaptation sensor space:
if (mcat is None) | (mcat == 'cat16'):
mcat = cat._MCATS['cat16']
elif isinstance(mcat, str):
mcat = cat._MCATS[mcat]
invmcat = np.linalg.inv(mcat)
#--------------------------------------------
# Get white point of D65 fro chromatic adaptation transform (CAT)
xyzw_d65 = np.array([[
9.5047e+01, 1.0000e+02, 1.0888e+02
]]) if cieobs == '1931_2' else spd_to_xyz(_CIE_D65, cieobs=cieobs)
#--------------------------------------------
# Get default white point:
if xyzw is None:
xyzw = xyzw_d65.copy()
#--------------------------------------------
# calculate condition dependent parameters:
Yw = xyzw[..., 1].T
k = 1.0 / (5.0 * La + 1.0)
FL = 0.2 * (k**4.0) * (5.0 * La) + 0.1 * ((1.0 - k**4.0)**2.0) * (
(5.0 * La)**(1.0 / 3.0)) # luminance adaptation factor
n = Yb / Yw
Nbb = 0.725 * (1 / n)**0.2
z = 1.48 + FLL * n**0.5
#--------------------------------------------
# Calculate degree of chromatic adaptation:
if D is None:
D = F * (1.0 - (1.0 / 3.6) * np.exp((-La - 42.0) / 92.0))
#===================================================================
# WHITE POINT transformations (common to forward and inverse modes):
#--------------------------------------------
# Apply CAT to white point:
xyzwc = cat.apply_vonkries1(xyzw,
xyzw,
xyzw_d65,
D=D,
mcat=mcat,
invmcat=invmcat)
#--------------------------------------------
# Get Iz,az,bz coordinates:
iabzw = xyz_to_jabz(xyzwc, ztype='iabz')
#===================================================================
# STIMULUS transformations:
#--------------------------------------------
# massage shape of data for broadcasting:
original_ndim = data.ndim
if data.ndim == 2: data = data[:, None]
if forward:
# Apply CAT to D65:
xyzc = cat.apply_vonkries1(data,
xyzw,
xyzw_d65,
D=D,
mcat=mcat,
invmcat=invmcat)
# Get Iz,az,bz coordinates:
iabz = xyz_to_jabz(xyzc, ztype='iabz')
#--------------------------------------------
# calculate hue h and eccentricity factor, et:
h = hue_angle(iabz[..., 1], iabz[..., 2], htype='deg')
et = 1.01 + np.cos(h * np.pi / 180 + 1.55)
#--------------------------------------------
# calculate Hue quadrature (if requested in 'out'):
if 'H' in outin:
H = hue_quadrature(h, unique_hue_data=_UNIQUE_HUE_DATA)
else:
H = None
#--------------------------------------------
# calculate lightness, J:
if ('J' in outin) | ('Q' in outin) | ('C' in outin) | (
'M' in outin) | ('s' in outin) | ('aS' in outin) | (
'aC' in outin) | ('aM' in outin):
J = 100.0 * (iabz[..., 0] / iabzw[..., 0])**(c * z)
#--------------------------------------------
# calculate brightness, Q:
if ('Q' in outin) | ('s' in outin) | ('aS' in outin):
Q = 192.5 * (J / c) * (FL**0.64)
#--------------------------------------------
# calculate chroma, C:
if ('C' in outin) | ('M' in outin) | ('s' in outin) | (
'aS' in outin) | ('aC' in outin) | ('aM' in outin):
C = ((1 / n)**0.074) * (
(iabz[..., 1]**2.0 + iabz[..., 2]**2.0)**0.37) * (et**0.067)
#--------------------------------------------
# calculate colorfulness, M:
if ('M' in outin) | ('s' in outin) | ('aM' in outin) | ('aS' in outin):
M = 1.42 * C * FL**0.25
#--------------------------------------------
# calculate saturation, s:
if ('s' in outin) | ('aS' in outin):
s = 100.0 * (M / Q)**0.5
#--------------------------------------------
# calculate cartesian coordinates:
if ('aS' in outin):
aS = s * np.cos(h * np.pi / 180.0)
bS = s * np.sin(h * np.pi / 180.0)
if ('aC' in outin):
aC = C * np.cos(h * np.pi / 180.0)
bC = C * np.sin(h * np.pi / 180.0)
if ('aM' in outin):
aM = M * np.cos(h * np.pi / 180.0)
bM = M * np.sin(h * np.pi / 180.0)
#--------------------------------------------
if outin != ['J', 'aM', 'bM']:
camout = eval('ajoin((' + ','.join(outin) + '))')
else:
camout = ajoin((J, aM, bM))
if (camout.shape[1] == 1) & (original_ndim < 3):
camout = camout[:, 0, :]
return camout
elif forward == False:
#--------------------------------------------
# Get Lightness J from data:
if ('J' in outin[0]):
J = data[..., 0].copy()
elif ('Q' in outin[0]):
Q = data[..., 0].copy()
J = c * (Q / (192.25 * FL**0.64))
else:
raise Exception(
'No lightness or brightness values in data[...,0]. Inverse CAM-transform not possible!'
)
#--------------------------------------------
if 'a' in outin[1]:
# calculate hue h:
h = hue_angle(data[..., 1], data[..., 2], htype='deg')
#--------------------------------------------
# calculate Colorfulness M or Chroma C or Saturation s from a,b:
MCs = (data[..., 1]**2.0 + data[..., 2]**2.0)**0.5
else:
h = data[..., 2]
MCs = data[..., 1]
if ('aS' in outin):
Q = 192.5 * (J / c) * (FL**0.64)
M = Q * (MCs / 100.0)**2.0
C = M / (1.42 * FL**0.25)
if ('aM' in outin): # convert M to C:
C = MCs / (1.42 * FL**0.25)
if ('aC' in outin):
C = MCs
#--------------------------------------------
# calculate achromatic signal, Iz:
Iz = iabzw[..., 0] * (J / 100.0)**(1.0 / (c * z))
#--------------------------------------------
# calculate eccentricity factor, et:
et = 1.01 + np.cos(h * np.pi / 180 + 1.55)
#--------------------------------------------
# calculate t (=a**2+b**2) from C:
t = (n**0.074 * C * (1 / et)**0.067)**(1 / 0.37)
#--------------------------------------------
# Calculate az, bz:
az = (t / (1 + np.tan(h * np.pi / 180)**2))**0.5
bz = az * np.tan(h * np.pi / 180)
#--------------------------------------------
# join values and convert to xyz:
xyzc = jabz_to_xyz(ajoin((Iz, az, bz)), ztype='iabz')
#-------------------------------------------
# Apply CAT from D65:
xyz = cat.apply_vonkries1(xyzc,
xyzw_d65,
xyzw,
D=D,
mcat=mcat,
invmcat=invmcat)
return xyz
def run(data,
xyzw=_DEFAULT_WHITE_POINT,
Yw=None,
conditions=None,
ucstype='ucs',
forward=True,
yellowbluepurplecorrect=False,
mcat='cat02'):
"""
Run the CAM02-UCS[,-LCD,-SDC] color appearance difference model in forward or backward modes.
Args:
:data:
| ndarray with sample xyz values (forward mode) or J'a'b' coordinates (inverse mode)
:xyzw:
| ndarray with white point tristimulus values
:conditions:
| None, optional
| Dictionary with viewing conditions.
| None results in:
| {'La':100, 'Yb':20, 'D':1, 'surround':'avg'}
| For more info see luxpy.cam.ciecam02()?
:ucstype:
| 'ucs', optional
| String with type of color difference appearance space
| options: 'ucs', 'scd', 'lcd'
:forward:
| True, optional
| If True: run in CAM in forward mode, else: inverse mode.
:yellowbluepurplecorrect:
| False, optional
| If False: don't correct for yellow-blue and purple problems in ciecam02.
| If 'brill-suss':
| for yellow-blue problem, see:
| - Brill [Color Res Appl, 2006; 31, 142-145] and
| - Brill and Süsstrunk [Color Res Appl, 2008; 33, 424-426]
| If 'jiang-luo':
| for yellow-blue problem + purple line problem, see:
| - Jiang, Jun et al. [Color Res Appl 2015: 40(5), 491-503]
:mcat:
| 'cat02', optional
| Specifies CAT sensor space.
| - options:
| - None defaults to 'cat02'
| (others e.g. 'cat02-bs', 'cat02-jiang',
| all trying to correct gamut problems of original cat02 matrix)
| - str: see see luxpy.cat._MCATS.keys() for options
| (details on type, ?luxpy.cat)
| - ndarray: matrix with sensor primaries
Returns:
:camout:
| ndarray with J'a'b' coordinates (forward mode)
| or
| XYZ tristimulus values (inverse mode)
References:
1. `M.R. Luo, G. Cui, and C. Li,
'Uniform colour spaces based on CIECAM02 colour appearance model,'
Color Res. Appl., vol. 31, no. 4, pp. 320–330, 2006.
<http://onlinelibrary.wiley.com/doi/10.1002/col.20227/abstract)>`_
"""
# get ucs parameters:
if isinstance(ucstype, str):
ucs_pars = _CAM_UCS_PARAMETERS
ucs = ucs_pars[ucstype]
else:
ucs = ucstype
KL, c1, c2 = ucs['KL'], ucs['c1'], ucs['c2']
# set conditions to use in CIECAM02 (overrides None-default in ciecam02() !!!)
if conditions is None:
conditions = _DEFAULT_CONDITIONS
if forward == True:
# run ciecam02 to get JMh:
data = ciecam02(data,
xyzw,
outin='J,M,h',
conditions=conditions,
forward=True,
mcat=mcat,
yellowbluepurplecorrect=yellowbluepurplecorrect)
camout = np.zeros_like(data) # for output
#--------------------------------------------
# convert to cam02ucs J', aM', bM':
camout[...,
0] = (1.0 + 100.0 * c1) * data[...,
0] / (1.0 + c1 * data[..., 0])
Mp = ((1.0 / c2) *
np.log(1.0 + c2 * data[..., 1])) if (c2 != 0) else data[..., 1]
camout[..., 1] = Mp * np.cos(data[..., 2] * np.pi / 180)
camout[..., 2] = Mp * np.sin(data[..., 2] * np.pi / 180)
return camout
else:
#--------------------------------------------
# convert cam02ucs J', aM', bM' to xyz:
# calc ciecam02 hue angle
#Jp, aMp, bMp = asplit(data)
h = np.arctan2(data[..., 2], data[..., 1])
# calc cam02ucs and CIECAM02 colourfulness
Mp = (data[..., 1]**2.0 + data[..., 2]**2.0)**0.5
M = ((np.exp(c2 * Mp) - 1.0) / c2) if (c2 != 0) else Mp
# calculate ciecam02 aM, bM:
aM = M * np.cos(h)
bM = M * np.sin(h)
# calc ciecam02 lightness
J = data[..., 0] / (1.0 + (100.0 - data[..., 0]) * c1)
# run ciecam02 in inverse mode to get xyz:
return ciecam02(ajoin((J, aM, bM)),
xyzw,
outin='J,aM,bM',
conditions=conditions,
forward=False,
mcat=mcat,
yellowbluepurplecorrect=yellowbluepurplecorrect)
def run(data, xyzw, out = 'J,aM,bM', conditions = None, forward = True):
"""
Run CIECAM02 color appearance model in forward or backward modes.
Args:
:data:
| ndarray with relative sample xyz values (forward mode) or J'a'b' coordinates (inverse mode)
:xyzw:
| ndarray with relative white point tristimulus values
:conditions:
| None, optional
| Dictionary with viewing conditions.
| None results in:
| {'La':100, 'Yb':20, 'D':1, 'surround':'avg'}
| For more info see luxpy.cam.ciecam02()?
:forward:
| True, optional
| If True: run in CAM in forward mode, else: inverse mode.
:out:
| 'J,aM,bM', optional
| String with requested output (e.g. "J,aM,bM,M,h") [Forward mode]
| String with inputs in data.
| Input must have data.shape[-1]==3 and last dim of data must have
| the following structure:
| * data[...,0] = J or Q,
| * data[...,1:] = (aM,bM) or (aC,bC) or (aS,bS)
Returns:
:camout:
| ndarray with Jab coordinates or whatever correlates requested in out.
Note:
* This is a simplified, less flexible, but faster version than the main ciecam02().
References:
1. `N. Moroney, M. D. Fairchild, R. W. G. Hunt, C. Li, M. R. Luo, and T. Newman, (2002),
"The CIECAM02 color appearance model,”
IS&T/SID Tenth Color Imaging Conference. p. 23, 2002.
<http://rit-mcsl.org/fairchild/PDFs/PRO19.pdf>`_
"""
outin = out.split(',') if isinstance(out,str) else out
#--------------------------------------------
# Get/ set conditions parameters:
if conditions is not None:
surround_parameters = {'surrounds': ['avg', 'dim', 'dark'],
'avg' : {'c':0.69, 'Nc':1.0, 'F':1.0,'FLL': 1.0},
'dim' : {'c':0.59, 'Nc':0.9, 'F':0.9,'FLL':1.0} ,
'dark' : {'c':0.525, 'Nc':0.8, 'F':0.8,'FLL':1.0}}
La = conditions['La']
Yb = conditions['Yb']
D = conditions['D']
surround = conditions['surround']
if isinstance(surround, str):
surround = surround_parameters[conditions['surround']]
F, FLL, Nc, c = [surround[x] for x in sorted(surround.keys())]
else:
# set defaults:
La, Yb, D, F, FLL, Nc, c = 100, 20, 1, 1, 1, 1, 0.69
#--------------------------------------------
# Define sensor space and cat matrices:
mhpe = np.array([[0.38971,0.68898,-0.07868],
[-0.22981,1.1834,0.04641],
[0.0,0.0,1.0]]) # Hunt-Pointer-Estevez sensors (cone fundamentals)
mcat = np.array([[0.7328, 0.4296, -0.1624],
[ -0.7036, 1.6975, 0.0061],
[ 0.0030, 0.0136, 0.9834]]) # CAT02 sensor space
#--------------------------------------------
# pre-calculate some matrices:
invmcat = np.linalg.inv(mcat)
mhpe_x_invmcat = np.dot(mhpe,invmcat)
if not forward: mcat_x_invmhpe = np.dot(mcat,np.linalg.inv(mhpe))
#--------------------------------------------
# calculate condition dependent parameters:
Yw = xyzw[...,1:2].T
k = 1.0 / (5.0*La + 1.0)
FL = 0.2*(k**4.0)*(5.0*La) + 0.1*((1.0 - k**4.0)**2.0)*((5.0*La)**(1.0/3.0)) # luminance adaptation factor
n = Yb/Yw
Nbb = 0.725*(1/n)**0.2
Ncb = Nbb
z = 1.48 + FLL*n**0.5
if D is None:
D = F*(1.0-(1.0/3.6)*np.exp((-La-42.0)/92.0))
#===================================================================
# WHITE POINT transformations (common to forward and inverse modes):
#--------------------------------------------
# transform from xyzw to cat sensor space:
rgbw = mcat @ xyzw.T
#--------------------------------------------
# apply von Kries cat:
rgbwc = ((D*Yw/rgbw) + (1 - D))*rgbw # factor 100 from ciecam02 is replaced with Yw[i] in cam16, but see 'note' in Fairchild's "Color Appearance Models" (p291 ni 3ed.)
#--------------------------------------------
# convert from cat02 sensor space to cone sensors (hpe):
rgbwp = (mhpe_x_invmcat @ rgbwc).T
#--------------------------------------------
# apply Naka_rushton repsonse compression to white:
NK = lambda x, forward: naka_rushton(x, scaling = 400, n = 0.42, sig = 27.13**(1/0.42), noise = 0.1, forward = forward)
rgbwpa = NK(FL*rgbwp/100.0, True)
pw = np.where(rgbwp<0)
rgbwpa[pw] = 0.1 - (NK(FL*np.abs(rgbwp[pw])/100.0, True) - 0.1)
#--------------------------------------------
# Calculate achromatic signal of white:
Aw = (2.0*rgbwpa[...,0] + rgbwpa[...,1] + (1.0/20.0)*rgbwpa[...,2] - 0.305)*Nbb
# massage shape of data for broadcasting:
if data.ndim == 2: data = data[:,None]
#===================================================================
# STIMULUS transformations
if forward:
#--------------------------------------------
# transform from xyz to cat sensor space:
rgb = math.dot23(mcat, data.T)
#--------------------------------------------
# apply von Kries cat:
rgbc = ((D*Yw/rgbw)[...,None] + (1 - D))*rgb # factor 100 from ciecam02 is replaced with Yw[i] in cam16, but see 'note' in Fairchild's "Color Appearance Models" (p291 ni 3ed.)
#--------------------------------------------
# convert from cat02 sensor space to cone sensors (hpe):
rgbp = math.dot23(mhpe_x_invmcat,rgbc).T
#--------------------------------------------
# apply Naka_rushton repsonse compression:
rgbpa = NK(FL*rgbp/100.0, forward)
p = np.where(rgbp<0)
rgbpa[p] = 0.1 - (NK(FL*np.abs(rgbp[p])/100.0, forward) - 0.1)
#--------------------------------------------
# Calculate achromatic signal:
A = (2.0*rgbpa[...,0] + rgbpa[...,1] + (1.0/20.0)*rgbpa[...,2] - 0.305)*Nbb
#--------------------------------------------
# calculate initial opponent channels:
a = rgbpa[...,0] - 12.0*rgbpa[...,1]/11.0 + rgbpa[...,2]/11.0
b = (1.0/9.0)*(rgbpa[...,0] + rgbpa[...,1] - 2.0*rgbpa[...,2])
#--------------------------------------------
# calculate hue h and eccentricity factor, et:
h = hue_angle(a,b, htype = 'deg')
et = (1.0/4.0)*(np.cos(h*np.pi/180 + 2.0) + 3.8)
#--------------------------------------------
# calculate Hue quadrature (if requested in 'out'):
if 'H' in outin:
H = hue_quadrature(h, unique_hue_data = 'ciecam02')
else:
H = None
#--------------------------------------------
# calculate lightness, J:
if ('J' in outin) | ('Q' in outin) | ('C' in outin) | ('M' in outin) | ('s' in outin) | ('aS' in outin) | ('aC' in outin) | ('aM' in outin):
J = 100.0* (A / Aw)**(c*z)
#--------------------------------------------
# calculate brightness, Q:
if ('Q' in outin) | ('s' in outin) | ('aS' in outin):
Q = (4.0/c)* ((J/100.0)**0.5) * (Aw + 4.0)*(FL**0.25)
#--------------------------------------------
# calculate chroma, C:
if ('C' in outin) | ('M' in outin) | ('s' in outin) | ('aS' in outin) | ('aC' in outin) | ('aM' in outin):
t = ((50000.0/13.0)*Nc*Ncb*et*((a**2.0 + b**2.0)**0.5)) / (rgbpa[...,0] + rgbpa[...,1] + (21.0/20.0*rgbpa[...,2]))
C = (t**0.9)*((J/100.0)**0.5) * (1.64 - 0.29**n)**0.73
#--------------------------------------------
# calculate colorfulness, M:
if ('M' in outin) | ('s' in outin) | ('aM' in outin) | ('aS' in outin):
M = C*FL**0.25
#--------------------------------------------
# calculate saturation, s:
if ('s' in outin) | ('aS' in outin):
s = 100.0* (M/Q)**0.5
#--------------------------------------------
# calculate cartesian coordinates:
if ('aS' in outin):
aS = s*np.cos(h*np.pi/180.0)
bS = s*np.sin(h*np.pi/180.0)
if ('aC' in outin):
aC = C*np.cos(h*np.pi/180.0)
bC = C*np.sin(h*np.pi/180.0)
if ('aM' in outin):
aM = M*np.cos(h*np.pi/180.0)
bM = M*np.sin(h*np.pi/180.0)
#--------------------------------------------
if outin != ['J','aM','bM']:
camout = eval('ajoin(('+','.join(outin)+'))')
else:
camout = ajoin((J,aM,bM))
if camout.shape[1] == 1:
camout = camout[:,0,:]
return camout
elif forward == False:
#--------------------------------------------
# Get Lightness J from data:
if ('J' in outin):
J = data[...,0].copy()
elif ('Q' in outin):
Q = data[...,0].copy()
J = 100.0*(Q / ((Aw + 4.0)*(FL**0.25)*(4.0/c)))**2.0
else:
raise Exception('No lightness or brightness values in data. Inverse CAM-transform not possible!')
#--------------------------------------------
# calculate hue h:
h = hue_angle(data[...,1],data[...,2], htype = 'deg')
#--------------------------------------------
# calculate Colorfulness M or Chroma C or Saturation s from a,b:
MCs = (data[...,1]**2.0 + data[...,2]**2.0)**0.5
if ('aS' in outin):
Q = (4.0/c)* ((J/100.0)**0.5) * (Aw + 4.0)*(FL**0.25)
M = Q*(MCs/100.0)**2.0
C = M/(FL**0.25)
if ('aM' in outin): # convert M to C:
C = MCs/(FL**0.25)
if ('aC' in outin):
C = MCs
#--------------------------------------------
# calculate t from J, C:
t = (C / ((J/100.0)**(1.0/2.0) * (1.64 - 0.29**n)**0.73))**(1.0/0.9)
#--------------------------------------------
# calculate eccentricity factor, et:
et = (np.cos(h*np.pi/180.0 + 2.0) + 3.8) / 4.0
#--------------------------------------------
# calculate achromatic signal, A:
A = Aw*(J/100.0)**(1.0/(c*z))
#--------------------------------------------
# calculate temporary cart. co. at, bt and p1,p2,p3,p4,p5:
at = np.cos(h*np.pi/180.0)
bt = np.sin(h*np.pi/180.0)
p1 = (50000.0/13.0)*Nc*Ncb*et/t
p2 = A/Nbb + 0.305
p3 = 21.0/20.0
p4 = p1/bt
p5 = p1/at
#--------------------------------------------
#q = np.where(np.abs(bt) < np.abs(at))[0]
q = (np.abs(bt) < np.abs(at))
b = p2*(2.0 + p3) * (460.0/1403.0) / (p4 + (2.0 + p3) * (220.0/1403.0) * (at/bt) - (27.0/1403.0) + p3*(6300.0/1403.0))
a = b * (at/bt)
a[q] = p2[q]*(2.0 + p3) * (460.0/1403.0) / (p5[q] + (2.0 + p3) * (220.0/1403.0) - ((27.0/1403.0) - p3*(6300.0/1403.0)) * (bt[q]/at[q]))
b[q] = a[q] * (bt[q]/at[q])
#--------------------------------------------
# calculate post-adaptation values
rpa = (460.0*p2 + 451.0*a + 288.0*b) / 1403.0
gpa = (460.0*p2 - 891.0*a - 261.0*b) / 1403.0
bpa = (460.0*p2 - 220.0*a - 6300.0*b) / 1403.0
#--------------------------------------------
# join values:
rgbpa = ajoin((rpa,gpa,bpa))
#--------------------------------------------
# decompress signals:
rgbp = (100.0/FL)*NK(rgbpa, forward)
#--------------------------------------------
# convert from to cone sensors (hpe) cat02 sensor space:
rgbc = math.dot23(mcat_x_invmhpe,rgbp.T)
#--------------------------------------------
# apply inverse von Kries cat:
rgb = rgbc / ((D*Yw/rgbw)[...,None] + (1.0 - D))
#--------------------------------------------
# transform from cat sensor space to xyz:
xyz = math.dot23(invmcat,rgb).T
return xyz
def cam15u(data,
fov=10.0,
inputtype='xyz',
direction='forward',
outin='Q,aW,bW',
parameters=None):
"""
Convert between CIE 2006 10° XYZ tristimulus values (or spectral data)
and CAM15u color appearance correlates.
Args:
:data:
| ndarray of CIE 2006 10° XYZ tristimulus values or spectral data
| or color appearance attributes
:fov:
| 10.0, optional
| Field-of-view of stimulus (for size effect on brightness)
:inputtpe:
| 'xyz' or 'spd', optional
| Specifies the type of input:
| tristimulus values or spectral data for the forward mode.
:direction:
| 'forward' or 'inverse', optional
| -'forward': xyz -> cam15u
| -'inverse': cam15u -> xyz
:outin:
| 'Q,aW,bW' or str, optional
| 'Q,aW,bW' (brightness and opponent signals for amount-of-neutral)
| other options: 'Q,aM,bM' (colorfulness) and 'Q,aS,bS' (saturation)
| Str specifying the type of
| input (:direction: == 'inverse') and
| output (:direction: == 'forward')
:parameters:
| None or dict, optional
| Set of model parameters.
| - None: defaults to luxpy.cam._CAM15U_PARAMETERS
| (see references below)
Returns:
:returns:
| ndarray with color appearance correlates (:direction: == 'forward')
| or
| XYZ tristimulus values (:direction: == 'inverse')
References:
1. `M. Withouck, K. A. G. Smet, W. R. Ryckaert, and P. Hanselaer,
“Experimental driven modelling of the color appearance of
unrelated self-luminous stimuli: CAM15u,”
Opt. Express, vol. 23, no. 9, pp. 12045–12064, 2015.
<https://www.osapublishing.org/oe/abstract.cfm?uri=oe-23-9-12045&origin=search>`_
2. `M. Withouck, K. A. G. Smet, and P. Hanselaer, (2015),
“Brightness prediction of different sized unrelated self-luminous stimuli,”
Opt. Express, vol. 23, no. 10, pp. 13455–13466.
<https://www.osapublishing.org/oe/abstract.cfm?uri=oe-23-10-13455&origin=search>`_
"""
if parameters is None:
parameters = _CAM15U_PARAMETERS
outin = outin.split(',')
#unpack model parameters:
Mxyz2rgb, cA, cAlms, cHK, cM, cW, ca, calms, cb, cblms, cfov, cp, k, unique_hue_data = [
parameters[x] for x in sorted(parameters.keys())
]
# precomputations:
invMxyz2rgb = np.linalg.inv(Mxyz2rgb)
MAab = np.array([cAlms, calms, cblms])
invMAab = np.linalg.inv(MAab)
#initialize data and camout:
data = np2d(data)
if len(data.shape) == 2:
data = np.expand_dims(data, axis=0) # avoid looping if not necessary
if (data.shape[0] > data.shape[1]): # loop over shortest dim.
flipaxis0and1 = True
data = np.transpose(data, axes=(1, 0, 2))
else:
flipaxis0and1 = False
dshape = list(data.shape)
dshape[-1] = len(outin) # requested number of correlates
if (inputtype != 'xyz') & (direction == 'forward'):
dshape[-2] = dshape[
-2] - 1 # wavelength row doesn't count & only with forward can the input data be spectral
camout = np.zeros(dshape)
camout.fill(np.nan)
for i in range(data.shape[0]):
if (inputtype != 'xyz') & (direction == 'forward'):
xyz = spd_to_xyz(data[i], cieobs='2006_10', relative=False)
lms = np.dot(_CMF['2006_10']['M'], xyz.T).T # convert to l,m,s
rgb = (lms /
_CMF['2006_10']['K']) * k # convert to rho, gamma, beta
elif (inputtype == 'xyz') & (direction == 'forward'):
rgb = np.dot(Mxyz2rgb, data[i].T).T
if direction == 'forward':
# apply cube-root compression:
rgbc = rgb**(cp)
# calculate achromatic and color difference signals, A, a, b:
Aab = np.dot(MAab, rgbc.T).T
A, a, b = asplit(Aab)
A = cA * A
a = ca * a
b = cb * b
# calculate colorfullness like signal M:
M = cM * ((a**2.0 + b**2.0)**0.5)
# calculate brightness Q:
Q = A + cHK[0] * M**cHK[
1] # last term is contribution of Helmholtz-Kohlrausch effect on brightness
# calculate saturation, s:
s = M / Q
# calculate amount of white, W:
W = 100.0 / (1.0 + cW[0] * (s**cW[1]))
# adjust Q for size (fov) of stimulus (matter of debate whether to do this before or after calculation of s or W, there was no data on s, M or W for different sized stimuli: after)
Q = Q * (fov / 10.0)**cfov
# calculate hue, h and Hue quadrature, H:
h = hue_angle(a, b, htype='deg')
if 'H' in outin:
H = hue_quadrature(h, unique_hue_data=unique_hue_data)
else:
H = None
# calculate cart. co.:
if 'aM' in outin:
aM = M * np.cos(h * np.pi / 180.0)
bM = M * np.sin(h * np.pi / 180.0)
if 'aS' in outin:
aS = s * np.cos(h * np.pi / 180.0)
bS = s * np.sin(h * np.pi / 180.0)
if 'aW' in outin:
aW = W * np.cos(h * np.pi / 180.0)
bW = W * np.sin(h * np.pi / 180.0)
if (outin != ['Q', 'aW', 'bW']):
camout[i] = eval('ajoin((' + ','.join(outin) + '))')
else:
camout[i] = ajoin((Q, aW, bW))
elif direction == 'inverse':
# get Q, M and a, b depending on input type:
if 'aW' in outin:
Q, a, b = asplit(data[i])
Q = Q / (
(fov / 10.0)**cfov
) #adjust Q for size (fov) of stimulus back to that 10° ref
W = (a**2.0 + b**2.0)**0.5
s = (((100 / W) - 1.0) / cW[0])**(1.0 / cW[1])
M = s * Q
if 'aM' in outin:
Q, a, b = asplit(data[i])
Q = Q / (
(fov / 10.0)**cfov
) #adjust Q for size (fov) of stimulus back to that 10° ref
M = (a**2.0 + b**2.0)**0.5
if 'aS' in outin:
Q, a, b = asplit(data[i])
Q = Q / (
(fov / 10.0)**cfov
) #adjust Q for size (fov) of stimulus back to that 10° ref
s = (a**2.0 + b**2.0)**0.5
M = s * Q
if 'h' in outin:
Q, WsM, h = asplit(data[i])
Q = Q / (
(fov / 10.0)**cfov
) #adjust Q for size (fov) of stimulus back to that 10° ref
if 'W' in outin:
s = (((100.0 / WsM) - 1.0) / cW[0])**(1.0 / cW[1])
M = s * Q
elif 's' in outin:
M = WsM * Q
elif 'M' in outin:
M = WsM
# calculate achromatic signal, A from Q and M:
A = Q - cHK[0] * M**cHK[1]
A = A / cA
# calculate hue angle:
h = hue_angle(a, b, htype='rad')
# calculate a,b from M and h:
a = (M / cM) * np.cos(h)
b = (M / cM) * np.sin(h)
a = a / ca
b = b / cb
# create Aab:
Aab = ajoin((A, a, b))
# calculate rgbc:
rgbc = np.dot(invMAab, Aab.T).T
# decompress rgbc to rgb:
rgb = rgbc**(1 / cp)
# convert rgb to xyz:
xyz = np.dot(invMxyz2rgb, rgb.T).T
camout[i] = xyz
if flipaxis0and1 == True: # loop over shortest dim.
camout = np.transpose(camout, axes=(1, 0, 2))
if camout.shape[0] == 1:
camout = np.squeeze(camout, axis=0)
return camout
def apply_ciecat94(xyz,
xyzw,
xyzwr=None,
E=1000,
Er=1000,
Yb=20,
D=1,
cat94_old=True):
"""
Calculate corresponding color tristimulus values using the CIECAT94 chromatic adaptation transform.
Args:
:xyz:
| ndarray with sample 1931 2° XYZ tristimulus values under the test illuminant
:xyzw:
| ndarray with white point tristimulus values of the test illuminant
:xyzwr:
| None, optional
| ndarray with white point tristimulus values of the reference illuminant
| None defaults to D65.
:E:
| 100, optional
| Illuminance (lx) of test illumination
:Er:
| 63.66, optional
| Illuminance (lx) of the reference illumination
:Yb:
| 20, optional
| Relative luminance of the adaptation field (background)
:D:
| 1, optional
| Degree of chromatic adaptation.
| For object colours D = 1,
| and for luminous colours (typically displays) D=0
Returns:
:xyzc:
| ndarray with corresponding tristimlus values.
Reference:
1. CIE160-2004. (2004). A review of chromatic adaptation transforms (Vols. CIE160-200). CIE.
"""
#--------------------------------------------
# Define cone/chromatic adaptation sensor space:
mcat = _MCATS['kries']
invmcat = np.linalg.inv(mcat)
#--------------------------------------------
# Define default ref. white point:
if xyzwr is None:
xyzwr = np.array(
[[9.5047e+01, 1.0000e+02, 1.0888e+02]]
) #spd_to_xyz(_CIE_D65, cieobs = '1931_2', relative = True, rfl = None)
#--------------------------------------------
# Calculate Y,x,y of white:
Yxyw = xyz_to_Yxy(xyzw)
Yxywr = xyz_to_Yxy(xyzwr)
#--------------------------------------------
# Calculate La, Lar:
La = Yb * E / np.pi / 100
Lar = Yb * Er / np.pi / 100
#--------------------------------------------
# Calculate CIELAB L* of samples:
Lstar = xyz_to_lab(xyz, xyzw)[..., 0]
#--------------------------------------------
# Define xi_, eta_ and zeta_ functions:
xi_ = lambda Yxy: (0.48105 * Yxy[..., 1] + 0.78841 * Yxy[..., 2] - 0.080811
) / Yxy[..., 2]
eta_ = lambda Yxy: (-0.27200 * Yxy[..., 1] + 1.11962 * Yxy[..., 2] +
0.04570) / Yxy[..., 2]
zeta_ = lambda Yxy: 0.91822 * (1 - Yxy[..., 1] - Yxy[..., 2]) / Yxy[..., 2]
#--------------------------------------------
# Calculate intermediate values for test and ref. illuminants:
xit, etat, zetat = xi_(Yxyw), eta_(Yxyw), zeta_(Yxyw)
xir, etar, zetar = xi_(Yxywr), eta_(Yxywr), zeta_(Yxywr)
#--------------------------------------------
# Calculate alpha:
if cat94_old == False:
alpha = 0.1151 * np.log10(La) + 0.0025 * (Lstar - 50) + (0.22 * D +
0.510)
alpha[alpha > 1] = 1
else:
alpha = 1
#--------------------------------------------
# Calculate adapted intermediate xip, etap zetap:
xip = alpha * xit - (1 - alpha) * xir
etap = alpha * etat - (1 - alpha) * etar
zetap = alpha * zetat - (1 - alpha) * zetar
#--------------------------------------------
# Calculate effective adapting response Rw, Gw, Bw and Rwr, Gwr, Bwr:
#Rw, Gw, Bw = La*xit, La*etat, La*zetat # according to westland's book: Computational Colour Science wirg Matlab
Rw, Gw, Bw = La * xip, La * etap, La * zetap # according to CIE160-2004
Rwr, Gwr, Bwr = Lar * xir, Lar * etar, Lar * zetar
#--------------------------------------------
# Calculate beta1_ and beta2_ exponents for (R,G) and B:
beta1_ = lambda x: (6.469 + 6.362 * x**0.4495) / (6.469 + x**0.4495)
beta2_ = lambda x: 0.7844 * (8.414 + 8.091 * x**0.5128) / (8.414 + x**
0.5128)
b1Rw, b1Rwr, b1Gw, b1Gwr = beta1_(Rw), beta1_(Rwr), beta1_(Gw), beta1_(Gwr)
b2Bw, b2Bwr = beta2_(Bw), beta2_(Bwr)
#--------------------------------------------
# Noise term:
n = 1 if cat94_old else 0.1
#--------------------------------------------
# K factor = p/q (for correcting the difference between
# the illuminance of the test and references conditions)
# calculate q:
p = ((Yb * xip + n) /
(20 * xip + n))**(2 / 3 * b1Rw) * ((Yb * etap + n) /
(20 * etap + n))**(1 / 3 * b1Gw)
q = ((Yb * xir + n) /
(20 * xir + n))**(2 / 3 * b1Rwr) * ((Yb * etar + n) /
(20 * etar + n))**(1 / 3 * b1Gwr)
K = p / q
#--------------------------------------------
# transform sample xyz to cat sensor space:
rgb = math.dot23(mcat, xyz.T).T
#--------------------------------------------
# Calculate corresponding colors:
Rc = (Yb * xir + n) * K**(1 / b1Rwr) * ((rgb[..., 0] + n) /
(Yb * xip + n))**(b1Rw / b1Rwr) - n
Gc = (Yb * etar + n) * K**(1 / b1Gwr) * (
(rgb[..., 1] + n) / (Yb * etap + n))**(b1Gw / b1Gwr) - n
Bc = (Yb * zetar + n) * K**(1 / b2Bwr) * (
(rgb[..., 2] + n) / (Yb * zetap + n))**(b2Bw / b2Bwr) - n
#--------------------------------------------
# transform to xyz and return:
xyzc = math.dot23(invmcat, ajoin((Rc, Gc, Bc)).T).T
return xyzc
def run(data,
xyzw=None,
outin='J,aM,bM',
cieobs=_CIEOBS,
conditions=None,
forward=True,
mcat='cat02',
**kwargs):
"""
Run the Jz,az,bz based color appearance model in forward or backward modes.
Args:
:data:
| ndarray with relative sample xyz values (forward mode) or J'a'b' coordinates (inverse mode)
:xyzw:
| ndarray with relative white point tristimulus values
| None defaults to D65
:cieobs:
| _CIEOBS, optional
| CMF set to use when calculating :xyzw: if this is None.
:conditions:
| None, optional
| Dictionary with viewing condition parameters for:
| La, Yb, D and surround.
| surround can contain:
| - str (options: 'avg','dim','dark') or
| - dict with keys c, Nc, F.
| None results in:
| {'La':100, 'Yb':20, 'D':1, 'surround':'avg'}
:forward:
| True, optional
| If True: run in CAM in forward mode, else: inverse mode.
:outin:
| 'J,aM,bM', optional
| String with requested output (e.g. "J,aM,bM,M,h") [Forward mode]
| - attributes: 'J': lightness,'Q': brightness,
| 'M': colorfulness,'C': chroma, 's': saturation,
| 'h': hue angle, 'H': hue quadrature/composition,
| 'Wz': whiteness, 'Kz':blackness, 'Sz': saturation, 'V': vividness
| String with inputs in data [inverse mode].
| Input must have data.shape[-1]==3 and last dim of data must have
| the following structure for inverse mode:
| * data[...,0] = J or Q,
| * data[...,1:] = (aM,bM) or (aC,bC) or (aS,bS) or (M,h) or (C, h), ...
:mcat:
| 'cat02', optional
| Specifies CAT sensor space.
| - options:
| - None defaults to 'cat02'
| - str: see see luxpy.cat._MCATS.keys() for options
| (details on type, ?luxpy.cat)
| - ndarray: matrix with sensor primaries
Returns:
:camout:
| ndarray with color appearance correlates (forward mode)
| or
| XYZ tristimulus values (inverse mode)
References:
1. `Safdar, M., Cui, G., Kim,Y. J., and Luo, M. R.(2017).
Perceptually uniform color space for image signals including high dynamic range and wide gamut.
Opt. Express, vol. 25, no. 13, pp. 15131–15151, Jun. 2017.
<https://www.opticsexpress.org/abstract.cfm?URI=oe-25-13-15131>`_
2. `Safdar, M., Hardeberg, J., Cui, G., Kim, Y. J., and Luo, M. R.(2018).
A Colour Appearance Model based on Jzazbz Colour Space,
26th Color and Imaging Conference (2018), Vancouver, Canada, November 12-16, 2018, pp96-101.
<https://doi.org/10.2352/ISSN.2169-2629.2018.26.96>`_
3. Safdar, M., Hardeberg, J.Y., Luo, M.R. (2021)
"ZCAM, a psychophysical model for colour appearance prediction",
Optics Express.
"""
print(
"WARNING: Z-CAM is as yet unpublished and under development, so parameter values might change! (07 Oct, 2020"
)
outin = outin.split(',') if isinstance(outin, str) else outin
#--------------------------------------------
# Get condition parameters:
if conditions is None:
conditions = _DEFAULT_CONDITIONS
D, Dtype, La, Yb, surround = (conditions[x]
for x in sorted(conditions.keys()))
surround_parameters = _SURROUND_PARAMETERS
if isinstance(surround, str):
surround = surround_parameters[conditions['surround']]
F, FLL, Nc, c = [surround[x] for x in sorted(surround.keys())]
# Define cone/chromatic adaptation sensor space:
if (mcat is None):
mcat = cat._MCATS['cat02']
elif isinstance(mcat, str):
mcat = cat._MCATS[mcat]
invmcat = np.linalg.inv(mcat)
#--------------------------------------------
# Get white point of D65 fro chromatic adaptation transform (CAT)
xyzw_d65 = np.array([[
9.5047e+01, 1.0000e+02, 1.08883e+02
]]) if cieobs == '1931_2' else spd_to_xyz(_CIE_D65, cieobs=cieobs)
#--------------------------------------------
# Get default white point:
if xyzw is None:
xyzw = xyzw_d65.copy()
#--------------------------------------------
# calculate condition dependent parameters:
Yw = xyzw[..., 1].T
FL = 0.171 * La**(1 / 3) * (1 - np.exp(-48 / 9 * La)
) # luminance adaptation factor
n = Yb / Yw
Fb = 1.045 + 1.46 * n**0.5 # background factor
Fs = c # surround factor
#--------------------------------------------
# Calculate degree of chromatic adaptation:
if D is None:
D = F * (1.0 - (1.0 / 3.6) * np.exp((-La - 42.0) / 92.0))
#===================================================================
# WHITE POINT transformations (common to forward and inverse modes):
#--------------------------------------------
# Apply CAT to white point:
xyzwc = cat.apply_vonkries2(xyzw,
xyzw1=xyzw,
xyzw2=xyzw_d65,
D=D,
mcat=mcat,
invmcat=invmcat,
use_Yw=True)
#--------------------------------------------
# Get Iz,az,bz coordinates:
iabzw = xyz_to_jabz(xyzwc, ztype='iabz', use_zcam_parameters=True)
# Get brightness of white point:
Qw = 925 * iabzw[..., 0]**1.17 * (FL / Fs)**0.5
#===================================================================
# STIMULUS transformations:
#--------------------------------------------
# massage shape of data for broadcasting:
original_ndim = data.ndim
if data.ndim == 2: data = data[:, None]
if forward:
# Apply CAT to D65:
xyzc = cat.apply_vonkries2(data,
xyzw1=xyzw,
xyzw2=xyzw_d65,
D=D,
mcat=mcat,
invmcat=invmcat,
use_Yw=True)
# Get Iz,az,bz coordinates:
iabz = xyz_to_jabz(xyzc, ztype='iabz', use_zcam_parameters=True)
#--------------------------------------------
# calculate hue h and eccentricity factor, et:
h = hue_angle(iabz[..., 1], iabz[..., 2], htype='deg')
ez = 1.014 + np.cos((h + 89.038) * np.pi / 180)
# ez = 1.014 + np.cos((h*np.pi/180) + 89.038)
#--------------------------------------------
# calculate Hue quadrature (if requested in 'out'):
if 'H' in outin:
H = hue_quadrature(h, unique_hue_data=_UNIQUE_HUE_DATA)
else:
H = None
#--------------------------------------------
# calculate brightness, Q:
Q = 925 * iabz[..., 0]**1.17 * (FL / Fs)**0.5
#--------------------------------------------
# calculate lightness, J:
J = 100.0 * (Q / Qw)**(Fs * Fb)
#--------------------------------------------
# calculate colorfulness, M:
M = 50 * ((iabz[..., 1]**2.0 + iabz[..., 2]**2.0)**
0.368) * (ez**0.068) * (FL**0.2) / ((iabzw[..., 0]**2.52) *
(Fb**0.3))
#--------------------------------------------
# calculate chroma, C:
C = 100 * M / Qw
#--------------------------------------------
# calculate saturation, s:
s = 100.0 * (M / Q)
S = s # make extra variable, jsut in case 'S' is called
#--------------------------------------------
# calculate whiteness, W:
if ('Wz' in outin) | ('aWz' in outin):
Wz = 100 - 0.68 * ((100 - J)**2 + C**2)**0.5
#--------------------------------------------
# calculate blackness, K:
if ('Kz' in outin) | ('aKz' in outin):
Kz = 100 - 0.82 * (J**2 + C**2)**0.5
#--------------------------------------------
# calculate saturation, S:
if ('Sz' in outin) | ('aSz' in outin):
Sz = 8 + 0.5 * ((J - 55)**2 + C**2)**0.5
#--------------------------------------------
# calculate vividness, V:
if ('Vz' in outin) | ('aVz' in outin):
Sz = 8 + 0.4 * ((J - 70)**2 + C**2)**0.5
#--------------------------------------------
# calculate cartesian coordinates:
if ('aS' in outin):
aS = s * np.cos(h * np.pi / 180.0)
bS = s * np.sin(h * np.pi / 180.0)
if ('aC' in outin):
aC = C * np.cos(h * np.pi / 180.0)
bC = C * np.sin(h * np.pi / 180.0)
if ('aM' in outin):
aM = M * np.cos(h * np.pi / 180.0)
bM = M * np.sin(h * np.pi / 180.0)
#--------------------------------------------
if outin != ['J', 'aM', 'bM']:
camout = eval('ajoin((' + ','.join(outin) + '))')
else:
camout = ajoin((J, aM, bM))
if (camout.shape[1] == 1) & (original_ndim < 3):
camout = camout[:, 0, :]
return camout
elif forward == False:
#--------------------------------------------
# Get Lightness J and brightness Q from data:
if ('J' in outin[0]):
J = data[..., 0].copy()
Q = Qw * (J / 100)**(1 / (Fs * Fb))
elif ('Q' in outin[0]):
Q = data[..., 0].copy()
J = 100.0 * (Q / Qw)**(Fs * Fb)
else:
raise Exception(
'No lightness or brightness values in data[...,0]. Inverse CAM-transform not possible!'
)
#--------------------------------------------
# calculate achromatic signal, Iz:
Iz = (Qw / 925 * ((J / 100)**(1 / (Fs * Fb))) * (Fs / FL)**0.5)**(1 /
1.17)
#--------------------------------------------
if 'a' in outin[1]:
# calculate hue h:
h = hue_angle(data[..., 1], data[..., 2], htype='deg')
#--------------------------------------------
# calculate Colorfulness M or Chroma C or Saturation s from a,b:
MCs = (data[..., 1]**2.0 + data[..., 2]**2.0)**0.5
else:
h = data[..., 2]
MCs = data[..., 1]
if ('aS' in outin) | ('S' in outin):
Q = Qw * (J / 100)**(1 / (Fs * Fb))
M = Q * (MCs / 100.0)
C = 100 * M / Qw
if ('aM' in outin) | ('M' in outin):
C = 100 * MCs / Qw
if ('aC' in outin) | ('C' in outin): # convert C to M:
C = MCs
if ('Wz' in outin) | ('aWz' in outin): #whiteness
C = ((100 / 68 * (100 - MCs))**2 - (J - 100)**2)**0.5
if ('Kz' in outin) | ('aKz' in outin): # blackness
C = ((100 / 82 * (100 - MCs))**2 - (J)**2)**0.5
if ('Sz' in outin) | ('aSz' in outin): # saturation
C = ((10 / 5 * (MCs - 8))**2 - (J - 55)**2)**0.5
if ('Vz' in outin) | ('aVz' in outin): # vividness
C = ((10 / 4 * (MCs - 8))**2 - (J - 70)**2)**0.5
#--------------------------------------------
# Calculate colorfulness, M:
M = Qw * C / 100
#--------------------------------------------
# calculate eccentricity factor, et:
# ez = 1.014 + np.cos(h*np.pi/180 + 89.038)
ez = 1.014 + np.cos((h + 89.038) * np.pi / 180)
#--------------------------------------------
# calculate t (=sqrt(a**2+b**2)) from M:
t = (((M / 50) * (iabzw[..., 0]**2.52) * (Fb**0.3)) /
((ez**0.068) * (FL**0.2)))**(1 / 0.368 / 2)
#--------------------------------------------
# Calculate az, bz:
az = t * np.cos(h * np.pi / 180)
bz = t * np.sin(h * np.pi / 180)
#--------------------------------------------
# join values and convert to xyz:
xyzc = jabz_to_xyz(ajoin((Iz, az, bz)),
ztype='iabz',
use_zcam_parameters=True)
#-------------------------------------------
# Apply CAT from D65:
xyz = cat.apply_vonkries2(xyzc,
xyzw_d65,
xyzw,
D=D,
mcat=mcat,
invmcat=invmcat,
use_Yw=True)
return xyz
def cam_sww16(data, dataw = None, Yb = 20.0, Lw = 400.0, Ccwb = None, relative = True, \
parameters = None, inputtype = 'xyz', direction = 'forward', \
cieobs = '2006_10'):
"""
A simple principled color appearance model based on a mapping
of the Munsell color system.
| This function implements the JOSA A (parameters = 'JOSA') published model.
Args:
:data:
| ndarray with input tristimulus values
| or spectral data
| or input color appearance correlates
| Can be of shape: (N [, xM], x 3), whereby:
| N refers to samples and M refers to light sources.
| Note that for spectral input shape is (N x (M+1) x wl)
:dataw:
| None or ndarray, optional
| Input tristimulus values or spectral data of white point.
| None defaults to the use of CIE illuminant C.
:Yb:
| 20.0, optional
| Luminance factor of background (perfect white diffuser, Yw = 100)
:Lw:
| 400.0, optional
| Luminance (cd/m²) of white point.
:Ccwb:
| None, optional
| Degree of cognitive adaptation (white point balancing)
| If None: use [..,..] from parameters dict.
:relative:
| True or False, optional
| True: xyz tristimulus values are relative (Yw = 100)
:parameters:
| None or str or dict, optional
| Dict with model parameters.
| - None: defaults to luxpy.cam._CAM_SWW_2016_PARAMETERS['JOSA']
| - str: 'best-fit-JOSA' or 'best-fit-all-Munsell'
| - dict: user defined model parameters
| (dict should have same structure)
:inputtype:
| 'xyz' or 'spd', optional
| Specifies the type of input:
| tristimulus values or spectral data for the forward mode.
:direction:
| 'forward' or 'inverse', optional
| -'forward': xyz -> cam_sww_2016
| -'inverse': cam_sww_2016 -> xyz
:cieobs:
| '2006_10', optional
| CMF set to use to perform calculations where spectral data
is involved (inputtype == 'spd'; dataw = None)
| Other options: see luxpy._CMF['types']
Returns:
:returns:
| ndarray with color appearance correlates (:direction: == 'forward')
| or
| XYZ tristimulus values (:direction: == 'inverse')
Notes:
| This function implements the JOSA A (parameters = 'JOSA')
published model.
| With:
| 1. A correction for the parameter
| in Eq.4 of Fig. 11: 0.952 --> -0.952
|
| 2. The delta_ac and delta_bc white-balance shifts in Eq. 5e & 5f
| should be: -0.028 & 0.821
|
| (cfr. Ccwb = 0.66 in:
| ab_test_out = ab_test_int - Ccwb*ab_gray_adaptation_field_int))
References:
1. `Smet, K. A. G., Webster, M. A., & Whitehead, L. A. (2016).
A simple principled approach for modeling and understanding uniform color metrics.
Journal of the Optical Society of America A, 33(3), A319–A331.
<https://doi.org/10.1364/JOSAA.33.00A319>`_
"""
# get model parameters
args = locals().copy()
if parameters is None:
parameters = _CAM_SWW16_PARAMETERS['JOSA']
if isinstance(parameters, str):
parameters = _CAM_SWW16_PARAMETERS[parameters]
parameters = put_args_in_db(
parameters,
args) #overwrite parameters with other (not-None) args input
#unpack model parameters:
Cc, Ccwb, Cf, Mxyz2lms, cLMS, cab_int, cab_out, calpha, cbeta, cga1, cga2, cgb1, cgb2, cl_int, clambda, lms0 = [
parameters[x] for x in sorted(parameters.keys())
]
# setup default adaptation field:
if (dataw is None):
dataw = _CIE_ILLUMINANTS['C'].copy() # get illuminant C
xyzw = spd_to_xyz(dataw, cieobs=cieobs,
relative=False) # get abs. tristimulus values
if relative == False: #input is expected to be absolute
dataw[1:] = Lw * dataw[
1:] / xyzw[:, 1:2] #dataw = Lw*dataw # make absolute
else:
dataw = dataw # make relative (Y=100)
if inputtype == 'xyz':
dataw = spd_to_xyz(dataw, cieobs=cieobs, relative=relative)
# precomputations:
Mxyz2lms = np.dot(
np.diag(cLMS),
math.normalize_3x3_matrix(Mxyz2lms, np.array([[1, 1, 1]]))
) # normalize matrix for xyz-> lms conversion to ill. E weighted with cLMS
invMxyz2lms = np.linalg.inv(Mxyz2lms)
MAab = np.array([clambda, calpha, cbeta])
invMAab = np.linalg.inv(MAab)
#initialize data and camout:
data = np2d(data).copy(
) # stimulus data (can be upto NxMx3 for xyz, or [N x (M+1) x wl] for spd))
dataw = np2d(dataw).copy(
) # white point (can be upto Nx3 for xyz, or [(N+1) x wl] for spd)
# make axis 1 of dataw have 'same' dimensions as data:
if (data.ndim == 2):
data = np.expand_dims(data, axis=1) # add light source axis 1
if inputtype == 'xyz':
if dataw.shape[
0] == 1: #make dataw have same lights source dimension size as data
dataw = np.repeat(dataw, data.shape[1], axis=0)
else:
if dataw.shape[0] == 2:
dataw = np.vstack(
(dataw[0], np.repeat(dataw[1:], data.shape[1], axis=0)))
# Flip light source dim to axis 0:
data = np.transpose(data, axes=(1, 0, 2))
# Initialize output array:
dshape = list(data.shape)
dshape[-1] = 3 # requested number of correlates: l_int, a_int, b_int
if (inputtype != 'xyz') & (direction == 'forward'):
dshape[-2] = dshape[
-2] - 1 # wavelength row doesn't count & only with forward can the input data be spectral
camout = np.zeros(dshape)
camout.fill(np.nan)
# apply forward/inverse model for each row in data:
for i in range(data.shape[0]):
# stage 1: calculate photon rates of stimulus and adapting field, lmst & lmsf:
if (inputtype != 'xyz'):
if relative == True:
xyzw_abs = spd_to_xyz(np.vstack((dataw[0], dataw[i + 1])),
cieobs=cieobs,
relative=False)
dataw[i +
1] = Lw * dataw[i + 1] / xyzw_abs[0, 1] # make absolute
xyzw = spd_to_xyz(np.vstack((dataw[0], dataw[i + 1])),
cieobs=cieobs,
relative=False)
lmsw = 683.0 * np.dot(Mxyz2lms, xyzw.T).T / _CMF[cieobs]['K']
lmsf = (Yb / 100.0
) * lmsw # calculate adaptation field and convert to l,m,s
if (direction == 'forward'):
if relative == True:
data[i, 1:, :] = Lw * data[i, 1:, :] / xyzw_abs[
0, 1] # make absolute
xyzt = spd_to_xyz(data[i], cieobs=cieobs,
relative=False) / _CMF[cieobs]['K']
lmst = 683.0 * np.dot(Mxyz2lms, xyzt.T).T # convert to l,m,s
else:
lmst = lmsf # put lmsf in lmst for inverse-mode
elif (inputtype == 'xyz'):
if relative == True:
dataw[i] = Lw * dataw[i] / 100.0 # make absolute
lmsw = 683.0 * np.dot(
Mxyz2lms, dataw[i].T).T / _CMF[cieobs]['K'] # convert to lms
lmsf = (Yb / 100.0) * lmsw
if (direction == 'forward'):
if relative == True:
data[i] = Lw * data[i] / 100.0 # make absolute
lmst = 683.0 * np.dot(
Mxyz2lms,
data[i].T).T / _CMF[cieobs]['K'] # convert to lms
else:
lmst = lmsf # put lmsf in lmst for inverse-mode
# stage 2: calculate cone outputs of stimulus lmstp
lmstp = math.erf(Cc * (np.log(lmst / lms0) + Cf * np.log(lmsf / lms0)))
lmsfp = math.erf(Cc * (np.log(lmsf / lms0) + Cf * np.log(lmsf / lms0)))
lmstp = np.vstack(
(lmsfp, lmstp)
) # add adaptation field lms temporarily to lmsp for quick calculation
# stage 3: calculate optic nerve signals, lam*, alphp, betp:
lstar, alph, bet = asplit(np.dot(MAab, lmstp.T).T)
alphp = cga1[0] * alph
alphp[alph < 0] = cga1[1] * alph[alph < 0]
betp = cgb1[0] * bet
betp[bet < 0] = cgb1[1] * bet[bet < 0]
# stage 4: calculate recoded nerve signals, alphapp, betapp:
alphpp = cga2[0] * (alphp + betp)
betpp = cgb2[0] * (alphp - betp)
# stage 5: calculate conscious color perception:
lstar_int = cl_int[0] * (lstar + cl_int[1])
alph_int = cab_int[0] * (np.cos(cab_int[1] * np.pi / 180.0) * alphpp -
np.sin(cab_int[1] * np.pi / 180.0) * betpp)
bet_int = cab_int[0] * (np.sin(cab_int[1] * np.pi / 180.0) * alphpp +
np.cos(cab_int[1] * np.pi / 180.0) * betpp)
lstar_out = lstar_int
if direction == 'forward':
if Ccwb is None:
alph_out = alph_int - cab_out[0]
bet_out = bet_int - cab_out[1]
else:
Ccwb = Ccwb * np.ones((2))
Ccwb[Ccwb < 0.0] = 0.0
Ccwb[Ccwb > 1.0] = 1.0
alph_out = alph_int - Ccwb[0] * alph_int[
0] # white balance shift using adaptation gray background (Yb=20%), with Ccw: degree of adaptation
bet_out = bet_int - Ccwb[1] * bet_int[0]
camout[i] = np.vstack(
(lstar_out[1:], alph_out[1:], bet_out[1:])
).T # stack together and remove adaptation field from vertical stack
elif direction == 'inverse':
labf_int = np.hstack((lstar_int[0], alph_int[0], bet_int[0]))
# get lstar_out, alph_out & bet_out for data:
lstar_out, alph_out, bet_out = asplit(data[i])
# stage 5 inverse:
# undo cortical white-balance:
if Ccwb is None:
alph_int = alph_out + cab_out[0]
bet_int = bet_out + cab_out[1]
else:
Ccwb = Ccwb * np.ones((2))
Ccwb[Ccwb < 0.0] = 0.0
Ccwb[Ccwb > 1.0] = 1.0
alph_int = alph_out + Ccwb[0] * alph_int[
0] # inverse white balance shift using adaptation gray background (Yb=20%), with Ccw: degree of adaptation
bet_int = bet_out + Ccwb[1] * bet_int[0]
lstar_int = lstar_out
alphpp = (1.0 / cab_int[0]) * (
np.cos(-cab_int[1] * np.pi / 180.0) * alph_int -
np.sin(-cab_int[1] * np.pi / 180.0) * bet_int)
betpp = (1.0 / cab_int[0]) * (
np.sin(-cab_int[1] * np.pi / 180.0) * alph_int +
np.cos(-cab_int[1] * np.pi / 180.0) * bet_int)
lstar_int = lstar_out
lstar = (lstar_int / cl_int[0]) - cl_int[1]
# stage 4 inverse:
alphp = 0.5 * (alphpp / cga2[0] + betpp / cgb2[0]
) # <-- alphpp = (Cga2.*(alphp+betp));
betp = 0.5 * (alphpp / cga2[0] - betpp / cgb2[0]
) # <-- betpp = (Cgb2.*(alphp-betp));
# stage 3 invers:
alph = alphp / cga1[0]
bet = betp / cgb1[0]
sa = np.sign(cga1[1])
sb = np.sign(cgb1[1])
alph[(sa * alphp) < 0.0] = alphp[(sa * alphp) < 0] / cga1[1]
bet[(sb * betp) < 0.0] = betp[(sb * betp) < 0] / cgb1[1]
lab = ajoin((lstar, alph, bet))
# stage 2 inverse:
lmstp = np.dot(invMAab, lab.T).T
lmstp[lmstp < -1.0] = -1.0
lmstp[lmstp > 1.0] = 1.0
lmstp = math.erfinv(lmstp) / Cc - Cf * np.log(lmsf / lms0)
lmst = np.exp(lmstp) * lms0
# stage 1 inverse:
xyzt = np.dot(invMxyz2lms, lmst.T).T
if relative == True:
xyzt = (100.0 / Lw) * xyzt
camout[i] = xyzt
# if flipaxis0and1 == True: # loop over shortest dim.
# camout = np.transpose(camout, axes = (1,0,2))
# Flip light source dim back to axis 1:
camout = np.transpose(camout, axes=(1, 0, 2))
if camout.shape[0] == 1:
camout = np.squeeze(camout, axis=0)
return camout
def cam_sww16(data,
dataw=None,
Yb=20.0,
Lw=400.0,
Ccwb=None,
relative=True,
inputtype='xyz',
direction='forward',
parameters=None,
cieobs='2006_10',
match_to_conversionmatrix_to_cieobs=True):
"""
A simple principled color appearance model based on a mapping of
the Munsell color system.
| This function implements the JOSA A (parameters = 'JOSA') published model.
Args:
:data:
| ndarray with input tristimulus values
| or spectral data
| or input color appearance correlates
| Can be of shape: (N [, xM], x 3), whereby:
| N refers to samples and M refers to light sources.
| Note that for spectral input shape is (N x (M+1) x wl)
:dataw:
| None or ndarray, optional
| Input tristimulus values or spectral data of white point.
| None defaults to the use of CIE illuminant C.
:Yb:
| 20.0, optional
| Luminance factor of background (perfect white diffuser, Yw = 100)
:Lw:
| 400.0, optional
| Luminance (cd/m²) of white point.
:Ccwb:
| None, optional
| Degree of cognitive adaptation (white point balancing)
| If None: use [..,..] from parameters dict.
:relative:
| True or False, optional
| True: xyz tristimulus values are relative (Yw = 100)
:parameters:
| None or str or dict, optional
| Dict with model parameters.
| - None: defaults to luxpy.cam._CAM_SWW_2016_PARAMETERS['JOSA']
| - str: 'best-fit-JOSA' or 'best-fit-all-Munsell'
| - dict: user defined model parameters
| (dict should have same structure)
:inputtype:
| 'xyz' or 'spd', optional
| Specifies the type of input:
| tristimulus values or spectral data for the forward mode.
:direction:
| 'forward' or 'inverse', optional
| -'forward': xyz -> cam_sww_2016
| -'inverse': cam_sww_2016 -> xyz
:cieobs:
| '2006_10', optional
| CMF set to use to perform calculations where spectral data
| is involved (inputtype == 'spd'; dataw = None)
| Other options: see luxpy._CMF['types']
:match_to_conversionmatrix_to_cieobs:
| When channging to a different CIE observer, change the xyz-to_lms
| matrix to the one corresponding to that observer. If False: use
| the one set in parameters or _CAM_SWW16_PARAMETERS
Returns:
:returns:
| ndarray with color appearance correlates (:direction: == 'forward')
| or
| XYZ tristimulus values (:direction: == 'inverse')
Notes:
| This function implements the JOSA A (parameters = 'JOSA')
| published model.
| With:
| 1. A correction for the parameter
| in Eq.4 of Fig. 11: 0.952 --> -0.952
|
| 2. The delta_ac and delta_bc white-balance shifts in Eq. 5e & 5f
| should be: -0.028 & 0.821
|
| (cfr. Ccwb = 0.66 in:
| ab_test_out = ab_test_int - Ccwb*ab_gray_adaptation_field_int))
References:
1. `Smet, K. A. G., Webster, M. A., & Whitehead, L. A. (2016).
A simple principled approach for modeling and understanding uniform color metrics.
Journal of the Optical Society of America A, 33(3), A319–A331.
<https://doi.org/10.1364/JOSAA.33.00A319>`_
"""
#--------------------------------------------------------------------------
# Get model parameters:
#--------------------------------------------------------------------------
args = locals().copy()
parameters = _update_parameter_dict(
args,
parameters=parameters,
match_to_conversionmatrix_to_cieobs=match_to_conversionmatrix_to_cieobs
)
#unpack model parameters:
Cc, Ccwb, Cf, Mxyz2lms, cLMS, cab_int, cab_out, calpha, cbeta, cga1, cga2, cgb1, cgb2, cl_int, clambda, lms0 = [
parameters[x] for x in sorted(parameters.keys())
]
#--------------------------------------------------------------------------
# Setup default adaptation field:
#--------------------------------------------------------------------------
dataw = _setup_default_adaptation_field(dataw=dataw,
Lw=Lw,
inputtype=inputtype,
relative=relative,
cieobs=cieobs)
#--------------------------------------------------------------------------
# Redimension input data to ensure most appropriate sizes
# for easy and efficient looping and initialize output array:
#--------------------------------------------------------------------------
data, dataw, camout, originalshape = _massage_input_and_init_output(
data, dataw, inputtype=inputtype, direction=direction)
#--------------------------------------------------------------------------
# Do precomputations needed for both the forward and inverse model,
# and which do not depend on sample or light source data:
#--------------------------------------------------------------------------
Mxyz2lms = np.dot(
np.diag(cLMS), Mxyz2lms
) # weight the xyz-to-lms conversion matrix with cLMS (cfr. stage 1 calculations)
invMxyz2lms = np.linalg.inv(
Mxyz2lms) # Calculate the inverse lms-to-xyz conversion matrix
MAab = np.array(
[clambda, calpha, cbeta]
) # Create matrix with scale factors for L, M, S for quick matrix multiplications
invMAab = np.linalg.inv(
MAab) # Pre-calculate its inverse to avoid repeat in loop.
#--------------------------------------------------------------------------
# Apply forward/inverse model by looping over each row (=light source dim.)
# in data:
#--------------------------------------------------------------------------
N = data.shape[0]
for i in range(N):
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# START FORWARD MODE and common part of inverse mode
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#-----------------------------------------------------------------------------
# Get absolute tristimulus values for stimulus field and white point for row i:
#-----------------------------------------------------------------------------
xyzt, xyzw, xyzw_abs = _get_absolute_xyz_xyzw(data,
dataw,
i=i,
Lw=Lw,
direction=direction,
cieobs=cieobs,
inputtype=inputtype,
relative=relative)
#-----------------------------------------------------------------------------
# stage 1: calculate photon rates of stimulus and white white, and
# adapting field: i.e. lmst, lmsw and lmsf
#-----------------------------------------------------------------------------
# Convert to white point l,m,s:
lmsw = 683.0 * np.dot(Mxyz2lms, xyzw.T).T / _CMF[cieobs]['K']
# Calculate adaptation field and convert to l,m,s:
lmsf = (Yb / 100.0) * lmsw
# Calculate lms of stimulus
# or put adaptation lmsf in test field lmst for later use in inverse-mode (no xyz in 'inverse' mode!!!):
lmst = (683.0 * np.dot(Mxyz2lms, xyzt.T).T /
_CMF[cieobs]['K']) if (direction == 'forward') else lmsf
#-----------------------------------------------------------------------------
# stage 2: calculate cone outputs of stimulus lmstp
#-----------------------------------------------------------------------------
lmstp = math.erf(Cc *
(np.log(lmst / lms0) +
Cf * np.log(lmsf / lms0))) # stimulus test field
lmsfp = math.erf(Cc * (np.log(lmsf / lms0) +
Cf * np.log(lmsf / lms0))) # adaptation field
# add adaptation field lms temporarily to lmstp for quick calculation
lmstp = np.vstack((lmsfp, lmstp))
#-----------------------------------------------------------------------------
# stage 3: calculate optic nerve signals, lam*, alphp, betp:
#-----------------------------------------------------------------------------
lstar, alph, bet = asplit(np.dot(MAab, lmstp.T).T)
alphp = cga1[0] * alph
alphp[alph < 0] = cga1[1] * alph[alph < 0]
betp = cgb1[0] * bet
betp[bet < 0] = cgb1[1] * bet[bet < 0]
#-----------------------------------------------------------------------------
# stage 4: calculate recoded nerve signals, alphapp, betapp:
#-----------------------------------------------------------------------------
alphpp = cga2[0] * (alphp + betp)
betpp = cgb2[0] * (alphp - betp)
#-----------------------------------------------------------------------------
# stage 5: calculate conscious color perception:
#-----------------------------------------------------------------------------
lstar_int = cl_int[0] * (lstar + cl_int[1])
alph_int = cab_int[0] * (np.cos(cab_int[1] * np.pi / 180.0) * alphpp -
np.sin(cab_int[1] * np.pi / 180.0) * betpp)
bet_int = cab_int[0] * (np.sin(cab_int[1] * np.pi / 180.0) * alphpp +
np.cos(cab_int[1] * np.pi / 180.0) * betpp)
lstar_out = lstar_int
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# stage 5 continued but SPLIT IN FORWARD AND INVERSE MODES:
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#--------------------------------------
# FORWARD MODE TO PERCEPTUAL SIGNALS:
#--------------------------------------
if direction == 'forward':
if Ccwb is None:
alph_out = alph_int - cab_out[0]
bet_out = bet_int - cab_out[1]
else:
Ccwb = Ccwb * np.ones((2))
Ccwb[Ccwb < 0.0] = 0.0
Ccwb[Ccwb > 1.0] = 1.0
# white balance shift using adaptation gray background (Yb=20%), with Ccw: degree of adaptation:
alph_out = alph_int - Ccwb[0] * alph_int[0]
bet_out = bet_int - Ccwb[1] * bet_int[0]
# stack together and remove adaptation field from vertical stack
# camout is an ndarray with perceptual signals:
camout[i] = np.vstack((lstar_out[1:], alph_out[1:], bet_out[1:])).T
#--------------------------------------
# INVERSE MODE FROM PERCEPTUAL SIGNALS:
#--------------------------------------
elif direction == 'inverse':
# stack cognitive pre-adapted adaptation field signals (first on stack) together:
#labf_int = np.hstack((lstar_int[0],alph_int[0],bet_int[0]))
# get lstar_out, alph_out & bet_out for data
#(contains model perceptual signals in inverse mode!!!):
lstar_out, alph_out, bet_out = asplit(data[i])
#------------------------------------------------------------------------
# Inverse stage 5: undo cortical white-balance:
#------------------------------------------------------------------------
if Ccwb is None:
alph_int = alph_out + cab_out[0]
bet_int = bet_out + cab_out[1]
else:
Ccwb = Ccwb * np.ones((2))
Ccwb[Ccwb < 0.0] = 0.0
Ccwb[Ccwb > 1.0] = 1.0
# inverse white balance shift using adaptation gray background (Yb=20%), with Ccw: degree of adaptation
alph_int = alph_out + Ccwb[0] * alph_int[0]
bet_int = bet_out + Ccwb[1] * bet_int[0]
alphpp = (1.0 / cab_int[0]) * (
np.cos(-cab_int[1] * np.pi / 180.0) * alph_int -
np.sin(-cab_int[1] * np.pi / 180.0) * bet_int)
betpp = (1.0 / cab_int[0]) * (
np.sin(-cab_int[1] * np.pi / 180.0) * alph_int +
np.cos(-cab_int[1] * np.pi / 180.0) * bet_int)
lstar_int = lstar_out
lstar = (lstar_int / cl_int[0]) - cl_int[1]
#---------------------------------------------------------------------------
# Inverse stage 4: pre-adapted perceptual signals to recoded nerve signals:
#---------------------------------------------------------------------------
alphp = 0.5 * (alphpp / cga2[0] + betpp / cgb2[0]
) # <-- alphpp = (Cga2.*(alphp+betp));
betp = 0.5 * (alphpp / cga2[0] - betpp / cgb2[0]
) # <-- betpp = (Cgb2.*(alphp-betp));
#---------------------------------------------------------------------------
# Inverse stage 3: recoded nerve signals to optic nerve signals:
#---------------------------------------------------------------------------
alph = alphp / cga1[0]
bet = betp / cgb1[0]
sa = np.sign(cga1[1])
sb = np.sign(cgb1[1])
alph[(sa * alphp) < 0.0] = alphp[(sa * alphp) < 0] / cga1[1]
bet[(sb * betp) < 0.0] = betp[(sb * betp) < 0] / cgb1[1]
lab = ajoin((lstar, alph, bet))
#---------------------------------------------------------------------------
# Inverse stage 2: optic nerve signals to cone outputs:
#---------------------------------------------------------------------------
lmstp = np.dot(invMAab, lab.T).T
lmstp[lmstp < -1.0] = -1.0
lmstp[lmstp > 1.0] = 1.0
#---------------------------------------------------------------------------
# Inverse stage 1: cone outputs to photon rates:
#---------------------------------------------------------------------------
lmstp = math.erfinv(lmstp) / Cc - Cf * np.log(lmsf / lms0)
lmst = np.exp(lmstp) * lms0
#---------------------------------------------------------------------------
# Photon rates to absolute or relative tristimulus values:
#---------------------------------------------------------------------------
xyzt = np.dot(invMxyz2lms, lmst.T).T * (_CMF[cieobs]['K'] / 683.0)
if relative == True:
xyzt = (100 / Lw) * xyzt
# store in same named variable as forward mode:
camout[i] = xyzt
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# END inverse mode
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
return _massage_output_data_to_original_shape(camout, originalshape)
def cam18sl(data,
datab=None,
Lb=[100],
fov=10.0,
inputtype='xyz',
direction='forward',
outin='Q,aS,bS',
parameters=None):
"""
Convert between CIE 2006 10° XYZ tristimulus values (or spectral data)
and CAM18sl color appearance correlates.
Args:
:data:
| ndarray of CIE 2006 10° absolute XYZ tristimulus values or spectral data
| or color appearance attributes of stimulus
:datab:
| ndarray of CIE 2006 10° absolute XYZ tristimulus values or spectral data
| of stimulus background
:Lb:
| [100], optional
| Luminance (cd/m²) value(s) of background(s) calculated using the CIE 2006 10° CMFs
| (only used in case datab == None and the background is assumed to be an Equal-Energy-White)
:fov:
| 10.0, optional
| Field-of-view of stimulus (for size effect on brightness)
:inputtpe:
| 'xyz' or 'spd', optional
| Specifies the type of input:
| tristimulus values or spectral data for the forward mode.
:direction:
| 'forward' or 'inverse', optional
| -'forward': xyz -> cam18sl
| -'inverse': cam18sl -> xyz
:outin:
| 'Q,aS,bS' or str, optional
| 'Q,aS,bS' (brightness and opponent signals for saturation)
| other options: 'Q,aM,bM' (colorfulness)
| (Note that 'Q,aW,bW' would lead to a Cartesian
| a,b-coordinate system centered at (1,0))
| Str specifying the type of
| input (:direction: == 'inverse') and
| output (:direction: == 'forward')
:parameters:
| None or dict, optional
| Set of model parameters.
| - None: defaults to luxpy.cam._CAM18SL_PARAMETERS
| (see references below)
Returns:
:returns:
| ndarray with color appearance correlates (:direction: == 'forward')
| or
| XYZ tristimulus values (:direction: == 'inverse')
Notes:
| * Instead of using the CIE 1964 10° CMFs in some places of the model,
| the CIE 2006 10° CMFs are used througout, making it more self_consistent.
| This has an effect on the k scaling factors (now different those in CAM15u)
| and the illuminant E normalization for use in the chromatic adaptation transform.
| (see future erratum to Hermans et al., 2018)
| * The paper also used an equation for the amount of white W, which is
| based on a Q value not expressed in 'bright' ('cA' = 0.937 instead of 123).
| This has been corrected for in the luxpy version of the model, i.e.
| _CAM18SL_PARAMETERS['cW'][0] has been changed from 2.29 to 1/11672.
| (see future erratum to Hermans et al., 2018)
| * Default output was 'Q,aW,bW' prior to March 2020, but since this
| is an a,b Cartesian system centered on (1,0), the default output
| has been changed to 'Q,aS,bS'.
References:
1. `Hermans, S., Smet, K. A. G., & Hanselaer, P. (2018).
"Color appearance model for self-luminous stimuli."
Journal of the Optical Society of America A, 35(12), 2000–2009.
<https://doi.org/10.1364/JOSAA.35.002000>`_
"""
if parameters is None:
parameters = _CAM18SL_PARAMETERS
outin = outin.split(',')
#unpack model parameters:
cA, cAlms, cHK, cM, cW, ca, calms, cb, cblms, cfov, cieobs, k, naka, unique_hue_data = [
parameters[x] for x in sorted(parameters.keys())
]
# precomputations:
Mlms2xyz = np.linalg.inv(_CMF[cieobs]['M'])
MAab = np.array([cAlms, calms, cblms])
invMAab = np.linalg.inv(MAab)
#-------------------------------------------------
# setup EEW reference field and default background field (Lr should be equal to Lb):
# Get Lb values:
if datab is not None:
if inputtype != 'xyz':
Lb = spd_to_xyz(datab, cieobs=cieobs, relative=False)[..., 1:2]
else:
Lb = datab[..., 1:2]
else:
if isinstance(Lb, list):
Lb = np2dT(Lb)
# Setup EEW ref of same luminance as datab:
if inputtype == 'xyz':
wlr = getwlr(_CAM18SL_WL3)
else:
if datab is None:
wlr = data[0] # use wlr of stimulus data
else:
wlr = datab[0] # use wlr of background data
datar = np.vstack((wlr, np.ones(
(Lb.shape[0], wlr.shape[0])))) # create eew
xyzr = spd_to_xyz(datar, cieobs=cieobs,
relative=False) # get abs. tristimulus values
datar[1:] = datar[1:] / xyzr[..., 1:2] * Lb
# Create datab if None:
if (datab is None):
if inputtype != 'xyz':
datab = datar.copy()
else:
datab = spd_to_xyz(datar, cieobs=cieobs, relative=False)
# prepare data and datab for loop over backgrounds:
# make axis 1 of datab have 'same' dimensions as data:
if (data.ndim == 2):
data = np.expand_dims(data, axis=1) # add light source axis 1
if inputtype == 'xyz':
datar = spd_to_xyz(datar, cieobs=cieobs,
relative=False) # convert to xyz!!
if datab.shape[
0] == 1: #make datab and datar have same lights source dimension (used to store different backgrounds) size as data
datab = np.repeat(datab, data.shape[1], axis=0)
datar = np.repeat(datar, data.shape[1], axis=0)
else:
if datab.shape[0] == 2:
datab = np.vstack(
(datab[0], np.repeat(datab[1:], data.shape[1], axis=0)))
if datar.shape[0] == 2:
datar = np.vstack(
(datar[0], np.repeat(datar[1:], data.shape[1], axis=0)))
# Flip light source/ background dim to axis 0:
data = np.transpose(data, axes=(1, 0, 2))
#-------------------------------------------------
#initialize camout:
dshape = list(data.shape)
dshape[-1] = len(outin) # requested number of correlates
if (inputtype != 'xyz') & (direction == 'forward'):
dshape[-2] = dshape[
-2] - 1 # wavelength row doesn't count & only with forward can the input data be spectral
camout = np.zeros(dshape)
camout.fill(np.nan)
for i in range(data.shape[0]):
# get rho, gamma, beta of background and reference white:
if (inputtype != 'xyz'):
xyzb = spd_to_xyz(np.vstack((datab[0], datab[i + 1:i + 2, :])),
cieobs=cieobs,
relative=False)
xyzr = spd_to_xyz(np.vstack((datar[0], datar[i + 1:i + 2, :])),
cieobs=cieobs,
relative=False)
else:
xyzb = datab[i:i + 1, :]
xyzr = datar[i:i + 1, :]
lmsb = np.dot(_CMF[cieobs]['M'], xyzb.T).T # convert to l,m,s
rgbb = (lmsb / _CMF[cieobs]['K']) * k # convert to rho, gamma, beta
#lmsr = np.dot(_CMF[cieobs]['M'],xyzr.T).T # convert to l,m,s
#rgbr = (lmsr / _CMF[cieobs]['K']) * k # convert to rho, gamma, beta
#rgbr = rgbr/rgbr[...,1:2]*Lb[i] # calculated EEW cone excitations at same luminance values as background
rgbr = np.ones(xyzr.shape) * Lb[
i] # explicitely equal EEW cone excitations at same luminance values as background
if direction == 'forward':
# get rho, gamma, beta of stimulus:
if (inputtype != 'xyz'):
xyz = spd_to_xyz(data[i], cieobs=cieobs, relative=False)
elif (inputtype == 'xyz'):
xyz = data[i]
lms = np.dot(_CMF[cieobs]['M'], xyz.T).T # convert to l,m,s
rgb = (lms / _CMF[cieobs]['K']) * k # convert to rho, gamma, beta
# apply von-kries cat with D = 1:
if (rgbb == 0).any():
Mcat = np.eye(3)
else:
Mcat = np.diag((rgbr / rgbb)[0])
rgba = np.dot(Mcat, rgb.T).T
# apply naka-rushton compression:
rgbc = naka_rushton(rgba,
n=naka['n'],
sig=naka['sig'](rgbr.mean()),
noise=naka['noise'],
scaling=naka['scaling'])
#rgbc = np.ones(rgbc.shape)*rgbc.mean() # test if eew ends up at origin
# calculate achromatic and color difference signals, A, a, b:
Aab = np.dot(MAab, rgbc.T).T
A, a, b = asplit(Aab)
a = ca * a
b = cb * b
# calculate colorfullness like signal M:
M = cM * ((a**2.0 + b**2.0)**0.5)
# calculate brightness Q:
Q = cA * (
A + cHK[0] * M**cHK[1]
) # last term is contribution of Helmholtz-Kohlrausch effect on brightness
# calculate saturation, s:
s = M / Q
S = s # make extra variable, jsut in case 'S' is called
# calculate amount of white, W:
W = 1 / (1.0 + cW[0] * (s**cW[1]))
# adjust Q for size (fov) of stimulus (matter of debate whether to do this before or after calculation of s or W, there was no data on s, M or W for different sized stimuli: after)
Q = Q * (fov / 10.0)**cfov
# calculate hue, h and Hue quadrature, H:
h = hue_angle(a, b, htype='deg')
if 'H' in outin:
H = hue_quadrature(h, unique_hue_data=unique_hue_data)
else:
H = None
# calculate cart. co.:
if 'aM' in outin:
aM = M * np.cos(h * np.pi / 180.0)
bM = M * np.sin(h * np.pi / 180.0)
if 'aS' in outin:
aS = s * np.cos(h * np.pi / 180.0)
bS = s * np.sin(h * np.pi / 180.0)
if 'aW' in outin:
aW = W * np.cos(h * np.pi / 180.0)
bW = W * np.sin(h * np.pi / 180.0)
if (outin != ['Q', 'as', 'bs']):
camout[i] = eval('ajoin((' + ','.join(outin) + '))')
else:
camout[i] = ajoin((Q, aS, bS))
elif direction == 'inverse':
# get Q, M and a, b depending on input type:
if 'aW' in outin:
Q, a, b = asplit(data[i])
Q = Q / (
(fov / 10.0)**cfov
) #adjust Q for size (fov) of stimulus back to that 10° ref
W = (a**2.0 + b**2.0)**0.5
s = (((1.0 / W) - 1.0) / cW[0])**(1.0 / cW[1])
M = s * Q
if 'aM' in outin:
Q, a, b = asplit(data[i])
Q = Q / (
(fov / 10.0)**cfov
) #adjust Q for size (fov) of stimulus back to that 10° ref
M = (a**2.0 + b**2.0)**0.5
if 'aS' in outin:
Q, a, b = asplit(data[i])
Q = Q / (
(fov / 10.0)**cfov
) #adjust Q for size (fov) of stimulus back to that 10° ref
s = (a**2.0 + b**2.0)**0.5
M = s * Q
if 'h' in outin:
Q, WsM, h = asplit(data[i])
Q = Q / (
(fov / 10.0)**cfov
) #adjust Q for size (fov) of stimulus back to that 10° ref
if 'W' in outin:
s = (((1.0 / WsM) - 1.0) / cW[0])**(1.0 / cW[1])
M = s * Q
elif 's' in outin:
M = WsM * Q
elif 'M' in outin:
M = WsM
# calculate achromatic signal, A from Q and M:
A = Q / cA - cHK[0] * M**cHK[1]
# calculate hue angle:
h = hue_angle(a, b, htype='rad')
# calculate a,b from M and h:
a = (M / cM) * np.cos(h)
b = (M / cM) * np.sin(h)
a = a / ca
b = b / cb
# create Aab:
Aab = ajoin((A, a, b))
# calculate rgbc:
rgbc = np.dot(invMAab, Aab.T).T
# decompress rgbc to (adapted) rgba :
rgba = naka_rushton(rgbc,
n=naka['n'],
sig=naka['sig'](rgbr.mean()),
noise=naka['noise'],
scaling=naka['scaling'],
direction='inverse')
# apply inverse von-kries cat with D = 1:
rgb = np.dot(np.diag((rgbb / rgbr)[0]), rgba.T).T
# convert rgb to lms to xyz:
lms = rgb / k * _CMF[cieobs]['K']
xyz = np.dot(Mlms2xyz, lms.T).T
camout[i] = xyz
camout = np.transpose(camout, axes=(1, 0, 2))
if camout.shape[1] == 1:
camout = np.squeeze(camout, axis=1)
return camout
def run(data, xyzw, conditions=None, ucs_type='ucs', forward=True):
"""
Run the CAM02-UCS[,-LCD,-SDC] color appearance difference model in forward or backward modes.
Args:
:data:
| ndarray with sample xyz values (forward mode) or J'a'b' coordinates (inverse mode)
:xyzw:
| ndarray with white point tristimulus values
:conditions:
| None, optional
| Dictionary with viewing conditions.
| None results in:
| {'La':100, 'Yb':20, 'D':1, 'surround':'avg'}
| For more info see luxpy.cam.ciecam02()?
:ucs_type:
| 'ucs', optional
| String with type of color difference appearance space
| options: 'ucs', 'scd', 'lcd'
:forward:
| True, optional
| If True: run in CAM in forward mode, else: inverse mode.
Returns:
:camout:
| ndarray with J'a'b' coordinates or whatever correlates requested in out.
Note:
* This is a simplified, less flexible, but faster version than the main cam02ucs().
"""
# get ucs parameters:
if isinstance(ucs_type, str):
ucs_pars = {
'ucs': {
'KL': 1.0,
'c1': 0.007,
'c2': 0.0228
},
'lcd': {
'KL': 0.77,
'c1': 0.007,
'c2': 0.0053
},
'scd': {
'KL': 1.24,
'c1': 0.007,
'c2': 0.0363
}
}
ucs = ucs_pars[ucs_type]
else:
ucs = ucs_type
KL, c1, c2 = ucs['KL'], ucs['c1'], ucs['c2']
if forward == True:
# run ciecam02 to get JMh:
data = ciecam02(data,
xyzw,
out='J,M,h',
conditions=conditions,
forward=True)
camout = np.zeros_like(data) # for output
#--------------------------------------------
# convert to cam02ucs J', aM', bM':
camout[...,
0] = (1.0 + 100.0 * c1) * data[...,
0] / (1.0 + c1 * data[..., 0])
Mp = (1.0 / c2) * np.log(1.0 + c2 * data[..., 1])
camout[..., 1] = Mp * np.cos(data[..., 2] * np.pi / 180)
camout[..., 2] = Mp * np.sin(data[..., 2] * np.pi / 180)
return camout
else:
#--------------------------------------------
# convert cam02ucs J', aM', bM' to xyz:
# calc CAM02 hue angle
#Jp, aMp, bMp = asplit(data)
h = np.arctan2(data[..., 2], data[..., 1])
# calc CAM02 and CIECAM02 colourfulness
Mp = (data[..., 1]**2.0 + data[..., 2]**2.0)**0.5
M = (np.exp(c2 * Mp) - 1.0) / c2
# calculate ciecam02 aM, bM:
aM = M * np.cos(h)
bM = M * np.sin(h)
# calc CAM02 lightness
J = data[..., 0] / (1.0 + (100.0 - data[..., 0]) * c1)
# run ciecam02 in inverse mode to get xyz:
return ciecam02(ajoin((J, aM, bM)),
xyzw,
out='J,aM,bM',
conditions=conditions,
forward=False)
