def _dot_M_xyz(M,xyz):
"""
Perform matrix multiplication between M and xyz (M*xyz) using einsum.
Args:
:xyz:
| 2D or 3D ndarray
:M:
| 2D or 3D ndarray
| if 2D: use same matrix M for each xyz,
| if 3D: use M[i] for xyz[i,:] (2D xyz) or xyz[:,i,:] (3D xyz)
Returns:
:M*xyz:
| ndarray with same shape as xyz containing dot product of M and xyz.
"""
# convert xyz to ...:
if np.ndim(M)==2:
if len(xyz.shape) == 3:
return np.einsum('ij,klj->kli', M, xyz)
else:
return np.einsum('ij,lj->li', M, xyz)
else:
if len(xyz.shape) == 3: # second dim of x must match dim of 1st of M and 1st dim of xyzw
return np.concatenate([np.einsum('ij,klj->kli', M[i], xyz[:,i:i+1,:]) for i in range(M.shape[0])],axis=1)
else: # first dim of xyz must match dim of 1st of M and 1st dim of xyzw
return np.concatenate([np.einsum('ij,lj->li', M[i], xyz[i:i+1,:]) for i in range(M.shape[0])],axis=0)
def join(self, data):
"""
Join data along last axis and return instance.
"""
if data[0].ndim == 2: #faster implementation
self.value = np.transpose(
np.concatenate(data, axis=0).reshape((np.hstack(
(len(data), data[0].shape)))), (1, 2, 0))
elif data[0].ndim == 1:
self.value = np.concatenate(data, axis=0).reshape((np.hstack(
(len(data), data[0].shape)))).T
else:
self.value = np.hstack(data)[0]
return self
def normalize_3x3_matrix(M, xyz0 = np.array([[1.0,1.0,1.0]])):
"""
Normalize 3x3 matrix M to xyz0 -- > [1,1,1]
| If M.shape == (1,9): M is reshaped to (3,3)
Args:
:M:
| ndarray((3,3) or ndarray((1,9))
:xyz0:
| 2darray, optional
Returns:
:returns:
| normalized matrix such that M*xyz0 = [1,1,1]
"""
M = np2d(M)
if M.shape[-1]==9:
M = M.reshape(3,3)
if xyz0.shape[0] == 1:
return np.dot(np.diagflat(1/(np.dot(M,xyz0.T))),M)
else:
return np.concatenate([np.dot(np.diagflat(1/(np.dot(M,xyz0[1].T))),M) for i in range(xyz0.shape[0])],axis=0).reshape(xyz0.shape[0],3,3)
def spd_to_mcri(SPD, D = 0.9, E = None, Yb = 20.0, out = 'Rm', wl = None):
"""
Calculates the MCRI or Memory Color Rendition Index, Rm
Args:
:SPD:
| ndarray with spectral data (can be multiple SPDs,
| first axis are the wavelengths)
:D:
| 0.9, optional
| Degree of adaptation.
:E:
| None, optional
| Illuminance in lux
| (used to calculate La = (Yb/100)*(E/pi) to then calculate D
| following the 'cat02' model).
| If None: the degree is determined by :D:
| If (:E: is not None) & (:Yb: is None): :E: is assumed to contain
| the adapting field luminance La (cd/m²).
:Yb:
| 20.0, optional
| Luminance factor of background. (used when calculating La from E)
| If None, E contains La (cd/m²).
:out:
| 'Rm' or str, optional
| Specifies requested output (e.g. 'Rm,Rmi,cct,duv')
:wl:
| None, optional
| Wavelengths (or [start, end, spacing]) to interpolate the SPDs to.
| None: default to no interpolation
Returns:
:returns:
| float or ndarray with MCRI Rm for :out: 'Rm'
| Other output is also possible by changing the :out: str value.
References:
1. `K.A.G. Smet, W.R. Ryckaert, M.R. Pointer, G. Deconinck, P. Hanselaer,(2012)
“A memory colour quality metric for white light sources,”
Energy Build., vol. 49, no. C, pp. 216–225.
<http://www.sciencedirect.com/science/article/pii/S0378778812000837>`_
"""
SPD = np2d(SPD)
if wl is not None:
SPD = spd(data = SPD, interpolation = _S_INTERP_TYPE, kind = 'np', wl = wl)
# unpack metric default values:
avg, catf, cieobs, cri_specific_pars, cspace, ref_type, rg_pars, sampleset, scale = [_MCRI_DEFAULTS[x] for x in sorted(_MCRI_DEFAULTS.keys())]
similarity_ai = cri_specific_pars['similarity_ai']
Mxyz2lms = cspace['Mxyz2lms']
scale_fcn = scale['fcn']
scale_factor = scale['cfactor']
sampleset = eval(sampleset)
# A. calculate xyz:
xyzti, xyztw = spd_to_xyz(SPD, cieobs = cieobs['xyz'], rfl = sampleset, out = 2)
if 'cct' in out.split(','):
cct, duv = xyz_to_cct(xyztw, cieobs = cieobs['cct'], out = 'cct,duv',mode = 'lut')
# B. perform chromatic adaptation to adopted whitepoint of ipt color space, i.e. D65:
if catf is not None:
Dtype_cat, F, Yb_cat, catmode_cat, cattype_cat, mcat_cat, xyzw_cat = [catf[x] for x in sorted(catf.keys())]
# calculate degree of adaptationn D:
if E is not None:
if Yb is not None:
La = (Yb/100.0)*(E/np.pi)
else:
La = E
D = cat.get_degree_of_adaptation(Dtype = Dtype_cat, F = F, La = La)
else:
Dtype_cat = None # direct input of D
if (E is None) and (D is None):
D = 1.0 # set degree of adaptation to 1 !
if D > 1.0: D = 1.0
if D < 0.6: D = 0.6 # put a limit on the lowest D
# apply cat:
xyzti = cat.apply(xyzti, cattype = cattype_cat, catmode = catmode_cat, xyzw1 = xyztw,xyzw0 = None, xyzw2 = xyzw_cat, D = D, mcat = [mcat_cat], Dtype = Dtype_cat)
xyztw = cat.apply(xyztw, cattype = cattype_cat, catmode = catmode_cat, xyzw1 = xyztw,xyzw0 = None, xyzw2 = xyzw_cat, D = D, mcat = [mcat_cat], Dtype = Dtype_cat)
# C. convert xyz to ipt and split:
ipt = xyz_to_ipt(xyzti, cieobs = cieobs['xyz'], M = Mxyz2lms) #input matrix as published in Smet et al. 2012, Energy and Buildings
I,P,T = asplit(ipt)
# D. calculate specific (hue dependent) similarity indicators, Si:
if len(xyzti.shape) == 3:
ai = np.expand_dims(similarity_ai, axis = 1)
else:
ai = similarity_ai
a1,a2,a3,a4,a5 = asplit(ai)
mahalanobis_d2 = (a3*np.power((P - a1),2.0) + a4*np.power((T - a2),2.0) + 2.0*a5*(P-a1)*(T-a2))
if (len(mahalanobis_d2.shape)==3) & (mahalanobis_d2.shape[-1]==1):
mahalanobis_d2 = mahalanobis_d2[:,:,0].T
Si = np.exp(-0.5*mahalanobis_d2)
# E. calculate general similarity indicator, Sa:
Sa = avg(Si, axis = 0,keepdims = True)
# F. rescale similarity indicators (Si, Sa) with a 0-1 scale to memory color rendition indices (Rmi, Rm) with a 0 - 100 scale:
Rmi = scale_fcn(np.log(Si),scale_factor = scale_factor)
Rm = np2d(scale_fcn(np.log(Sa),scale_factor = scale_factor))
# G. calculate Rg (polyarea of test / polyarea of memory colours):
if 'Rg' in out.split(','):
I = I[...,None] #broadcast_shape(I, target_shape = None,expand_2d_to_3d = 0)
a1 = a1[:,None]*np.ones(I.shape)#broadcast_shape(a1, target_shape = None,expand_2d_to_3d = 0)
a2 = a2[:,None]*np.ones(I.shape) #broadcast_shape(a2, target_shape = None,expand_2d_to_3d = 0)
a12 = np.concatenate((a1,a2),axis=2) #broadcast_shape(np.hstack((a1,a2)), target_shape = ipt.shape,expand_2d_to_3d = 0)
ipt_mc = np.concatenate((I,a12),axis=2)
nhbins, normalize_gamut, normalized_chroma_ref, start_hue = [rg_pars[x] for x in sorted(rg_pars.keys())]
hue_bin_data = _get_hue_bin_data(ipt, ipt_mc,
start_hue = start_hue, nhbins = nhbins,
normalized_chroma_ref = normalized_chroma_ref)
Rg = _hue_bin_data_to_rg(hue_bin_data)
if (out != 'Rm'):
return eval(out)
else:
return Rm
def ipt_to_xyz(ipt, cieobs=_CIEOBS, xyzw=None, M=None, **kwargs):
"""
Convert XYZ tristimulus values to IPT color coordinates.
| I: Lightness axis, P, red-green axis, T: yellow-blue axis.
Args:
:ipt:
| ndarray with IPT color coordinates
:xyzw:
| None or ndarray with tristimulus values of white point, optional
| None defaults to xyz of CIE D65 using the :cieobs: observer.
:cieobs:
| luxpy._CIEOBS, optional
| CMF set to use when calculating xyzw for rescaling Mxyz2lms
| (only when not None).
:M: | None, optional
| None defaults to xyz to lms conversion matrix determined by:cieobs:
Returns:
:xyz:
| ndarray with tristimulus values
Note:
:xyz: is assumed to be under D65 viewing conditions! If necessary perform chromatic adaptation !
Reference:
1. `Ebner F, and Fairchild MD (1998).
Development and testing of a color space (IPT) with improved hue uniformity.
In IS&T 6th Color Imaging Conference, (Scottsdale, Arizona, USA), pp. 8–13.
<http://www.ingentaconnect.com/content/ist/cic/1998/00001998/00000001/art00003?crawler=true>`_
"""
ipt = np2d(ipt)
# get M to convert xyz to lms and apply normalization to matrix or input your own:
if M is None:
M = _IPT_M['xyz2lms'][cieobs].copy(
) # matrix conversions from xyz to lms
if xyzw is None:
xyzw = spd_to_xyz(_CIE_ILLUMINANTS['D65'], cieobs=cieobs,
out=1) / 100.0
else:
xyzw = xyzw / 100.0
M = math.normalize_3x3_matrix(M, xyzw)
# convert from ipt to lms':
if len(ipt.shape) == 3:
lmsp = np.einsum('ij,klj->kli', np.linalg.inv(_IPT_M['lms2ipt']), ipt)
else:
lmsp = np.einsum('ij,lj->li', np.linalg.inv(_IPT_M['lms2ipt']), ipt)
# reverse response compression: lms' to lms
lms = lmsp**(1.0 / 0.43)
p = np.where(lmsp < 0.0)
lms[p] = -np.abs(lmsp[p])**(1.0 / 0.43)
# convert from lms to xyz:
if np.ndim(M) == 2:
if len(ipt.shape) == 3:
xyz = np.einsum('ij,klj->kli', np.linalg.inv(M), lms)
else:
xyz = np.einsum('ij,lj->li', np.linalg.inv(M), lms)
else:
if len(
ipt.shape
) == 3: # second dim of lms must match dim of 1st of M and 1st dim of xyzw
xyz = np.concatenate([
np.einsum('ij,klj->kli', np.linalg.inv(M[i]),
lms[:, i:i + 1, :]) for i in range(M.shape[0])
],
axis=1)
else: # first dim of lms must match dim of 1st of M and 1st dim of xyzw
xyz = np.concatenate([
np.einsum('ij,lj->li', np.linalg.inv(M[i]), lms[i:i + 1, :])
for i in range(M.shape[0])
],
axis=0)
#xyz = np.dot(np.linalg.inv(M),lms.T).T
xyz = xyz * 100.0
xyz[np.where(xyz < 0.0)] = 0.0
return xyz
def spd_to_xyz(data,
relative=True,
rfl=None,
cieobs=_CIEOBS,
K=None,
out=None,
cie_std_dev_obs=None):
"""
Calculates xyz tristimulus values from spectral data.
Args:
:data:
| ndarray or pandas.dataframe with spectral data
| (.shape = (number of spectra + 1, number of wavelengths))
| Note that :data: is never interpolated, only CMFs and RFLs.
| This way interpolation errors due to peaky spectra are avoided.
| Conform CIE15-2018.
:relative:
| True or False, optional
| Calculate relative XYZ (Yw = 100) or absolute XYZ (Y = Luminance)
:rfl:
| ndarray with spectral reflectance functions.
| Will be interpolated if wavelengths do not match those of :data:
:cieobs:
| luxpy._CIEOBS or str, optional
| Determines the color matching functions to be used in the
| calculation of XYZ.
:K:
| None, optional
| e.g. K = 683 lm/W for '1931_2' (relative == False)
| or K = 100/sum(spd*dl) (relative == True)
:out:
| None or 1 or 2, optional
| Determines number and shape of output. (see :returns:)
:cie_std_dev_obs:
| None or str, optional
| - None: don't use CIE Standard Deviate Observer function.
| - 'f1': use F1 function.
Returns:
:returns:
| If rfl is None:
| If out is None: ndarray of xyz values
| (.shape = (data.shape[0],3))
| If out == 1: ndarray of xyz values
| (.shape = (data.shape[0],3))
| If out == 2: (ndarray of xyz, ndarray of xyzw) values
| Note that xyz == xyzw, with (.shape = (data.shape[0],3))
| If rfl is not None:
| If out is None: ndarray of xyz values
| (.shape = (rfl.shape[0],data.shape[0],3))
| If out == 1: ndarray of xyz values
| (.shape = (rfl.shape[0]+1,data.shape[0],3))
| The xyzw values of the light source spd are the first set
| of values of the first dimension. The following values
| along this dimension are the sample (rfl) xyz values.
| If out == 2: (ndarray of xyz, ndarray of xyzw) values
| with xyz.shape = (rfl.shape[0],data.shape[0],3)
| and with xyzw.shape = (data.shape[0],3)
References:
1. `CIE15:2018, “Colorimetry,” CIE, Vienna, Austria, 2018. <https://doi.org/10.25039/TR.015.2018>`_
"""
data = getdata(data,
kind='np') if isinstance(data, pd.DataFrame) else np2d(
data) # convert to np format and ensure 2D-array
# get wl spacing:
dl = getwld(data[0])
# get cmf,k for cieobs:
if isinstance(cieobs, str):
if K is None: K = _CMF[cieobs]['K']
scr = 'dict'
else:
scr = 'cieobs'
if (K is None) & (relative == False): K = 1
# Interpolate to wl of data:
cmf = xyzbar(cieobs=cieobs, scr=scr, wl_new=data[0], kind='np')
# Add CIE standard deviate observer function to cmf if requested:
if cie_std_dev_obs is not None:
cmf_cie_std_dev_obs = xyzbar(cieobs='cie_std_dev_obs_' +
cie_std_dev_obs.lower(),
scr=scr,
wl_new=data[0],
kind='np')
cmf[1:] = cmf[1:] + cmf_cie_std_dev_obs[1:]
# Rescale xyz using k or 100/Yw:
if relative == True: K = 100.0 / np.dot(data[1:], cmf[2, :] * dl)
# Interpolate rfls to lambda range of spd and calculate xyz:
if rfl is not None:
rfl = cie_interp(data=np2d(rfl), wl_new=data[0], kind='rfl')
rfl = np.concatenate((np.ones((1, data.shape[1])),
rfl[1:])) #add rfl = 1 for light source spectrum
xyz = K * np.array(
[np.dot(rfl, (data[1:] * cmf[i + 1, :] * dl).T)
for i in range(3)]) #calculate tristimulus values
rflwasnotnone = 1
else:
rfl = np.ones((1, data.shape[1]))
xyz = (K * (np.dot((cmf[1:] * dl), data[1:].T))[:, None, :])
rflwasnotnone = 0
xyz = np.transpose(xyz, [1, 2, 0]) #order [rfl,spd,xyz]
# Setup output:
if out == 2:
xyzw = xyz[0, ...]
xyz = xyz[rflwasnotnone:, ...]
if rflwasnotnone == 0: xyz = np.squeeze(xyz, axis=0)
return xyz, xyzw
elif out == 1:
if rflwasnotnone == 0: xyz = np.squeeze(xyz, axis=0)
return xyz
else:
xyz = xyz[rflwasnotnone:, ...]
if rflwasnotnone == 0: xyz = np.squeeze(xyz, axis=0)
return xyz
