def plot_cri_graphics(data, cri_type = None, hbins = 16, start_hue = 0.0, scalef = 100, \
plot_axis_labels = False, bin_labels = None, plot_edge_lines = True, \
plot_center_lines = False, plot_bin_colors = True, \
axtype = 'polar', ax = None, force_CVG_layout = True,
vf_model_type = _VF_MODEL_TYPE, vf_pcolorshift = _VF_PCOLORSHIFT, vf_color = 'k', \
vf_bin_labels = _VF_PCOLORSHIFT['labels'], vf_plot_bin_colors = True, \
scale_vf_chroma_to_sample_chroma = False,\
plot_VF = True, plot_CF = False, plot_SF = False):
"""
Plot graphical information on color rendition properties.
Args:
:data:
| ndarray with spectral data or dict with pre-computed metrics.
:cri_type:
| None, optional
| If None: defaults to cri_type = 'iesrf'.
| :hbins:, :start_hue: and :scalef: are ignored if cri_type not None
| and values are replaced by those in cri_type['rg_pars']
:hbins:
| 16 or ndarray with sorted hue bin centers (°), optional
:start_hue:
| 0.0, optional
:scalef:
| 100, optional
| Scale factor for graphic.
:plot_axis_labels:
| False, optional
| Turns axis ticks on/off (True/False).
:bin_labels:
| None or list[str] or '#', optional
| Plots labels at the bin center hues.
| - None: don't plot.
| - list[str]: list with str for each bin.
| (len(:bin_labels:) = :nhbins:)
| - '#': plots number.
:plot_edge_lines:
| True or False, optional
| Plot grey bin edge lines with '--'.
:plot_center_lines:
| False or True, optional
| Plot colored lines at 'center' of hue bin.
:plot_bin_colors:
| True, optional
| Colorize hue bins.
:axtype:
| 'polar' or 'cart', optional
| Make polar or Cartesian plot.
:ax:
| None or 'new' or 'same', optional
| - None or 'new' creates new plot
| - 'same': continue plot on same axes.
| - axes handle: plot on specified axes.
:force_CVG_layout:
| False or True, optional
| True: Force plot of basis of CVG.
:vf_model_type:
| _VF_MODEL_TYPE or 'M6' or 'M5', optional
| Type of polynomial vector field model to use for the calculation of
base color shift and metameric uncertainty.
:vf_pcolorshift:
| _VF_PCOLORSHIFT or user defined dict, optional
| The polynomial models of degree 5 and 6 can be fully specified or
summarized by the model parameters themselved OR by calculating the
dCoverC and dH at resp. 5 and 6 hues. :VF_pcolorshift: specifies
these hues and chroma level.
:vf_color:
| 'k', optional
| For plotting the vector fields.
:vf_plot_bin_colors:
| True, optional
| Colorize hue bins of VF graph.
:scale_vf_chroma_to_sample_chroma:
| False, optional
| Scale chroma of reference and test vf fields such that average of
binned reference chroma equals that of the binned sample chroma
before calculating hue bin metrics.
:vf_bin_labels:
| see :bin_labels:
| Set VF model hue-bin labels.
:plot_CF:
| False, optional
| Plot circle fields.
:plot_VF:
| True, optional
| Plot vector fields.
:plot_SF:
| True, optional
| Plot sample shifts.
Returns:
:returns:
| (data,
| [plt.gcf(),ax_spd, ax_CVG, ax_locC, ax_locH, ax_VF],
| cmap )
|
| :data: dict with color rendering data
| with keys:
| - 'SPD' : ndarray test SPDs
| - 'bjabt': ndarray with binned jab data under test SPDs
| - 'bjabr': ndarray with binned jab data under reference SPDs
| - 'cct' : ndarray with CCT of test SPD
| - 'duv' : ndarray with distance to blackbody locus of test SPD
| - 'Rf' : ndarray with general color fidelity indices
| - 'Rg' : ndarray with gamut area indices
| - 'Rfi' : ndarray with specific color fidelity indices
| - 'Rfhi' : ndarray with local (hue binned) fidelity indices
| - 'Rcshi': ndarray with local chroma shifts indices
| - 'Rhshi': ndarray with local hue shifts indices
| - 'Rt' : ndarray with general metameric uncertainty index Rt
| - 'Rti' : ndarray with specific metameric uncertainty indices Rti
| - 'Rfhi_vf' : ndarray with local (hue binned) fidelity indices
| obtained from VF model predictions at color space
| pixel coordinates
| - 'Rcshi_vf': ndarray with local chroma shifts indices
| (same as above)
| - 'Rhshi_vf': ndarray with local hue shifts indices
| (same as above)
|
| :[...]: list with handles to current figure and 5 axes.
|
| :cmap: list with rgb colors for hue bins
(for use in other plotting fcns)
"""
if not isinstance(data,dict):
data = spd_to_ies_tm30_metrics(data, cri_type = cri_type, hbins = hbins, start_hue = start_hue, scalef = scalef, vf_model_type = vf_model_type, vf_pcolorshift = vf_pcolorshift, scale_vf_chroma_to_sample_chroma = scale_vf_chroma_to_sample_chroma)
Rcshi, Rf, Rfchhi_vf, Rfhi, Rfhi_vf, Rfhshi_vf, Rfi, Rg, Rhshi, Rt, Rti, SPD, bjabr, bjabt, cct, cri_type, dataVF, duv = [data[x] for x in sorted(data.keys())]
hbins = cri_type['rg_pars']['nhbins']
start_hue = cri_type['rg_pars']['start_hue']
scalef = cri_type['rg_pars']['normalized_chroma_ref']
#layout = np.array([[3,3,0,0],[1,0,2,2],[0,0,2,1],[2,2,1,1],[0,2,1,1],[1,2,1,1]])
#layout = np.array([[6,6,0,0],[0,3,3,3],[3,3,3,3],[0,0,3,2],[2,2,2,2],[2,0,2,2],[4,0,2,2]])
layout = np.array([[6,7,0,0],[0,4,3,3],[3,4,3,3],[0,0,4,2],[2,0,2,2],[4,2,2,2],[4,0,2,2],[2,2,2,2]])
def create_subplot(layout,n, polar = False, frameon = True):
ax = plt.subplot2grid(layout[0,0:2], layout[n,0:2], colspan = layout[n,2], rowspan = layout[n,3], polar = polar, frameon = frameon)
return ax
for i in range(cct.shape[0]):
fig = plt.figure(figsize=(10, 6), dpi=144)
# Plot CVG:
ax_CVG = create_subplot(layout,1, polar = True, frameon = False)
figCVG, ax, cmap = plot_ColorVectorGraphic(bjabt[...,i,:], bjabr[...,i,:], hbins = hbins, axtype = axtype, ax = ax_CVG, plot_center_lines = plot_center_lines, plot_edge_lines = plot_edge_lines, plot_bin_colors = plot_bin_colors, scalef = scalef, force_CVG_layout = force_CVG_layout, bin_labels = '#')
# Plot VF:
ax_VF = create_subplot(layout,2, polar = True, frameon = False)
if i == 0:
hbin_cmap = None
ax_VF, hbin_cmap = plot_VF_PX_models([dataVF[i]], dataPX = None, plot_VF = plot_VF, plot_PX = None, axtype = 'polar', ax = ax_VF, \
plot_circle_field = plot_CF, plot_sample_shifts = plot_SF, plot_bin_colors = vf_plot_bin_colors, \
plot_samples_shifts_at_pixel_center = False, jabp_sampled = None, \
plot_VF_colors = [vf_color], plot_PX_colors = ['r'], hbin_cmap = hbin_cmap, force_CVG_layout = True, bin_labels = vf_bin_labels)
# Plot test SPD:
ax_spd = create_subplot(layout,3)
ax_spd.plot(SPD[0],SPD[i+1]/SPD[i+1].max(),'r-')
ax_spd.text(730,0.9,'CCT = {:1.0f} K'.format(cct[i][0]),fontsize = 9, horizontalalignment='left',verticalalignment='center',rotation = 0, color = np.array([1,1,1])*0.3)
ax_spd.text(730,0.8,'Duv = {:1.4f}'.format(duv[i][0]),fontsize = 9, horizontalalignment='left',verticalalignment='center',rotation = 0, color = np.array([1,1,1])*0.3)
ax_spd.text(730,0.7,'IES Rf = {:1.0f}'.format(Rf[:,i][0]),fontsize = 9, horizontalalignment='left',verticalalignment='center',rotation = 0, color = np.array([1,1,1])*0.3)
ax_spd.text(730,0.6,'IES Rg = {:1.0f}'.format(Rg[:,i][0]),fontsize = 9, horizontalalignment='left',verticalalignment='center',rotation = 0, color = np.array([1,1,1])*0.3)
ax_spd.text(730,0.5,'Rt = {:1.0f}'.format(Rt[:,i][0]),fontsize = 9, horizontalalignment='left',verticalalignment='center',rotation = 0, color = np.array([1,1,1])*0.3)
ax_spd.set_xlabel('Wavelength (nm)', fontsize = 9)
ax_spd.set_ylabel('Rel. spectral intensity', fontsize = 9)
ax_spd.set_xlim([360,830])
# Plot local color fidelity, Rfhi:
ax_Rfi = create_subplot(layout,4)
for j in range(hbins):
ax_Rfi.bar(range(hbins)[j],Rfhi[j,i], color = cmap[j], width = 1,edgecolor = 'k', alpha = 0.4)
ax_Rfi.text(range(hbins)[j],Rfhi[j,i]*1.1, '{:1.0f}'.format(Rfhi[j,i]) ,fontsize = 9,horizontalalignment='center',verticalalignment='center',color = np.array([1,1,1])*0.3)
ax_Rfi.set_ylim([0,120])
xticks = np.arange(hbins)
xtickslabels = ['{:1.0f}'.format(ii+1) for ii in range(hbins)]
ax_Rfi.set_xticks(xticks)
ax_Rfi.set_xticklabels(xtickslabels, fontsize = 8)
ax_Rfi.set_ylabel(r'Local color fidelity $R_{f,hi}$')
ax_Rfi.set_xlabel('Hue bin #')
# Plot local chroma shift, Rcshi:
ax_locC = create_subplot(layout,5)
for j in range(hbins):
ax_locC.bar(range(hbins)[j],Rcshi[j,i], color = cmap[j], width = 1,edgecolor = 'k', alpha = 0.4)
ax_locC.text(range(hbins)[j],-np.sign(Rcshi[j,i])*0.1, '{:1.0f}%'.format(100*Rcshi[j,i]) ,fontsize = 9,horizontalalignment='center',verticalalignment='center',rotation = 90, color = np.array([1,1,1])*0.3)
ylim = np.array([np.abs(Rcshi.min()),np.abs(Rcshi.min()),0.2]).max()*1.5
ax_locC.set_ylim([-ylim,ylim])
ax_locC.set_ylabel(r'Local chroma shift, $R_{cs,hi}$')
ax_locC.set_xticklabels([])
ax_locC.set_yticklabels(['{:1.2f}'.format(ii) for ii in ax_locC.set_ylim()], color = 'white')
# Plot local hue shift, Rhshi:
ax_locH = create_subplot(layout,6)
for j in range(hbins):
ax_locH.bar(range(hbins)[j],Rhshi[j,i], color = cmap[j], width = 1,edgecolor = 'k', alpha = 0.4)
ax_locH.text(range(hbins)[j],-np.sign(Rhshi[j,i])*0.2, '{:1.3f}'.format(Rhshi[j,i]) ,fontsize = 9,horizontalalignment='center',verticalalignment='center',rotation = 90, color = np.array([1,1,1])*0.3)
ylim = np.array([np.abs(Rhshi.min()),np.abs(Rhshi.min()),0.2]).max()*1.5
ax_locH.set_ylim([-ylim,ylim])
ax_locH.set_ylabel(r'Local hue shift, $R_{hs,hi}$')
ax_locH.set_xticklabels([])
ax_locH.set_yticklabels(['{:1.2f}'.format(ii) for ii in ax_locH.set_ylim()], color = 'white')
# Plot local color fidelity of VF, vfRfhi:
ax_vfRfi = create_subplot(layout,7)
for j in range(hbins):
ax_vfRfi.bar(range(hbins)[j],Rfhi_vf[j,i], color = cmap[j], width = 1,edgecolor = 'k', alpha = 0.4)
ax_vfRfi.text(range(hbins)[j],Rfhi_vf[j,i]*1.1, '{:1.0f}'.format(Rfhi_vf[j,i]) ,fontsize = 9,horizontalalignment='center',verticalalignment='center',color = np.array([1,1,1])*0.3)
ax_vfRfi.set_ylim([0,120])
xticks = np.arange(hbins)
xtickslabels = ['{:1.0f}'.format(ii+1) for ii in range(hbins)]
ax_vfRfi.set_xticks(xticks)
ax_vfRfi.set_xticklabels(xtickslabels, fontsize = 8)
ax_vfRfi.set_ylabel(r'Local VF color fidelity $vfR_{f,hi}$')
ax_vfRfi.set_xlabel('Hue bin #')
plt.tight_layout()
return data, [plt.gcf(),ax_spd, ax_CVG, ax_locC, ax_locH, ax_VF], cmap
def plot_ColorVectorGraphic(jabt, jabr, hbins = 16, start_hue = 0.0, scalef = 100, \
plot_axis_labels = False, bin_labels = None, \
plot_edge_lines = True, plot_center_lines = False, \
plot_bin_colors = True, axtype = 'polar', ax = None,\
force_CVG_layout = False):
"""
Plot Color Vector Graphic (CVG).
Args:
:jabt:
| ndarray with jab data under test SPD
:jabr:
| ndarray with jab data under reference SPD
:hbins:
| 16 or ndarray with sorted hue bin centers (°), optional
:start_hue:
| 0.0, optional
:scalef:
| 100, optional
| Scale factor for graphic.
:plot_axis_labels:
| False, optional
| Turns axis ticks on/off (True/False).
:bin_labels:
| None or list[str] or '#', optional
| Plots labels at the bin center hues.
| - None: don't plot.
| - list[str]: list with str for each bin.
| (len(:bin_labels:) = :nhbins:)
| - '#': plots number.
:plot_edge_lines:
| True or False, optional
| Plot grey bin edge lines with '--'.
:plot_center_lines:
| False or True, optional
| Plot colored lines at 'center' of hue bin.
:plot_bin_colors:
| True, optional
| Colorize hue-bins.
:axtype:
| 'polar' or 'cart', optional
| Make polar or Cartesian plot.
:ax:
| None or 'new' or 'same', optional
| - None or 'new' creates new plot
| - 'same': continue plot on same axes.
| - axes handle: plot on specified axes.
:force_CVG_layout:
| False or True, optional
| True: Force plot of basis of CVG.
Returns:
:returns:
| gcf(), gca(), list with rgb colors for hue bins (for use in
other plotting fcns)
"""
# Plot basis of CVG:
figCVG, ax, cmap = plot_hue_bins(hbins=hbins,
start_hue=start_hue,
scalef=scalef,
axtype=axtype,
ax=ax,
plot_center_lines=plot_center_lines,
plot_edge_lines=plot_edge_lines,
force_CVG_layout=force_CVG_layout,
bin_labels=bin_labels,
plot_bin_colors=plot_bin_colors)
if cmap == []:
cmap = ['k' for i in range(hbins)]
if axtype == 'polar':
jabr_theta, jabr_r = math.cart2pol(jabr[..., 1:3], htype='rad')
jabt_theta, jabt_r = math.cart2pol(jabt[..., 1:3], htype='rad')
#ax.quiver(jabrtheta,jabr_r,jabt[...,1]-jabr[...,1], jabt[...,2]-jabr_binned[...,2], color = 'k', headlength=3, angles='uv', scale_units='y', scale = 2,linewidth = 0.5)
ax.plot(jabt_theta, jabt_r, color='grey', linewidth=2)
for j in range(hbins):
c = cmap[j]
ax.quiver(jabr_theta[j],
jabr_r[j],
jabt[j, 1] - jabr[j, 1],
jabt[j, 2] - jabr[j, 2],
edgecolor='k',
facecolor=c,
headlength=3,
angles='uv',
scale_units='y',
scale=2,
linewidth=0.5)
else:
#ax.quiver(jabr[...,1],jabr[...,2],jabt[...,1]-jabr[...,1], jabt[...,2]-jabr[...,2], color = 'k', headlength=3, angles='uv', scale_units='xy', scale = 1,linewidth = 0.5)
ax.plot(jabt, jabt, color='grey', linewidth=2)
for j in range(hbins):
ax.quiver(jabr[j, 1],
jabr[j, 2],
jabt[j, 1] - jabr[j, 1],
jabt[j, 2] - jabr[j, 2],
color=cmap[j],
headlength=3,
angles='uv',
scale_units='xy',
scale=1,
linewidth=0.5)
if axtype == 'cart':
plt.xlabel("a'")
plt.ylabel("b'")
return plt.gcf(), plt.gca(), cmap
def plot_hue_bins(hbins = 16, start_hue = 0.0, scalef = 100, \
plot_axis_labels = False, bin_labels = '#', plot_edge_lines = True, \
plot_center_lines = False, plot_bin_colors = True, \
axtype = 'polar', ax = None, force_CVG_layout = False):
"""
Makes basis plot for Color Vector Graphic (CVG).
Args:
:hbins:
| 16 or ndarray with sorted hue bin centers (°), optional
:start_hue:
| 0.0, optional
:scalef:
| 100, optional
| Scale factor for graphic.
:plot_axis_labels:
| False, optional
| Turns axis ticks on/off (True/False).
:bin_labels:
| None or list[str] or '#', optional
| Plots labels at the bin center hues.
| - None: don't plot.
| - list[str]: list with str for each bin.
| (len(:bin_labels:) = :nhbins:)
| - '#': plots number.
:plot_edge_lines:
| True or False, optional
| Plot grey bin edge lines with '--'.
:plot_center_lines:
| False or True, optional
| Plot colored lines at 'center' of hue bin.
:plot_bin_colors:
| True, optional
| Colorize hue bins.
:axtype:
| 'polar' or 'cart', optional
| Make polar or Cartesian plot.
:ax:
| None or 'new' or 'same', optional
| - None or 'new' creates new plot
| - 'same': continue plot on same axes.
| - axes handle: plot on specified axes.
:force_CVG_layout:
| False or True, optional
| True: Force plot of basis of CVG on first encounter.
Returns:
:returns:
| gcf(), gca(), list with rgb colors for hue bins (for use in
other plotting fcns)
"""
# Setup hbincenters and hsv_hues:
if isinstance(hbins, float) | isinstance(hbins, int):
nhbins = hbins
dhbins = 360 / (nhbins) # hue bin width
hbincenters = np.arange(start_hue + dhbins / 2, 360, dhbins)
hbincenters = np.sort(hbincenters)
else:
hbincenters = hbins
idx = np.argsort(hbincenters)
if isinstance(bin_labels, list) | isinstance(bin_labels, np.ndarray):
bin_labels = bin_labels[idx]
hbincenters = hbincenters[idx]
nhbins = hbincenters.shape[0]
hbincenters = hbincenters * np.pi / 180
# Setup hbin labels:
if bin_labels is '#':
bin_labels = ['#{:1.0f}'.format(i + 1) for i in range(nhbins)]
# initializing the figure
cmap = None
if (ax == None) or (ax == 'new'):
fig = plt.figure()
newfig = True
else:
newfig = False
rect = [0.1, 0.1, 0.8,
0.8] # setting the axis limits in [left, bottom, width, height]
if axtype == 'polar':
# the polar axis:
if newfig == True:
ax = fig.add_axes(rect, polar=True, frameon=False)
else:
#cartesian axis:
if newfig == True:
ax = fig.add_axes(rect)
if (newfig == True) | (force_CVG_layout == True):
# Calculate hue-bin boundaries:
r = np.vstack(
(np.zeros(hbincenters.shape), scalef * np.ones(hbincenters.shape)))
theta = np.vstack((np.zeros(hbincenters.shape), hbincenters))
#t = hbincenters.copy()
dU = np.roll(hbincenters.copy(), -1)
dL = np.roll(hbincenters.copy(), 1)
dtU = dU - hbincenters
dtL = hbincenters - dL
dtU[dtU < 0] = dtU[dtU < 0] + 2 * np.pi
dtL[dtL < 0] = dtL[dtL < 0] + 2 * np.pi
dL = hbincenters - dtL / 2
dU = hbincenters + dtU / 2
dt = (dU - dL)
dM = dL + dt / 2
# Setup color for plotting hue bins:
hsv_hues = hbincenters - 30 * np.pi / 180
hsv_hues = hsv_hues / hsv_hues.max()
edges = np.vstack(
(np.zeros(hbincenters.shape), dL)) # setup hue bin edges array
if axtype == 'cart':
if plot_center_lines == True:
hx = r * np.cos(theta)
hy = r * np.sin(theta)
if bin_labels is not None:
hxv = np.vstack((np.zeros(hbincenters.shape),
1.3 * scalef * np.cos(hbincenters)))
hyv = np.vstack((np.zeros(hbincenters.shape),
1.3 * scalef * np.sin(hbincenters)))
if plot_edge_lines == True:
hxe = np.vstack(
(np.zeros(hbincenters.shape), 1.2 * scalef * np.cos(dL)))
hye = np.vstack(
(np.zeros(hbincenters.shape), 1.2 * scalef * np.sin(dL)))
# Plot hue-bins:
for i in range(nhbins):
# Create color from hue angle:
c = np.abs(np.array(colorsys.hsv_to_rgb(hsv_hues[i], 0.84, 0.9)))
#c = [abs(c[0]),abs(c[1]),abs(c[2])] # ensure all positive elements
if i == 0:
cmap = [c]
else:
cmap.append(c)
if axtype == 'polar':
if plot_edge_lines == True:
ax.plot(edges[:, i],
r[:, i] * 1.2,
color='grey',
marker='None',
linestyle=':',
linewidth=3,
markersize=2)
if plot_center_lines == True:
if np.mod(i, 2) == 1:
ax.plot(theta[:, i],
r[:, i],
color=c,
marker=None,
linestyle='--',
linewidth=2)
else:
ax.plot(theta[:, i],
r[:, i],
color=c,
marker='o',
linestyle='-',
linewidth=3,
markersize=10)
if plot_bin_colors == True:
bar = ax.bar(dM[i],
r[1, i],
width=dt[i],
color=c,
alpha=0.15)
if bin_labels is not None:
ax.text(hbincenters[i],
1.3 * scalef,
bin_labels[i],
fontsize=12,
horizontalalignment='center',
verticalalignment='center',
color=np.array([1, 1, 1]) * 0.3)
if plot_axis_labels == False:
ax.set_xticklabels([])
ax.set_yticklabels([])
else:
if plot_edge_lines == True:
ax.plot(hxe[:, i],
hye[:, i],
color='grey',
marker='None',
linestyle=':',
linewidth=3,
markersize=2)
if plot_center_lines == True:
if np.mod(i, 2) == 1:
ax.plot(hx[:, i],
hy[:, i],
color=c,
marker=None,
linestyle='--',
linewidth=2)
else:
ax.plot(hx[:, i],
hy[:, i],
color=c,
marker='o',
linestyle='-',
linewidth=3,
markersize=10)
if bin_labels is not None:
ax.text(hxv[1, i],
hyv[1, i],
bin_labels[i],
fontsize=12,
horizontalalignment='center',
verticalalignment='center',
color=np.array([1, 1, 1]) * 0.3)
ax.axis(1.1 * np.array(
[hxv.min(), hxv.max(),
hyv.min(), hyv.max()]))
if plot_axis_labels == False:
ax.set_xticklabels([])
ax.set_yticklabels([])
else:
plt.xlabel("a'")
plt.ylabel("b'")
plt.plot(0, 0, color='k', marker='o', linestyle=None)
return plt.gcf(), plt.gca(), cmap
def demo_opt(f, args=(), xrange=None, options={}):
"""
DEMO_OPT: Multi-objective optimization using the DEMO
This function uses the Differential Evolution for Multi-objective
Optimization (a.k.a. DEMO) to solve a multi-objective problem. The
result is a set of nondominated points that are (hopefully) very close
to the true Pareto front.
Args:
:f:
| handle to objective function.
| The output must be, for each point, a column vector of size m x 1,
| with m > 1 the number of objectives.
:args: (), optional
| Input arguments required for f.
:xrange: None, optional
| ndarray with lower and upperbounds.
| If n is the dimension, it will be a n x 2 matrix, such that the
| first column contains the lower bounds,
| and the second, the upper bounds.
| None defaults to no bounds ( [-Inf, Inf] ndarray).
:options:
| None, optional
| dict with internal parameters of the algorithm.
| None initializes default values.
| keys:
| - 'F': the scale factor to be used in the mutation (default: 0.5);
| - 'CR': the crossover factor used in the recombination (def.: 0.3);
| - 'mu': the population size (number of individuals) (def.: 100);
| - 'kmax': maximum number of iterations (def.: 300);
| - 'display': 'on' to display the population while the algorithm is
| being executed, and 'off' to not (default: 'off');
| If any of the parameters is not set, the default ones are used
| instead.
Returns: fopt, xopt
:fopt: the m x mu_opt ndarray with the mu_opt best objectives
:xopt: the n x mu_opt ndarray with the mu_opt best individuals
"""
# Initialize the parameters of the algorithm with values contained in dict:
options = init_options(options=options)
# Initial considerations
n = xrange.shape[0] #dimension of the problem
P = {'x': np.random.rand(n, options['mu'])} #initial decision variables
P['f'] = fobjeval(f, P['x'], args,
xrange) #evaluates the initial population
m = P['f'].shape[0] #number of objectives
k = 0 #iterations counter
# Beginning of the main loop
Pfirst = P.copy()
axh = None
while (k <= options['kmax']):
# Plot the current population (if desired):
if options['display'] == True:
if (k == 0) & (m < 4):
fig = plt.gcf()
fig.show()
fig.canvas.draw()
if m == 2:
# fig = plt.figure()
axh = plt.axes()
plt.plot(P['f'][0], P['f'][1], 'o')
plt.title('Objective values during the execution')
plt.xlabel('f_1')
plt.ylabel('f_2')
fig.canvas.draw()
del axh.lines[0]
elif m == 3:
# fig = plt.figure()
axh = plt.axes(projection='3d')
# print(P['f'])
axh.plot3D(P['f'][0], P['f'][1], P['f'][2], 'o')
plt.title('Objective values during the execution')
axh.set_xlabel('f_1')
axh.set_ylabel('f_2')
axh.set_zlabel('f_3')
fig.canvas.draw()
plt.pause(0.01)
del axh.lines[0]
# Perform the variation operation (mutation and recombination):
O = {'x': mutation(P['x'], options)} #mutation
O['x'] = recombination(P['x'].copy(), O['x'], options) #recombination
O['x'] = repair(
O['x']) #assure the offspring do not cross the search limits
O['f'] = fobjeval(f, O['x'], args,
xrange) #compute objective functions
# Selection and updates
P = selection(P, O, options)
print('Iteration #{:1.0f} of {:1.0f}'.format(k, options['kmax']))
k += 1
# Return the final population:
# First, unnormalize it
Xmin = xrange[:,
0][:,
None] # * np.ones(options['mu']) #replicate lower bound
Xmax = xrange[:,
1][:,
None] # * np.ones(options['mu']) #replicate upper limit
Xun = (Xmax - Xmin) * P['x'] + Xmin
# Then, return the nondominated front:
ispar = ndset(P['f'])
fopt = P['f'][:, ispar]
xopt = Xun[:, ispar]
return fopt, xopt