def plot_results(training_details, validation_details, note=None):
"""
Generates a combined training/validation graph.
"""
print "\tPlotting results..."
fig, ax1 = plt.subplots()
ax1.plot(training_details["iters"], training_details["loss"], "b-")
ax1.set_xlabel("Iterations")
ax1.set_ylabel("Training Loss", color="b")
for tl in ax1.get_yticklabels():
tl.set_color("b")
ax2 = ax1.twinx()
ax2.plot(validation_details["iters"], validation_details["loss"], "r-")
ax2.set_ylabel("Validation Loss", color="r")
for tl in ax2.get_yticklabels():
tl.set_color("r")
legend_font = FontProperties()
legend_font.set_size("small")
blue_line = mpatches.Patch(color="blue", label="Training Loss")
red_line = mpatches.Patch(color="red", label="Validation Loss")
plt.legend(handles=[blue_line, red_line], prop=legend_font, loc="lower right")
plt.suptitle("Iterations vs. Training/Validation Loss", fontsize=14)
plt.title(get_hyperparameter_details(note), style="italic", fontsize=12)
plt.savefig(constants.OUTPUT_GRAPH_PATH)
print("\t\tGraph saved to %s" % constants.OUTPUT_GRAPH_PATH)
def make_overview_plot(filename, title, noip_arrs, ip_arrs):
plt.title("Inner parallelism - " + title)
plt.ylabel('Time (ms)', fontsize=12)
x = 0
barwidth = 0.5
bargroupspacing = 1.5
for z in zip(noip_arrs, ip_arrs):
noip,ip = z
noip_mean,noip_conf = conf_stats(noip)
ip_mean,ip_conf = conf_stats(ip)
b_noip = plt.bar(x, noip_mean, barwidth, color='r', yerr=noip_conf, ecolor='black', alpha=0.7)
x += barwidth
b_ip = plt.bar(x, ip_mean, barwidth, color='b', yerr=ip_conf, ecolor='black', alpha=0.7)
x += bargroupspacing
plt.xticks([0.5, 2.5, 4.5], ['50k', '100k', '200k'], rotation='horizontal')
fontP = FontProperties()
fontP.set_size('small')
plt.legend([b_noip, b_ip], \
('no inner parallelism', 'inner parallelism'), \
prop=fontP, loc='upper center', bbox_to_anchor=(0.5, -0.05), fancybox=True, shadow=True, ncol=2)
plt.ylim([0,62000])
plt.savefig(output_file(filename))
plt.clf()
def frequency_plots(filename, xs_list, normalize=False, color='b', labels=['Plot1'], title=None, ylim=None, xlim=None, xlabel=None, ylabel=None):
'''Take lists of lists of values, create multiple frequency tables and plot multiple lines'''
ccolors = colors(len(xs_list))
plt.clf()
plt.figure().set_size_inches(25,15)
ax = plt.subplot(111)
for i, xs in enumerate(xs_list):
dik = Counter(xs)
if normalize:
diksum = sum(dik.values())
dik = {k:float(v)/diksum for k,v in dik.iteritems()}
dicty = zip(*sorted(dik.iteritems()))
ax.plot(dicty[0], dicty[1], color=ccolors[i], label=labels[i])
ax.scatter(max(dik, key=dik.get), dik[max(dik, key=dik.get)], color=ccolors[i])
if xlabel:
ax.xlabel(xlabel)
if ylabel:
ax.ylabel(ylabel)
if ylim:
plt.ylim(ylim)
else:
plt.ylim(ymin=0)
if xlim:
plt.xlim(xlim)
if title:
plt.title(title)
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])
from matplotlib.font_manager import FontProperties
fontP = FontProperties()
fontP.set_size('small')
ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop=fontP)
plt.savefig('%s' % filename)
def legend(labels, ax=None, im=None, handles=None, bbox=None,
loc='upper center', ncol=None):
"""Adds legend to plot.
"""
if ax == None:
ax = pylab.gca()
fontP = FontProperties()
fontP.set_size('small')
#
if bbox == None:
bbox = (0.5, -0.05)
if ncol == None:
ncol = int(round(len(labels)/2))
if im == None:
if handles == None:
ax.legend(labels, loc=loc, bbox_to_anchor=bbox,
ncol=ncol, prop=fontP)
else:
ax.legend(handles, labels, loc=loc, bbox_to_anchor=bbox,
ncol=ncol, prop=fontP)
else:
_proxy, _legend = [], []
for lc, pc in zip(labels, im.collections):
if lc != None:
_proxy.append(pylab.Rectangle((0, 0), 1, 1,
fc=pc.get_facecolor()[0], hatch=pc.get_hatch()))
_legend.append(lc)
ax.legend(_proxy, _legend, loc='upper center',
bbox_to_anchor=bbox, ncol=int(round(len(labels)/2)),
prop=fontP)
#
return
def plot_np_simple(x_labels, x_values_np, y_values_np, x_label, y_label, title, nb_x_labels, style):
x = np.arange(len(y_values_np))
fig, ax = plt.subplots()
if style != None:
ax.plot(x_values_np, y_values_np, style)
else:
ax.plot(x_values_np, y_values_np)
plt.xlabel(x_label)
plt.ylabel(y_label)
plt.title(title)
fontP = FontProperties()
fontP.set_size('small')
plt.legend(loc='lower right', prop=fontP)
if x_labels != None:
labels = np.array(x_labels)
jump_step = len(labels)/nb_x_labels
label_indexes = np.arange(1,len(labels),jump_step)
for (X, Z) in zip(x[label_indexes], labels[label_indexes]):
ax.annotate('{}'.format(Z), xy=(X,0), xytext=(X, (-0.1*y_max)), rotation=90, ha='center', size=10,
textcoords='data')
fig.tight_layout(pad=4)
plt.draw()
def make_legend(labels, colors, output_file):
""" Hack to generate a legend as a separate image. A dummy plot
is created in one figure, and its legend gets saved to an
output file.
Inputs:
labels - text labels for the legend
colors - list of colors for the legend (same length as labels)
output_file - filename for the resulting output figure
Outputs:
(None - output figure is written to output_file)
"""
if len(labels) != len(colors):
raise ValueError("Lists of labels and colors "
" should have the same length")
fig = plt.figure()
font_prop = FontProperties()
font_prop.set_size('xx-large')
font_prop.set_family('sans-serif')
seperate_legend = plt.figure(figsize=(5, 3.5))
ax = fig.add_subplot(111)
N = len(labels)
# Make a dummy pie chart so we can steal its legend
wedges, texts = ax.pie([100/N]*N, colors=colors)
seperate_legend.legend(wedges, labels, 'center',
prop=font_prop, frameon=False)
seperate_legend.savefig(output_file)
def plot_all(wells, errors=None, do_legend=True, legend_position=0.8):
"""Plots all of the timecourses in the dict.
Parameters
----------
wells : dict of timecourse data of the type returned by read_wallac.
"""
for wellname, wellval in wells.iteritems():
if errors is None:
plot(wellval[TIME], wellval[VALUE], label=wellname)
else:
errorbar(wellval[TIME], wellval[VALUE],
yerr=errors[wellname][VALUE], label=wellname)
# Label the axes and add a legend
xlabel('Time') # TODO: automatically determine seconds or minutes, etc.
ylabel('Value')
if do_legend:
fontP = FontProperties()
fontP.set_size('small')
ax = gca()
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * legend_position,
box.height])
legend(loc='upper left', prop=fontP, ncol=1, bbox_to_anchor=(1, 1),
fancybox=True, shadow=True)
def grafico(dicionario, info):
fontP = FontProperties()
fontP.set_size("small")
marcadores = ["+", ".", "o", "*", "p", "s", "x", "D", "h"]
eixo_y = []
eixo_x = range(1, 9)
nome_bairro = []
legendas = []
for i in dicionario.items():
eixo_y.append(i[1])
nome_bairro.append(i[0])
for i in nome_bairro:
legendas.append(info[i[6:]])
for i in range(len(eixo_x)):
plt.plot(eixo_x, eixo_y[i], label=legendas[i])
plt.ylabel("numero de roubos")
plt.xlabel("meses")
art = []
lgd = plt.legend(loc=9, bbox_to_anchor=(0.5, -0.1), ncol=2, prop=fontP)
art.append(lgd)
plt.savefig("grafico_roubos2015.png", additional_artists=art, bbox_inches="tight")
def plot_gradient_over_time(points, get_grad_over_time):
fig = plt.figure(figsize=(6.5, 4))
# Remove the plot frame lines. They are unnecessary chartjunk.
ax = plt.subplot(111)
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)
# ax.xaxis.set_major_locator(plt.MultipleLocator(1.0))
# ax.xaxis.set_minor_locator(plt.MultipleLocator(0.1))
# ax.yaxis.set_major_locator(plt.MultipleLocator(1.0))
# ax.yaxis.set_minor_locator(plt.MultipleLocator(0.1))
# ax.grid(which='major', axis='x', linewidth=0.75, linestyle='-', color='0.75')
# ax.grid(which='minor', axis='x', linewidth=0.25, linestyle='-', color='0.75')
# ax.grid(which='major', axis='y', linewidth=0.75, linestyle='-', color='0.75')
# ax.grid(which='minor', axis='y', linewidth=0.25, linestyle='-', color='0.75')
ax.grid(b=True, which='major', linewidth=0.75, linestyle=':', color='0.75')
ax.yaxis.set_ticks_position('none')
ax.xaxis.set_ticks_position('none')
for wx, wRec, c in points:
grad_over_time = get_grad_over_time(wx, wRec)
x = np.arange(1, grad_over_time.shape[1]+1, 1)
plt.plot(x, np.sum(grad_over_time, axis=0), c+'.-', label='({0}, {1})'.format(wx, wRec), linewidth=1, markersize=8)
plt.xlim(1, grad_over_time.shape[1])
plt.xticks(x)
plt.gca().invert_xaxis()
plt.yscale('symlog')
plt.yticks([10**8, 10**6, 10**4, 10**2, 0, -10**2, -10**4, -10**6, -10**8])
plt.xlabel('time k')
plt.ylabel('gradient ')
plt.title('Unstability of gradient in backward propagation.\n(backpropagate from left to right)')
leg = plt.legend(loc='center left', bbox_to_anchor=(1, 0.5), frameon=False, numpoints=1)
leg_font = FontProperties()
leg_font.set_size('x-large')
leg.set_title('$(w_x, w_{rec})$', prop=leg_font)
def _get_3d_plot(self, label_stable=True):
"""
Shows the plot using pylab. Usually I won"t do imports in methods,
but since plotting is a fairly expensive library to load and not all
machines have matplotlib installed, I have done it this way.
"""
import matplotlib.pyplot as plt
import mpl_toolkits.mplot3d.axes3d as p3
from matplotlib.font_manager import FontProperties
fig = plt.figure()
ax = p3.Axes3D(fig)
font = FontProperties()
font.set_weight("bold")
font.set_size(20)
(lines, labels, unstable) = self.pd_plot_data
count = 1
newlabels = list()
for x, y, z in lines:
ax.plot(x, y, z, "bo-", linewidth=3, markeredgecolor="b", markerfacecolor="r", markersize=10)
for coords in sorted(labels.keys()):
entry = labels[coords]
label = entry.name
if label_stable:
if len(entry.composition.elements) == 1:
ax.text(coords[0], coords[1], coords[2], label)
else:
ax.text(coords[0], coords[1], coords[2], str(count))
newlabels.append("{} : {}".format(count, latexify(label)))
count += 1
plt.figtext(0.01, 0.01, "\n".join(newlabels))
ax.axis("off")
return plt
def _show_3d_plot(self):
'''
Shows the plot using pylab. Usually I won't do imports in methods,
but since plotting is a fairly expensive library to load and not all
machines have matplotlib installed, I have done it this way.
'''
import matplotlib.pyplot as plt
import mpl_toolkits.mplot3d.axes3d as p3
from matplotlib.font_manager import FontProperties
fig = plt.figure()
ax = p3.Axes3D(fig)
font = FontProperties()
font.set_weight('bold')
font.set_size(20)
(lines, labels, unstable) = self.pd_plot_data
count = 1
newlabels = list()
for x, y, z in lines:
ax.plot(x, y, z, 'bo-', linewidth=3, markeredgecolor='b', markerfacecolor='r', markersize=10)
for coords in sorted(labels.keys()):
entry = labels[coords]
label = entry.name
if len(entry.composition.elements) == 1:
# commented out options are only for matplotlib 1.0. Removed them so that most ppl can use this class.
ax.text(coords[0], coords[1], coords[2], label)#, horizontalalignment=halign, verticalalignment=valign, fontproperties=font)
else:
ax.text(coords[0], coords[1], coords[2], str(count))#, horizontalalignment=halign, verticalalignment=valign, fontproperties=font)
newlabels.append(str(count) + " : " + label)
count += 1
plt.figtext(0.01, 0.01, '\n'.join(newlabels))
ax.axis('off')
plt.show()
def bargraph(self):
ind = np.arange(int(self.count))
width = 0.25
data = reportDB().selectSql(self.LATE_FIVE_SQL)
errorsList = tuple(error[0] for error in data)[::-1]
passedList = tuple(right[1] for right in data)[::-1]
failedList = tuple(fail[2] for fail in data)[::-1]
startTime = tuple(runtime[3] for runtime in data)[::-1]
fig, ax = plt.subplots()
ax.set_ylabel(u'个数')
ax.set_title(u'最近%s次测试结果柱状图' % self.count)
ax.set_xticks(ind+width)
ax.set_xticklabels(startTime,rotation=18, fontsize='small')
rectError = ax.bar(ind, errorsList, width, color='r')
rectFail = ax.bar(ind+width, failedList, width, color='y')
rectPass = ax.bar(ind+2*width, passedList, width, color='g')
fontP = FontProperties()
fontP.set_size('small')
for e_rect in rectError:
height = e_rect.get_height()
ax.text(e_rect.get_x()+e_rect.get_width()/2., 1.05*height, '%d'%int(height),
ha='center', va='bottom')
for f_rect in rectFail:
height = f_rect.get_height()
ax.text(f_rect.get_x()+f_rect.get_width()/2., 1.05*height, '%d'%int(height),
ha='center', va='bottom')
for p_rect in rectPass:
height = p_rect.get_height()
ax.text(p_rect.get_x()+p_rect.get_width()/2., 0.8*height, '%d'%int(height),
ha='center', va='bottom')
ax.legend( (rectError[0], rectPass[0], rectFail[0]), (u'错误', u'通过', u'失败'),prop = fontP)
plt.savefig('E:\\apk\huodong\\tr\\pic\\bargraph')
def create_plot(plot_title, datasets, offset, count, output_path):
x = 0
for dataset_path in datasets:
first,average,conf = statistics(dataset_path, offset, count)
b_first = plt.bar(x, first, 0.5, color='b')
x += 0.5
b_average = plt.bar(x, average, 0.5, color='r', yerr=conf, ecolor='black')
x += 1.5
plt.title("benchmark: " + plot_title)
plt.xlabel('Dataset', fontsize=12)
plt.ylabel('Time', fontsize=12)
plt.xticks([0.5, 2.5, 4.5, 6.5, 8.5], ['10', '100', '1000', '10000', '100000'], rotation='horizontal')
# Create graph legend
fontP = FontProperties()
fontP.set_size('small')
plt.legend([b_first, b_average], \
('first query time', 'average time of other queries'), \
prop=fontP, loc='upper center', bbox_to_anchor=(0.5, -0.05), fancybox=True, shadow=True, ncol=2)
# Plot to file
plt.savefig(output_path)
plt.clf()
def initGraph(self):
""" initalize graph to draw spans """
self.trial = 1
self.sbs = {}
self.sbs['Lever'] = ScatterBrain('Lever','#3399FF','o')
self.sbs['Mark'] = ScatterBrain('Mark','#000000','x')
for i in range(0,5):
name = 'aTaste%d'%i
self.sbs[name] = ScatterBrain(name,uv.TasteColors[i],'s')
name2 = 'mTaste%d'%i
self.sbs[name2] = ScatterBrain(name2,uv.TasteColors[i],'s',False)
self.figure = Figure(dpi=100,figsize=(5,5.5))
self.axes = self.figure.add_subplot(111)
print 'X.trial', X.trialDuration
self.axes.axis([0,X.trialDuration,0,1.5])
self.axes.set_xlabel('time (s)')
self.drawSpans(True)
LText = FontProperties()
LText.set_size("small")
self.axes.legend((self.sbs['Lever'].getPlot(self.axes),self.sbs['Mark'].getPlot(self.axes),
self.sbs['aTaste1'].getPlot(self.axes),self.sbs['mTaste1'].getPlot(self.axes)),
("Lever Press","Time Marked", "Reward","Manual Reward"),
prop=LText, fancybox=True, bbox_to_anchor=(0., 1.02, 1., .102), loc=1, ncol=2, mode="expand", borderaxespad=0)
self.canvas = FigureCanvas(self, -1, self.figure)
def plotProfile(plotname, data):
''' Plot a profile of the colors'''
dtc=None
if args.window:
dt=numpy.transpose(data)
for i in range(dt.shape[0]):
dt[i]=movingAverage(dt[i], args.window)
dtc=numpy.transpose(dt)
else:
dtc=data
fontP = FontProperties()
fontP.set_size('small')
fig = plt.figure()
ax = plt.subplot(111)
ax.plot(dtc)
#ax.set_xticklabels(xlabels, rotation=45, fontproperties=fontP)
#ax.set_xlabel('Image number in the series')
ax.set_ylabel('Reef colors')
box = ax.get_position()
#ax.set_position([box.x0, box.y0 + box.height * 0.1, box.width, box.height * 0.9])
#ax.set_position([box.x0, box.y0 + box.height * 0.1, box.width, box.height])
ax.set_position([box.x0, box.y0 + box.height * 0.1, box.width, box.height *0.85])
header=["blue", "green", "red"]
ax.legend((header), loc='upper center', bbox_to_anchor=(0.5, -0.10), ncol=4, prop=fontP)
fig.savefig(plotname)
def add_plot(title, plots, min_class_label, max_class_label):
colors = ["r", "y"]
place = [0, 0.35]
Utils.subplot += 1
# fig = .figure()
ax = Utils.figure.add_subplot(Utils.subplot)
Utils.figure.subplots_adjust(hspace=0.75, wspace=0.5)
ax.set_title(title)
ax.set_xticks(np.arange(8))
for i in xrange(len(plots)):
item = plots[i]
if item["xlim"] != None:
ax.set_xlim(item["xlim"])
if item["ylim"] != None:
ax.set_ylim(item["ylim"])
ax.set_xlabel(item["xlabel"])
ax.set_ylabel(item["ylabel"])
ax.bar(
np.arange(min_class_label, max_class_label + 1) + place[i],
item["y_values"],
0.35,
color=colors[i],
label=item["label"],
)
handles, labels = ax.get_legend_handles_labels()
fontP = FontProperties()
fontP.set_size("small")
Utils.figure.legend(handles, labels, loc="upper right", prop=fontP)
def plot_markers(data, x_base, name, map, xoff_sgn, width, off_fac,
markersize):
maxD = 0
ds = {}
used = []
font = FontProperties()
font.set_family('sans-serif')
font.set_size(10)
for (kind, subkind, dimval) in data:
try:
symb, lab = map[kind][subkind]
except KeyError:
raise KeyError("Invalid key for %s symbols"%name)
used.append((kind, subkind))
try:
ds[dimval] += 1
x_off = xoff_sgn*width*off_fac*(ds[dimval]-1)
except KeyError:
ds[dimval] = 1
x_off = 0
plot([x_base+x_off], [dimval], symb, markersize=markersize)
# hack tweaks
## if lab=='C':
## x_off -= width/15
if lab=='A':
x_off += width/30
text(x_base+x_off-width*.15, dimval-width*2., lab,
fontproperties=font)
if dimval > maxD:
maxD = dimval
return ds, maxD, used
def format_plot(axes, xlim=None, ylim=None, xlabel='', ylabel=''):
'''format 2d-plot black and with with times legends
'''
#-------------------------------------------------------------------
# configure the style of the font to be used for labels and ticks
#-------------------------------------------------------------------
#
from matplotlib.font_manager import FontProperties
font = FontProperties()
font.set_name('Script MT')
font.set_family('serif')
font.set_style('normal')
# font.set_size('small')
font.set_size('large')
font.set_variant('normal')
font.set_weight('medium')
if xlim != None and ylim != None:
axes.axis([0, xlim, 0., ylim], fontproperties=font)
# format ticks for plot
#
locs, labels = axes.xticks()
axes.xticks(locs, map(lambda x: "%.0f" % x, locs), fontproperties=font)
axes.xlabel(xlabel, fontproperties=font)
locs, labels = axes.yticks()
axes.yticks(locs, map(lambda x: "%.0f" % x, locs), fontproperties=font)
axes.ylabel(ylabel, fontproperties=font)
def PlotSensitivityAndPPVGraphs(sensitivityDict, ppvDict, graphTitle, xAxisTitle, index, graphFileName):
sensDremeMeanValues, sensDremeErrorValues, sensKspectrumMeanValues, sensKspectrumErrorValues, labels = parseResults.GetMeanAndStdErrorValues(sensitivityDict, index);
ppvDremeMeanValues, ppvDremeErrorValues, ppvKspectrumMeanValues, ppvKspectrumErrorValues, labels = parseResults.GetMeanAndStdErrorValues(ppvDict, index);
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
matplotlib.rcParams.update({'font.size': 8})
#Two subplots, the axes array is 1-d
fig, (ax1, ax2) = plt.subplots(nrows=2)
eb1, eb2, eb3, eb4 = sensitivity_ppv_plot(ax1, graphTitle + " on Sensitivity", sensDremeMeanValues, sensDremeErrorValues, sensKspectrumMeanValues, sensKspectrumErrorValues, labels, xAxisTitle, "Sensitivity");
eb1, eb2, eb3, eb4= sensitivity_ppv_plot(ax2, graphTitle + " on PPV", ppvDremeMeanValues, ppvDremeErrorValues, ppvKspectrumMeanValues, ppvKspectrumErrorValues, labels, xAxisTitle, "PPV");
#ax2.set_xlabel(xAxisTitle)
handles_ax1, labels_ax1 = ax1.get_legend_handles_labels();
handles_ax1 = [h[0] for h in handles_ax1];
from matplotlib.font_manager import FontProperties
fontP = FontProperties();
fontP.set_size('small');
#fig.legend([eb1, eb2, eb3, eb4], ["DREME", "k-spectrum-25", "k-spectrum-50", "k-spectrum-100"], prop = fontP)
fig.legend(handles_ax1, labels_ax1, loc = 'upper right')
plt.savefig(graphFileName);
plt.close(fig)
def plot_benchmarks(runs, out_file="output.eps", dpi=1200):
from matplotlib import pyplot as plt
from matplotlib.font_manager import FontProperties
fontP = FontProperties()
fontP.set_size("small")
lines, densities = regroup_runs(runs)
for line in lines:
method = line["method"]
condensation = line["2x2"]
ys = [line[x] for x in densities]
plt.plot(
densities,
ys,
METHOD_SHAPE[method] + COND_SHAPE[condensation],
color=METHOD_COLOR[method],
label=method + COND_LEGEND[condensation],
)
plt.xlabel("density, %")
plt.ylabel("CPU time, ms")
if "2000" not in out_file:
lgd = plt.legend(loc=2, prop=fontP)
else:
lgd = plt.legend(loc=2, bbox_to_anchor=(1, 1), prop=fontP)
plt.grid(True)
plt.savefig(out_file, bbox_extra_artists=(lgd,), bbox_inches="tight", format=out_file[-3:], dpi=dpi)
def basic_skysurvey_plot_setup(from_plane=ephem.degrees('0')):
# # EmulateApJ columnwidth=245.26 pts
# fig_width_pt = 246.0
# inches_per_pt = 1.0 / 72.27
# golden_mean = (sqrt(5.) - 1.0) / 2.0
# fig_width = fig_width_pt * inches_per_pt
# fig_height = fig_width * golden_mean * 1.5
# fig_size = [fig_width, fig_height]
fig = plt.figure()
ax = fig.add_subplot(111) # , aspect="equal")
handles = [] # this handles the creation of the legend properly at the end of plotting
labels = []
handles, labels = plot_galactic_plane(handles, labels)
# handles, labels = plot_ecliptic_plane(handles, labels)
handles, labels = plot_invariable_plane(handles, labels, from_plane)
fontP = FontProperties()
fontP.set_size('small') # make the fonts smaller
plt.xlabel('RA (deg)')
plt.ylabel('Declination (deg)')
plt.grid(True, which='both')
# plot_fanciness.remove_border(ax)
return handles, labels, ax, fontP
def graph(fil):
heap, time , free = np.loadtxt(fil, delimiter=',', unpack=True)
fig,ax1 = plt.subplots(dpi=120, figsize=(7,7))
ax2 = plt.twinx()
ax1.set_ylabel("Allocation time ($ms$)",color = 'blue')
ax1.set_xlabel("Initial heap size ($MB$)")
ax2.set_ylabel("Free space on heap ($MB$)",color = 'green')
ax2.set_xlabel("Initial heap size ($MB$)")
p1,= ax1.plot(heap,time, label='Time taken to allocate large array')
p2,= ax2.plot(heap,free , label='Free space on heap' ,color = 'green')
plt.title('Scala Fragmentation tolerance')
from matplotlib.font_manager import FontProperties
fontP = FontProperties()
fontP.set_size('small')
lines =[p1,p2]
plt.legend(lines, [l.get_label() for l in lines],prop = fontP ,loc =9)
name = fil.split('.')[0]
name = name +".png"
plt.savefig(name)
def make_cross_plot(wac_df, clm_df):
'''
x = 320/415
y = 950/750
'''
for index_name in wac_df.index:
roi_name = index_name[:-4]
x = wac_df.loc[index_name].values
y = clm_df.loc[roi_name+'_clm'].values
x_data = np.ma.masked_array(x[0],np.isnan(x[0]))
y_data = np.ma.masked_array(y[0],np.isnan(y[0]))
print roi_name, np.mean(x_data), np.mean(y_data), np.std(x_data), np.std(y_data)
plt.errorbar(np.mean(x_data), np.mean(y_data), xerr=np.std(x_data),
yerr=np.std(y_data), marker='o', label=(roi_name),
c=colorloop.next())
rois_rough = pd.read_csv('/home/sbraden/imps_ratio_rough.csv', index_col=0)
rois_mare = pd.read_csv('/home/sbraden/imps_ratio_mare.csv', index_col=0)
for roi_name in rois_rough.index:
ratio = rois_rough.loc[roi_name].values
plt.scatter(ratio[1], ratio[0], marker='s', c='blue')
for roi_name in rois_mare.index:
ratio = rois_mare.loc[roi_name].values
plt.scatter(ratio[1], ratio[0], marker='s', c='red')
fontP = FontProperties()
fontP.set_size('small')
plt.legend(loc='lower right', prop=fontP, numpoints=1)
plt.xlabel('320/415 nm WAC ratio', fontsize=14)
plt.ylabel('950/750 nm CLEM ratio', fontsize=14)
plt.savefig('lunar_roi_cross_plot.png', dpi=300)
plt.close()
def compile_scatter_plot_3d(args):
bytes = args['tp_sizes'][0]
tracers = args['tracers']
res_dir = '/home/mogeb/git/benchtrace/trace-client/'
values = defaultdict(list)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
fname = res_dir + 'none_' + str(bytes) + 'bytes_1process.hist'
with open(fname, 'r') as f:
legend = f.readline()
legend = legend.split(',')
i = 0
for tracer in tracers:
fname = res_dir + tracer + '_' + str(bytes) + 'bytes_1process.hist'
values[tracer] = np.genfromtxt(fname, delimiter=',', skip_header=1, names=legend,
dtype=None)
fontP = FontProperties()
fontP.set_size('small')
for tracer in tracers:
ax.scatter(values[tracer]['cache_misses'], values[tracer]['Instructions'],
values[tracer]['latency'])
plt.title('Latency according to cache_misses and instructions')
ax.set_xlabel('cache_misses')
ax.set_ylabel('Instructions')
ax.set_zlabel('latency')
plt.legend(prop=fontP)
plt.show()
def main():
# Write a part to put image directories into "groups"
source_dirs = [
'/home/sbraden/400mpp_15x15_clm_wac/mare/',
'/home/sbraden/400mpp_15x15_clm_wac/pyro/',
'/home/sbraden/400mpp_15x15_clm_wac/imps/',
'/home/sbraden/400mpp_15x15_clm_wac/mare_immature/'
]
for directory in source_dirs:
print directory
groupname = os.path.split(os.path.dirname(directory))[1]
print groupname
# read in LROC WAC images
wac_img_list = iglob(directory+'*_wac.cub')
# read in Clementine images
clm_img_list = iglob(directory+'*_clm.cub')
make_cloud_plot(wac_img_list, colorloop.next(), groupname)
fontP = FontProperties()
fontP.set_size('small')
#plt.legend(loc='upper left', fancybox=True, prop=fontP, scatterpoints=1)
#plt.axis([0.70, 0.86, 0.90, 1.15],fontsize=14)
plt.axis([0.60, 0.90, 0.90, 1.20],fontsize=14)
plt.axes().set_aspect('equal')
# THIS next line does not get called:
plt.margins(0.20) # 4% add "padding" to the data limits before they're autoscaled
plt.xlabel('WAC 320/415 nm', fontsize=14)
plt.ylabel('CLM 950/750 nm', fontsize=14)
plt.savefig('lunar_roi_cloud_plot.png', dpi=300)
plt.close()
def compile_scatter_plot_ICL(args):
bytes = args['tp_sizes'][0]
tracers = args['tracers']
res_dir = '/home/mogeb/git/benchtrace/trace-client/'
values = defaultdict(list)
cpi = defaultdict(list)
fname = res_dir + 'none_' + str(bytes) + 'bytes_1process.hist'
with open(fname, 'r') as f:
legend = f.readline()
legend = legend.split(',')
for tracer in tracers:
fname = res_dir + tracer + '_' + str(bytes) + 'bytes_1process.hist'
values[tracer] = np.genfromtxt(fname, delimiter=',', skip_header=1, names=legend, dtype=int)
for tracer in tracers:
for i in range(0, len(values[tracer])):
cpi[tracer].append(values[tracer]['CPU_cycles'][i] / values[tracer]['Instructions'][i])
for tracer in tracers:
plt.scatter(values[tracer]['L1_misses'], cpi[tracer], s=values[tracer]['latency']*0.8,
color=tracers_colors[tracer], alpha=0.3, label=tracer)
fontP = FontProperties()
fontP.set_size('small')
plt.title('Latency according to CPI and L1 misses')
plt.xlabel('L1_misses')
plt.ylabel('CPI')
plt.legend(prop=fontP)
plt.show()
def compile_lttng_subbuf(args):
res_dir = '/home/mogeb/git/benchtrace/trace-client/'
tp_sizes = args['tp_sizes']
nprocesses = args['nprocesses']
tracer = 'lttng'
buf_sizes_kb = args['buf_sizes_kb']
perc = 0.90
for tp_size in tp_sizes:
percentiles = []
for buf_size_kb in buf_sizes_kb:
for tp_size in tp_sizes:
# fname = res_dir + tracer + '_' + str(byte_size) + 'bytes_' + nprocess + 'process.hist'
fname = tracer + '_' + str(tp_size) + 'bytes_' + buf_size_kb\
+ 'kbsubbuf_1_process.hist'
with open(fname, 'r') as f:
legend = f.readline()
legend = legend.split(',')
values = np.genfromtxt(fname, delimiter=',', skip_header=1, names=legend, dtype=None,
invalid_raise=False)
# percentiles.append(np.percentile(values['latency'], perc))
percentiles.append(np.average(values['latency']))
plt.plot(buf_sizes_kb, percentiles, 'o-', label=tracer, color=tracers_colors[tracer])
plt.title(str(int(perc * 100)) + 'th percentiles for the cost of a tracepoint according to'
'payload size')
plt.xlabel('Subbuffer size in kb')
plt.ylabel('Time in ns')
fontP = FontProperties()
fontP.set_size('small')
# imgname = 'pertp/90th_' + nprocess + 'proc_' + str(args['buf_size_kb']) + 'subbuf_kb'
plt.legend()
plt.show()
def topic_distribution(name = None, study = None, order = None, **options):
'''Given a model p_z,p_w_z,p_d_z, we can plot the document's distribution
using p(z|d) = normalized((p(d|z)*p(z))) '''
m = microbplsa.MicrobPLSA()
m.open_model(name = name, study = study, **options) #get model from the results file
#return document's distribution
p_z_d = m.model.document_topics()
Z,N =p_z_d.shape #number of samples
if order is not None:
p_z_d = p_z_d[:,order]
n = np.arange(N)
width = 25.0/float(N) #scale width of bars by number of samples
p = [] #list of plots
colors = plt.cm.rainbow(np.linspace(0, 1, Z))
Lab = Labelling(m, ignore_continuous = False)
Lab.metadata(non_labels = ['BarcodeSequence'])
R = Lab.correlate()
labels_r = Lab.assignlabels(R,num_labels = 1)
labels, r = zip(*labels_r)
labels = [l.replace('(','\n(') for l in labels]
#sort and organize labels and topics so they are always plotted in the same order
labelsUnsorted = zipper(labels,range(0,Z))
labelsUnsorted.sort()
labels, Zrange = zip(*labelsUnsorted)
Zrange = list(Zrange)
p.append(plt.bar(n, p_z_d[Zrange[0],:], width, color=colors[0], linewidth = 0))
height = p_z_d[Zrange[0],:]
for i,z in enumerate(Zrange[1:]):
p.append(plt.bar(n, p_z_d[z,:], width, color=colors[i+1], bottom=height, linewidth = 0))
height += p_z_d[z,:]
plt.ylabel('Probability P(z|d)')
plt.xlabel('Sample')
plt.title('Sample\'s topic distribution')
#plt.xticks(np.arange(0,width/2.0,N*width), ['S'+str(n) for n in range(1,N)])
topiclegend = ['Topic' + str(Zrange[labels.index(l)]+1) + ': '+ l + '\n ('+ str(r[Zrange[labels.index(l)]]) + ')' for l in labels]
fontP = FontProperties()
if N >60:
fontP.set_size('xx-small')
else: fontP.set_size('small')
ax = plt.subplot(111)
ratio = float(N)*0.5
ax.set_aspect(ratio)
ax.tick_params(axis = 'x', colors='w') #remove tick labels by setting them the same color as background
box = ax.get_position()
ax.set_position([box.x0, box.y0, 0.5, box.height])
if order is not None:
plt.xticks(n, order, size = 'xx-small')
if Z > 12:
columns = 2
else: columns = 1
plt.legend(p, topiclegend, prop = fontP, title = 'Topic Label', loc='center left', bbox_to_anchor=(1, 0.5), ncol = columns)
return plt
def plot(X, Y, Graphs, Type, State_State):
colors = iter(cm.rainbow(np.linspace(0, 1, len(Graphs))))
if Type == 1:
XTitle = 'delta'
elif Type == 2:
XTitle = 'epsilon'
Y = Y.T
else:
print "Incorrect plot type, correct plottypes are 1 for row by columns and 2 for columns by rows."
exit()
Title = "Plot of rate " + str(State_State) + " for different values of " + XTitle
#not sure if this works
plt.figure(Title)
for x in range(len(Graphs)):
plt.plot(X, Y[x], label= str(Graphs[x]), color=next(colors))
plt.ylabel('rate')
plt.xlabel(XTitle)
plt.grid(True)
plt.title(Title)
fontP = FontProperties()
fontP.set_size('small')
plt.legend(bbox_to_anchor=(1.01, 1), loc='upper left', borderaxespad=0., prop = fontP)
FileName = 'rate_' + str(State_State) + '_' + XTitle +'.png'
plt.savefig(FileName)
def save_graph(go_dict, chart_type, level, parser):
fontP = FontProperties()
fontP.set_size('small')
# The slices will be ordered and plotted counter-clockwise.
figure = plt.figure(figsize=(10,10))
labels = go_dict.keys()
sizes = [parser.go_term_by_name_dict.get(x)[0].encountered_count for x in go_dict]
#sizes = go_dict.values()
#print (chart_type)
#print (zip(labels, sizes))
#print (sum(sizes))
plt.title('Graph Level %s Pie Chart [%s]' % (level, chart_type))
total = sum(sizes)
labels = [l+" "+str(float(s)/total * 100)[0:4]+"% ("+ str(s) + ")" for l,s in zip(labels, sizes)]
patches, texts = plt.pie(sizes, startangle=90)
plt.legend(patches, labels, prop = fontP, loc="best")
# Set aspect ratio to be equal so that pie is drawn as a circle.
plt.axis('equal')
#plt.tight_layout()
#plt.show()
print (chart_type)
out = [str(x) + "\t" + str(parser.go_term_by_name_dict.get(x)[0].encountered_count) for x in go_dict]
for x in out:
print (x)
print ("\n")
figure.savefig(chart_type+"_level_"+level+'.png',aspect='auto',dpi=100)
lw = 2.3
args = [fp_range, fp_range_val, take_log, ax1, ax2, ax3, ax4]
l1 = plot(root_path + 'olta0', args, PL1, 's', PL1, lw, '-', oluct_lo_mea)
if discrete:
l2 = plot(root_path + 'olta1', args, PL2, 's', PL2, lw, '-', oluct_lo_mea)
l3 = plot(root_path + 'olta2', args, PL3, '^', 'none', lw, '-.', oluct_lo_mea)
l4 = plot(root_path + 'olta3', args, PL4, 'o', 'none', lw, '--', oluct_lo_mea)
l5 = plot(root_path + 'olta4', args, PL5, 's', 'none', lw, '-', oluct_lo_mea)
l0 = plot(root_path + 'oluct', args, PL0, 'o', PL0, lw, '-', oluct_lo_mea)
# Label ------------------------------------------------------------------------
font = FontProperties()
font.set_family('serif')
font.set_style('normal')
font.set_size('x-large')
font.set_weight('light')
labsz = 13
xlab = 'Transition misstep probability'
ylab1 = 'Loss (time steps\nto reach all the\nwaypoints)'
ylab2 = 'Mean loss\nrelatively to\nOLUCT loss'
ylab3 = 'Computational\ncost (ms)'
ylab4 = 'Number of\ncalls'
apply_label(ax1, xlab, ylab1, font, False)
apply_label(ax2, xlab, ylab2, font, True)
apply_label(ax3, xlab, ylab3, font, False)
apply_label(ax4, xlab, ylab4, font, False)
# Legend -----------------------------------------------------------------------
def SEAMO2(transportNetwork, problem):
'''
The main algorithm - detailed description in Paper
'''
population_size, generation_count = problem.initial, problem.generations
population = generate_initial_population(transportNetwork, problem)
#objectives = ["passengers", "operator"]
objectives = ["passengers"]
gen_stats = []
best_objective = min(population, key = lambda x: x.get_scores("passengers"))
for generation in range(generation_count):
gen_stats.append(GenStat(generation, population_size))
print "new generation", generation
for parent1_index in range(population_size):
# select parent 1
parent1 = population[parent1_index]
gen_stats[-1].all_scores.append(parent1.get_scores("passengers"))
# select parent 2
parent2_index = random.randint(0, population_size - 1)
parent2 = population[parent2_index]
# generate an offspring
offspring = crossover(parent1, parent2, transportNetwork, problem)
# repair the offspring - this shouldn't be necessary
repair(offspring, transportNetwork, problem.max, problem.min)
# apply mutation - gamma ray radiation
mutate(offspring, problem.busses, problem.max, problem.min)
if len(offspring.covered) < len(offspring.transportNetwork.nodes()):
gen_stats[-1].offs_bad += 1
continue
# this is a heavy function
offspring.calc_scores()
# insert offspring into population
if offspring in population:
continue
# if offspring dominates best so far objective
if offspring.get_scores("passengers") < best_objective.get_scores("passengers"):
gen_stats[-1].offs_best_news += 1
best_objective = offspring
population[random.choice([parent1_index, parent2_index])] = offspring
# if offspring dominates either parent
elif offspring.dominates(parent1):
#print "offspring dominates parent 1"
gen_stats[-1].offs_dominates_parent += 1
population[parent1_index] = offspring
elif offspring.dominates(parent2):
#print "offspring dominates parent 2"
gen_stats[-1].offs_dominates_parent += 1
population[parent2_index] = offspring
# mutual non domination
elif not parent1.dominates(offspring) and not parent2.dominates(offspring):
for ind in range(population_size):
if offspring.dominates(population[ind]):
gen_stats[-1].offs_replace_other += 1
population[ind] = offspring
break
# just delete offspring
else:
gen_stats[-1].offs_thrown_away += 1
continue
gen_stats[-1].finalize()
datas = zip(*[stat.get_params() for stat in gen_stats])
labels = gen_stats[0].property_names
for i, data in enumerate(datas):
plt.plot(range(len(data)), data, label = labels[i], marker = 'o', linestyle = 'None')
plt.legend()
fontP = FontProperties()
fontP.set_size('small')
plt.legend(prop = fontP, bbox_to_anchor=(0.95, 1), loc='upper right', ncol=1)
plt.title('Map %s - Population size: %d, Generations: %d' % (problem.graph, population_size, generation_count))
plt.savefig(os.path.join('generating','stats.png'))
plt.clf()
return best_objective, gen_stats
class Legend(Artist):
"""
Place a legend on the axes at location loc. Labels are a
sequence of strings and loc can be a string or an integer
specifying the legend location
The location codes are::
'best' : 0, (only implemented for axis legends)
'upper right' : 1,
'upper left' : 2,
'lower left' : 3,
'lower right' : 4,
'right' : 5,
'center left' : 6,
'center right' : 7,
'lower center' : 8,
'upper center' : 9,
'center' : 10,
loc can be a tuple of the noramilzed coordinate values with
respect its parent.
Return value is a sequence of text, line instances that make
up the legend
"""
codes = {
'best': 0, # only implemented for axis legends
'upper right': 1,
'upper left': 2,
'lower left': 3,
'lower right': 4,
'right': 5,
'center left': 6,
'center right': 7,
'lower center': 8,
'upper center': 9,
'center': 10,
}
zorder = 5
def __str__(self):
return "Legend"
def __init__(
self,
parent,
handles,
labels,
loc=None,
numpoints=None, # the number of points in the legend line
markerscale=None, # the relative size of legend markers vs. original
scatterpoints=3, # TODO: may be an rcParam
scatteryoffsets=None,
prop=None, # properties for the legend texts
# the following dimensions are in axes coords
pad=None, # deprecated; use borderpad
labelsep=None, # deprecated; use labelspacing
handlelen=None, # deprecated; use handlelength
handletextsep=None, # deprecated; use handletextpad
axespad=None, # deprecated; use borderaxespad
# spacing & pad defined as a fraction of the font-size
borderpad=None, # the whitespace inside the legend border
labelspacing=None, #the vertical space between the legend entries
handlelength=None, # the length of the legend handles
handletextpad=None, # the pad between the legend handle and text
borderaxespad=None, # the pad between the axes and legend border
columnspacing=None, # spacing between columns
ncol=1, # number of columns
mode=None, # mode for horizontal distribution of columns. None, "expand"
fancybox=None, # True use a fancy box, false use a rounded box, none use rc
shadow=None,
title=None, # set a title for the legend
bbox_to_anchor=None, # bbox that the legend will be anchored.
bbox_transform=None, # transform for the bbox
frameon=True, # draw frame
):
"""
- *parent* : the artist that contains the legend
- *handles* : a list of artists (lines, patches) to add to the legend
- *labels* : a list of strings to label the legend
Optional keyword arguments:
================ ==================================================================
Keyword Description
================ ==================================================================
loc a location code
prop the font property
markerscale the relative size of legend markers vs. original
numpoints the number of points in the legend for line
scatterpoints the number of points in the legend for scatter plot
scatteryoffsets a list of yoffsets for scatter symbols in legend
frameon if True, draw a frame (default is True)
fancybox if True, draw a frame with a round fancybox. If None, use rc
shadow if True, draw a shadow behind legend
ncol number of columns
borderpad the fractional whitespace inside the legend border
labelspacing the vertical space between the legend entries
handlelength the length of the legend handles
handletextpad the pad between the legend handle and text
borderaxespad the pad between the axes and legend border
columnspacing the spacing between columns
title the legend title
bbox_to_anchor the bbox that the legend will be anchored.
bbox_transform the transform for the bbox. transAxes if None.
================ ==================================================================
The pad and spacing parameters are measure in font-size units. E.g.,
a fontsize of 10 points and a handlelength=5 implies a handlelength of
50 points. Values from rcParams will be used if None.
Users can specify any arbitrary location for the legend using the
*bbox_to_anchor* keyword argument. bbox_to_anchor can be an instance
of BboxBase(or its derivatives) or a tuple of 2 or 4 floats.
See :meth:`set_bbox_to_anchor` for more detail.
The legend location can be specified by setting *loc* with a tuple of
2 floats, which is interpreted as the lower-left corner of the legend
in the normalized axes coordinate.
"""
from matplotlib.axes import Axes # local import only to avoid circularity
from matplotlib.figure import Figure # local import only to avoid circularity
Artist.__init__(self)
if prop is None:
self.prop = FontProperties(size=rcParams["legend.fontsize"])
elif isinstance(prop, dict):
self.prop = FontProperties(**prop)
if "size" not in prop:
self.prop.set_size(rcParams["legend.fontsize"])
else:
self.prop = prop
self._fontsize = self.prop.get_size_in_points()
propnames = [
'numpoints', 'markerscale', 'shadow', "columnspacing",
"scatterpoints"
]
self.texts = []
self.legendHandles = []
self._legend_title_box = None
localdict = locals()
for name in propnames:
if localdict[name] is None:
value = rcParams["legend." + name]
else:
value = localdict[name]
setattr(self, name, value)
# Take care the deprecated keywords
deprecated_kwds = {
"pad": "borderpad",
"labelsep": "labelspacing",
"handlelen": "handlelength",
"handletextsep": "handletextpad",
"axespad": "borderaxespad"
}
# convert values of deprecated keywords (ginve in axes coords)
# to new vaules in a fraction of the font size
# conversion factor
bbox = parent.bbox
axessize_fontsize = min(bbox.width, bbox.height) / self._fontsize
for k, v in deprecated_kwds.items():
# use deprecated value if not None and if their newer
# counter part is None.
if localdict[k] is not None and localdict[v] is None:
warnings.warn("Use '%s' instead of '%s'." % (v, k),
DeprecationWarning)
setattr(self, v, localdict[k] * axessize_fontsize)
continue
# Otherwise, use new keywords
if localdict[v] is None:
setattr(self, v, rcParams["legend." + v])
else:
setattr(self, v, localdict[v])
del localdict
handles = list(handles)
if len(handles) < 2:
ncol = 1
self._ncol = ncol
if self.numpoints <= 0:
raise ValueError("numpoints must be >= 0; it was %d" % numpoints)
# introduce y-offset for handles of the scatter plot
if scatteryoffsets is None:
self._scatteryoffsets = np.array([3. / 8., 4. / 8., 2.5 / 8.])
else:
self._scatteryoffsets = np.asarray(scatteryoffsets)
reps = int(self.scatterpoints / len(self._scatteryoffsets)) + 1
self._scatteryoffsets = np.tile(self._scatteryoffsets,
reps)[:self.scatterpoints]
# _legend_box is an OffsetBox instance that contains all
# legend items and will be initialized from _init_legend_box()
# method.
self._legend_box = None
if isinstance(parent, Axes):
self.isaxes = True
self.set_axes(parent)
self.set_figure(parent.figure)
elif isinstance(parent, Figure):
self.isaxes = False
self.set_figure(parent)
else:
raise TypeError("Legend needs either Axes or Figure as parent")
self.parent = parent
if loc is None:
loc = rcParams["legend.loc"]
if not self.isaxes and loc in [0, 'best']:
loc = 'upper right'
if is_string_like(loc):
if loc not in self.codes:
if self.isaxes:
warnings.warn(
'Unrecognized location "%s". Falling back on "best"; '
'valid locations are\n\t%s\n' %
(loc, '\n\t'.join(self.codes.keys())))
loc = 0
else:
warnings.warn(
'Unrecognized location "%s". Falling back on "upper right"; '
'valid locations are\n\t%s\n' %
(loc, '\n\t'.join(self.codes.keys())))
loc = 1
else:
loc = self.codes[loc]
if not self.isaxes and loc == 0:
warnings.warn(
'Automatic legend placement (loc="best") not implemented for figure legend. '
'Falling back on "upper right".')
loc = 1
self._mode = mode
self.set_bbox_to_anchor(bbox_to_anchor, bbox_transform)
# We use FancyBboxPatch to draw a legend frame. The location
# and size of the box will be updated during the drawing time.
self.legendPatch = FancyBboxPatch(xy=(0.0, 0.0),
width=1.,
height=1.,
facecolor=rcParams["axes.facecolor"],
edgecolor=rcParams["axes.edgecolor"],
mutation_scale=self._fontsize,
snap=True)
# The width and height of the legendPatch will be set (in the
# draw()) to the length that includes the padding. Thus we set
# pad=0 here.
if fancybox is None:
fancybox = rcParams["legend.fancybox"]
if fancybox == True:
self.legendPatch.set_boxstyle("round", pad=0, rounding_size=0.2)
else:
self.legendPatch.set_boxstyle("square", pad=0)
self._set_artist_props(self.legendPatch)
self._drawFrame = frameon
# init with null renderer
self._init_legend_box(handles, labels)
self._loc = loc
self.set_title(title)
self._last_fontsize_points = self._fontsize
self._draggable = None
def _set_artist_props(self, a):
"""
set the boilerplate props for artists added to axes
"""
a.set_figure(self.figure)
if self.isaxes:
a.set_axes(self.axes)
a.set_transform(self.get_transform())
def _set_loc(self, loc):
# find_offset function will be provided to _legend_box and
# _legend_box will draw itself at the location of the return
# value of the find_offset.
self._loc_real = loc
if loc == 0:
_findoffset = self._findoffset_best
else:
_findoffset = self._findoffset_loc
#def findoffset(width, height, xdescent, ydescent):
# return _findoffset(width, height, xdescent, ydescent, renderer)
self._legend_box.set_offset(_findoffset)
self._loc_real = loc
def _get_loc(self):
return self._loc_real
_loc = property(_get_loc, _set_loc)
def _findoffset_best(self, width, height, xdescent, ydescent, renderer):
"Helper function to locate the legend at its best position"
ox, oy = self._find_best_position(width, height, renderer)
return ox + xdescent, oy + ydescent
def _findoffset_loc(self, width, height, xdescent, ydescent, renderer):
"Heper function to locate the legend using the location code"
if iterable(self._loc) and len(self._loc) == 2:
# when loc is a tuple of axes(or figure) coordinates.
fx, fy = self._loc
bbox = self.get_bbox_to_anchor()
x, y = bbox.x0 + bbox.width * fx, bbox.y0 + bbox.height * fy
else:
bbox = Bbox.from_bounds(0, 0, width, height)
x, y = self._get_anchored_bbox(self._loc, bbox,
self.get_bbox_to_anchor(), renderer)
return x + xdescent, y + ydescent
@allow_rasterization
def draw(self, renderer):
"Draw everything that belongs to the legend"
if not self.get_visible(): return
renderer.open_group('legend')
fontsize = renderer.points_to_pixels(self._fontsize)
# if mode == fill, set the width of the legend_box to the
# width of the paret (minus pads)
if self._mode in ["expand"]:
pad = 2 * (self.borderaxespad + self.borderpad) * fontsize
self._legend_box.set_width(self.get_bbox_to_anchor().width - pad)
if self._drawFrame:
# update the location and size of the legend
bbox = self._legend_box.get_window_extent(renderer)
self.legendPatch.set_bounds(bbox.x0, bbox.y0, bbox.width,
bbox.height)
self.legendPatch.set_mutation_scale(fontsize)
if self.shadow:
shadow = Shadow(self.legendPatch, 2, -2)
shadow.draw(renderer)
self.legendPatch.draw(renderer)
self._legend_box.draw(renderer)
renderer.close_group('legend')
def _approx_text_height(self, renderer=None):
"""
Return the approximate height of the text. This is used to place
the legend handle.
"""
if renderer is None:
return self._fontsize
else:
return renderer.points_to_pixels(self._fontsize)
def _init_legend_box(self, handles, labels):
"""
Initiallize the legend_box. The legend_box is an instance of
the OffsetBox, which is packed with legend handles and
texts. Once packed, their location is calculated during the
drawing time.
"""
fontsize = self._fontsize
# legend_box is a HPacker, horizontally packed with
# columns. Each column is a VPacker, vertically packed with
# legend items. Each legend item is HPacker packed with
# legend handleBox and labelBox. handleBox is an instance of
# offsetbox.DrawingArea which contains legend handle. labelBox
# is an instance of offsetbox.TextArea which contains legend
# text.
text_list = [] # the list of text instances
handle_list = [] # the list of text instances
label_prop = dict(
verticalalignment='baseline',
horizontalalignment='left',
fontproperties=self.prop,
)
labelboxes = []
handleboxes = []
# The approximate height and descent of text. These values are
# only used for plotting the legend handle.
height = self._approx_text_height() * 0.7
descent = 0.
# each handle needs to be drawn inside a box of (x, y, w, h) =
# (0, -descent, width, height). And their corrdinates should
# be given in the display coordinates.
# The transformation of each handle will be automatically set
# to self.get_trasnform(). If the artist does not uses its
# default trasnform (eg, Collections), you need to
# manually set their transform to the self.get_transform().
for handle, lab in zip(handles, labels):
if isinstance(handle, RegularPolyCollection) or \
isinstance(handle, CircleCollection):
npoints = self.scatterpoints
else:
npoints = self.numpoints
if npoints > 1:
# we put some pad here to compensate the size of the
# marker
xdata = np.linspace(0.3 * fontsize,
(self.handlelength - 0.3) * fontsize,
npoints)
xdata_marker = xdata
elif npoints == 1:
xdata = np.linspace(0, self.handlelength * fontsize, 2)
xdata_marker = [0.5 * self.handlelength * fontsize]
if isinstance(handle, Line2D):
ydata = ((height - descent) / 2.) * np.ones(xdata.shape, float)
legline = Line2D(xdata, ydata)
legline.update_from(handle)
self._set_artist_props(legline) # after update
legline.set_clip_box(None)
legline.set_clip_path(None)
legline.set_drawstyle('default')
legline.set_marker('None')
handle_list.append(legline)
legline_marker = Line2D(xdata_marker,
ydata[:len(xdata_marker)])
legline_marker.update_from(handle)
self._set_artist_props(legline_marker)
legline_marker.set_clip_box(None)
legline_marker.set_clip_path(None)
legline_marker.set_linestyle('None')
if self.markerscale != 1:
newsz = legline_marker.get_markersize() * self.markerscale
legline_marker.set_markersize(newsz)
# we don't want to add this to the return list because
# the texts and handles are assumed to be in one-to-one
# correpondence.
legline._legmarker = legline_marker
elif isinstance(handle, Patch):
p = Rectangle(
xy=(0., 0.),
width=self.handlelength * fontsize,
height=(height - descent),
)
p.update_from(handle)
self._set_artist_props(p)
p.set_clip_box(None)
p.set_clip_path(None)
handle_list.append(p)
elif isinstance(handle, LineCollection):
ydata = ((height - descent) / 2.) * np.ones(xdata.shape, float)
legline = Line2D(xdata, ydata)
self._set_artist_props(legline)
legline.set_clip_box(None)
legline.set_clip_path(None)
lw = handle.get_linewidth()[0]
dashes = handle.get_dashes()[0]
color = handle.get_colors()[0]
legline.set_color(color)
legline.set_linewidth(lw)
if dashes[0] is not None: # dashed line
legline.set_dashes(dashes[1])
handle_list.append(legline)
elif isinstance(handle, RegularPolyCollection):
#ydata = self._scatteryoffsets
ydata = height * self._scatteryoffsets
size_max, size_min = max(handle.get_sizes())*self.markerscale**2,\
min(handle.get_sizes())*self.markerscale**2
if self.scatterpoints < 4:
sizes = [.5 * (size_max + size_min), size_max, size_min]
else:
sizes = (size_max - size_min) * np.linspace(
0, 1, self.scatterpoints) + size_min
p = type(handle)(
handle.get_numsides(),
rotation=handle.get_rotation(),
sizes=sizes,
offsets=zip(xdata_marker, ydata),
transOffset=self.get_transform(),
)
p.update_from(handle)
p.set_figure(self.figure)
p.set_clip_box(None)
p.set_clip_path(None)
handle_list.append(p)
elif isinstance(handle, CircleCollection):
ydata = height * self._scatteryoffsets
size_max, size_min = max(handle.get_sizes())*self.markerscale**2,\
min(handle.get_sizes())*self.markerscale**2
if self.scatterpoints < 4:
sizes = [.5 * (size_max + size_min), size_max, size_min]
else:
sizes = (size_max - size_min) * np.linspace(
0, 1, self.scatterpoints) + size_min
p = type(handle)(
sizes,
offsets=zip(xdata_marker, ydata),
transOffset=self.get_transform(),
)
p.update_from(handle)
p.set_figure(self.figure)
p.set_clip_box(None)
p.set_clip_path(None)
handle_list.append(p)
else:
handle_type = type(handle)
warnings.warn(
"Legend does not support %s\nUse proxy artist instead.\n\nhttp://matplotlib.sourceforge.net/users/legend_guide.html#using-proxy-artist\n"
% (str(handle_type), ))
handle_list.append(None)
handle = handle_list[-1]
if handle is not None: # handle is None is the artist is not supproted
textbox = TextArea(lab,
textprops=label_prop,
multilinebaseline=True,
minimumdescent=True)
text_list.append(textbox._text)
labelboxes.append(textbox)
handlebox = DrawingArea(width=self.handlelength * fontsize,
height=height,
xdescent=0.,
ydescent=descent)
handlebox.add_artist(handle)
# special case for collection instances
if isinstance(handle, RegularPolyCollection) or \
isinstance(handle, CircleCollection):
handle._transOffset = handlebox.get_transform()
handle.set_transform(None)
if hasattr(handle, "_legmarker"):
handlebox.add_artist(handle._legmarker)
handleboxes.append(handlebox)
if len(handleboxes) > 0:
# We calculate number of lows in each column. The first
# (num_largecol) columns will have (nrows+1) rows, and remaing
# (num_smallcol) columns will have (nrows) rows.
ncol = min(self._ncol, len(handleboxes))
nrows, num_largecol = divmod(len(handleboxes), ncol)
num_smallcol = ncol - num_largecol
# starting index of each column and number of rows in it.
largecol = safezip(
range(0, num_largecol * (nrows + 1), (nrows + 1)),
[nrows + 1] * num_largecol)
smallcol = safezip(
range(num_largecol * (nrows + 1), len(handleboxes), nrows),
[nrows] * num_smallcol)
else:
largecol, smallcol = [], []
handle_label = safezip(handleboxes, labelboxes)
columnbox = []
for i0, di in largecol + smallcol:
# pack handleBox and labelBox into itemBox
itemBoxes = [
HPacker(pad=0,
sep=self.handletextpad * fontsize,
children=[h, t],
align="baseline") for h, t in handle_label[i0:i0 + di]
]
# minimumdescent=False for the text of the last row of the column
itemBoxes[-1].get_children()[1].set_minimumdescent(False)
# pack columnBox
columnbox.append(
VPacker(pad=0,
sep=self.labelspacing * fontsize,
align="baseline",
children=itemBoxes))
if self._mode == "expand":
mode = "expand"
else:
mode = "fixed"
sep = self.columnspacing * fontsize
self._legend_handle_box = HPacker(pad=0,
sep=sep,
align="baseline",
mode=mode,
children=columnbox)
self._legend_title_box = TextArea("")
self._legend_box = VPacker(
pad=self.borderpad * fontsize,
sep=self.labelspacing * fontsize,
align="center",
children=[self._legend_title_box, self._legend_handle_box])
self._legend_box.set_figure(self.figure)
self.texts = text_list
self.legendHandles = handle_list
def _auto_legend_data(self):
"""
Returns list of vertices and extents covered by the plot.
Returns a two long list.
First element is a list of (x, y) vertices (in
display-coordinates) covered by all the lines and line
collections, in the legend's handles.
Second element is a list of bounding boxes for all the patches in
the legend's handles.
"""
assert self.isaxes # should always hold because function is only called internally
ax = self.parent
vertices = []
bboxes = []
lines = []
for handle in ax.lines:
assert isinstance(handle, Line2D)
path = handle.get_path()
trans = handle.get_transform()
tpath = trans.transform_path(path)
lines.append(tpath)
for handle in ax.patches:
assert isinstance(handle, Patch)
if isinstance(handle, Rectangle):
transform = handle.get_data_transform()
bboxes.append(handle.get_bbox().transformed(transform))
else:
transform = handle.get_transform()
bboxes.append(handle.get_path().get_extents(transform))
return [vertices, bboxes, lines]
def draw_frame(self, b):
'b is a boolean. Set draw frame to b'
self.set_frame_on(b)
def get_children(self):
'return a list of child artists'
children = []
if self._legend_box:
children.append(self._legend_box)
children.extend(self.get_lines())
children.extend(self.get_patches())
children.extend(self.get_texts())
children.append(self.get_frame())
if self._legend_title_box:
children.append(self.get_title())
return children
def get_frame(self):
'return the Rectangle instance used to frame the legend'
return self.legendPatch
def get_lines(self):
'return a list of lines.Line2D instances in the legend'
return [h for h in self.legendHandles if isinstance(h, Line2D)]
def get_patches(self):
'return a list of patch instances in the legend'
return silent_list(
'Patch', [h for h in self.legendHandles if isinstance(h, Patch)])
def get_texts(self):
'return a list of text.Text instance in the legend'
return silent_list('Text', self.texts)
def set_title(self, title):
'set the legend title'
self._legend_title_box._text.set_text(title)
if title:
self._legend_title_box.set_visible(True)
else:
self._legend_title_box.set_visible(False)
def get_title(self):
'return Text instance for the legend title'
return self._legend_title_box._text
def get_window_extent(self):
'return a extent of the the legend'
return self.legendPatch.get_window_extent()
def get_frame_on(self):
"""
Get whether the legend box patch is drawn
"""
return self._drawFrame
def set_frame_on(self, b):
"""
Set whether the legend box patch is drawn
ACCEPTS: [ *True* | *False* ]
"""
self._drawFrame = b
def get_bbox_to_anchor(self):
"""
return the bbox that the legend will be anchored
"""
if self._bbox_to_anchor is None:
return self.parent.bbox
else:
return self._bbox_to_anchor
def set_bbox_to_anchor(self, bbox, transform=None):
"""
set the bbox that the legend will be anchored.
*bbox* can be a BboxBase instance, a tuple of [left, bottom,
width, height] in the given transform (normalized axes
coordinate if None), or a tuple of [left, bottom] where the
width and height will be assumed to be zero.
"""
if bbox is None:
self._bbox_to_anchor = None
return
elif isinstance(bbox, BboxBase):
self._bbox_to_anchor = bbox
else:
try:
l = len(bbox)
except TypeError:
raise ValueError("Invalid argument for bbox : %s" % str(bbox))
if l == 2:
bbox = [bbox[0], bbox[1], 0, 0]
self._bbox_to_anchor = Bbox.from_bounds(*bbox)
if transform is None:
transform = BboxTransformTo(self.parent.bbox)
self._bbox_to_anchor = TransformedBbox(self._bbox_to_anchor, transform)
def _get_anchored_bbox(self, loc, bbox, parentbbox, renderer):
"""
Place the *bbox* inside the *parentbbox* according to a given
location code. Return the (x,y) coordinate of the bbox.
- loc: a location code in range(1, 11).
This corresponds to the possible values for self._loc, excluding "best".
- bbox: bbox to be placed, display coodinate units.
- parentbbox: a parent box which will contain the bbox. In
display coordinates.
"""
assert loc in range(1, 11) # called only internally
BEST, UR, UL, LL, LR, R, CL, CR, LC, UC, C = range(11)
anchor_coefs = {
UR: "NE",
UL: "NW",
LL: "SW",
LR: "SE",
R: "E",
CL: "W",
CR: "E",
LC: "S",
UC: "N",
C: "C"
}
c = anchor_coefs[loc]
fontsize = renderer.points_to_pixels(self._fontsize)
container = parentbbox.padded(-(self.borderaxespad) * fontsize)
anchored_box = bbox.anchored(c, container=container)
return anchored_box.x0, anchored_box.y0
def _find_best_position(self, width, height, renderer, consider=None):
"""
Determine the best location to place the legend.
`consider` is a list of (x, y) pairs to consider as a potential
lower-left corner of the legend. All are display coords.
"""
assert self.isaxes # should always hold because function is only called internally
verts, bboxes, lines = self._auto_legend_data()
bbox = Bbox.from_bounds(0, 0, width, height)
consider = [
self._get_anchored_bbox(x, bbox, self.get_bbox_to_anchor(),
renderer)
for x in range(1, len(self.codes))
]
#tx, ty = self.legendPatch.get_x(), self.legendPatch.get_y()
candidates = []
for l, b in consider:
legendBox = Bbox.from_bounds(l, b, width, height)
badness = 0
badness = legendBox.count_contains(verts)
badness += legendBox.count_overlaps(bboxes)
for line in lines:
if line.intersects_bbox(legendBox):
badness += 1
ox, oy = l, b
if badness == 0:
return ox, oy
candidates.append((badness, (l, b)))
# rather than use min() or list.sort(), do this so that we are assured
# that in the case of two equal badnesses, the one first considered is
# returned.
# NOTE: list.sort() is stable.But leave as it is for now. -JJL
minCandidate = candidates[0]
for candidate in candidates:
if candidate[0] < minCandidate[0]:
minCandidate = candidate
ox, oy = minCandidate[1]
return ox, oy
def draggable(self, state=None, use_blit=False):
"""
Set the draggable state -- if state is
* None : toggle the current state
* True : turn draggable on
* False : turn draggable off
If draggable is on, you can drag the legend on the canvas with
the mouse. The DraggableLegend helper instance is returned if
draggable is on.
"""
is_draggable = self._draggable is not None
# if state is None we'll toggle
if state is None:
state = not is_draggable
if state:
if self._draggable is None:
self._draggable = DraggableLegend(self, use_blit)
else:
if self._draggable is not None:
self._draggable.disconnect()
self._draggable = None
return self._draggable
class Legend(Artist):
"""
Place a legend on the axes at location loc.
"""
codes = {'best': 0, # only implemented for axes legends
'upper right': 1,
'upper left': 2,
'lower left': 3,
'lower right': 4,
'right': 5,
'center left': 6,
'center right': 7,
'lower center': 8,
'upper center': 9,
'center': 10,
}
zorder = 5
def __str__(self):
return "Legend"
@docstring.dedent_interpd
def __init__(self, parent, handles, labels,
loc=None,
numpoints=None, # the number of points in the legend line
markerscale=None, # the relative size of legend markers
# vs. original
markerfirst=True, # controls ordering (left-to-right) of
# legend marker and label
scatterpoints=None, # number of scatter points
scatteryoffsets=None,
prop=None, # properties for the legend texts
fontsize=None, # keyword to set font size directly
labelcolor=None, # keyword to set the text color
# spacing & pad defined as a fraction of the font-size
borderpad=None, # the whitespace inside the legend border
labelspacing=None, # the vertical space between the legend
# entries
handlelength=None, # the length of the legend handles
handleheight=None, # the height of the legend handles
handletextpad=None, # the pad between the legend handle
# and text
borderaxespad=None, # the pad between the axes and legend
# border
columnspacing=None, # spacing between columns
ncol=1, # number of columns
mode=None, # mode for horizontal distribution of columns.
# None, "expand"
fancybox=None, # True use a fancy box, false use a rounded
# box, none use rc
shadow=None,
title=None, # set a title for the legend
title_fontsize=None, # the font size for the title
framealpha=None, # set frame alpha
edgecolor=None, # frame patch edgecolor
facecolor=None, # frame patch facecolor
bbox_to_anchor=None, # bbox that the legend will be anchored.
bbox_transform=None, # transform for the bbox
frameon=None, # draw frame
handler_map=None,
):
"""
Parameters
----------
parent : `~matplotlib.axes.Axes` or `.Figure`
The artist that contains the legend.
handles : list of `.Artist`
A list of Artists (lines, patches) to be added to the legend.
labels : list of str
A list of labels to show next to the artists. The length of handles
and labels should be the same. If they are not, they are truncated
to the smaller of both lengths.
Other Parameters
----------------
%(_legend_kw_doc)s
Notes
-----
Users can specify any arbitrary location for the legend using the
*bbox_to_anchor* keyword argument. *bbox_to_anchor* can be a
`.BboxBase` (or derived therefrom) or a tuple of 2 or 4 floats.
See `set_bbox_to_anchor` for more detail.
The legend location can be specified by setting *loc* with a tuple of
2 floats, which is interpreted as the lower-left corner of the legend
in the normalized axes coordinate.
"""
# local import only to avoid circularity
from matplotlib.axes import Axes
from matplotlib.figure import Figure
Artist.__init__(self)
if prop is None:
if fontsize is not None:
self.prop = FontProperties(size=fontsize)
else:
self.prop = FontProperties(
size=mpl.rcParams["legend.fontsize"])
else:
self.prop = FontProperties._from_any(prop)
if isinstance(prop, dict) and "size" not in prop:
self.prop.set_size(mpl.rcParams["legend.fontsize"])
self._fontsize = self.prop.get_size_in_points()
self.texts = []
self.legendHandles = []
self._legend_title_box = None
#: A dictionary with the extra handler mappings for this Legend
#: instance.
self._custom_handler_map = handler_map
locals_view = locals()
for name in ["numpoints", "markerscale", "shadow", "columnspacing",
"scatterpoints", "handleheight", 'borderpad',
'labelspacing', 'handlelength', 'handletextpad',
'borderaxespad']:
if locals_view[name] is None:
value = mpl.rcParams["legend." + name]
else:
value = locals_view[name]
setattr(self, name, value)
del locals_view
# trim handles and labels if illegal label...
_lab, _hand = [], []
for label, handle in zip(labels, handles):
if isinstance(label, str) and label.startswith('_'):
cbook._warn_external('The handle {!r} has a label of {!r} '
'which cannot be automatically added to'
' the legend.'.format(handle, label))
else:
_lab.append(label)
_hand.append(handle)
labels, handles = _lab, _hand
handles = list(handles)
if len(handles) < 2:
ncol = 1
self._ncol = ncol
if self.numpoints <= 0:
raise ValueError("numpoints must be > 0; it was %d" % numpoints)
# introduce y-offset for handles of the scatter plot
if scatteryoffsets is None:
self._scatteryoffsets = np.array([3. / 8., 4. / 8., 2.5 / 8.])
else:
self._scatteryoffsets = np.asarray(scatteryoffsets)
reps = self.scatterpoints // len(self._scatteryoffsets) + 1
self._scatteryoffsets = np.tile(self._scatteryoffsets,
reps)[:self.scatterpoints]
# _legend_box is a VPacker instance that contains all
# legend items and will be initialized from _init_legend_box()
# method.
self._legend_box = None
if isinstance(parent, Axes):
self.isaxes = True
self.axes = parent
self.set_figure(parent.figure)
elif isinstance(parent, Figure):
self.isaxes = False
self.set_figure(parent)
else:
raise TypeError("Legend needs either Axes or Figure as parent")
self.parent = parent
self._loc_used_default = loc is None
if loc is None:
loc = mpl.rcParams["legend.loc"]
if not self.isaxes and loc in [0, 'best']:
loc = 'upper right'
if isinstance(loc, str):
if loc not in self.codes:
raise ValueError(
"Unrecognized location {!r}. Valid locations are\n\t{}\n"
.format(loc, '\n\t'.join(self.codes)))
else:
loc = self.codes[loc]
if not self.isaxes and loc == 0:
raise ValueError(
"Automatic legend placement (loc='best') not implemented for "
"figure legend.")
self._mode = mode
self.set_bbox_to_anchor(bbox_to_anchor, bbox_transform)
# We use FancyBboxPatch to draw a legend frame. The location
# and size of the box will be updated during the drawing time.
if facecolor is None:
facecolor = mpl.rcParams["legend.facecolor"]
if facecolor == 'inherit':
facecolor = mpl.rcParams["axes.facecolor"]
if edgecolor is None:
edgecolor = mpl.rcParams["legend.edgecolor"]
if edgecolor == 'inherit':
edgecolor = mpl.rcParams["axes.edgecolor"]
if fancybox is None:
fancybox = mpl.rcParams["legend.fancybox"]
self.legendPatch = FancyBboxPatch(
xy=(0, 0), width=1, height=1,
facecolor=facecolor, edgecolor=edgecolor,
# If shadow is used, default to alpha=1 (#8943).
alpha=(framealpha if framealpha is not None
else 1 if shadow
else mpl.rcParams["legend.framealpha"]),
# The width and height of the legendPatch will be set (in draw())
# to the length that includes the padding. Thus we set pad=0 here.
boxstyle=("round,pad=0,rounding_size=0.2" if fancybox
else "square,pad=0"),
mutation_scale=self._fontsize,
snap=True,
visible=(frameon if frameon is not None
else mpl.rcParams["legend.frameon"])
)
self._set_artist_props(self.legendPatch)
# init with null renderer
self._init_legend_box(handles, labels, markerfirst)
tmp = self._loc_used_default
self._set_loc(loc)
self._loc_used_default = tmp # ignore changes done by _set_loc
# figure out title fontsize:
if title_fontsize is None:
title_fontsize = mpl.rcParams['legend.title_fontsize']
tprop = FontProperties(size=title_fontsize)
self.set_title(title, prop=tprop)
self._draggable = None
# set the text color
color_getters = { # getter function depends on line or patch
'linecolor': ['get_color', 'get_facecolor'],
'markerfacecolor': ['get_markerfacecolor', 'get_facecolor'],
'mfc': ['get_markerfacecolor', 'get_facecolor'],
'markeredgecolor': ['get_markeredgecolor', 'get_edgecolor'],
'mec': ['get_markeredgecolor', 'get_edgecolor'],
}
if labelcolor is None:
pass
elif isinstance(labelcolor, str) and labelcolor in color_getters:
getter_names = color_getters[labelcolor]
for handle, text in zip(self.legendHandles, self.texts):
for getter_name in getter_names:
try:
color = getattr(handle, getter_name)()
text.set_color(color)
break
except AttributeError:
pass
elif np.iterable(labelcolor):
for text, color in zip(self.texts,
itertools.cycle(
colors.to_rgba_array(labelcolor))):
text.set_color(color)
else:
raise ValueError("Invalid argument for labelcolor : %s" %
str(labelcolor))
def _set_artist_props(self, a):
"""
Set the boilerplate props for artists added to axes.
"""
a.set_figure(self.figure)
if self.isaxes:
# a.set_axes(self.axes)
a.axes = self.axes
a.set_transform(self.get_transform())
def _set_loc(self, loc):
# find_offset function will be provided to _legend_box and
# _legend_box will draw itself at the location of the return
# value of the find_offset.
self._loc_used_default = False
self._loc_real = loc
self.stale = True
self._legend_box.set_offset(self._findoffset)
def _get_loc(self):
return self._loc_real
_loc = property(_get_loc, _set_loc)
def _findoffset(self, width, height, xdescent, ydescent, renderer):
"""Helper function to locate the legend."""
if self._loc == 0: # "best".
x, y = self._find_best_position(width, height, renderer)
elif self._loc in Legend.codes.values(): # Fixed location.
bbox = Bbox.from_bounds(0, 0, width, height)
x, y = self._get_anchored_bbox(self._loc, bbox,
self.get_bbox_to_anchor(),
renderer)
else: # Axes or figure coordinates.
fx, fy = self._loc
bbox = self.get_bbox_to_anchor()
x, y = bbox.x0 + bbox.width * fx, bbox.y0 + bbox.height * fy
return x + xdescent, y + ydescent
@allow_rasterization
def draw(self, renderer):
# docstring inherited
if not self.get_visible():
return
renderer.open_group('legend', gid=self.get_gid())
fontsize = renderer.points_to_pixels(self._fontsize)
# if mode == fill, set the width of the legend_box to the
# width of the parent (minus pads)
if self._mode in ["expand"]:
pad = 2 * (self.borderaxespad + self.borderpad) * fontsize
self._legend_box.set_width(self.get_bbox_to_anchor().width - pad)
# update the location and size of the legend. This needs to
# be done in any case to clip the figure right.
bbox = self._legend_box.get_window_extent(renderer)
self.legendPatch.set_bounds(bbox.x0, bbox.y0, bbox.width, bbox.height)
self.legendPatch.set_mutation_scale(fontsize)
if self.shadow:
Shadow(self.legendPatch, 2, -2).draw(renderer)
self.legendPatch.draw(renderer)
self._legend_box.draw(renderer)
renderer.close_group('legend')
self.stale = False
# _default_handler_map defines the default mapping between plot
# elements and the legend handlers.
_default_handler_map = {
StemContainer: legend_handler.HandlerStem(),
ErrorbarContainer: legend_handler.HandlerErrorbar(),
Line2D: legend_handler.HandlerLine2D(),
Patch: legend_handler.HandlerPatch(),
LineCollection: legend_handler.HandlerLineCollection(),
RegularPolyCollection: legend_handler.HandlerRegularPolyCollection(),
CircleCollection: legend_handler.HandlerCircleCollection(),
BarContainer: legend_handler.HandlerPatch(
update_func=legend_handler.update_from_first_child),
tuple: legend_handler.HandlerTuple(),
PathCollection: legend_handler.HandlerPathCollection(),
PolyCollection: legend_handler.HandlerPolyCollection()
}
# (get|set|update)_default_handler_maps are public interfaces to
# modify the default handler map.
@classmethod
def get_default_handler_map(cls):
"""
A class method that returns the default handler map.
"""
return cls._default_handler_map
@classmethod
def set_default_handler_map(cls, handler_map):
"""
A class method to set the default handler map.
"""
cls._default_handler_map = handler_map
@classmethod
def update_default_handler_map(cls, handler_map):
"""
A class method to update the default handler map.
"""
cls._default_handler_map.update(handler_map)
def get_legend_handler_map(self):
"""
Return the handler map.
"""
default_handler_map = self.get_default_handler_map()
if self._custom_handler_map:
hm = default_handler_map.copy()
hm.update(self._custom_handler_map)
return hm
else:
return default_handler_map
@staticmethod
def get_legend_handler(legend_handler_map, orig_handle):
"""
Return a legend handler from *legend_handler_map* that
corresponds to *orig_handler*.
*legend_handler_map* should be a dictionary object (that is
returned by the get_legend_handler_map method).
It first checks if the *orig_handle* itself is a key in the
*legend_handler_map* and return the associated value.
Otherwise, it checks for each of the classes in its
method-resolution-order. If no matching key is found, it
returns ``None``.
"""
try:
return legend_handler_map[orig_handle]
except (TypeError, KeyError): # TypeError if unhashable.
pass
for handle_type in type(orig_handle).mro():
try:
return legend_handler_map[handle_type]
except KeyError:
pass
return None
def _init_legend_box(self, handles, labels, markerfirst=True):
"""
Initialize the legend_box. The legend_box is an instance of
the OffsetBox, which is packed with legend handles and
texts. Once packed, their location is calculated during the
drawing time.
"""
fontsize = self._fontsize
# legend_box is a HPacker, horizontally packed with
# columns. Each column is a VPacker, vertically packed with
# legend items. Each legend item is HPacker packed with
# legend handleBox and labelBox. handleBox is an instance of
# offsetbox.DrawingArea which contains legend handle. labelBox
# is an instance of offsetbox.TextArea which contains legend
# text.
text_list = [] # the list of text instances
handle_list = [] # the list of text instances
handles_and_labels = []
label_prop = dict(verticalalignment='baseline',
horizontalalignment='left',
fontproperties=self.prop,
)
# The approximate height and descent of text. These values are
# only used for plotting the legend handle.
descent = 0.35 * fontsize * (self.handleheight - 0.7)
# 0.35 and 0.7 are just heuristic numbers and may need to be improved.
height = fontsize * self.handleheight - descent
# each handle needs to be drawn inside a box of (x, y, w, h) =
# (0, -descent, width, height). And their coordinates should
# be given in the display coordinates.
# The transformation of each handle will be automatically set
# to self.get_transform(). If the artist does not use its
# default transform (e.g., Collections), you need to
# manually set their transform to the self.get_transform().
legend_handler_map = self.get_legend_handler_map()
for orig_handle, lab in zip(handles, labels):
handler = self.get_legend_handler(legend_handler_map, orig_handle)
if handler is None:
cbook._warn_external(
"Legend does not support {!r} instances.\nA proxy artist "
"may be used instead.\nSee: "
"https://matplotlib.org/users/legend_guide.html"
"#creating-artists-specifically-for-adding-to-the-legend-"
"aka-proxy-artists".format(orig_handle))
# We don't have a handle for this artist, so we just defer
# to None.
handle_list.append(None)
else:
textbox = TextArea(lab, textprops=label_prop,
multilinebaseline=True,
minimumdescent=True)
handlebox = DrawingArea(width=self.handlelength * fontsize,
height=height,
xdescent=0., ydescent=descent)
text_list.append(textbox._text)
# Create the artist for the legend which represents the
# original artist/handle.
handle_list.append(handler.legend_artist(self, orig_handle,
fontsize, handlebox))
handles_and_labels.append((handlebox, textbox))
if handles_and_labels:
# We calculate number of rows in each column. The first
# (num_largecol) columns will have (nrows+1) rows, and remaining
# (num_smallcol) columns will have (nrows) rows.
ncol = min(self._ncol, len(handles_and_labels))
nrows, num_largecol = divmod(len(handles_and_labels), ncol)
num_smallcol = ncol - num_largecol
# starting index of each column and number of rows in it.
rows_per_col = [nrows + 1] * num_largecol + [nrows] * num_smallcol
start_idxs = np.concatenate([[0], np.cumsum(rows_per_col)[:-1]])
cols = zip(start_idxs, rows_per_col)
else:
cols = []
columnbox = []
for i0, di in cols:
# pack handleBox and labelBox into itemBox
itemBoxes = [HPacker(pad=0,
sep=self.handletextpad * fontsize,
children=[h, t] if markerfirst else [t, h],
align="baseline")
for h, t in handles_and_labels[i0:i0 + di]]
# minimumdescent=False for the text of the last row of the column
if markerfirst:
itemBoxes[-1].get_children()[1].set_minimumdescent(False)
else:
itemBoxes[-1].get_children()[0].set_minimumdescent(False)
# pack columnBox
alignment = "baseline" if markerfirst else "right"
columnbox.append(VPacker(pad=0,
sep=self.labelspacing * fontsize,
align=alignment,
children=itemBoxes))
mode = "expand" if self._mode == "expand" else "fixed"
sep = self.columnspacing * fontsize
self._legend_handle_box = HPacker(pad=0,
sep=sep, align="baseline",
mode=mode,
children=columnbox)
self._legend_title_box = TextArea("")
self._legend_box = VPacker(pad=self.borderpad * fontsize,
sep=self.labelspacing * fontsize,
align="center",
children=[self._legend_title_box,
self._legend_handle_box])
self._legend_box.set_figure(self.figure)
self.texts = text_list
self.legendHandles = handle_list
def _auto_legend_data(self):
"""
Return display coordinates for hit testing for "best" positioning.
Returns
-------
bboxes
List of bounding boxes of all patches.
lines
List of `.Path` corresponding to each line.
offsets
List of (x, y) offsets of all collection.
"""
assert self.isaxes # always holds, as this is only called internally
ax = self.parent
lines = [line.get_transform().transform_path(line.get_path())
for line in ax.lines]
bboxes = [patch.get_bbox().transformed(patch.get_data_transform())
if isinstance(patch, Rectangle) else
patch.get_path().get_extents(patch.get_transform())
for patch in ax.patches]
offsets = []
for handle in ax.collections:
_, transOffset, hoffsets, _ = handle._prepare_points()
for offset in transOffset.transform(hoffsets):
offsets.append(offset)
return bboxes, lines, offsets
def get_children(self):
# docstring inherited
return [self._legend_box, self.get_frame()]
def get_frame(self):
"""Return the `~.patches.Rectangle` used to frame the legend."""
return self.legendPatch
def get_lines(self):
r"""Return the list of `~.lines.Line2D`\s in the legend."""
return [h for h in self.legendHandles if isinstance(h, Line2D)]
def get_patches(self):
r"""Return the list of `~.patches.Patch`\s in the legend."""
return silent_list('Patch',
[h for h in self.legendHandles
if isinstance(h, Patch)])
def get_texts(self):
r"""Return the list of `~.text.Text`\s in the legend."""
return silent_list('Text', self.texts)
def set_title(self, title, prop=None):
"""
Set the legend title. Fontproperties can be optionally set
with *prop* parameter.
"""
self._legend_title_box._text.set_text(title)
if title:
self._legend_title_box._text.set_visible(True)
self._legend_title_box.set_visible(True)
else:
self._legend_title_box._text.set_visible(False)
self._legend_title_box.set_visible(False)
if prop is not None:
self._legend_title_box._text.set_fontproperties(prop)
self.stale = True
def get_title(self):
"""Return the `.Text` instance for the legend title."""
return self._legend_title_box._text
def get_window_extent(self, renderer=None):
# docstring inherited
if renderer is None:
renderer = self.figure._cachedRenderer
return self._legend_box.get_window_extent(renderer=renderer)
def get_tightbbox(self, renderer):
"""
Like `.Legend.get_window_extent`, but uses the box for the legend.
Parameters
----------
renderer : `.RendererBase` subclass
renderer that will be used to draw the figures (i.e.
``fig.canvas.get_renderer()``)
Returns
-------
`.BboxBase`
The bounding box in figure pixel coordinates.
"""
return self._legend_box.get_window_extent(renderer)
def get_frame_on(self):
"""Get whether the legend box patch is drawn."""
return self.legendPatch.get_visible()
def set_frame_on(self, b):
"""
Set whether the legend box patch is drawn.
Parameters
----------
b : bool
"""
self.legendPatch.set_visible(b)
self.stale = True
draw_frame = set_frame_on # Backcompat alias.
def get_bbox_to_anchor(self):
"""Return the bbox that the legend will be anchored to."""
if self._bbox_to_anchor is None:
return self.parent.bbox
else:
return self._bbox_to_anchor
def set_bbox_to_anchor(self, bbox, transform=None):
"""
Set the bbox that the legend will be anchored to.
*bbox* can be
- A `.BboxBase` instance
- A tuple of ``(left, bottom, width, height)`` in the given transform
(normalized axes coordinate if None)
- A tuple of ``(left, bottom)`` where the width and height will be
assumed to be zero.
"""
if bbox is None:
self._bbox_to_anchor = None
return
elif isinstance(bbox, BboxBase):
self._bbox_to_anchor = bbox
else:
try:
l = len(bbox)
except TypeError as err:
raise ValueError("Invalid argument for bbox : %s" %
str(bbox)) from err
if l == 2:
bbox = [bbox[0], bbox[1], 0, 0]
self._bbox_to_anchor = Bbox.from_bounds(*bbox)
if transform is None:
transform = BboxTransformTo(self.parent.bbox)
self._bbox_to_anchor = TransformedBbox(self._bbox_to_anchor,
transform)
self.stale = True
def _get_anchored_bbox(self, loc, bbox, parentbbox, renderer):
"""
Place the *bbox* inside the *parentbbox* according to a given
location code. Return the (x, y) coordinate of the bbox.
- loc: a location code in range(1, 11).
This corresponds to the possible values for self._loc, excluding
"best".
- bbox: bbox to be placed, display coordinate units.
- parentbbox: a parent box which will contain the bbox. In
display coordinates.
"""
assert loc in range(1, 11) # called only internally
BEST, UR, UL, LL, LR, R, CL, CR, LC, UC, C = range(11)
anchor_coefs = {UR: "NE",
UL: "NW",
LL: "SW",
LR: "SE",
R: "E",
CL: "W",
CR: "E",
LC: "S",
UC: "N",
C: "C"}
c = anchor_coefs[loc]
fontsize = renderer.points_to_pixels(self._fontsize)
container = parentbbox.padded(-self.borderaxespad * fontsize)
anchored_box = bbox.anchored(c, container=container)
return anchored_box.x0, anchored_box.y0
def _find_best_position(self, width, height, renderer, consider=None):
"""
Determine the best location to place the legend.
*consider* is a list of ``(x, y)`` pairs to consider as a potential
lower-left corner of the legend. All are display coords.
"""
assert self.isaxes # always holds, as this is only called internally
start_time = time.perf_counter()
bboxes, lines, offsets = self._auto_legend_data()
bbox = Bbox.from_bounds(0, 0, width, height)
if consider is None:
consider = [self._get_anchored_bbox(x, bbox,
self.get_bbox_to_anchor(),
renderer)
for x in range(1, len(self.codes))]
candidates = []
for idx, (l, b) in enumerate(consider):
legendBox = Bbox.from_bounds(l, b, width, height)
badness = 0
# XXX TODO: If markers are present, it would be good to take them
# into account when checking vertex overlaps in the next line.
badness = (sum(legendBox.count_contains(line.vertices)
for line in lines)
+ legendBox.count_contains(offsets)
+ legendBox.count_overlaps(bboxes)
+ sum(line.intersects_bbox(legendBox, filled=False)
for line in lines))
if badness == 0:
return l, b
# Include the index to favor lower codes in case of a tie.
candidates.append((badness, idx, (l, b)))
_, _, (l, b) = min(candidates)
if self._loc_used_default and time.perf_counter() - start_time > 1:
cbook._warn_external(
'Creating legend with loc="best" can be slow with large '
'amounts of data.')
return l, b
def contains(self, event):
inside, info = self._default_contains(event)
if inside is not None:
return inside, info
return self.legendPatch.contains(event)
def set_draggable(self, state, use_blit=False, update='loc'):
"""
Enable or disable mouse dragging support of the legend.
Parameters
----------
state : bool
Whether mouse dragging is enabled.
use_blit : bool, optional
Use blitting for faster image composition. For details see
:ref:`func-animation`.
update : {'loc', 'bbox'}, optional
The legend parameter to be changed when dragged:
- 'loc': update the *loc* parameter of the legend
- 'bbox': update the *bbox_to_anchor* parameter of the legend
Returns
-------
If *state* is ``True`` this returns the `~.DraggableLegend` helper
instance. Otherwise this returns ``None``.
"""
if state:
if self._draggable is None:
self._draggable = DraggableLegend(self,
use_blit,
update=update)
else:
if self._draggable is not None:
self._draggable.disconnect()
self._draggable = None
return self._draggable
def get_draggable(self):
"""Return ``True`` if the legend is draggable, ``False`` otherwise."""
return self._draggable is not None
s=100)
p5 = plt.scatter(V_14,
E_14,
color='grey',
marker="^",
facecolors='none',
label='Calcite II',
s=100)
#p7 = plt.scatter(V_7, E_7, color='magenta', marker="^", facecolors='none', label='S.G. 7', s=100)
#p8 = plt.scatter(V_161, E_161, color='green', marker="^", facecolors='none', label='S.G. 161', s=100)
fontP = FontProperties()
#fontP.set_size('small')
fontP.set_size('15')
#plt.legend((p1, p2, p5, p6, p8, p161), ("Calcite I", "Cubic fit Calcite I", "Calcite II", 'Cubic fit Calcite II', "S.G. 161", "Cubic fit S.G. 161"), prop=fontP)
plt.legend(
(p1, p2, p5, p6),
("Calcite I", "Cubic fit Calcite I", "Calcite II", 'Cubic fit Calcite II'),
prop=fontP)
global V0, B0, B0_prime
E0 = popt_C_I[0]
V0 = popt_C_I[1]
B0 = popt_C_I[2]
B0_prime = popt_C_I[3]
pressures_per_F_unit_C_I = P(V_C_I, V0, B0, B0_prime)
print 'popt_C_I = ', popt_C_I
import functools as ft
import numpy as np
from math import sqrt, pi
import matplotlib as mpl
mpl.rcParams['axes.labelsize'] = 'x-large'
mpl.rcParams['legend.fontsize'] = 'x-large'
mpl.rcParams['xtick.labelsize'] = 'x-large'
mpl.rcParams['ytick.labelsize'] = 'x-large'
output_dir = './plots/'
from matplotlib.font_manager import FontProperties
fontP = FontProperties()
fontP.set_size('small')
def save_pic(renderer, fig, p, suffix):
fh = renderer._get_figure(fig)
plt.tight_layout()
# tikz_save(f'{output_dir}/heatRate_{suffix}.tex', figureheight='\\figureheight', figurewidth='\\figurewidth')
plt.savefig(f'{output_dir}/heatRate_{suffix}.eps')
def analytical_sol_xv(renderer, fig, p):
save_pic(renderer, fig, p, 'icrm_traj')
def analytical_sol_u(renderer, fig, p):
def plot_gat_duration_error(data_dict,
astar_data,
action_durations,
title="",
log10=True):
markers = itertools.cycle(plot_markers)
linestyles = itertools.cycle(plot_linestyles)
handles = []
astar_gat_per_duration = astar_data
if not astar_gat_per_duration: # empty
print("No data for A*")
# astar_gat_per_duration_means, astar_confidence_interval_low, astar_confidence_interval_high = \
# mean_confidence_intervals(astar_gat_per_duration)
x = np.arange(1, len(action_durations) + 1)
fig = plt.figure()
ax = plt.subplot()
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.tick_params(direction='out')
ax.get_xaxis().tick_bottom()
ax.get_yaxis().tick_left()
# Plot for each provided algorithm
color_index = 0
for algorithm, algorithm_gat_per_duration in data_dict.items():
if not algorithm_gat_per_duration: # empty
print("No data for " + algorithm)
continue
# print(algorithm_gat_per_duration)
# if log10:
# algorithm_gat_per_duration = [np.log10(gat) for gat in algorithm_gat_per_duration]
algorithm_gat_per_duration_mean, algorithm_confidence_interval_low, algorithm_confidence_interval_high = \
mean_confidence_intervals(algorithm_gat_per_duration)
data_mask = np.isfinite(algorithm_gat_per_duration_mean)
masked_x = x[data_mask]
masked_data = np.array(algorithm_gat_per_duration_mean)[data_mask]
masked_confidence_low = algorithm_confidence_interval_low[data_mask]
masked_confidence_high = algorithm_confidence_interval_high[data_mask]
label = translate_algorithm_name(algorithm)
handle = plt.errorbar(masked_x,
masked_data,
label=label,
color=tableau20[color_index],
markeredgecolor='none',
linestyle=next(linestyles),
marker=next(markers),
clip_on=False,
yerr=(masked_confidence_low,
masked_confidence_high))
handles.append((handle, label, masked_data.tolist()))
color_index += 1
# Set labels, sort legend by mean value
handles = sorted(handles, key=lambda handle: handle[2], reverse=True)
ordered_handles = [a[0] for a in handles]
ordered_labels = [a[1] for a in handles]
font_properties = FontProperties()
font_properties.set_size('small')
lgd = plt.legend(
handles=ordered_handles,
labels=ordered_labels,
prop=font_properties,
ncol=2,
frameon=False,
# loc="upper center",bbox_to_anchor=(0.5, -0.1)
loc='best')
plt.xticks(x, [
duration if duration - int(duration) > 0 else int(duration)
for duration in action_durations
])
plt.title(title)
if log10:
plt.yscale('symlog', basey=10)
# plt.yscale('log', basey=10, nonposy='clip')
plt.ylabel("Goal Achievement Time log10")
else:
plt.ylabel("Goal Achievement Time (ms)")
plt.xlabel("Action Duration (ms)")
ax.autoscale(tight=True)
plt.gcf().tight_layout()
return lgd
def plot_clusters(num_clusters,
feature_matrix,
cluster_data,
book_data,
plot_size=(16, 8)):
# generate random color for clusters
def generate_random_color():
color = '#%06x' % random.randint(0, 0xFFFFFF)
return color
# define markers for clusters
markers = ['o', 'v', '^', '<', '>', '8', 's', 'p', '*', 'h', 'H', 'D', 'd']
# build cosine distance matrix
cosine_distance = 1 - cosine_similarity(feature_matrix)
# dimensionality reduction using MDS
mds = MDS(n_components=2, dissimilarity="precomputed", random_state=1)
# get coordinates of clusters in new low-dimensional space
plot_positions = mds.fit_transform(cosine_distance)
x_pos, y_pos = plot_positions[:, 0], plot_positions[:, 1]
# build cluster plotting data
cluster_color_map = {}
cluster_name_map = {}
for cluster_num, cluster_details in cluster_data[:].items():
# assign cluster features to unique label
cluster_color_map[cluster_num] = generate_random_color()
cluster_name_map[cluster_num] = ', '.join(
cluster_details['key_features'][:5]).strip()
# map each unique cluster label with its coordinates and books
cluster_plot_frame = pd.DataFrame({
'x':
x_pos,
'y':
y_pos,
'label':
book_data['Cluster'].values.tolist(),
'title':
book_data['title'].values.tolist()
})
grouped_plot_frame = cluster_plot_frame.groupby('label')
# set plot figure size and axes
fig, ax = plt.subplots(figsize=plot_size)
ax.margins(0.05)
# plot each cluster using co-ordinates and book titles
for cluster_num, cluster_frame in grouped_plot_frame:
marker = markers[cluster_num] if cluster_num < len(markers) \
else np.random.choice(markers, size=1)[0]
ax.plot(cluster_frame['x'],
cluster_frame['y'],
marker=marker,
linestyle='',
ms=12,
label=cluster_name_map[cluster_num],
color=cluster_color_map[cluster_num],
mec='none')
ax.set_aspect('auto')
ax.tick_params(axis='x',
which='both',
bottom='off',
top='off',
labelbottom='off')
ax.tick_params(axis='y',
which='both',
left='off',
top='off',
labelleft='off')
fontP = FontProperties()
fontP.set_size('small')
ax.legend(loc='upper center',
bbox_to_anchor=(0.5, -0.01),
fancybox=True,
shadow=True,
ncol=5,
numpoints=1,
prop=fontP)
# add labels as the film titles
for index in range(len(cluster_plot_frame)):
ax.text(cluster_plot_frame.ix[index]['x'],
cluster_plot_frame.ix[index]['y'],
cluster_plot_frame.ix[index]['title'],
size=8)
# show the plot
plt.show()
map2.drawcoastlines()
map2.drawlsmask(ocean_color="aqua")
# For each group the obtained by grouping the dataset by Cities, one city (the first occurrence),
# is selected to represent the city and it is plotted to have a reference of the precise location
# of this city and compare the result with the clustering algorithm
for i, cluster_row in sorted_cities.iterrows():
rgb = [rd.random(), rd.random(), rd.random()]
clusteri = df[df.City == cluster_row['City']]
reference = clusteri.iloc[0]
x, y = map2(reference['Longitude'], reference['Latitude'])
map2.plot(x,
y,
marker='o',
markersize=10,
label=reference['City'],
color=rgb)
fontP = FontProperties()
fontP.set_size('xx-small')
plt.legend(loc='upper right', bbox_to_anchor=(1.2, 1), prop=fontP)
plt.show()
# %%
# As can be inspected, 10 out of 20 of the total clusters match, that is, a 50%.
# There are some cases in which to cities are merged in one cluster, that is the case of San Diego
# and Los Angeles or Columbia and Atlanta. This happen because this cities are closed to each other
# and the zip codes are located uniformly throughout the cities.
# On the other hand, large cities may have the zip codes sparsely located and they are not correctly
# clustered.
# %%
class AnchoredOffsetbox(OffsetBox):
"""
An offset box placed according to the legend location
loc. AnchoredOffsetbox has a single child. When multiple children
is needed, use other OffsetBox class to enlose them. By default,
the offset box is anchored against its parent axes. You may
explicitly specify the bbox_to_anchor.
"""
zorder = 5 # zorder of the legend
def __init__(self,
loc,
pad=0.4,
borderpad=0.5,
child=None,
prop=None,
frameon=True,
bbox_to_anchor=None,
bbox_transform=None,
**kwargs):
"""
loc is a string or an integer specifying the legend location.
The valid location codes are::
'upper right' : 1,
'upper left' : 2,
'lower left' : 3,
'lower right' : 4,
'right' : 5,
'center left' : 6,
'center right' : 7,
'lower center' : 8,
'upper center' : 9,
'center' : 10,
pad : pad around the child for drawing a frame. given in
fraction of fontsize.
borderpad : pad between offsetbox frame and the bbox_to_anchor,
child : OffsetBox instance that will be anchored.
prop : font property. This is only used as a reference for paddings.
frameon : draw a frame box if True.
bbox_to_anchor : bbox to anchor. Use self.axes.bbox if None.
bbox_transform : with which the bbox_to_anchor will be transformed.
"""
super(AnchoredOffsetbox, self).__init__(**kwargs)
self.set_bbox_to_anchor(bbox_to_anchor, bbox_transform)
self.set_child(child)
self.loc = loc
self.borderpad = borderpad
self.pad = pad
if prop is None:
self.prop = FontProperties(size=rcParams["legend.fontsize"])
elif isinstance(prop, dict):
self.prop = FontProperties(**prop)
if "size" not in prop:
self.prop.set_size(rcParams["legend.fontsize"])
else:
self.prop = prop
self.patch = FancyBboxPatch(
xy=(0.0, 0.0),
width=1.,
height=1.,
facecolor='w',
edgecolor='k',
mutation_scale=self.prop.get_size_in_points(),
snap=True)
self.patch.set_boxstyle("square", pad=0)
self._drawFrame = frameon
def set_child(self, child):
"set the child to be anchored"
self._child = child
def get_child(self):
"return the child"
return self._child
def get_children(self):
"return the list of children"
return [self._child]
def get_extent(self, renderer):
"""
return the extent of the artist. The extent of the child
added with the pad is returned
"""
w, h, xd, yd = self.get_child().get_extent(renderer)
fontsize = renderer.points_to_pixels(self.prop.get_size_in_points())
pad = self.pad * fontsize
return w + 2 * pad, h + 2 * pad, xd + pad, yd + pad
def get_bbox_to_anchor(self):
"""
return the bbox that the legend will be anchored
"""
if self._bbox_to_anchor is None:
return self.axes.bbox
else:
transform = self._bbox_to_anchor_transform
if transform is None:
return self._bbox_to_anchor
else:
return TransformedBbox(self._bbox_to_anchor, transform)
def set_bbox_to_anchor(self, bbox, transform=None):
"""
set the bbox that the child will be anchored.
*bbox* can be a Bbox instance, a list of [left, bottom, width,
height], or a list of [left, bottom] where the width and
height will be assumed to be zero. The bbox will be
transformed to display coordinate by the given transform.
"""
if bbox is None or isinstance(bbox, BboxBase):
self._bbox_to_anchor = bbox
else:
try:
l = len(bbox)
except TypeError:
raise ValueError("Invalid argument for bbox : %s" % str(bbox))
if l == 2:
bbox = [bbox[0], bbox[1], 0, 0]
self._bbox_to_anchor = Bbox.from_bounds(*bbox)
self._bbox_to_anchor_transform = transform
def get_window_extent(self, renderer):
'''
get the bounding box in display space.
'''
self._update_offset_func(renderer)
w, h, xd, yd = self.get_extent(renderer)
ox, oy = self.get_offset(w, h, xd, yd, renderer)
return Bbox.from_bounds(ox - xd, oy - yd, w, h)
def _update_offset_func(self, renderer, fontsize=None):
"""
Update the offset func which depends on the dpi of the
renderer (because of the padding).
"""
if fontsize is None:
fontsize = renderer.points_to_pixels(
self.prop.get_size_in_points())
def _offset(w, h, xd, yd, renderer, fontsize=fontsize, self=self):
bbox = Bbox.from_bounds(0, 0, w, h)
borderpad = self.borderpad * fontsize
bbox_to_anchor = self.get_bbox_to_anchor()
x0, y0 = self._get_anchored_bbox(self.loc, bbox, bbox_to_anchor,
borderpad)
return x0 + xd, y0 + yd
self.set_offset(_offset)
def update_frame(self, bbox, fontsize=None):
self.patch.set_bounds(bbox.x0, bbox.y0, bbox.width, bbox.height)
if fontsize:
self.patch.set_mutation_scale(fontsize)
def draw(self, renderer):
"draw the artist"
if not self.get_visible(): return
fontsize = renderer.points_to_pixels(self.prop.get_size_in_points())
self._update_offset_func(renderer, fontsize)
if self._drawFrame:
# update the location and size of the legend
bbox = self.get_window_extent(renderer)
self.update_frame(bbox, fontsize)
self.patch.draw(renderer)
width, height, xdescent, ydescent = self.get_extent(renderer)
px, py = self.get_offset(width, height, xdescent, ydescent, renderer)
self.get_child().set_offset((px, py))
self.get_child().draw(renderer)
def _get_anchored_bbox(self, loc, bbox, parentbbox, borderpad):
"""
return the position of the bbox anchored at the parentbbox
with the loc code, with the borderpad.
"""
assert loc in range(1, 11) # called only internally
BEST, UR, UL, LL, LR, R, CL, CR, LC, UC, C = range(11)
anchor_coefs = {
UR: "NE",
UL: "NW",
LL: "SW",
LR: "SE",
R: "E",
CL: "W",
CR: "E",
LC: "S",
UC: "N",
C: "C"
}
c = anchor_coefs[loc]
container = parentbbox.padded(-borderpad)
anchored_box = bbox.anchored(c, container=container)
return anchored_box.x0, anchored_box.y0
class AnimatedSpins(object):
def __init__(self, l, J, B, Ramp,
simul_step): #, spins, singweight, spinup, simul_step):
"""
Class for Ising 2D lattice animation
constructor takes as arguments
-- l: the lattice size
-- J: coupling constant
-- B: field
-- Ramp: speed at which J is increased/decreased
-- simul_step: routine which performs the update
"""
self.l = l
self.J = J
self.B = B
self.Ramp = Ramp
self.spins = np.ones((self.l, self.l), dtype=int)
self.spins[0, 0] = -1
self.singweight = np.exp(-2 * self.J * np.arange(-4, 5, 2))
self.spinup = np.exp(-2 * self.B * np.arange(-1, 2, 2))
self.xdata = [J]
self.MagPoint = np.sum(self.spins) / (self.l)**2
self.ydata = [self.MagPoint]
self.iter = 0
self.suspend = False
self.stream = self.data_stream()
self.simul_step = simul_step
self.fig, self.ax = plt.subplots(figsize=(10, 10))
plt.axis('off')
self.gs = gridspec.GridSpec(2,
2,
width_ratios=[1, 25],
height_ratios=[2, 1])
self.font = FontProperties()
self.font.set_size(20)
self.ax1 = self.fig.add_subplot(self.gs[0])
self.ax1.set_ylim(-1.0, 1.0)
self.ax1.tick_params(axis='x',
which='both',
bottom='off',
top='off',
labelbottom='off')
self.ax2 = self.fig.add_subplot(self.gs[1])
self.ax2.set_axis_off()
self.ax3 = self.fig.add_subplot(self.gs[3])
self.ax3.set_ylim(-1.0, 1.0)
self.ax3.set_xlim(0.0, 1.0)
self.ax3.set_xlabel('J', fontproperties=self.font)
self.ax3.set_ylabel('<s>', fontproperties=self.font)
self.ax3.axhline(color='red')
self.ax3.axvline(x=0.44, color='red')
self.line, = self.ax3.plot(self.xdata, self.ydata, lw=2)
plt.subplots_adjust(left=0.05, bottom=0.30)
axcolor = 'lightgoldenrodyellow'
self.axg = plt.axes([0.15, 0.05, 0.65, 0.03]) #, axisbg=axcolor)
self.axt = plt.axes([0.15, 0.10, 0.65, 0.03]) #, axisbg=axcolor)
self.axr = plt.axes([0.15, 0.15, 0.65, 0.03]) #, axisbg=axcolor)
self.axl = plt.axes([0.15, 0.20, 0.65, 0.03]) #, axisbg=axcolor)
self.Jslider = Slider(self.axg, 'J', 0.1, 1.0, valinit=0.3)
self.Bslider = Slider(self.axt, 'B', -0.5, 0.5, valinit=0.0)
self.Rslider = Slider(self.axr,
'Ramp',
-0.01,
0.01,
valinit=0.0,
valfmt=u'%1.5f')
self.Lslider = Slider(self.axl,
'L',
1,
200,
valinit=self.l,
valfmt=u'%3.0f')
self.im1 = self.ax1.add_patch(patches.Rectangle(
(0.0, 0.0),
1.0,
0.0,
))
self.im1.set_height(0.0)
self.im2 = self.ax2.imshow(0.5 * (self.spins + 1),
cmap='YlGn',
interpolation='nearest')
self.ani = animation.FuncAnimation(self.fig,
self.display,
self.simul_step(
self.l, self.spins,
self.singweight, self.spinup),
interval=40)
self.Jslider.on_changed(self.update)
self.Bslider.on_changed(self.update)
self.Rslider.on_changed(self.update)
self.Lslider.on_changed(self.update)
self.rar = plt.axes([0.78, 0.75, 0.15, 0.15]) #, axisbg=axcolor)
self.radio_reset = RadioButtons(self.rar, ('$T=0$', '$T=\infty$'))
self.radio_reset.on_clicked(self.reset_spins)
self.susb = plt.axes([0.78, 0.65, 0.15, 0.05]) #, axisbg=axcolor)
self.suspend_button = Button(self.susb,
"Click to suspend",
color=axcolor,
hovercolor='white')
self.suspend_button.on_clicked(self.suspend_MC)
self.resb = plt.axes([0.78, 0.55, 0.15, 0.05]) #, axisbg=axcolor)
self.reset_mag_button = Button(self.resb,
"Clear mag plot",
color=axcolor,
hovercolor='white')
self.reset_mag_button.on_clicked(self.reset_magplot)
def update(self, val):
""" This function is called whenever a slider has been changed """
self.J = self.Jslider.val
self.B = self.Bslider.val
self.Ramp = self.Rslider.val
self.singweight = np.exp(-2 * self.J * np.arange(-4, 5, 2))
self.spinup = np.exp(-2 * self.B * np.arange(-1, 2, 2))
OldL = self.l
self.l = np.int(self.Lslider.val / 2)
self.l = self.l * 2
if OldL != self.l:
self.reset_spins("T=0")
self.fig.canvas.draw()
self.Switch = True
def reset_spins(self, label):
""" Resets the spin to either the T=0 (ordered) or T=infty (disordered) configuration """
if label == '$T=0$':
self.spins = np.ones((self.l, self.l), dtype=int)
else:
self.spins = rand.random_integers(0, 1, (self.l, self.l))
self.spins = 2 * self.spins - 1
def suspend_MC(self, label):
""" MC simulation is suspended / resumed """
self.suspend = not (self.suspend)
if self.suspend:
self.suspend_button.label.set_text('Click to resume')
else:
self.suspend_button.label.set_text('Click to suspend')
def reset_magplot(self, label):
""" Resets the plot of the magnetization """
self.xdata = []
self.ydata = []
def data_stream(self):
"""
Calls spin update routine, copies it to the relevant section of the 'data' array which
is then yielded
"""
self.spins = self.simul_step(self.l, self.spins, self.singweight,
self.spinup)
data = self.spins
while True:
if not (self.suspend):
if (self.Ramp != 0):
self.J = self.J + self.Ramp
self.J = np.minimum(self.J, MaxJ)
self.J = np.maximum(self.J, MinJ)
self.singweight = np.exp(-2 * self.J * np.arange(-4, 5, 2))
self.spinup = np.exp(-2 * self.B * np.arange(-1, 2, 2))
self.spins = self.simul_step(self.l, self.spins,
self.singweight, self.spinup)
data = self.spins
yield data
def display(
self, i
): # , simul_step, l, spins, J, B, Ramp, singweight, spinup, xdata, ydata):
""" function called by FuncAnimation. Plots all graphs """
if (self.iter % 10) == 0:
self.Jslider.set_val(self.J)
self.iter = self.iter + 1
data = next(self.stream)
self.im2.set_data((data + 1) / 2)
self.im1.set_height(np.sum(data) / (self.l)**2)
self.MagPoint = np.sum(data) / (self.l)**2
self.xdata.append(self.J)
self.ydata.append(self.MagPoint)
self.line.set_data(self.xdata, self.ydata)
plt.draw()
return self.im1, self.im2, self.line, self.xdata, self.ydata
def show(self):
plt.show()
from __future__ import division, print_function
import sys, os, re, matplotlib
import numpy as np
import matplotlib.pyplot as plt
import numericalunits, colors
matplotlib.rcParams['text.usetex'] = True
from matplotlib.font_manager import FontProperties
small_font = FontProperties()
small_font.set_size('small')
matplotlib.rcParams['text.usetex'] = True
matplotlib.rc('font', family='serif')
"""
Create deliverable capacity and density plots from NIST Thermophysical fluid
data generated with isothermal-save-gas-csv.py using Python 3
Copyright (c) 2019 - 2020 Jordan K. Pommerenck
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
def test_plots2pdf(chnf,figNo,subplotNo,outfilename,pp,primaryAxisChs,secondaryAxisChs,layout,Primary2Ylabel):
# # this function is called for each OUT file, for each PDF
#if wanting to save iamges, check image outputs directory exists, and create if not:
# if SAVE_IMAGES and not os.path.exists(IMAGEDIR):
# os.makedirs(IMAGEDIR)
# # matplotlib general settings
fontP = FontProperties()
fontP.set_size('x-small') #will be used on legends
font = {'size': 8}
matplotlib.rc('font', **font) #set all matplotlib items to font size specified
matplotlib.rcParams['axes.linewidth'] = 0.1
# # extract channel file object data
sh_ttl, ch_id, ch_data = chnf.get_data()
sh_ttl, ch_id = chnf.get_id()
ch_range = chnf.get_range()
figNo2SubNo2Chs={}
sNo = subplotNo #sNo starts from subplotNo
fNo = figNo #fNo starts from figNo
for i in range(1,len(primaryAxisChs)+1):
if fNo not in figNo2SubNo2Chs.keys():
figNo2SubNo2Chs[fNo]={}
figNo2SubNo2Chs[fNo][sNo]=findChs(primaryAxisChs[i-1],ch_id)
sNo = sNo+1
if sNo > int(layout[0])*int(layout[1]):
sNo = 1
fNo = fNo+1
# subplotNo=sNo
# figNo=fNo
numRow = int(layout[0])
numCol = int(layout[1])
k = 0
for fNo in figNo2SubNo2Chs.keys():
"""matplotlib.pyplot.subplots(nrows=1, ncols=1, sharex=False, sharey=False, squeeze=True, subplot_kw=None, gridspec_kw=None, **fig_kw)
fig_kw : Dict with keywords passed to the figure() call. Note that all keywords not recognized above will be automatically included here."""
fig_kw = {'num': fNo}
f, axarr = plt.subplots(figsize=(11.7,8.3), nrows=int(layout[0]),ncols=int(layout[1]), **fig_kw)
f.suptitle(outfilename[:-4],fontsize = 10)
for sNo in figNo2SubNo2Chs[fNo].keys():
plt.subplot(int(layout+str(sNo)))
for i in figNo2SubNo2Chs[fNo][sNo]:
plt.plot(ch_data['time'], ch_data[i], label=ch_id[i])
#plt.autoscale(enable=True, axis='both', tight=False)
plt.autoscale(enable=True, axis='both', tight=False)
# BP added following to reset ylim if abs(ymax-ymin)<0.01-------------------
ymin, ymax = plt.ylim()
if abs(ymax-ymin) < 0.01:
yminnew = ymin-(0.01-abs(ymax-ymin))/2
ymaxnew = ymax+(0.01-abs(ymax-ymin))/2
plt.ylim(yminnew,ymaxnew)
# --------------------------------------------------------------------------
i = int(math.ceil(float(sNo)/float(numCol))) - 1 ######################
j = ((sNo) % numCol) - 1
if j < 0: #only true if nth subplot is at the end of a row
j = numCol - 1
ax = plt.subplot(int(layout[0]), int(layout[1]), int(layout[1]) * i + j + 1)
ax.get_xaxis().get_major_formatter().set_useOffset(False)
ax.get_yaxis().get_major_formatter().set_useOffset(False)
#---------------------------------------------------------------------------
#BP added follwoing, this code rely on numbering of output ch in dynamic sim
#Plotting reactive current
if secondaryAxisChs[k]=="Iq":
#ch_data[1] = INV1_Voltage, ch_data[3] = INV1_Qelec
num_UUT = 0
num_UUT2 = 0
chan_UUT_vol_id = 4
chan_UUT_Q_id = 6
# id_indx = 0
# for id_val_1 in ch_id:
# if "UUT_Voltage" in str(ch_id[id_val_1]):
# num_UUT = num_UUT + 1
# if num_UUT == 1:
# chan_UUT_vol_id = idIndx
# if "UUT_Qelec" in str(ch_id[id_val_1]):
# num_UUT2 = num_UUT2 + 1
# if num_UUT2 == 1:
# chan_UUT_Q_id = idIndx
# id_indx = id_indx + 1
Iq_Calc(outfilename,ch_data['time'],ch_data[chan_UUT_vol_id],ch_data[chan_UUT_Q_id])
#---------------------------------------------------------------------------
#---------------------------------------------------------------------------
#BP added follwoing, this code rely on numbering of output ch in dynamic sim
#Plotting reactive current
if secondaryAxisChs[k]=="Ip":
#ch_data[1] = INV1_Voltage, ch_data[3] = INV1_Qelec
P_Recovery_Calc(outfilename,ch_data['time'],ch_data[2])
#---------------------------------------------------------------------------
# # try to plot on secondary axis
ax2 = ax.twinx()
ChsS=[]
#---------------------------------------------------------------------------
#BP added follwoing, this code rely on numbering of output ch in dynamic sim
#Calculating rise time and settling time
if secondaryAxisChs[k]=="Rise time and settling time calc":
#ch_data[3] = INV1_Qelec
rise_settle_TimeCalc(ch_data['time'],ch_data[6])
#---------------------------------------------------------------------------
elif secondaryAxisChs[k]!="":
ChsS=findChs(secondaryAxisChs[k],ch_id)
for ch in ChsS:
ax2.plot(ch_data['time'],ch_data[ch],':',label=ch_id[ch])
ax2.autoscale(enable=True, axis='x', tight=True)
ax.grid(b=True, which='both', color='gray',linestyle=':')
ax.set_xlim(xmin=round(ch_range['time']['min']),xmax=round(ch_range['time']['max']))
primaryAxisChs[sNo-subplotNo] in Primary2Ylabel.keys()
if primaryAxisChs[sNo-subplotNo] in Primary2Ylabel.keys():
#if user has defined a specific y label for this set of primary axis content (e.g. VARS->Q)
ax.set_ylabel(Primary2Ylabel[primaryAxisChs[k]])
else:
#otherwise set y label to primary axis content
ax.set_ylabel(primaryAxisChs[k])
# # Shrink current axis's height by 10% on the bottom
box = axarr[i,j].get_position()
ax.set_position([box.x0, box.y0 + box.height * 0.1,box.width, box.height * 0.9])
# # Put a legend below current axis
if int(matplotlib.__version__.split('.')[0]) >= 2:
ax.legend(loc='center left', bbox_to_anchor=(0, -0.125), ncol=3, fontsize='x-small', frameon=False)
else:
ax.legend(loc='center left', bbox_to_anchor=(0, -0.125), ncol=3, prop=fontP, frameon=False)
if ENABLE_TITLE:
ax.set_title(primaryAxisChs[k])
#secondary axis labelling
if secondaryAxisChs[k] in Primary2Ylabel.keys():
ax2.set_ylabel(Primary2Ylabel[secondaryAxisChs[k]])
else:
ax2.set_ylabel(secondaryAxisChs[k])
if int(matplotlib.__version__.split('.')[0]) >= 2:
ax2.legend(loc='center right', bbox_to_anchor=(1, -0.125), ncol=3, fontsize='x-small', frameon=False)
else:
ax2.legend(loc='center right', bbox_to_anchor=(1, -0.125), ncol=3, prop=fontP, frameon=False)
k = k+1
if sNo == int(layout[0])*int(layout[1]):
plt.tight_layout(pad=5.0,w_pad=5.0, h_pad=7.0)
plt.savefig(pp, format='pdf') #bbox_inches='tight' #TM: added 29/07/2016
# if SAVE_IMAGES:
# plt.savefig(IMAGEDIR+outfilename+'_'+str(fNo)+'.png')
# print IMAGEDIR+outfilename+'_'+str(fNo)+'.png saved'
plt.close(f) # Added by BP to address python crashing issue experienced when plotting a large number of .out files
sNo = sNo+1
if sNo > int(layout[0])*int(layout[1]):
sNo = 1
fNo = fNo+1
subplotNo=sNo
figNo=fNo
return figNo,subplotNo
def make_line_plot(dir_path,
data_file_link,
background_color,
label_color,
xy_coords,
props,
x_len=8,
y_len=4,
draw_axes=False,
generate_eps=True):
""" Write a line plot
xy_coords: a dict of form {series_label:([x data], [y data], point_marker, color)}
(code adapted from Micah Hamady's code)
"""
rc('font', size='8')
rc('axes', linewidth=.5, edgecolor=label_color)
rc('axes', labelsize=8)
rc('xtick', labelsize=8)
rc('ytick', labelsize=8)
fig = figure(figsize=(x_len, y_len))
mtitle = props.get("title", "Groups")
x_label = props.get("xlabel", "X")
y_label = props.get("ylabel", "Y")
title('%s' % mtitle, fontsize='10', color=label_color)
xlabel(x_label, fontsize='8', color=label_color)
ylabel(y_label, fontsize='8', color=label_color)
sorted_keys = sorted(xy_coords.keys())
labels = []
for s_label in sorted_keys:
s_data = xy_coords[s_label]
c = s_data[3]
m = s_data[2]
plot(s_data[0],
s_data[1],
c=c,
marker=m,
label=s_label,
linewidth=.1,
ms=5,
alpha=1.0)
fp = FontProperties()
fp.set_size('8')
legend(prop=fp, loc=0)
show()
img_name = 'scree_plot.png'
savefig(os.path.join(dir_path, img_name),
dpi=80,
facecolor=background_color)
# Create zipped eps files
eps_link = ""
if generate_eps:
eps_img_name = str('scree_plot.eps')
savefig(os.path.join(dir_path, eps_img_name), format='eps')
out, err, retcode = qiime_system_call(
"gzip -f " + os.path.join(dir_path, eps_img_name))
eps_link = DOWNLOAD_LINK % (
(os.path.join(data_file_link, eps_img_name) + ".gz"),
"Download Figure")
return os.path.join(data_file_link, img_name), eps_link
fontsize=10)
#plot actual outputs
i = ps_inputs.index(alt)
ax2[(i - (i % 2)) / 2, i % 2].plot(output[0], output[1], '-r')
exp_x = np.arange(0.9 * min(IND_asses), 1.1 * max(IND_asses),
(max(IND_asses) - min(IND_asses)) / 50.)
exp_y = fuzz.trapmf(
exp_x,
[min(IND_asses),
min(IND_asses),
max(IND_asses),
max(IND_asses)])
ax2[(i - (i % 2)) / 2, i % 2].plot(exp_x, exp_y, '-b')
ax1.set_ylim([0, 11])
ax1.set_xlim([0.6, 1.0])
ax1.yaxis.grid(True)
ax1.set_yticks(range(1, 11))
ax1.set_yticklabels([alt[0] for alt in ps_inputs])
ax1.set_xlabel('System Propulsive Efficiency')
fontP = FontProperties()
fontP.set_size('medium')
ax1.legend(['Fuzzy System Output', 'Expert System Evaluations'],
bbox_to_anchor=(1.0, 1.06),
prop=fontP)
plt.draw()
plt.show()
import matplotlib.pyplot as plt
import numpy as np
from matplotlib import style
from matplotlib.font_manager import FontProperties
plt.rcParams['axes.autolimit_mode'] = 'round_numbers'
plt.rcParams['axes.xmargin'] = 0.
plt.rcParams['axes.ymargin'] = 0.
fontP = FontProperties()
fontP.set_size('smaller')
fig1, ax1 = plt.subplots()
yref = 25
ax2 = ax1.twinx()
x, y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17 = np.loadtxt(
'07july2017_chambdata.csv', unpack=True, delimiter=',', skiprows=1)
#ax1.plot(x,y1,label="101_Temp")
#ax1.plot(x,y2,label="102_Temp")
#ax1.plot(x,y3,label="103_Temp")
#ax1.plot(x,y4,label="104_Temp")
#ax1.plot(x,y5,label="105_Temp")
#ax1.plot(x,y6,label="106_Temp")
#ax1.plot(x,y7,label="107_Temp")
#ax1.plot(x,y8,label="108_Temp")
#ax1.plot(x,y9,label="109_Temp")
#ax1.plot(x,y10,label="110_Temp")
#ax1.plot(x,y11,label="111_Temp")
#ax1.plot(x,y12,label="112_Temp")
#ax1.plot(x,y13,label="113_Temp")
class Legend(Artist):
"""
Place a legend on the axes at location loc. Labels are a
sequence of strings and loc can be a string or an integer
specifying the legend location
The location codes are::
'best' : 0, (only implemented for axes legends)
'upper right' : 1,
'upper left' : 2,
'lower left' : 3,
'lower right' : 4,
'right' : 5, (same as 'center right', for back-compatibility)
'center left' : 6,
'center right' : 7,
'lower center' : 8,
'upper center' : 9,
'center' : 10,
loc can be a tuple of the normalized coordinate values with
respect its parent.
"""
codes = {
'best': 0, # only implemented for axes legends
'upper right': 1,
'upper left': 2,
'lower left': 3,
'lower right': 4,
'right': 5,
'center left': 6,
'center right': 7,
'lower center': 8,
'upper center': 9,
'center': 10,
}
zorder = 5
def __str__(self):
return "Legend"
def __init__(
self,
parent,
handles,
labels,
loc=None,
numpoints=None, # the number of points in the legend line
markerscale=None, # the relative size of legend markers
# vs. original
markerfirst=True, # controls ordering (left-to-right) of
# legend marker and label
scatterpoints=None, # number of scatter points
scatteryoffsets=None,
prop=None, # properties for the legend texts
fontsize=None, # keyword to set font size directly
# spacing & pad defined as a fraction of the font-size
borderpad=None, # the whitespace inside the legend border
labelspacing=None, # the vertical space between the legend
# entries
handlelength=None, # the length of the legend handles
handleheight=None, # the height of the legend handles
handletextpad=None, # the pad between the legend handle
# and text
borderaxespad=None, # the pad between the axes and legend
# border
columnspacing=None, # spacing between columns
ncol=1, # number of columns
mode=None, # mode for horizontal distribution of columns.
# None, "expand"
fancybox=None, # True use a fancy box, false use a rounded
# box, none use rc
shadow=None,
title=None, # set a title for the legend
framealpha=None, # set frame alpha
edgecolor=None, # frame patch edgecolor
facecolor=None, # frame patch facecolor
bbox_to_anchor=None, # bbox that the legend will be anchored.
bbox_transform=None, # transform for the bbox
frameon=None, # draw frame
handler_map=None,
):
"""
- *parent*: the artist that contains the legend
- *handles*: a list of artists (lines, patches) to be added to the
legend
- *labels*: a list of strings to label the legend
Optional keyword arguments:
================ ====================================================
Keyword Description
================ ====================================================
loc Location code string, or tuple (see below).
prop the font property
fontsize the font size (used only if prop is not specified)
markerscale the relative size of legend markers vs. original
markerfirst If True (default), marker is to left of the label.
numpoints the number of points in the legend for line
scatterpoints the number of points in the legend for scatter plot
scatteryoffsets a list of yoffsets for scatter symbols in legend
frameon If True, draw the legend on a patch (frame).
fancybox If True, draw the frame with a round fancybox.
shadow If True, draw a shadow behind legend.
framealpha Transparency of the frame.
edgecolor Frame edgecolor.
facecolor Frame facecolor.
ncol number of columns
borderpad the fractional whitespace inside the legend border
labelspacing the vertical space between the legend entries
handlelength the length of the legend handles
handleheight the height of the legend handles
handletextpad the pad between the legend handle and text
borderaxespad the pad between the axes and legend border
columnspacing the spacing between columns
title the legend title
bbox_to_anchor the bbox that the legend will be anchored.
bbox_transform the transform for the bbox. transAxes if None.
================ ====================================================
The pad and spacing parameters are measured in font-size units. e.g.,
a fontsize of 10 points and a handlelength=5 implies a handlelength of
50 points. Values from rcParams will be used if None.
Users can specify any arbitrary location for the legend using the
*bbox_to_anchor* keyword argument. bbox_to_anchor can be an instance
of BboxBase(or its derivatives) or a tuple of 2 or 4 floats.
See :meth:`set_bbox_to_anchor` for more detail.
The legend location can be specified by setting *loc* with a tuple of
2 floats, which is interpreted as the lower-left corner of the legend
in the normalized axes coordinate.
"""
# local import only to avoid circularity
from matplotlib.axes import Axes
from matplotlib.figure import Figure
Artist.__init__(self)
if prop is None:
if fontsize is not None:
self.prop = FontProperties(size=fontsize)
else:
self.prop = FontProperties(size=rcParams["legend.fontsize"])
elif isinstance(prop, dict):
self.prop = FontProperties(**prop)
if "size" not in prop:
self.prop.set_size(rcParams["legend.fontsize"])
else:
self.prop = prop
self._fontsize = self.prop.get_size_in_points()
self.texts = []
self.legendHandles = []
self._legend_title_box = None
#: A dictionary with the extra handler mappings for this Legend
#: instance.
self._custom_handler_map = handler_map
locals_view = locals()
for name in [
"numpoints", "markerscale", "shadow", "columnspacing",
"scatterpoints", "handleheight", 'borderpad', 'labelspacing',
'handlelength', 'handletextpad', 'borderaxespad'
]:
if locals_view[name] is None:
value = rcParams["legend." + name]
else:
value = locals_view[name]
setattr(self, name, value)
del locals_view
handles = list(handles)
if len(handles) < 2:
ncol = 1
self._ncol = ncol
if self.numpoints <= 0:
raise ValueError("numpoints must be > 0; it was %d" % numpoints)
# introduce y-offset for handles of the scatter plot
if scatteryoffsets is None:
self._scatteryoffsets = np.array([3. / 8., 4. / 8., 2.5 / 8.])
else:
self._scatteryoffsets = np.asarray(scatteryoffsets)
reps = self.scatterpoints // len(self._scatteryoffsets) + 1
self._scatteryoffsets = np.tile(self._scatteryoffsets,
reps)[:self.scatterpoints]
# _legend_box is an OffsetBox instance that contains all
# legend items and will be initialized from _init_legend_box()
# method.
self._legend_box = None
if isinstance(parent, Axes):
self.isaxes = True
self.axes = parent
self.set_figure(parent.figure)
elif isinstance(parent, Figure):
self.isaxes = False
self.set_figure(parent)
else:
raise TypeError("Legend needs either Axes or Figure as parent")
self.parent = parent
if loc is None:
loc = rcParams["legend.loc"]
if not self.isaxes and loc in [0, 'best']:
loc = 'upper right'
if isinstance(loc, six.string_types):
if loc not in self.codes:
if self.isaxes:
warnings.warn('Unrecognized location "%s". Falling back '
'on "best"; valid locations are\n\t%s\n' %
(loc, '\n\t'.join(self.codes)))
loc = 0
else:
warnings.warn('Unrecognized location "%s". Falling back '
'on "upper right"; '
'valid locations are\n\t%s\n' %
(loc, '\n\t'.join(self.codes)))
loc = 1
else:
loc = self.codes[loc]
if not self.isaxes and loc == 0:
warnings.warn('Automatic legend placement (loc="best") not '
'implemented for figure legend. '
'Falling back on "upper right".')
loc = 1
self._mode = mode
self.set_bbox_to_anchor(bbox_to_anchor, bbox_transform)
# We use FancyBboxPatch to draw a legend frame. The location
# and size of the box will be updated during the drawing time.
if facecolor is None:
facecolor = rcParams["legend.facecolor"]
if facecolor == 'inherit':
facecolor = rcParams["axes.facecolor"]
if edgecolor is None:
edgecolor = rcParams["legend.edgecolor"]
if edgecolor == 'inherit':
edgecolor = rcParams["axes.edgecolor"]
self.legendPatch = FancyBboxPatch(xy=(0.0, 0.0),
width=1.,
height=1.,
facecolor=facecolor,
edgecolor=edgecolor,
mutation_scale=self._fontsize,
snap=True)
# The width and height of the legendPatch will be set (in the
# draw()) to the length that includes the padding. Thus we set
# pad=0 here.
if fancybox is None:
fancybox = rcParams["legend.fancybox"]
if fancybox:
self.legendPatch.set_boxstyle("round", pad=0, rounding_size=0.2)
else:
self.legendPatch.set_boxstyle("square", pad=0)
self._set_artist_props(self.legendPatch)
self._drawFrame = frameon
if frameon is None:
self._drawFrame = rcParams["legend.frameon"]
# init with null renderer
self._init_legend_box(handles, labels, markerfirst)
# If shadow is activated use framealpha if not
# explicitly passed. See Issue 8943
if framealpha is None:
if shadow:
self.get_frame().set_alpha(1)
else:
self.get_frame().set_alpha(rcParams["legend.framealpha"])
else:
self.get_frame().set_alpha(framealpha)
self._loc = loc
self.set_title(title)
self._last_fontsize_points = self._fontsize
self._draggable = None
def _set_artist_props(self, a):
"""
set the boilerplate props for artists added to axes
"""
a.set_figure(self.figure)
if self.isaxes:
# a.set_axes(self.axes)
a.axes = self.axes
a.set_transform(self.get_transform())
def _set_loc(self, loc):
# find_offset function will be provided to _legend_box and
# _legend_box will draw itself at the location of the return
# value of the find_offset.
self._loc_real = loc
self.stale = True
def _get_loc(self):
return self._loc_real
_loc = property(_get_loc, _set_loc)
def _findoffset(self, width, height, xdescent, ydescent, renderer):
"Helper function to locate the legend"
if self._loc == 0: # "best".
x, y = self._find_best_position(width, height, renderer)
elif self._loc in Legend.codes.values(): # Fixed location.
bbox = Bbox.from_bounds(0, 0, width, height)
x, y = self._get_anchored_bbox(self._loc, bbox,
self.get_bbox_to_anchor(), renderer)
else: # Axes or figure coordinates.
fx, fy = self._loc
bbox = self.get_bbox_to_anchor()
x, y = bbox.x0 + bbox.width * fx, bbox.y0 + bbox.height * fy
return x + xdescent, y + ydescent
@allow_rasterization
def draw(self, renderer):
"Draw everything that belongs to the legend"
if not self.get_visible():
return
renderer.open_group('legend')
fontsize = renderer.points_to_pixels(self._fontsize)
# if mode == fill, set the width of the legend_box to the
# width of the paret (minus pads)
if self._mode in ["expand"]:
pad = 2 * (self.borderaxespad + self.borderpad) * fontsize
self._legend_box.set_width(self.get_bbox_to_anchor().width - pad)
# update the location and size of the legend. This needs to
# be done in any case to clip the figure right.
bbox = self._legend_box.get_window_extent(renderer)
self.legendPatch.set_bounds(bbox.x0, bbox.y0, bbox.width, bbox.height)
self.legendPatch.set_mutation_scale(fontsize)
if self._drawFrame:
if self.shadow:
shadow = Shadow(self.legendPatch, 2, -2)
shadow.draw(renderer)
self.legendPatch.draw(renderer)
self._legend_box.draw(renderer)
renderer.close_group('legend')
self.stale = False
def _approx_text_height(self, renderer=None):
"""
Return the approximate height of the text. This is used to place
the legend handle.
"""
if renderer is None:
return self._fontsize
else:
return renderer.points_to_pixels(self._fontsize)
# _default_handler_map defines the default mapping between plot
# elements and the legend handlers.
_default_handler_map = {
StemContainer:
legend_handler.HandlerStem(),
ErrorbarContainer:
legend_handler.HandlerErrorbar(),
Line2D:
legend_handler.HandlerLine2D(),
Patch:
legend_handler.HandlerPatch(),
LineCollection:
legend_handler.HandlerLineCollection(),
RegularPolyCollection:
legend_handler.HandlerRegularPolyCollection(),
CircleCollection:
legend_handler.HandlerCircleCollection(),
BarContainer:
legend_handler.HandlerPatch(
update_func=legend_handler.update_from_first_child),
tuple:
legend_handler.HandlerTuple(),
PathCollection:
legend_handler.HandlerPathCollection(),
PolyCollection:
legend_handler.HandlerPolyCollection()
}
# (get|set|update)_default_handler_maps are public interfaces to
# modify the default handler map.
@classmethod
def get_default_handler_map(cls):
"""
A class method that returns the default handler map.
"""
return cls._default_handler_map
@classmethod
def set_default_handler_map(cls, handler_map):
"""
A class method to set the default handler map.
"""
cls._default_handler_map = handler_map
@classmethod
def update_default_handler_map(cls, handler_map):
"""
A class method to update the default handler map.
"""
cls._default_handler_map.update(handler_map)
def get_legend_handler_map(self):
"""
return the handler map.
"""
default_handler_map = self.get_default_handler_map()
if self._custom_handler_map:
hm = default_handler_map.copy()
hm.update(self._custom_handler_map)
return hm
else:
return default_handler_map
@staticmethod
def get_legend_handler(legend_handler_map, orig_handle):
"""
return a legend handler from *legend_handler_map* that
corresponds to *orig_handler*.
*legend_handler_map* should be a dictionary object (that is
returned by the get_legend_handler_map method).
It first checks if the *orig_handle* itself is a key in the
*legend_hanler_map* and return the associated value.
Otherwise, it checks for each of the classes in its
method-resolution-order. If no matching key is found, it
returns None.
"""
if is_hashable(orig_handle):
try:
return legend_handler_map[orig_handle]
except KeyError:
pass
for handle_type in type(orig_handle).mro():
try:
return legend_handler_map[handle_type]
except KeyError:
pass
return None
def _init_legend_box(self, handles, labels, markerfirst=True):
"""
Initialize the legend_box. The legend_box is an instance of
the OffsetBox, which is packed with legend handles and
texts. Once packed, their location is calculated during the
drawing time.
"""
fontsize = self._fontsize
# legend_box is a HPacker, horizontally packed with
# columns. Each column is a VPacker, vertically packed with
# legend items. Each legend item is HPacker packed with
# legend handleBox and labelBox. handleBox is an instance of
# offsetbox.DrawingArea which contains legend handle. labelBox
# is an instance of offsetbox.TextArea which contains legend
# text.
text_list = [] # the list of text instances
handle_list = [] # the list of text instances
label_prop = dict(
verticalalignment='baseline',
horizontalalignment='left',
fontproperties=self.prop,
)
labelboxes = []
handleboxes = []
# The approximate height and descent of text. These values are
# only used for plotting the legend handle.
descent = 0.35 * self._approx_text_height() * (self.handleheight - 0.7)
# 0.35 and 0.7 are just heuristic numbers and may need to be improved.
height = self._approx_text_height() * self.handleheight - descent
# each handle needs to be drawn inside a box of (x, y, w, h) =
# (0, -descent, width, height). And their coordinates should
# be given in the display coordinates.
# The transformation of each handle will be automatically set
# to self.get_trasnform(). If the artist does not use its
# default transform (e.g., Collections), you need to
# manually set their transform to the self.get_transform().
legend_handler_map = self.get_legend_handler_map()
for orig_handle, lab in zip(handles, labels):
handler = self.get_legend_handler(legend_handler_map, orig_handle)
if handler is None:
warnings.warn(
"Legend does not support {!r} instances.\nA proxy artist "
"may be used instead.\nSee: "
"http://matplotlib.org/users/legend_guide.html"
"#creating-artists-specifically-for-adding-to-the-legend-"
"aka-proxy-artists".format(orig_handle))
# We don't have a handle for this artist, so we just defer
# to None.
handle_list.append(None)
else:
textbox = TextArea(lab,
textprops=label_prop,
multilinebaseline=True,
minimumdescent=True)
text_list.append(textbox._text)
labelboxes.append(textbox)
handlebox = DrawingArea(width=self.handlelength * fontsize,
height=height,
xdescent=0.,
ydescent=descent)
handleboxes.append(handlebox)
# Create the artist for the legend which represents the
# original artist/handle.
handle_list.append(
handler.legend_artist(self, orig_handle, fontsize,
handlebox))
if handleboxes:
# We calculate number of rows in each column. The first
# (num_largecol) columns will have (nrows+1) rows, and remaining
# (num_smallcol) columns will have (nrows) rows.
ncol = min(self._ncol, len(handleboxes))
nrows, num_largecol = divmod(len(handleboxes), ncol)
num_smallcol = ncol - num_largecol
# starting index of each column and number of rows in it.
rows_per_col = [nrows + 1] * num_largecol + [nrows] * num_smallcol
start_idxs = np.concatenate([[0], np.cumsum(rows_per_col)[:-1]])
cols = zip(start_idxs, rows_per_col)
else:
cols = []
handle_label = list(zip(handleboxes, labelboxes))
columnbox = []
for i0, di in cols:
# pack handleBox and labelBox into itemBox
itemBoxes = [
HPacker(pad=0,
sep=self.handletextpad * fontsize,
children=[h, t] if markerfirst else [t, h],
align="baseline") for h, t in handle_label[i0:i0 + di]
]
# minimumdescent=False for the text of the last row of the column
if markerfirst:
itemBoxes[-1].get_children()[1].set_minimumdescent(False)
else:
itemBoxes[-1].get_children()[0].set_minimumdescent(False)
# pack columnBox
alignment = "baseline" if markerfirst else "right"
columnbox.append(
VPacker(pad=0,
sep=self.labelspacing * fontsize,
align=alignment,
children=itemBoxes))
mode = "expand" if self._mode == "expand" else "fixed"
sep = self.columnspacing * fontsize
self._legend_handle_box = HPacker(pad=0,
sep=sep,
align="baseline",
mode=mode,
children=columnbox)
self._legend_title_box = TextArea("")
self._legend_box = VPacker(
pad=self.borderpad * fontsize,
sep=self.labelspacing * fontsize,
align="center",
children=[self._legend_title_box, self._legend_handle_box])
self._legend_box.set_figure(self.figure)
self._legend_box.set_offset(self._findoffset)
self.texts = text_list
self.legendHandles = handle_list
def _auto_legend_data(self):
"""
Returns list of vertices and extents covered by the plot.
Returns a two long list.
First element is a list of (x, y) vertices (in
display-coordinates) covered by all the lines and line
collections, in the legend's handles.
Second element is a list of bounding boxes for all the patches in
the legend's handles.
"""
# should always hold because function is only called internally
assert self.isaxes
ax = self.parent
bboxes = []
lines = []
offsets = []
for handle in ax.lines:
assert isinstance(handle, Line2D)
path = handle.get_path()
trans = handle.get_transform()
tpath = trans.transform_path(path)
lines.append(tpath)
for handle in ax.patches:
assert isinstance(handle, Patch)
if isinstance(handle, Rectangle):
transform = handle.get_data_transform()
bboxes.append(handle.get_bbox().transformed(transform))
else:
transform = handle.get_transform()
bboxes.append(handle.get_path().get_extents(transform))
for handle in ax.collections:
transform, transOffset, hoffsets, paths = handle._prepare_points()
if len(hoffsets):
for offset in transOffset.transform(hoffsets):
offsets.append(offset)
try:
vertices = np.concatenate([l.vertices for l in lines])
except ValueError:
vertices = np.array([])
return [vertices, bboxes, lines, offsets]
def draw_frame(self, b):
'b is a boolean. Set draw frame to b'
self.set_frame_on(b)
def get_children(self):
'return a list of child artists'
children = []
if self._legend_box:
children.append(self._legend_box)
children.append(self.get_frame())
return children
def get_frame(self):
'return the Rectangle instance used to frame the legend'
return self.legendPatch
def get_lines(self):
'return a list of lines.Line2D instances in the legend'
return [h for h in self.legendHandles if isinstance(h, Line2D)]
def get_patches(self):
'return a list of patch instances in the legend'
return silent_list(
'Patch', [h for h in self.legendHandles if isinstance(h, Patch)])
def get_texts(self):
'return a list of text.Text instance in the legend'
return silent_list('Text', self.texts)
def set_title(self, title, prop=None):
"""
set the legend title. Fontproperties can be optionally set
with *prop* parameter.
"""
self._legend_title_box._text.set_text(title)
if prop is not None:
if isinstance(prop, dict):
prop = FontProperties(**prop)
self._legend_title_box._text.set_fontproperties(prop)
if title:
self._legend_title_box.set_visible(True)
else:
self._legend_title_box.set_visible(False)
self.stale = True
def get_title(self):
'return Text instance for the legend title'
return self._legend_title_box._text
def get_window_extent(self, *args, **kwargs):
'return a extent of the legend'
return self.legendPatch.get_window_extent(*args, **kwargs)
def get_frame_on(self):
"""
Get whether the legend box patch is drawn
"""
return self._drawFrame
def set_frame_on(self, b):
"""
Set whether the legend box patch is drawn
ACCEPTS: [ *True* | *False* ]
"""
self._drawFrame = b
self.stale = True
def get_bbox_to_anchor(self):
"""
return the bbox that the legend will be anchored
"""
if self._bbox_to_anchor is None:
return self.parent.bbox
else:
return self._bbox_to_anchor
def set_bbox_to_anchor(self, bbox, transform=None):
"""
set the bbox that the legend will be anchored.
*bbox* can be a BboxBase instance, a tuple of [left, bottom,
width, height] in the given transform (normalized axes
coordinate if None), or a tuple of [left, bottom] where the
width and height will be assumed to be zero.
"""
if bbox is None:
self._bbox_to_anchor = None
return
elif isinstance(bbox, BboxBase):
self._bbox_to_anchor = bbox
else:
try:
l = len(bbox)
except TypeError:
raise ValueError("Invalid argument for bbox : %s" % str(bbox))
if l == 2:
bbox = [bbox[0], bbox[1], 0, 0]
self._bbox_to_anchor = Bbox.from_bounds(*bbox)
if transform is None:
transform = BboxTransformTo(self.parent.bbox)
self._bbox_to_anchor = TransformedBbox(self._bbox_to_anchor, transform)
self.stale = True
def _get_anchored_bbox(self, loc, bbox, parentbbox, renderer):
"""
Place the *bbox* inside the *parentbbox* according to a given
location code. Return the (x,y) coordinate of the bbox.
- loc: a location code in range(1, 11).
This corresponds to the possible values for self._loc, excluding
"best".
- bbox: bbox to be placed, display coodinate units.
- parentbbox: a parent box which will contain the bbox. In
display coordinates.
"""
assert loc in range(1, 11) # called only internally
BEST, UR, UL, LL, LR, R, CL, CR, LC, UC, C = list(xrange(11))
anchor_coefs = {
UR: "NE",
UL: "NW",
LL: "SW",
LR: "SE",
R: "E",
CL: "W",
CR: "E",
LC: "S",
UC: "N",
C: "C"
}
c = anchor_coefs[loc]
fontsize = renderer.points_to_pixels(self._fontsize)
container = parentbbox.padded(-(self.borderaxespad) * fontsize)
anchored_box = bbox.anchored(c, container=container)
return anchored_box.x0, anchored_box.y0
def _find_best_position(self, width, height, renderer, consider=None):
"""
Determine the best location to place the legend.
`consider` is a list of (x, y) pairs to consider as a potential
lower-left corner of the legend. All are display coords.
"""
# should always hold because function is only called internally
assert self.isaxes
verts, bboxes, lines, offsets = self._auto_legend_data()
bbox = Bbox.from_bounds(0, 0, width, height)
if consider is None:
consider = [
self._get_anchored_bbox(x, bbox, self.get_bbox_to_anchor(),
renderer)
for x in range(1, len(self.codes))
]
candidates = []
for idx, (l, b) in enumerate(consider):
legendBox = Bbox.from_bounds(l, b, width, height)
badness = 0
# XXX TODO: If markers are present, it would be good to
# take them into account when checking vertex overlaps in
# the next line.
badness = (legendBox.count_contains(verts) +
legendBox.count_contains(offsets) +
legendBox.count_overlaps(bboxes) + sum(
line.intersects_bbox(legendBox, filled=False)
for line in lines))
if badness == 0:
return l, b
# Include the index to favor lower codes in case of a tie.
candidates.append((badness, idx, (l, b)))
_, _, (l, b) = min(candidates)
return l, b
def contains(self, event):
return self.legendPatch.contains(event)
def draggable(self, state=None, use_blit=False, update="loc"):
"""
Set the draggable state -- if state is
* None : toggle the current state
* True : turn draggable on
* False : turn draggable off
If draggable is on, you can drag the legend on the canvas with
the mouse. The DraggableLegend helper instance is returned if
draggable is on.
The update parameter control which parameter of the legend changes
when dragged. If update is "loc", the *loc* parameter of the legend
is changed. If "bbox", the *bbox_to_anchor* parameter is changed.
"""
is_draggable = self._draggable is not None
# if state is None we'll toggle
if state is None:
state = not is_draggable
if state:
if self._draggable is None:
self._draggable = DraggableLegend(self,
use_blit,
update=update)
else:
if self._draggable is not None:
self._draggable.disconnect()
self._draggable = None
return self._draggable
def create_benchmark_plot(train_X,
train_y,
test_X,
test_y,
clf,
splits=20,
plot_outfile=None,
y_ticks=0.025,
min_y_lim=0.4):
"""
This method creates a benchmark plot.
:param train_X:
:param train_y:
:param test_X:
:param test_y:
:param clf:
:param splits:
:param plot_outfile:
:param y_ticks:
:param min_y_lim:
:return:
"""
results = {'train_size': [], 'on_test': [], 'on_train': []}
# splitting the train X in n (almost) equal splits)
train_x_splits = np.array_split(ary=train_X,
indices_or_sections=splits,
axis=0)
# splitting the train y in the same splits as the train X
train_y_splits = np.array_split(ary=train_y,
indices_or_sections=splits,
axis=0)
# setting parameters for the graph.
font_p = FontProperties()
font_p.set_size('small')
fig = plt.figure()
fig.suptitle('Learning Curves', fontsize=20)
ax = fig.add_subplot(111)
ax.axis(xmin=0, xmax=train_X.shape[0] * 1.05, ymin=0, ymax=1.1)
plt.xlabel('N. of training instances', fontsize=18)
plt.ylabel('Accuracy', fontsize=16)
plt.grid(True)
plt.axvline(x=int(train_X.shape[0] * 0.3))
plt.yticks(np.arange(0, 1.025, 0.025))
if y_ticks == 0.05:
plt.yticks(np.arange(0, 1.025, 0.05))
elif y_ticks == 0.025:
plt.yticks(np.arange(0, 1.025, 0.025))
plt.ylim([min_y_lim, 1.025])
# each time adds up one split and refits the model.
for i in range(1, splits + 1):
train_x_part = np.concatenate(train_x_splits[:i])
train_y_part = np.concatenate(train_y_splits[:i])
print(20 * '*')
print('Split {} size: {}'.format(i, train_x_part.shape))
results['train_size'].append(train_x_part.shape[0])
result_on_test = benchmark(clf=clf,
train_X=train_x_part,
train_y=train_y_part,
test_X=test_X,
test_y=test_y)
# calculates each time the metrics also on the test.
results['on_test'].append(result_on_test['accuracy'])
# calculates the metrics for the given training part
result_on_train_part = benchmark(clf=clf,
train_X=train_x_part,
train_y=train_y_part,
test_X=train_x_part,
test_y=train_y_part)
results['on_train'].append(result_on_train_part['accuracy'])
line_up, = ax.plot(results['train_size'],
results['on_train'],
'o-',
label='Accuracy on Train')
line_down, = ax.plot(results['train_size'],
results['on_test'],
'o-',
label='Accuracy on Test')
plt.legend([line_up, line_down],
['Accuracy on Train', 'Accuracy on Test'],
prop=font_p)
if plot_outfile:
fig.savefig(plot_outfile)
plt.show()
return results
def full_matrix_hnn():
m_encoder = scalar_sdr(40,22,-0.25,0.25,(6,12))
b_encoder = scalar_sdr(460,200,0.0,1.0)
# calculate number of nodes
nodes = m_encoder.n*reduce(lambda x, y: x*y, m_encoder.ndarray_shape) + b_encoder.n
# initialize hopfield net
hnn = Hopfield_Neural_Network(nodes)
# store data in hnn i.e. brain_id -- matrix[brain_id] pairs
for id_ in brain_id:
data = np.array([])
matrix = matrices[id_]
matrix = m_encoder.encode_ndarray(matrix)
data = np.append(data,matrix.flatten())
brain_sig = brain_id[id_]
brain_sig = b_encoder.encode(brain_sig)
data = np.append(data,brain_sig)
hnn.store(data)
durations = []
diffs = []
samples = 10
for i in range(samples):
for id_ in matrices:
# setup input with complete brain_id signal
data = np.zeros(m_encoder.n*reduce(lambda x, y: x*y, m_encoder.ndarray_shape))-1
brain_sig = brain_id[id_]
brain_sig = b_encoder.encode(brain_sig)
data = np.append(data,brain_sig)
# set number of iterations -- proportional to number of nodes (i.e. 300*72 = 21600)
hnn.setIter(21600)
# recall matrix value
t0 = time.time()
mem = hnn.recall(data)
duration = time.time()-t0
durations.append(duration)
# decode recalled matrix
mem_decoded = m_encoder.decode_ndarray(mem[0:m_encoder.n*reduce(lambda x, y: x*y, m_encoder.ndarray_shape)])
# calculate recall error
matrix_decoded = m_encoder.decode_ndarray(m_encoder.encode_ndarray(matrices[id_]).flatten())
diff = mem_decoded-matrix_decoded
diffs.append(abs(np.array(diff)))
# print meta data
print "mean: ", np.mean(np.array(diffs).flatten())
print "max: ", np.max(np.array(diffs).flatten())
print "std: ", np.std(np.array(diffs).flatten())
print "duration: ", np.mean(durations)
# Bar graph plot
# plotting constants
max_ = 0.5
bars = 40
# calculate category indices
categories = []
for i in range(bars):
categories.append(i*max_/bars)
width = categories[1]
# tally number of instances for each category
values = np.zeros(bars)
for diff in np.array(diffs).flatten():
i = int(diff/(max_+0.0000001)*bars)
values[i] += 1
# divide by number of samples to obtain normalized score
values /= samples
values /= 288.
# plot bar graph
from matplotlib.font_manager import FontProperties
fontP = FontProperties()
fontP.set_size('small')
plt.figure(1)
plt.title("Average error distribution across 10 samples")
plt.bar(categories, values, width, align='center')
plt.xlabel("Error bars - width = %0.4f" %(max_/bars))
plt.ylabel("Proportion")
plt.show()
# print number of values that fall into first category (good approximation of how well the memory does)
print "Values[0]: ", values[0]
def visualize():
def load(lib):
batch = np.loadtxt("results-batch-size-%s.csv" % lib, delimiter=",")
nfeat = np.loadtxt("results-nfeat-%s.csv" % lib, delimiter=",")
return batch, nfeat
fig, axes = plt.subplots(nrows=2, ncols=2)
sns.despine()
# sns.set_context("poster")
fig.set_figheight(6)
fig.set_figwidth(9)
names = [f[f.index('size-') + 5:-4] for f in glob('*size*.csv')]
for name in names:
batch_res, nfeat_res = load(name)
axes[0, 0].plot(batch_res[:, 0], batch_res[:, 1], label=name)
axes[0, 1].plot(nfeat_res[:, 0], nfeat_res[:, 1], label=name)
# pytorch_batch, pytorch_nfeat = load("pytorch")
# spflow_batch, spflow_nfeat = load("spflow")
# tf_batch, tf_nfeat = load("spflow-tf")
# spflow_layers_batch, spflow_layers_nfeat = load("spflow-layer")
# Plot absolute values
#axes[0, 0].plot(spflow_batch[:, 0], spflow_batch[:, 1], label="SPFlow")
#axes[0, 0].plot(tf_batch[:, 0], tf_batch[:, 1], label="SPFlow-TF")
#axes[0, 0].plot(pytorch_batch[:, 0], pytorch_batch[:, 1], label="Layerwise PyTorch")
#axes[0, 0].plot(spflow_layers_batch[:, 0], spflow_layers_batch[:, 1], label="SPFlow Layers")
#axes[0, 1].plot(spflow_nfeat[:, 0], spflow_nfeat[:, 1], label="SPFlow")
#axes[0, 1].plot(tf_nfeat[:, 0], tf_nfeat[:, 1], label="SPFlow-TF")
#axes[0, 1].plot(pytorch_nfeat[:, 0], pytorch_nfeat[:, 1], label="Layerwise PyTorch")
#axes[0, 1].plot(spflow_layers_nfeat[:, 0], spflow_layers_nfeat[:, 1], label="SPFlow Layers")
fontP = FontProperties()
fontP.set_size("small")
axes[0, 1].legend(loc="upper left",
fancybox=True,
framealpha=0.5,
prop=fontP)
axes[0, 0].set_xscale("log", basex=2)
axes[0, 0].set_yscale("log", basey=10)
axes[0, 1].set_xscale("log", basex=2)
axes[0, 1].set_yscale("log", basey=10)
# Plot relative improvements
# axes[1, 0].plot(
# spflow_batch[:, 0],
# spflow_batch[:, 1] / pytorch_batch[:, 1],
# label="SPFlow/Layerwise PyTorch",
# )
# axes[1, 0].plot(
# tf_batch[:, 0],
# tf_batch[:, 1] / pytorch_batch[:, 1],
# label="SPFlow-TF/Layerwise PyTorch",
# )
# axes[1, 1].plot(
# spflow_nfeat[:, 0],
# spflow_nfeat[:, 1] / pytorch_nfeat[:, 1],
# label="SPFlow/Layerwise PyTorch",
# )
# axes[1, 1].plot(
# tf_nfeat[:, 0],
# tf_nfeat[:, 1] / pytorch_nfeat[:, 1],
# label="SPFlow-TF/Layerwise PyTorch",
# )
axes[1, 0].set_xscale("log", basex=2)
# axes[1, 0].set_yscale("log", basey=10)
axes[1, 1].set_xscale("log", basex=2)
# axes[1, 1].set_yscale("log", basey=10)
axes[0, 0].set_ylabel("Avg Time (s) over 100 Runs")
axes[0, 1].set_ylabel("Avg Time (s) over 100 Runs")
axes[1, 0].set_ylabel(r"Relative Time $\frac{t_x}{t_{PyTorch}}$")
axes[1, 1].set_ylabel(r"Relative Time $\frac{t_x}{t_{PyTorch}}$")
axes[0, 0].set_xlabel("Batch Size")
axes[0, 1].set_xlabel("Features")
axes[1, 0].set_xlabel("Batch Size")
axes[1, 1].set_xlabel("Features")
axes[1, 1].legend(loc="upper left",
fancybox=True,
framealpha=0.5,
prop=fontP)
# Titles
title = "vs".join(
names
) + " SPN Forward" #"SPFlow vs SPFlow-TF vs PyTorch: SPN Forward Pass"
fig.suptitle(title)
plt.savefig("benchmark.png", dpi=300) # , bbox_inches="tight")
def plotter(fdict):
""" Go """
font0 = FontProperties()
font0.set_family('monospace')
font0.set_size(16)
pgconn = get_dbconn('asos')
ctx = get_autoplot_context(fdict, get_description())
varname = ctx['var']
month = ctx['month']
network = ctx['network']
station = ctx['zstation']
hour = ctx['hour']
nt = NetworkTable(network)
if month == 'all':
months = range(1, 13)
elif month == 'fall':
months = [9, 10, 11]
elif month == 'winter':
months = [12, 1, 2]
elif month == 'spring':
months = [3, 4, 5]
elif month == 'summer':
months = [6, 7, 8]
elif month == 'gs':
months = [5, 6, 7, 8, 9]
else:
ts = datetime.datetime.strptime("2000-"+month+"-01", '%Y-%b-%d')
# make sure it is length two for the trick below in SQL
months = [ts.month]
df = read_sql("""
WITH obs as (
SELECT (valid + '10 minutes'::interval) at time zone %s as ts,
tmpf::int as itmpf, dwpf::int as idwpf from alldata
where station = %s and tmpf is not null
and dwpf is not null and
extract(month from valid at time zone %s) in %s),
agg1 as (
SELECT date_trunc('hour', ts) as hts, avg(itmpf) as avg_itmpf,
avg(idwpf) as avg_idwpf from obs
WHERE extract(hour from ts) = %s GROUP by hts)
SELECT extract(year from hts)::int as year, avg(avg_itmpf) as avg_tmpf,
count(*) as cnt
from agg1 GROUP by year ORDER by year ASC
""", pgconn, params=(nt.sts[station]['tzname'], station,
nt.sts[station]['tzname'], tuple(months), hour),
index_col='year')
minfreq = len(months) * 30 * 0.8
df2 = df[df['cnt'] > minfreq]
(fig, ax) = plt.subplots(1, 1)
ax.bar(df2.index.values, df2[varname], align='center', ec='b', fc='b')
m = df2[varname].mean()
ax.axhline(m, lw=2, zorder=5, color='k')
slp, intercept, r, _, _ = stats.linregress(df2.index.values,
df2[varname].values)
ax.plot(df2.index.values, intercept + (df2.index.values * slp), color='r',
lw=2, zorder=6)
ax.text(0.02, 0.92,
r"$\frac{^\circ}{decade} = %.2f,R^2=%.2f, avg = %.1f$" % (
slp * 10.0, r ** 2, m), va='bottom',
transform=ax.transAxes, bbox=dict(color='white'))
ax.set_ylim([df2[varname].min() - 5,
df2[varname].max() + 5])
ax.grid(True)
lts = datetime.datetime(2000, 1, 1, int(hour), 0)
fig.text(0.5, 0.91, ("%s [%s] %s Local %s-%s\n"
"%s [%s]"
) % (nt.sts[station]['name'], station,
lts.strftime("%-I %p"),
df2.index.min(),
df2.index.max(),
PDICT[varname],
MDICT[month]), ha='center')
return fig, df
def full_matrix_lam():
matrix_shape = matrices["zero"].shape
m_encoder = scalar_sdr(100,21,-0.25,0.25,matrix_shape,neg=False)
b_encoder = scalar_sdr(100,21,0.0,1.0,neg=False)
shape = (b_encoder.n,m_encoder.n*reduce(lambda x, y: x*y, m_encoder.ndarray_shape))
lma = LAM(shape)
for id_ in brain_id:
data = np.array([])
matrix = matrices[id_]
matrix = m_encoder.encode_ndarray(matrix)
data = np.append(data,matrix.flatten())
brain_sig = brain_id[id_]
brain_sig = b_encoder.encode(brain_sig)
data = np.append(data,brain_sig)
lma.store(brain_sig,matrix)
diffs = []
durations = []
for i in range(1):
for id_ in brain_id:
brain_sig = brain_id[id_]
brain_sig = b_encoder.encode(brain_sig)
t0 = time.time()
mem = lma.recall(np.array(brain_sig))
duration = time.time()-t0
durations.append(duration)
matrix_decoded = m_encoder.decode_ndarray(np.array(mem).reshape((reduce(lambda x, y: x*y, m_encoder.ndarray_shape)*m_encoder.n,)))
diff = m_encoder.decode_ndarray(np.array(m_encoder.encode_ndarray(matrices[id_])).reshape((reduce(lambda x, y: x*y, m_encoder.ndarray_shape)*m_encoder.n,)))-matrix_decoded
diffs.append(diff)
# print meta data
print "mean: ", np.mean(np.array(diffs).flatten())
print "max: ", np.max(np.array(diffs).flatten())
print "std: ", np.std(np.array(diffs).flatten())
print "duration: ", np.mean(durations)
# Bar graph plot
# plotting constants
max_ = 0.5
bars = 40
# calculate category indices
categories = []
for i in range(bars):
categories.append(i*max_/bars)
width = categories[1]
# tally number of instances for each category
values = np.zeros(bars)
for diff in np.array(diffs).flatten():
i = int(diff/(max_+0.0000001)*bars)
values[i] += 1
values /= 288.
# plot bar graph
from matplotlib.font_manager import FontProperties
fontP = FontProperties()
fontP.set_size('small')
plt.figure(1)
plt.title("Average error distribution across 10 samples")
plt.bar(categories, values, width, align='center')
plt.xlabel("Error bars - width = %0.4f" %(max_/bars))
plt.ylabel("Proportion")
plt.show()
# print number of values that fall into first category (good approximation of how well the memory does)
print "Values[0]: ", values[0]
# save new clusters for chart
y_km = kmeans.fit_predict(points)
#k means ++ plot
plt.scatter(points[y_km == 0, 0], points[y_km == 0, 1], s=100, c='red')
plt.scatter(points[y_km == 1, 0], points[y_km == 1, 1], s=100, c='black')
plt.scatter(points[y_km == 2, 0], points[y_km == 2, 1], s=100, c='blue')
plt.scatter(points[y_km == 3, 0], points[y_km == 3, 1], s=100, c='cyan')
plt.xlim(-6, 6)
plt.ylim(-8, 6)
plt.xlabel('PC1')
plt.ylabel('PC2')
plt.title('K-means++ wine clustering')
plt.grid(color='lightgray', linestyle='--', linewidth=0.5)
fontpar = FontProperties()
fontpar.set_size('small')
plt.legend(['C1', 'C2', 'C3', 'C4'],
loc=2,
prop=fontpar,
bbox_to_anchor=(-0.01, 1.15),
ncol=4)
plt.savefig('K-means-clusters-wine-data-4.png', dpi=250)
plt.clf()
print('4 clusters computed')
# create kmeans object
kmeans5 = KMeans(n_clusters=5)
# fit kmeans object to data
kmeans5.fit(points)
# print location of clusters learned by kmeans object
def single_cell_hnn():
matrix_shape = (1,)
m_encoder = scalar_sdr(40,22,-0.25,0.25,matrix_shape)
b_encoder = scalar_sdr(46,20,0.0,1.0)
# Calculate number of nodes of hopfield net
nodes = m_encoder.n*reduce(lambda x, y: x*y, m_encoder.ndarray_shape) + b_encoder.n
# i) Initialize hopfield network for each matrix value
# ii) Store data for each brain_id+matrix[brain_id] for given matrix index
nns = {}
for index in np.ndindex(matrices["zero"].shape):
hnn = Hopfield_Neural_Network(nodes)
for id_ in brain_id:
data = np.array([])
matrix = matrices[id_][index].reshape(matrix_shape)
matrix = m_encoder.encode_ndarray(matrix)
data = np.append(data,matrix.flatten())
brain_sig = brain_id[id_]
brain_sig = b_encoder.encode(brain_sig)
data = np.append(data,brain_sig)
hnn.store(data)
nns[index] = hnn
# Recall matrix values from brain_id
# setup some arrays to hold data
nans_avg = []
diffs = []
durations = []
# run recall fo network 'samples' number of times
samples = 10
for i in range(samples):
nans = 0
diffs_m = []
# for each index in the DEP matrix
for index in np.ndindex(matrices["zero"].shape):
# for each brain id
for id_ in brain_id:
# generate data
data = np.zeros(nodes)-1
brain_sig = brain_id[id_]
brain_sig = b_encoder.encode(brain_sig)
data[-b_encoder.n:] = brain_sig
# set iteration number
nns[index].setIter(300)
# recall matrix value
t0 = time.time()
mem = nns[index].recall(data,(0,m_encoder.n))
duration = time.time()-t0
durations.append(duration)
# decode matrix value
matrix_out = mem[0:m_encoder.n*reduce(lambda x, y: x*y, m_encoder.ndarray_shape)]
# calculate error of recalled matrix value
matrix_decoded = m_encoder.decode_ndarray(matrix_out)
diff_m = m_encoder.decode_ndarray(m_encoder.encode_ndarray(matrices[id_][index].reshape(matrix_shape)).flatten())-matrix_decoded
if np.isnan(diff_m):
nans += 1
diffs_m.append(diff_m)
nans_avg.append(nans)
diffs.append(abs(np.array(diffs_m)))
# print meta data
print "nans: ", np.max(nans_avg)
print "mean: ", np.mean(np.array(diffs).flatten())
print "max: ", np.max(np.array(diffs).flatten())
print "std: ", np.std(np.array(diffs).flatten())
print "duration: ", np.mean(durations)
# Bar graph plot
# plotting constants
max_ = 0.5
bars = 40
# calculate category indices
categories = []
for i in range(bars):
categories.append(i*max_/bars)
width = categories[1]
# tally number of instances for each category
values = np.zeros(bars)
for diff in np.array(diffs).flatten():
i = int(diff/(max_+0.0000001)*bars)
values[i] += 1
# divide by number of samples to obtain normalized score
values /= samples
values /= 288.0
# plot bar graph
from matplotlib.font_manager import FontProperties
fontP = FontProperties()
fontP.set_size('small')
plt.figure(1)
plt.title("Average error distribution across 10 samples")
plt.bar(categories, values, width, align='center')
plt.xlabel("Error bars - width = %0.4f" %(max_/bars))
plt.ylabel("Proportion")
plt.show()
# print number of values that fall into first category (good approximation of how well the memory does)
print "Values[0]: ", values[0]
#!/usr/local/bin/python3
import os, sys, json
import numpy as np
import pandas as pd
import matplotlib
import matplotlib.pyplot as plt
from matplotlib.pyplot import *
from matplotlib.font_manager import FontProperties
matplotlib.rcParams["pdf.fonttype"] = 42
matplotlib.rcParams["ps.fonttype"] = 42
matplotlib.rcParams["font.size"] = 8
font = FontProperties()
font.set_size(8)
font2 = FontProperties()
font2.set_size(8)
font2.set_weight("bold")
font3 = FontProperties()
font3.set_size(7)
# get label from string
def get_label(x):
x = x.split("_")[0]
return x.upper() if len(x) <= 2 else x.capitalize()
# get browser from string
def get_browser(x):
x = "".join([l for l in x if l.isalpha()])
def make_bench_plot(x,
ys,
y_errors,
labels,
title,
ylabel,
poly,
deg,
output_fp,
scale=1):
"""Generates a plot with the benchmark results
Parameters
----------
x : list
The values for the x axis
ys : list of lists
Each element of the list a series of data to plot
y_errors : list of lists
Values of the errorbars for each data series
labels : list of strings
Data series names
title : string
The plot title
ylabel : string
The y axis label
poly : array
Polynomial that fits the dataseries
deg : integer
Degree of the polynomial
output_fp : string
The path to the output figure
scale : number, optional
Value used to scale the y values (default: 1, no scale is performed)
Raises
------
ValueError
If scale is <= 0
"""
if scale <= 0:
raise ValueError("Scale should be an integer greater than 0")
# Check if the x axis is numerical
x_ticks = x
try:
x = np.asarray(x, dtype=np.float64)
except ValueError:
x = np.arange(len(x))
# For the function resulted from curve fitting, we use an extended x axis,
# so the trend line is more clear
interval = x[1] - x[0]
x2 = np.arange(x[0] - interval, x[-1] + 2 * interval)
# Generate plot
# First plot the fitted curve
y2 = np.polyval(poly, x2)
# Scale the y2 value
y2 = y2 / scale
figure = plt.figure()
ax = figure.add_subplot(111)
ax.plot(x2, y2, 'k', label=generate_poly_label(poly, deg))
# Plot the benchmark data
for label, y, y_err in izip(labels, ys, y_errors):
y = np.array(y) / scale
y_err = np.array(y_err) / scale
ax.errorbar(x, y, yerr=y_err, label=label)
figure.suptitle(title)
ax.set_xlabel("Input file")
ax.set_ylabel(ylabel)
fontP = FontProperties()
fontP.set_size('small')
ax.legend(loc='best', prop=fontP, fancybox=True).get_frame().set_alpha(0.2)
ax.set_xticks(x)
ax.set_xticklabels(x_ticks)
figure.savefig(output_fp)
def plotBand(self, gs_main, pos=0, band='K', cutoff=3.,
pstamp=None, pstamp_hdr=None, tdhst_cat=None, tdhst_vers=None):
gs = gridspec.GridSpecFromSubplotSpec(2,2,
subplot_spec = gs_main[pos],
width_ratios = [7,1],
height_ratios = [1,1],
hspace=0.2,
wspace=0.01)
# Set Default Font properties
font_header = FontProperties()
font_header.set_size(8.)
font_axes = FontProperties()
font_axes.set_size(6.5)
tick_fontsize = 6.5
labelpad = -1
# &&&&&&&&&&&&&&&&&&&&
# SPEC2D plot prep:
# Add 2D spectrum axis:
ax2 = self.fig.add_subplot(gs[1,0])
ax2.set_axis_off()
# Read in data from files
spec2d, spec2d_hdr = read_spec2d(self.query_info['spec2d_file_'+band.lower()])
lamdelt = spec2d_hdr['cdelt1']
lam0 = spec2d_hdr['crval1'] - ((spec2d_hdr['crpix1']-1)*spec2d_hdr['cdelt1'])
lamend = lam0+lamdelt*(np.shape(spec2d)[1]-1)
spec2d_x = np.linspace(lam0, lamend, num=np.shape(spec2d)[1])/1.e4 # plotting um
# In the interest of plotting, trim all ranges where the columns are full
# of nans, or are all zero.
# Need to check left and right
left_inds = np.array([0,0])
right_inds = np.array([np.shape(spec2d)[1]-1, np.shape(spec2d)[1]-1])
# Keep columns left_inds[1] to right_inds[0]-1,
# ie index as [left_inds[1], right_inds[0]]
l_flag, r_flag = 0, 0
li, ri = 0, np.shape(spec2d)[1]-1
while l_flag == 0:
# Check finite:
if (np.all(np.isfinite(spec2d[:,li])) == False) or \
(spec2d[:,li].min() == 0 and spec2d[:,li].max() == 0):
li += 1
else:
left_inds[1] = li
l_flag = 1
while r_flag == 0:
# Check finite:
if (np.all(np.isfinite(spec2d[:,ri])) == False) or \
(spec2d[:,ri].min() == 0 and spec2d[:,ri].max() == 0):
ri -= 1
else:
right_inds[0] = ri+1
r_flag = 1
spec2d = spec2d[:,left_inds[1]:right_inds[0]]
spec2d_x = spec2d_x[left_inds[1]:right_inds[0]]
# &&&&&&&&&&&&&&&&&&&&
# SPEC1D plot:
# Add 1D spectrum axis:
ax, spec1d_flux, spec1d_hdr, spec1d_light_profile = plot_1d(self, gs, band,
font_header, font_axes,
labelpad, tick_fontsize,
left_inds, right_inds,
cutoff=cutoff)
# &&&&&&&&&&&&&&&&&&&&
# SPEC2D plot:
if spec2d is not None:
range_spec = spec2d[np.isfinite(spec2d)].copy()
range_spec.sort()
ax2.imshow(spec2d, cmap=cm.gray, \
vmin = range_spec[np.int(np.round(frac_spec*len(range_spec)))], \
vmax = range_spec[np.int(np.round((1.-frac_spec)*len(range_spec)))], \
interpolation='None', origin='lower')
ax2.format_coord = make_format_ax2(ax2, spec2d_hdr, left_inds[1])
xlim = ax2.get_xlim()
ylim = ax2.get_ylim()
plot_lines(ax2, self.z,
np.array(range(np.shape(spec2d)[1])), spec2d_x,
ls='-', flag_2d=True, quiescent_lines=self.quilines_cb.isChecked())
if spec1d_hdr is not None:
plot_spatial_pos(ax2, spec1d_hdr['ypos'], ls='-', length=0.08)
ax2.set_xlim(xlim)
ax2.set_ylim(ylim)
range_spec = None
## spec2d_hdr contains PA, position offset, pix_scale, etc etc!!!
# &&&&&&&&&&&&&&&&&&&&
# Thumbnail + slit plot:
ax3 = self.fig.add_subplot(gs[0,1])
ax3.set_axis_off()
# WFC3 pixel scale is ~0.06"/pix
if pstamp is not None:
range_spec = pstamp[np.isfinite(pstamp)].copy()
range_spec.sort()
ax3.imshow(pstamp, cmap=cm.gray, \
vmin = range_spec[np.int(np.round(frac_pstamp*len(range_spec)))], \
vmax = range_spec[np.int(np.round((1.-frac_pstamp)*len(range_spec)))], \
interpolation='None', origin='lower')
# Angle btween 3DHST and MOSFIRE slit PA-
angle = angle_offset(self.maskname, self.obj_id,
field=self.field,
mask_PA=spec2d_hdr['PA'],
pstamp_hdr=pstamp_hdr, vers=tdhst_vers) # Decimal_degrees
if message:
print('Mask PA={}'.format(spec2d_hdr['PA']))
print(angle)
# Setup values
# Assume angle already is slit angle
slit_angle = angle # PA for MOSFIRE slits
sci_angle = angle -4. + 0.22 # PA for MOSFIRE science detector, not to slit.
d2r = np.pi/180.
slit_len = np.shape(spec2d)[0]*spec2d_hdr['pscale'] # arcsec
slit_wid = 0.7 # arcsec -- can you get this from the headers?
pscale_3dhst = 0.06 # arcsec -- taken from Brammer+11
pscale_mosfire = spec2d_hdr['pscale']
xlim = ax3.get_xlim()
ylim = ax3.get_ylim()
x0 = np.average(xlim)
y0 = np.average(ylim)
# Offset in slit coords
try:
y0_off = spec2d_hdr['c_offset']/pscale_3dhst
except:
# Someone doesn't have the updated header version of 2D: fall back to
# raw data offset.
y0_off = spec2d_hdr['offset']/pscale_3dhst
y0 -= y0_off
##############
# Corner coords: slit rectangle
off_angle = 4.-0.22 # exaggerate for test. really: 4.-0.22
y_shear = slit_wid/pscale_3dhst*np.tan(off_angle*d2r)
pos_11 = np.array([x0-0.5*slit_wid/pscale_3dhst, y0-0.5*slit_len/pscale_3dhst])
pos_12 = np.array([x0-0.5*slit_wid/pscale_3dhst, y0+0.5*slit_len/pscale_3dhst])
pos_21 = np.array([x0+0.5*slit_wid/pscale_3dhst, y0-0.5*slit_len/pscale_3dhst])
pos_22 = np.array([x0+0.5*slit_wid/pscale_3dhst, y0+0.5*slit_len/pscale_3dhst])
# Modify BL, TR corner y coords: shear
pos_11[1] += y_shear
pos_22[1] -= y_shear
rect_sci_x, rect_sci_y = rot_corner_coords([pos_11,pos_21,pos_22,pos_12,pos_11],
slit_angle*d2r, x0=x0, y0=y0+y0_off)
ax3.plot(rect_sci_x, rect_sci_y, lw=1, ls='-', c='lime')
############
###################################################################
# Overplot circles for objects within the field of view:
# If the tdhst_cat is found:
if tdhst_cat is not None:
pad_arcsec = 1. # 2.
# Define region with 1" padding around slit area, for plotting object IDs.
rect_padded_x, rect_padded_y = padded_region([pos_11,pos_21,pos_22,pos_12,pos_11],
slit_angle*d2r, x0=x0, y0=y0+y0_off, pad=pad_arcsec, pscale_3dhst=pscale_3dhst)
# Get info for primary object, if the 1D spectra exist:
try:
prim_y_pos = get_primary_y_pos(self, band)
main_y_pos = spec1d_hdr['ypos']
except:
prim_y_pos = -1
main_y_pos = -1
w = WCS(pstamp_hdr)
main_id = self.obj_id
plot_detections_in_stamp(self, ax3, ax2, tdhst_cat, w,
main_id, main_y_pos, prim_y_pos, slit_angle,
pscale_ratio=pscale_mosfire/pscale_3dhst,
x0=x0, y0=y0+y0_off,
rect_pad_x=rect_padded_x, rect_pad_y=rect_padded_y,
band=band)
###################################################################
ax3.set_xlim(xlim)
ax3.set_ylim(ylim)
##########
# &&&&&&&&&&&&&&&&&&&&
# Spatial profile plot:
if spec1d_flux is not None:
ax4 = self.fig.add_subplot(gs[1,1])
# Light profile in spec1d_light_profile
#Get spec2d aspect ratio:
h_2d, w_2d = np.shape(spec2d)
ax_ratio = np.float(h_2d)/np.float(w_2d)
ax2_pos = ax2.get_position()
ax3_pos = ax3.get_position()
ax2_ratio = np.float(ax2_pos.bounds[3])/np.float(ax2_pos.bounds[2])
scale = ax_ratio/ax2_ratio*1.35 #*1.15 #*1.65
diff = (ax2_pos.bounds[3]*(1-scale))
rect = [ax3_pos.bounds[0], ax2_pos.bounds[1]+diff/2.,
ax3_pos.bounds[2], ax2_pos.bounds[3]*scale]
ax4.set_position(rect)
spatial_y = np.array(range(len(spec1d_light_profile)))
profile = spec1d_light_profile.copy()
ax4.plot(profile, spatial_y, 'b-')
ax4.set_ylim([spatial_y.min(), spatial_y.max()])
ax4.get_xaxis().set_ticks([])
ax4.get_yaxis().set_ticks([])
return None
def plot(self) -> matplotlib.figure.Figure:
"""Plot temperature history of adaptive simulated annealing."""
# Code adjusted based on:
# https://matplotlib.org/3.1.1/gallery/ticks_and_spines/multiple_yaxis_with_spines.html
if self._temperature_history is None:
raise NoHistoryKept("No history datapoints kept")
x = [i for i in range(len(self._temperature_history))]
# Top rated candidate was chosen.
y1 = [i[0] if i[1] is True else None for i in self._temperature_history]
# A neighbour candidate was chosen.
y2 = [i[0] if i[1] is False else None for i in self._temperature_history]
# Acceptance probability - as the probability in 0 - 1, lets make it larger - scale to temperature size.
y3 = [i[2] for i in self._temperature_history]
# Number of products.
y4 = [i[3] for i in self._temperature_history]
fig, host = plt.subplots()
fig.subplots_adjust(right=0.75)
par1 = host.twinx()
par2 = host.twinx()
# Offset the right spine of par1 and par2. The ticks and label have already been
# placed on the right by twinx above.
par1.spines["right"].set_position(("axes", 1.050))
par2.spines["right"].set_position(("axes", 1.225))
# Having been created by twinx, par1 par2 have their frame off, so the line of its
# detached spine is invisible. First, activate the frame but make the patch
# and spines invisible.
self._make_patch_spines_invisible(par1)
self._make_patch_spines_invisible(par2)
# Second, show the right spine.
par1.spines["right"].set_visible(True)
par2.spines["right"].set_visible(True)
host.spines["right"].set_visible(False)
host.spines["top"].set_visible(False)
host.plot(x, y1, ".g", label="Expansion of a highest rated candidate")
host.plot(x, y2, ",r", label="Expansion of a neighbour candidate")
(p3,) = par1.plot(x, y3, ",b", label="Acceptance probability for a neighbour candidate")
(p4,) = par2.plot(x, y4, ",y", label="Number of products produced in the pipeline")
host.set_xlabel("iteration")
host.set_ylabel("temperature")
par1.set_ylabel("acceptance probability")
par2.set_ylabel("product count")
host.yaxis.label.set_color("black")
par1.yaxis.label.set_color(p3.get_color())
par2.yaxis.label.set_color(p4.get_color())
tkw = dict(size=4, width=1.5)
host.tick_params(axis="y", colors="black", **tkw)
par1.tick_params(axis="y", colors=p3.get_color(), **tkw)
par2.tick_params(axis="y", colors=p4.get_color(), **tkw)
host.tick_params(axis="x", **tkw)
font_prop = FontProperties()
font_prop.set_size("small")
fig.legend(
loc="upper center",
bbox_to_anchor=(0.50, 1.00),
ncol=2,
fancybox=True,
shadow=True,
prop=font_prop,
)
return fig
def main(training_conf_dir):
with open(join(training_conf_dir, "conf.yaml")) as f:
conf = yaml.safe_load(f)
training_dir = conf["training_dir"]
color = None
for hue_bin in conf["hue_bins"]:
name = hue_bin["name"]
if color != None:
print ("Number of colors has to be 1 in this experiment. Exiting")
exit(1)
color = []
for r in hue_bin["ranges"]:
color.append((r["start"], r["end"]))
executor = ProcessPoolExecutor(max_workers=8)
obj_frames = {}
vids = [d for d in listdir(training_dir) if isdir(join(training_dir, d))]
futures = []
for vid in vids:
vid_dir = join(training_dir, vid)
bin_file = [join(vid_dir, f) for f in listdir(vid_dir) if isfile(join(vid_dir, f)) and f.endswith(".bin")][0]
future = executor.submit(extract_per_vid_hfs, bin_file, color, vid)
futures.append(future)
uniq_obj_file = join(join(training_dir, vid), "unique_objs_per_frame.txt")
if not isfile(uniq_obj_file):
continue
obj_frames[vid] = object_based_metrics_calc.get_obj_frames(uniq_obj_file)
dfs = []
hf_map = {}
max_hf = None
for f in futures:
df, hfs, vid = f.result()
hf_map[vid] = hfs
dfs.append(df)
M = max([hf for (hf, l) in hfs])
if max_hf == None or M> max_hf:
max_hf= M
df = pd.concat(dfs, ignore_index=True)
fontsize=20
fontP = FontProperties()
fontP.set_size(fontsize)
df.loc[df.label == False, "label"] = "-ve"
df.loc[df.label == True, "label"] = "+ve"
num_vids = len(df["vid"].unique())
plt.close()
fig, ax = plt.subplots(figsize=(8,4))
sns.stripplot(data=df, x="vid", y="hf", hue="label", dodge=True, ax=ax)
ax.set_xlabel("Video file")
ax.set_ylabel("Hue Fraction")
ax.grid()
fig.savefig("hf_stripplot.png", bbox_inches="tight")
plt.close()
fig, ax = plt.subplots(figsize=(8,4))
sns.boxplot(data=df, x="vid", y="hf", hue="label", ax=ax)
ax.set_xlabel("Video File", fontsize=fontsize)
ax.set_ylabel("Hue Fraction", fontsize=fontsize)
ax.grid()
ax.set_xticklabels(range(1, num_vids+1))
ax.tick_params(axis='both', which='major', labelsize=fontsize)
legend = ax.legend(fancybox=True,shadow=False,title='Frame label', prop=fontP, ncol=2)
plt.setp(legend.get_title(),fontsize=fontsize)
fig.savefig("hf_catplot.png", bbox_inches="tight")
num_points = 100
step = max_hf/num_points
X = []
FP = []
FN = []
obj_det_rates = []
qors = []
frame_drops = []
for idx in range(num_points):
hf_threshold = idx*step
#fp, fn = compute_fp_fn(hf_map, hf_threshold)
obj_det_rate, frame_drop_rate, qor = compute_qor(hf_map, obj_frames, hf_threshold)
X.append(hf_threshold)
#FP.append(fp)
#FN.append(fn)
frame_drops.append(frame_drop_rate)
qors.append(qor)
obj_det_rates.append(obj_det_rate)
plt.close()
fig, ax = plt.subplots(figsize=(8,4))
#ax.plot(X, FP, label="FP")
#ax.plot(X, FN, label="FN")
#ax.plot(X, obj_det_rates, label="Obj. Detn. Rate")
ax.plot(X, qors, label="Per-Object QoR")
ax.plot(X, frame_drops, label="Frame Drop Rate")
ax.set_xlabel("Hue Fraction threshold", fontsize=fontsize)
ax.tick_params(axis='both', which='major', labelsize=fontsize)
legend = ax.legend(fancybox=True,shadow=False, prop=fontP)
ax.grid()
fig.savefig("hue_fp_np.png", bbox_inches="tight")
meas[run].mean_veh[k], 2)
error_distance[k][run] = np.sum(error_square[k][run], axis=0)
for l in range(n_v):
error[l] = np.mean(error_square[l], axis=0)
error_mean_norm[l] = np.sqrt(np.mean(error_distance[l], axis=0))
with open(
'/home/tomek/TheTitans/ICP/Pickles/errorKalman' + str(n_v) + '_' +
str(n_f) + '_' + str(meas[0].vehicle(0, 0).get_cov()[0, 0]) + '_' +
str(meas[0].vehicle(1, 0).get_cov()[0, 0]) + '_' +
str(meas[0].feature(0, 0, 0).get_cov()[0, 0]) + '_' + str(runs) +
'.pickle', 'wb') as output:
pickle.dump(error_mean_norm, output)
fontprop = FontProperties()
fontprop.set_size('small')
plt.figure(1, figsize=(9, 5))
err1 = plt.subplot(211)
plt.plot(error[0][0, :], label='Square error in x')
plt.plot(error[0][1, :], label='Square error in y')
plt.plot(error_mean_norm[0], label='Mean distance error')
plt.title('The RMSE for vehicle 1')
plt.xlabel('Time')
plt.ylabel('RMSE [m]')
plt.subplots_adjust(hspace=0.36)
err1.legend(ncol=3, prop=fontprop)
err1.set_ylim([
err1.get_ylim()[0],
err1.get_ylim()[0] + (err1.get_ylim()[1] - err1.get_ylim()[0]) * 1.15
])
