def _xyz_to_jab_cam02ucs(xyz, xyzw, ucs=True, conditions=None):
"""
Calculate CAM02-UCS J'a'b' coordinates from xyz tristimulus values of sample and white point.
Args:
:xyz:
| ndarray with sample tristimulus values
: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()?
Returns:
:jab:
| ndarray with J'a'b' coordinates.
"""
#--------------------------------------------
# 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)
#--------------------------------------------
# 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))
#--------------------------------------------
# transform from xyz, xyzw to cat sensor space:
rgb = math.dot23(mcat, xyz.T)
rgbw = mcat @ xyzw.T
#--------------------------------------------
# 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.)
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):
rgbp = math.dot23(mhpe_x_invmcat, rgbc).T
rgbwp = (mhpe_x_invmcat @ rgbwc).T
#--------------------------------------------
# apply Naka_rushton repsonse compression:
naka_rushton = lambda x: 400 * x**0.42 / (x**0.42 + 27.13) + 0.1
rgbpa = naka_rushton(FL * rgbp / 100.0)
p = np.where(rgbp < 0)
rgbpa[p] = 0.1 - (naka_rushton(FL * np.abs(rgbp[p]) / 100.0) - 0.1)
rgbwpa = naka_rushton(FL * rgbwp / 100.0)
pw = np.where(rgbwp < 0)
rgbwpa[pw] = 0.1 - (naka_rushton(FL * np.abs(rgbwp[pw]) / 100.0) - 0.1)
#--------------------------------------------
# Calculate achromatic signal:
A = (2.0 * rgbpa[..., 0] + rgbpa[..., 1] +
(1.0 / 20.0) * rgbpa[..., 2] - 0.305) * Nbb
Aw = (2.0 * rgbwpa[..., 0] + rgbwpa[..., 1] +
(1.0 / 20.0) * rgbwpa[..., 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 = np.arctan2(b, a)
et = (1.0 / 4.0) * (np.cos(h + 2.0) + 3.8)
#--------------------------------------------
# calculate lightness, J:
J = 100.0 * (A / Aw)**(c * z)
#--------------------------------------------
# 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
#--------------------------------------------
# convert to cam02ucs J', aM', bM':
if ucs == True:
KL, c1, c2 = 1.0, 0.007, 0.0228
Jp = (1.0 + 100.0 * c1) * J / (1.0 + c1 * J)
Mp = (1.0 / c2) * np.log(1.0 + c2 * M)
else:
Jp = J
Mp = M
aMp = Mp * np.cos(h)
bMp = Mp * np.sin(h)
return np.dstack((Jp, aMp, bMp))
def generate_grid(jab_ranges = None, out = 'grid', \
ax = np.arange(-_VF_MAXR,_VF_MAXR+_VF_DELTAR,_VF_DELTAR),\
bx = np.arange(-_VF_MAXR,_VF_MAXR+_VF_DELTAR,_VF_DELTAR), \
jx = None, limit_grid_radius = 0):
"""
Generate a grid of color coordinates.
Args:
:out:
| 'grid' or 'vectors', optional
| - 'grid': outputs a single 2d numpy.nd-vector with the grid coordinates
| - 'vector': outputs each dimension seperately.
:jab_ranges:
| None or ndarray, optional
| Specifies the pixelization of color space.
| (ndarray.shape = (3,3), with first axis: J,a,b, and second
| axis: min, max, delta)
:ax:
| default ndarray or user defined ndarray, optional
| default = np.arange(-_VF_MAXR,_VF_MAXR+_VF_DELTAR,_VF_DELTAR)
:bx:
| default ndarray or user defined ndarray, optional
| default = np.arange(-_VF_MAXR,_VF_MAXR+_VF_DELTAR,_VF_DELTAR)
:jx:
| None, optional
| Note that not-None :jab_ranges: override :ax:, :bx: and :jx input.
:limit_grid_radius:
| 0, optional
| A value of zeros keeps grid as specified by axr,bxr.
| A value > 0 only keeps (a,b) coordinates within :limit_grid_radius:
Returns:
:returns:
| single ndarray with ax,bx [,jx]
| or
| seperate ndarrays for each dimension specified.
"""
# generate grid from jab_ranges array input, otherwise use ax, bx, jx input:
if jab_ranges is not None:
if jab_ranges.shape[0] == 3:
jx = np.arange(jab_ranges[0][0], jab_ranges[0][1],
jab_ranges[0][2])
ax = np.arange(jab_ranges[1][0], jab_ranges[1][1],
jab_ranges[1][2])
bx = np.arange(jab_ranges[2][0], jab_ranges[2][1],
jab_ranges[2][2])
else:
jx = None
ax = np.arange(jab_ranges[0][0], jab_ranges[0][1],
jab_ranges[0][2])
bx = np.arange(jab_ranges[1][0], jab_ranges[1][1],
jab_ranges[1][2])
# Generate grid from (jx), ax, bx:
Ax, Bx = np.meshgrid(ax, bx)
grid = np.dstack((Ax, Bx))
grid = np.reshape(grid, (np.array(grid.shape[:-1]).prod(), grid.ndim - 1))
if jx is not None:
for i, v in enumerate(jx):
gridi = np.hstack((np.ones((grid.shape[0], 1)) * v, grid))
if i == 0:
gridwithJ = gridi
else:
gridwithJ = np.vstack((gridwithJ, gridi))
grid = gridwithJ
if jx is None:
ax = grid[:, 0:1]
bx = grid[:, 1:2]
else:
jx = grid[:, 0:1]
ax = grid[:, 1:2]
bx = grid[:, 2:3]
if limit_grid_radius > 0: # limit radius of grid:
Cr = (ax**2 + bx**2)**0.5
ax = ax[Cr <= limit_grid_radius, None]
bx = bx[Cr <= limit_grid_radius, None]
if jx is not None:
jx = jx[Cr <= limit_grid_radius, None]
# create output:
if out == 'grid':
if jx is None:
return np.hstack((ax, bx))
else:
return np.hstack((jx, ax, bx))
else:
if jx is None:
return ax, bx
else:
return jx, ax, bx
def plot_chromaticity_diagram_colors(diagram_samples = 256, diagram_opacity = 1.0, diagram_lightness = 0.25,\
cieobs = _CIEOBS, cspace = 'Yxy', cspace_pars = {},\
show = True, axh = None,\
show_grid = False, label_fontname = 'Times New Roman', label_fontsize = 12,\
**kwargs):
"""
Plot the chromaticity diagram colors.
Args:
:diagram_samples:
| 256, optional
| Sampling resolution of color space.
:diagram_opacity:
| 1.0, optional
| Sets opacity of chromaticity diagram
:diagram_lightness:
| 0.25, optional
| Sets lightness of chromaticity diagram
:axh:
| None or axes handle, optional
| Determines axes to plot data in.
| None: make new figure.
:show:
| True or False, optional
| Invoke matplotlib.pyplot.show() right after plotting
:cieobs:
| luxpy._CIEOBS or str, optional
| Determines CMF set to calculate spectrum locus or other.
:cspace:
| luxpy._CSPACE or str, optional
| Determines color space / chromaticity diagram to plot data in.
| Note that data is expected to be in specified :cspace:
:cspace_pars:
| {} or dict, optional
| Dict with parameters required by color space specified in :cspace:
| (for use with luxpy.colortf())
:show_grid:
| False, optional
| Show grid (True) or not (False)
:label_fontname:
| 'Times New Roman', optional
| Sets font type of axis labels.
:label_fontsize:
| 12, optional
| Sets font size of axis labels.
:kwargs:
| additional keyword arguments for use with matplotlib.pyplot.
Returns:
"""
if isinstance(cieobs, str):
SL = _CMF[cieobs]['bar'][1:4].T
else:
SL = cieobs[1:4].T
SL = 100.0 * SL / (SL[:, 1, None] + _EPS)
SL = SL[SL.sum(axis=1) >
0, :] # avoid div by zero in xyz-to-Yxy conversion
SL = colortf(SL, tf=cspace, tfa0=cspace_pars)
plambdamax = SL[:, 1].argmax()
SL = np.vstack(
(SL[:(plambdamax + 1), :], SL[0])
) # add lowest wavelength data and go to max of gamut in x (there is a reversal for some cmf set wavelengths >~700 nm!)
Y, x, y = asplit(SL)
SL = np.vstack((x, y)).T
# create grid for conversion to srgb
offset = _EPS
min_x = min(offset, x.min())
max_x = max(1, x.max())
min_y = min(offset, y.min())
max_y = max(1, y.max())
ii, jj = np.meshgrid(
np.linspace(min_x - offset, max_x + offset, int(diagram_samples)),
np.linspace(max_y + offset, min_y - offset, int(diagram_samples)))
ij = np.dstack((ii, jj))
ij[ij == 0] = offset
ij2D = ij.reshape((diagram_samples**2, 2))
ij2D = np.hstack((diagram_lightness * 100 * np.ones(
(ij2D.shape[0], 1)), ij2D))
xyz = colortf(ij2D, tf=cspace + '>xyz', tfa0=cspace_pars)
xyz[xyz < 0] = 0
xyz[np.isinf(xyz.sum(axis=1)), :] = np.nan
xyz[np.isnan(xyz.sum(axis=1)), :] = offset
srgb = xyz_to_srgb(xyz)
srgb = srgb / srgb.max()
srgb = srgb.reshape((diagram_samples, diagram_samples, 3))
if show == True:
if axh is None:
fig = plt.figure()
axh = fig.add_subplot(111)
polygon = Polygon(SL, facecolor='none', edgecolor='none')
axh.add_patch(polygon)
image = axh.imshow(srgb,
interpolation='bilinear',
extent=(min_x, max_x, min_y - 0.05, max_y),
clip_path=None,
alpha=diagram_opacity)
image.set_clip_path(polygon)
axh.plot(x, y, color='darkgray')
if (cspace == 'Yxy') & (isinstance(cieobs, str)):
axh.set_xlim([0, 1])
axh.set_ylim([0, 1])
elif (cspace == 'Yuv') & (isinstance(cieobs, str)):
axh.set_xlim([0, 0.6])
axh.set_ylim([0, 0.6])
if (cspace is not None):
xlabel = _CSPACE_AXES[cspace][1]
ylabel = _CSPACE_AXES[cspace][2]
if (label_fontname is not None) & (label_fontsize is not None):
axh.set_xlabel(xlabel,
fontname=label_fontname,
fontsize=label_fontsize)
axh.set_ylabel(ylabel,
fontname=label_fontname,
fontsize=label_fontsize)
if show_grid == True:
axh.grid(True)
#plt.show()
return axh
else:
return None
def apply_poly_model_at_hue_x(poly_model, pmodel, dCHoverC_res, \
hx = None, Cxr = 40, sig = _VF_SIG):
"""
Applies base color shift model at (hue,chroma) coordinates
Args:
:poly_model:
| function handle to model
:pmodel:
| ndarray with model parameters.
:dCHoverC_res:
| ndarray with residuals between 'dCoverC,dH' of samples
| and 'dCoverC,dH' predicted by the model.
| Note: dCoverC = (Ct - Cr)/Cr and dH = ht - hr
| (predicted from model, see notes luxpy.cri.get_poly_model())
:hx:
| None or ndarray, optional
| None defaults to np.arange(np.pi/10.0,2*np.pi,2*np.pi/10.0)
:Cxr:
| 40, optional
:sig:
| _VF_SIG or float, optional
| Determines smooth transition between hue-bin-boundaries (no hard
| cutoff at hue bin boundary).
Returns:
:returns:
| ndarrays with dCoverC_x, dCoverC_x_sig, dH_x, dH_x_sig
| Note '_sig' denotes the uncertainty:
| e.g. dH_x_sig is the uncertainty of dH at input (hue/chroma).
"""
if hx is None:
dh = 2 * np.pi / 10.0
hx = np.arange(
dh / 2, 2 * np.pi, dh
) #hue angles at which to apply model, i.e. calculate 'average' measures
# A calculate reference coordinates:
axr = Cxr * np.cos(hx)
bxr = Cxr * np.sin(hx)
# B apply model at reference coordinates to obtain test coordinates:
axt, bxt, Cxt, hxt, axr, bxr, Cxr, hxr = apply_poly_model_at_x(
poly_model, pmodel, axr, bxr)
# C Calculate dC/C, dH for test and ref at fixed hues:
dCoverC_x = (Cxt - Cxr) / (np.hstack((Cxr + Cxt)).max())
dH_x = (180 / np.pi) * (hxt - hxr)
# dCoverC_x = np.round(dCoverC_x,decimals = 2)
# dH_x = np.round(dH_x,decimals = 0)
# D calculate 'average' noise measures using sig-value:
href = dCHoverC_res[:, 0:1]
dCoverC_res = dCHoverC_res[:, 1:2]
dHoverC_res = dCHoverC_res[:, 2:3]
dHsigi = np.exp((np.dstack(
(np.abs(hx - href), np.abs((hx - href - 2 * np.pi)),
np.abs(hx - href - 2 * np.pi))).min(axis=2)**2) / (-2) / sig)
dH_x_sig = (180 / np.pi) * (np.sqrt(
(dHsigi * (dHoverC_res**2)).sum(axis=0, keepdims=True) /
dHsigi.sum(axis=0, keepdims=True)))
#dH_x_sig_avg = np.sqrt(np.sum(dH_x_sig**2,axis=1)/hx.shape[0])
dCoverC_x_sig = (np.sqrt(
(dHsigi * (dCoverC_res**2)).sum(axis=0, keepdims=True) /
dHsigi.sum(axis=0, keepdims=True)))
#dCoverC_x_sig_avg = np.sqrt(np.sum(dCoverC_x_sig**2,axis=1)/hx.shape[0])
return dCoverC_x, dCoverC_x_sig, dH_x, dH_x_sig
def get_macadam_ellipse(xy = None, k_neighbours = 3, nsteps = 10, average_cik = True):
"""
Estimate n-step MacAdam ellipse at CIE x,y coordinates xy by calculating
average inverse covariance ellipse of the k_neighbours closest ellipses.
Args:
:xy:
| None or ndarray, optional
| If None: output Macadam ellipses, if not None: xy are the
| CIE xy coordinates for which ellipses will be estimated.
:k_neighbours:
| 3, optional
| Number of nearest ellipses to use to calculate ellipse at xy
:nsteps:
| 10, optional
| Set number of MacAdam steps of ellipse.
:average_cik:
| True, optional
| If True: take distance weighted average of inverse
| 'covariance ellipse' elements cik.
| If False: average major & minor axis lengths and
| ellipse orientation angles directly.
Returns:
:v_mac_est:
| estimated MacAdam ellipse(s) in v-format [Rmax,Rmin,xc,yc,theta]
References:
1. MacAdam DL. Visual Sensitivities to Color Differences in Daylight*. J Opt Soc Am. 1942;32(5):247-274.
"""
# list of MacAdam ellipses (x10)
v_mac = np.atleast_2d([
[0.16, 0.057, 0.0085, 0.0035, 62.5],
[0.187, 0.118, 0.022, 0.0055, 77],
[0.253, 0.125, 0.025, 0.005, 55.5],
[0.15, 0.68, 0.096, 0.023, 105],
[0.131, 0.521, 0.047, 0.02, 112.5],
[0.212, 0.55, 0.058, 0.023, 100],
[0.258, 0.45, 0.05, 0.02, 92],
[0.152, 0.365, 0.038, 0.019, 110],
[0.28, 0.385, 0.04, 0.015, 75.5],
[0.38, 0.498, 0.044, 0.012, 70],
[0.16, 0.2, 0.021, 0.0095, 104],
[0.228, 0.25, 0.031, 0.009, 72],
[0.305, 0.323, 0.023, 0.009, 58],
[0.385, 0.393, 0.038, 0.016, 65.5],
[0.472, 0.399, 0.032, 0.014, 51],
[0.527, 0.35, 0.026, 0.013, 20],
[0.475, 0.3, 0.029, 0.011, 28.5],
[0.51, 0.236, 0.024, 0.012, 29.5],
[0.596, 0.283, 0.026, 0.013, 13],
[0.344, 0.284, 0.023, 0.009, 60],
[0.39, 0.237, 0.025, 0.01, 47],
[0.441, 0.198, 0.028, 0.0095, 34.5],
[0.278, 0.223, 0.024, 0.0055, 57.5],
[0.3, 0.163, 0.029, 0.006, 54],
[0.365, 0.153, 0.036, 0.0095, 40]
])
# convert to v-format ([a,b, xc, yc, theta]):
v_mac = v_mac[:,[2,3,0,1,4]]
# convert last column to rad.:
v_mac[:,-1] = v_mac[:,-1]*np.pi/180
# convert to desired number of MacAdam-steps:
v_mac[:,0:2] = v_mac[:,0:2]/10*nsteps
if xy is not None:
#calculate inverse covariance matrices:
cik = math.v_to_cik(v_mac, inverse = True)
if average_cik == True:
cik_long = np.hstack((cik[:,0,:],cik[:,1,:]))
# Calculate k_neighbours closest ellipses to xy:
tree = sp.spatial.cKDTree(v_mac[:,2:4], copy_data = True)
d, inds = tree.query(xy, k = k_neighbours)
if k_neighbours > 1:
pd = 1
w = (1.0 / np.abs(d)**pd)[:,:,None] # inverse distance weigthing
if average_cik == True:
cik_long_est = np.sum(w * cik_long[inds,:], axis=1) / np.sum(w, axis=1)
else:
v_mac_est = np.sum(w * v_mac[inds,:], axis=1) / np.sum(w, axis=1) # for average xyc
else:
v_mac_est = v_mac[inds,:].copy()
# convert cik back to v:
if (average_cik == True) & (k_neighbours >1):
cik_est = np.dstack((cik_long_est[:,0:2],cik_long_est[:,2:4]))
v_mac_est = math.cik_to_v(cik_est, inverse = True)
v_mac_est[:,2:4] = xy
else:
v_mac_est = v_mac
return v_mac_est
def xyz_to_Ydlep(xyz,
cieobs=_CIEOBS,
xyzw=_COLORTF_DEFAULT_WHITE_POINT,
flip_axes=False,
SL_max_lambda=None,
**kwargs):
"""
Convert XYZ tristimulus values to Y, dominant (complementary) wavelength
and excitation purity.
Args:
:xyz:
| ndarray with tristimulus values
:xyzw:
| None or ndarray with tristimulus values of a single (!) native white point, optional
| None defaults to xyz of CIE D65 using the :cieobs: observer.
:cieobs:
| luxpy._CIEOBS, optional
| CMF set to use when calculating spectrum locus coordinates.
:flip_axes:
| False, optional
| If True: flip axis 0 and axis 1 in Ydelep to increase speed of loop in function.
| (single xyzw with is not flipped!)
:SL_max_lambda:
| None or float, optional
| Maximum wavelength of spectrum locus before it turns back on itelf in the high wavelength range (~700 nm)
Returns:
:Ydlep:
| ndarray with Y, dominant (complementary) wavelength
| and excitation purity
"""
xyz3 = np3d(xyz).copy().astype(np.float)
# flip axis so that shortest dim is on axis0 (save time in looping):
if (xyz3.shape[0] < xyz3.shape[1]) & (flip_axes == True):
axes12flipped = True
xyz3 = xyz3.transpose((1, 0, 2))
else:
axes12flipped = False
# convert xyz to Yxy:
Yxy = xyz_to_Yxy(xyz3)
Yxyw = xyz_to_Yxy(xyzw)
# get spectrum locus Y,x,y and wavelengths:
SL = _CMF[cieobs]['bar']
SL = SL[:, SL[1:].sum(axis=0) >
0] # avoid div by zero in xyz-to-Yxy conversion
wlsl = SL[0]
Yxysl = xyz_to_Yxy(SL[1:4].T)[:, None]
# Get maximum wavelength of spectrum locus (before it turns back on itself)
if SL_max_lambda is None:
pmaxlambda = Yxysl[..., 1].argmax() # lambda with largest x value
dwl = np.diff(
Yxysl[:, 0,
1]) # spectrumlocus in that range should have increasing x
dwl[wlsl[:-1] < 600] = 10000
pmaxlambda = np.where(
dwl <= 0)[0][0] # Take first element with zero or <zero slope
else:
pmaxlambda = np.abs(wlsl - SL_max_lambda).argmin()
Yxysl = Yxysl[:(pmaxlambda + 1), :]
wlsl = wlsl[:(pmaxlambda + 1)]
# center on xyzw:
Yxy = Yxy - Yxyw
Yxysl = Yxysl - Yxyw
Yxyw = Yxyw - Yxyw
#split:
Y, x, y = asplit(Yxy)
Yw, xw, yw = asplit(Yxyw)
Ysl, xsl, ysl = asplit(Yxysl)
# calculate hue:
h = math.positive_arctan(x, y, htype='deg')
hsl = math.positive_arctan(xsl, ysl, htype='deg')
hsl_max = hsl[0] # max hue angle at min wavelength
hsl_min = hsl[-1] # min hue angle at max wavelength
if hsl_min < hsl_max: hsl_min += 360
dominantwavelength = np.empty(Y.shape)
purity = np.empty(Y.shape)
for i in range(xyz3.shape[1]):
# find index of complementary wavelengths/hues:
pc = np.where(
(h[:, i] > hsl_max) & (h[:, i] < hsl_min)
) # hue's requiring complementary wavelength (purple line)
h[:, i][pc] = h[:, i][pc] - np.sign(
h[:, i][pc] - 180.0
) * 180.0 # add/subtract 180° to get positive complementary wavelength
# find 2 closest enclosing hues in sl:
#hslb,hib = meshblock(hsl,h[:,i:i+1])
hib, hslb = np.meshgrid(h[:, i:i + 1], hsl)
dh = (hslb - hib)
q1 = np.abs(dh).argmin(axis=0) # index of closest hue
sign_q1 = np.sign(dh[q1])[0]
dh[np.sign(dh) ==
sign_q1] = 1000000 # set all dh on the same side as q1 to a very large value
q2 = np.abs(dh).argmin(
axis=0) # index of second closest (enclosing) hue
# # Test changes to code:
# print('wls',i, wlsl[q1],wlsl[q2])
# import matplotlib.pyplot as plt
# plt.figure()
# plt.plot(wlsl[:-1],np.diff(xsl[:,0]),'k.-')
# plt.figure()
# plt.plot(x[0,i],y[0,i],'k.'); plt.plot(xsl,ysl,'r.-');plt.plot(xsl[q1],ysl[q1],'b.');plt.plot(xsl[q2],ysl[q2],'g.');plt.plot(xsl[-1],ysl[-1],'c+')
dominantwavelength[:, i] = wlsl[q1] + np.multiply(
(h[:, i] - hsl[q1, 0]),
np.divide((wlsl[q2] - wlsl[q1]), (hsl[q2, 0] - hsl[q1, 0]))
) # calculate wl corresponding to h: y = y1 + (x-x1)*(y2-y1)/(x2-x1)
dominantwavelength[:, i][pc] = -dominantwavelength[:, i][
pc] #complementary wavelengths are specified by '-' sign
# calculate excitation purity:
x_dom_wl = xsl[q1, 0] + (xsl[q2, 0] - xsl[q1, 0]) * (h[:, i] - hsl[
q1, 0]) / (hsl[q2, 0] - hsl[q1, 0]) # calculate x of dom. wl
y_dom_wl = ysl[q1, 0] + (ysl[q2, 0] - ysl[q1, 0]) * (h[:, i] - hsl[
q1, 0]) / (hsl[q2, 0] - hsl[q1, 0]) # calculate y of dom. wl
d_wl = (x_dom_wl**2.0 +
y_dom_wl**2.0)**0.5 # distance from white point to sl
d = (x[:, i]**2.0 +
y[:, i]**2.0)**0.5 # distance from white point to test point
purity[:, i] = d / d_wl
# correct for those test points that have a complementary wavelength
# calculate intersection of line through white point and test point and purple line:
xy = np.vstack((x[:, i], y[:, i])).T
xyw = np.hstack((xw, yw))
xypl1 = np.hstack((xsl[0, None], ysl[0, None]))
xypl2 = np.hstack((xsl[-1, None], ysl[-1, None]))
da = (xy - xyw)
db = (xypl2 - xypl1)
dp = (xyw - xypl1)
T = np.array([[0.0, -1.0], [1.0, 0.0]])
dap = np.dot(da, T)
denom = np.sum(dap * db, axis=1, keepdims=True)
num = np.sum(dap * dp, axis=1, keepdims=True)
xy_linecross = (num / denom) * db + xypl1
d_linecross = np.atleast_2d(
(xy_linecross[:, 0]**2.0 + xy_linecross[:, 1]**2.0)**0.5).T #[0]
purity[:, i][pc] = d[pc] / d_linecross[pc][:, 0]
Ydlep = np.dstack((xyz3[:, :, 1], dominantwavelength, purity))
if axes12flipped == True:
Ydlep = Ydlep.transpose((1, 0, 2))
else:
Ydlep = Ydlep.transpose((0, 1, 2))
return Ydlep.reshape(xyz.shape)
def xyz_to_Ydlep_(xyz,
cieobs=_CIEOBS,
xyzw=_COLORTF_DEFAULT_WHITE_POINT,
flip_axes=False,
**kwargs):
"""
Convert XYZ tristimulus values to Y, dominant (complementary) wavelength
and excitation purity.
Args:
:xyz:
| ndarray with tristimulus values
:xyzw:
| None or ndarray with tristimulus values of a single (!) native white point, optional
| None defaults to xyz of CIE D65 using the :cieobs: observer.
:cieobs:
| luxpy._CIEOBS, optional
| CMF set to use when calculating spectrum locus coordinates.
:flip_axes:
| False, optional
| If True: flip axis 0 and axis 1 in Ydelep to increase speed of loop in function.
| (single xyzw with is not flipped!)
Returns:
:Ydlep:
| ndarray with Y, dominant (complementary) wavelength
| and excitation purity
"""
xyz3 = np3d(xyz).copy().astype(np.float)
# flip axis so that shortest dim is on axis0 (save time in looping):
if (xyz3.shape[0] < xyz3.shape[1]) & (flip_axes == True):
axes12flipped = True
xyz3 = xyz3.transpose((1, 0, 2))
else:
axes12flipped = False
# convert xyz to Yxy:
Yxy = xyz_to_Yxy(xyz3)
Yxyw = xyz_to_Yxy(xyzw)
# get spectrum locus Y,x,y and wavelengths:
SL = _CMF[cieobs]['bar']
SL = SL[:, SL[1:].sum(axis=0) >
0] # avoid div by zero in xyz-to-Yxy conversion
wlsl = SL[0]
Yxysl = xyz_to_Yxy(SL[1:4].T)[:, None]
pmaxlambda = Yxysl[..., 1].argmax()
maxlambda = wlsl[pmaxlambda]
maxlambda = 700
print(np.where(wlsl == maxlambda))
pmaxlambda = np.where(wlsl == maxlambda)[0][0]
Yxysl = Yxysl[:(pmaxlambda + 1), :]
wlsl = wlsl[:(pmaxlambda + 1)]
# center on xyzw:
Yxy = Yxy - Yxyw
Yxysl = Yxysl - Yxyw
Yxyw = Yxyw - Yxyw
#split:
Y, x, y = asplit(Yxy)
Yw, xw, yw = asplit(Yxyw)
Ysl, xsl, ysl = asplit(Yxysl)
# calculate hue:
h = math.positive_arctan(x, y, htype='deg')
print(h)
print('rh', h[0, 0] - h[0, 1])
print(wlsl[0], wlsl[-1])
hsl = math.positive_arctan(xsl, ysl, htype='deg')
hsl_max = hsl[0] # max hue angle at min wavelength
hsl_min = hsl[-1] # min hue angle at max wavelength
if hsl_min < hsl_max: hsl_min += 360
dominantwavelength = np.empty(Y.shape)
purity = np.empty(Y.shape)
print('xyz:', xyz)
for i in range(xyz3.shape[1]):
print('\ni:', i, h[:, i], hsl_max, hsl_min)
print(h)
# find index of complementary wavelengths/hues:
pc = np.where(
(h[:, i] > hsl_max) & (h[:, i] < hsl_min)
) # hue's requiring complementary wavelength (purple line)
print('pc', (h[:, i] > hsl_max) & (h[:, i] < hsl_min))
h[:, i][pc] = h[:, i][pc] - np.sign(
h[:, i][pc] - 180.0
) * 180.0 # add/subtract 180° to get positive complementary wavelength
# find 2 closest hues in sl:
#hslb,hib = meshblock(hsl,h[:,i:i+1])
hib, hslb = np.meshgrid(h[:, i:i + 1], hsl)
dh = np.abs(hslb - hib)
q1 = dh.argmin(axis=0) # index of closest hue
dh[q1] = 1000000.0
q2 = dh.argmin(axis=0) # index of second closest hue
print('q1q2', q2, q1)
print('wls:', h[:, i], wlsl[q1], wlsl[q2])
print('hsls:', hsl[q2, 0], hsl[q1, 0])
print('d', (wlsl[q2] - wlsl[q1]), (hsl[q2, 0] - hsl[q1, 0]),
(wlsl[q2] - wlsl[q1]) / (hsl[q2, 0] - hsl[q1, 0]))
print('(h[:,i] - hsl[q1,0])', (h[:, i] - hsl[q1, 0]))
print('div', np.divide((wlsl[q2] - wlsl[q1]),
(hsl[q2, 0] - hsl[q1, 0])))
print(
'mult(...)',
np.multiply((h[:, i] - hsl[q1, 0]),
np.divide((wlsl[q2] - wlsl[q1]),
(hsl[q2, 0] - hsl[q1, 0]))))
dominantwavelength[:, i] = wlsl[q1] + np.multiply(
(h[:, i] - hsl[q1, 0]),
np.divide((wlsl[q2] - wlsl[q1]), (hsl[q2, 0] - hsl[q1, 0]))
) # calculate wl corresponding to h: y = y1 + (x-x1)*(y2-y1)/(x2-x1)
print('dom', dominantwavelength[:, i])
dominantwavelength[(dominantwavelength[:,
i] > max(wlsl[q1], wlsl[q2])),
i] = max(wlsl[q1], wlsl[q2])
dominantwavelength[(dominantwavelength[:,
i] < min(wlsl[q1], wlsl[q2])),
i] = min(wlsl[q1], wlsl[q2])
dominantwavelength[:, i][pc] = -dominantwavelength[:, i][
pc] #complementary wavelengths are specified by '-' sign
# calculate excitation purity:
x_dom_wl = xsl[q1, 0] + (xsl[q2, 0] - xsl[q1, 0]) * (h[:, i] - hsl[
q1, 0]) / (hsl[q2, 0] - hsl[q1, 0]) # calculate x of dom. wl
y_dom_wl = ysl[q1, 0] + (ysl[q2, 0] - ysl[q1, 0]) * (h[:, i] - hsl[
q1, 0]) / (hsl[q2, 0] - hsl[q1, 0]) # calculate y of dom. wl
d_wl = (x_dom_wl**2.0 +
y_dom_wl**2.0)**0.5 # distance from white point to sl
d = (x[:, i]**2.0 +
y[:, i]**2.0)**0.5 # distance from white point to test point
purity[:, i] = d / d_wl
# correct for those test points that have a complementary wavelength
# calculate intersection of line through white point and test point and purple line:
xy = np.vstack((x[:, i], y[:, i])).T
xyw = np.hstack((xw, yw))
xypl1 = np.hstack((xsl[0, None], ysl[0, None]))
xypl2 = np.hstack((xsl[-1, None], ysl[-1, None]))
da = (xy - xyw)
db = (xypl2 - xypl1)
dp = (xyw - xypl1)
T = np.array([[0.0, -1.0], [1.0, 0.0]])
dap = np.dot(da, T)
denom = np.sum(dap * db, axis=1, keepdims=True)
num = np.sum(dap * dp, axis=1, keepdims=True)
xy_linecross = (num / denom) * db + xypl1
d_linecross = np.atleast_2d(
(xy_linecross[:, 0]**2.0 + xy_linecross[:, 1]**2.0)**0.5).T #[0]
purity[:, i][pc] = d[pc] / d_linecross[pc][:, 0]
Ydlep = np.dstack((xyz3[:, :, 1], dominantwavelength, purity))
if axes12flipped == True:
Ydlep = Ydlep.transpose((1, 0, 2))
else:
Ydlep = Ydlep.transpose((0, 1, 2))
return Ydlep.reshape(xyz.shape)
def Ydlep_to_xyz(Ydlep,
cieobs=_CIEOBS,
xyzw=_COLORTF_DEFAULT_WHITE_POINT,
flip_axes=False,
SL_max_lambda=None,
**kwargs):
"""
Convert Y, dominant (complementary) wavelength and excitation purity to XYZ
tristimulus values.
Args:
:Ydlep:
| ndarray with Y, dominant (complementary) wavelength
and excitation purity
:xyzw:
| None or narray with tristimulus values of a single (!) native white point, optional
| None defaults to xyz of CIE D65 using the :cieobs: observer.
:cieobs:
| luxpy._CIEOBS, optional
| CMF set to use when calculating spectrum locus coordinates.
:flip_axes:
| False, optional
| If True: flip axis 0 and axis 1 in Ydelep to increase speed of loop in function.
| (single xyzw with is not flipped!)
:SL_max_lambda:
| None or float, optional
| Maximum wavelength of spectrum locus before it turns back on itelf in the high wavelength range (~700 nm)
Returns:
:xyz:
| ndarray with tristimulus values
"""
Ydlep3 = np3d(Ydlep).copy().astype(np.float)
# flip axis so that longest dim is on first axis (save time in looping):
if (Ydlep3.shape[0] < Ydlep3.shape[1]) & (flip_axes == True):
axes12flipped = True
Ydlep3 = Ydlep3.transpose((1, 0, 2))
else:
axes12flipped = False
# convert xyzw to Yxyw:
Yxyw = xyz_to_Yxy(xyzw)
Yxywo = Yxyw.copy()
# get spectrum locus Y,x,y and wavelengths:
SL = _CMF[cieobs]['bar']
SL = SL[:, SL[1:].sum(axis=0) >
0] # avoid div by zero in xyz-to-Yxy conversion
wlsl = SL[0, None].T
Yxysl = xyz_to_Yxy(SL[1:4].T)[:, None]
# Get maximum wavelength of spectrum locus (before it turns back on itself)
if SL_max_lambda is None:
pmaxlambda = Yxysl[..., 1].argmax() # lambda with largest x value
dwl = np.diff(
Yxysl[:, 0,
1]) # spectrumlocus in that range should have increasing x
dwl[wlsl[:-1, 0] < 600] = 10000
pmaxlambda = np.where(
dwl <= 0)[0][0] # Take first element with zero or <zero slope
else:
pmaxlambda = np.abs(wlsl - SL_max_lambda).argmin()
Yxysl = Yxysl[:(pmaxlambda + 1), :]
wlsl = wlsl[:(pmaxlambda + 1), :1]
# center on xyzw:
Yxysl = Yxysl - Yxyw
Yxyw = Yxyw - Yxyw
#split:
Y, dom, pur = asplit(Ydlep3)
Yw, xw, yw = asplit(Yxyw)
Ywo, xwo, ywo = asplit(Yxywo)
Ysl, xsl, ysl = asplit(Yxysl)
# loop over longest dim:
x = np.empty(Y.shape)
y = np.empty(Y.shape)
for i in range(Ydlep3.shape[1]):
# find closest wl's to dom:
#wlslb,wlib = meshblock(wlsl,np.abs(dom[i,:])) #abs because dom<0--> complemtary wl
wlib, wlslb = np.meshgrid(np.abs(dom[:, i]), wlsl)
dwl = wlslb - wlib
q1 = np.abs(dwl).argmin(axis=0) # index of closest wl
sign_q1 = np.sign(dwl[q1])
dwl[np.sign(dwl) ==
sign_q1] = 1000000 # set all dwl on the same side as q1 to a very large value
q2 = np.abs(dwl).argmin(
axis=0) # index of second closest (enclosing) wl
# calculate x,y of dom:
x_dom_wl = xsl[q1, 0] + (xsl[q2, 0] - xsl[q1, 0]) * (
np.abs(dom[:, i]) - wlsl[q1, 0]) / (wlsl[q2, 0] - wlsl[q1, 0]
) # calculate x of dom. wl
y_dom_wl = ysl[q1, 0] + (ysl[q2, 0] - ysl[q1, 0]) * (
np.abs(dom[:, i]) - wlsl[q1, 0]) / (wlsl[q2, 0] - wlsl[q1, 0]
) # calculate y of dom. wl
# calculate x,y of test:
d_wl = (x_dom_wl**2.0 +
y_dom_wl**2.0)**0.5 # distance from white point to dom
d = pur[:, i] * d_wl
hdom = math.positive_arctan(x_dom_wl, y_dom_wl, htype='deg')
x[:, i] = d * np.cos(hdom * np.pi / 180.0)
y[:, i] = d * np.sin(hdom * np.pi / 180.0)
# complementary:
pc = np.where(dom[:, i] < 0.0)
hdom[pc] = hdom[pc] - np.sign(dom[:, i][pc] -
180.0) * 180.0 # get positive hue angle
# calculate intersection of line through white point and test point and purple line:
xy = np.vstack((x_dom_wl, y_dom_wl)).T
xyw = np.vstack((xw, yw)).T
xypl1 = np.vstack((xsl[0, None], ysl[0, None])).T
xypl2 = np.vstack((xsl[-1, None], ysl[-1, None])).T
da = (xy - xyw)
db = (xypl2 - xypl1)
dp = (xyw - xypl1)
T = np.array([[0.0, -1.0], [1.0, 0.0]])
dap = np.dot(da, T)
denom = np.sum(dap * db, axis=1, keepdims=True)
num = np.sum(dap * dp, axis=1, keepdims=True)
xy_linecross = (num / denom) * db + xypl1
d_linecross = np.atleast_2d(
(xy_linecross[:, 0]**2.0 + xy_linecross[:, 1]**2.0)**0.5).T[:, 0]
x[:, i][pc] = pur[:, i][pc] * d_linecross[pc] * np.cos(
hdom[pc] * np.pi / 180)
y[:, i][pc] = pur[:, i][pc] * d_linecross[pc] * np.sin(
hdom[pc] * np.pi / 180)
Yxy = np.dstack((Ydlep3[:, :, 0], x + xwo, y + ywo))
if axes12flipped == True:
Yxy = Yxy.transpose((1, 0, 2))
else:
Yxy = Yxy.transpose((0, 1, 2))
return Yxy_to_xyz(Yxy).reshape(Ydlep.shape)
