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 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 Ydlep_to_xyz(Ydlep,
cieobs=_CIEOBS,
xyzw=_COLORTF_DEFAULT_WHITE_POINT,
flip_axes=False,
**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!)
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']
wlsl = SL[0, None].T
Yxysl = xyz_to_Yxy(SL[1:4].T)[:, None]
# 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 = np.abs(wlslb - wlib)
q1 = dwl.argmin(axis=0) # index of closest wl
dwl[q1] = 10000.0
q2 = dwl.argmin(axis=0) # index of second closest 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)
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']
wlsl = SL[0]
Yxysl = xyz_to_Yxy(SL[1:4].T)[:, None]
# 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
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 + 360.0)
) # 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 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] = 1000.0
q2 = dh.argmin(axis=0) # index of second closest hue
dominantwavelength[:, i] = wlsl[q1] + np.divide(
np.multiply((wlsl[q2] - wlsl[q1]),
(h[:, i] - hsl[q1, 0])), (hsl[q2, 0] - hsl[q1, 0])
) # calculate wl corresponding to h: y = y1 + (y2-y1)*(x-x1)/(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 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 = True, 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:
| True, 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:
"""
offset = _EPS
ii, jj = np.meshgrid(np.linspace(offset, 1 + offset, diagram_samples), np.linspace(1+offset, offset, diagram_samples))
ij = np.dstack((ii, jj))
SL = _CMF[cieobs]['bar'][1:4].T
SL = np.vstack((SL,SL[0]))
SL = 100.0*SL/SL[:,1,None]
SL = colortf(SL, tf = cspace, tfa0 = cspace_pars)
Y,x,y = asplit(SL)
SL = np.vstack((x,y)).T
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 = (0.0, 1, -0.05, 1),
clip_path=None,
alpha=diagram_opacity)
image.set_clip_path(polygon)
plt.plot(x,y, color = 'darkgray')
if cspace == 'Yxy':
plt.xlim([0,1])
plt.ylim([0,1])
elif cspace == 'Yuv':
plt.xlim([0,0.6])
plt.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):
plt.xlabel(xlabel, fontname = label_fontname, fontsize = label_fontsize)
plt.ylabel(ylabel, fontname = label_fontname, fontsize = label_fontsize)
if show_grid == True:
plt.grid()
#plt.show()
return axh
else:
return None
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]
"""
# 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 = 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
