def test_repeated_save_with_alpha():
# We want an image which has a background color of bluish green, with an
# alpha of 0.25.
fig = Figure([1, 0.4])
canvas = FigureCanvas(fig)
fig.set_facecolor((0, 1, 0.4))
fig.patch.set_alpha(0.25)
# The target color is fig.patch.get_facecolor()
_, img_fname = tempfile.mkstemp(suffix='.png')
try:
fig.savefig(img_fname,
facecolor=fig.get_facecolor(),
edgecolor='none')
# Save the figure again to check that the
# colors don't bleed from the previous renderer.
fig.savefig(img_fname,
facecolor=fig.get_facecolor(),
edgecolor='none')
# Check the first pixel has the desired color & alpha
# (approx: 0, 1.0, 0.4, 0.25)
assert_array_almost_equal(tuple(imread(img_fname)[0, 0]),
(0.0, 1.0, 0.4, 0.250),
decimal=3)
finally:
os.remove(img_fname)
class MplCanvas(FigureCanvas):
def __init__(self, parent=None, width=5, height=4, dpi=100):
matplotlib.rcParams['font.size'] = 8
self.figure = Figure(figsize=(width, height), dpi=dpi)
self.axes = self.figure.add_subplot(111)
FigureCanvas.__init__(self, self.figure)
self.setParent(parent)
self.toolbar = NavigationToolbar(self, parent)
self.toolbar.setIconSize(QSize(16, 16))
FigureCanvas.setSizePolicy(self,
QSizePolicy.Expanding,
QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
def getToolbar(self):
return self.toolbar
def clear(self):
self.figure.clear()
self.axes = self.figure.add_subplot(111)
def test(self):
self.axes.plot([1,2,3,4])
def saveAs(self, fname):
self.figure.savefig(fname)
def imsave(fname, arr, vmin=None, vmax=None, cmap=None, format=None, origin=None):
"""
Saves a 2D :class:`numpy.array` as an image with one pixel per element.
The output formats available depend on the backend being used.
Arguments:
*fname*:
A string containing a path to a filename, or a Python file-like object.
If *format* is *None* and *fname* is a string, the output
format is deduced from the extension of the filename.
*arr*:
A 2D array.
Keyword arguments:
*vmin*/*vmax*: [ None | scalar ]
*vmin* and *vmax* set the color scaling for the image by fixing the
values that map to the colormap color limits. If either *vmin* or *vmax*
is None, that limit is determined from the *arr* min/max value.
*cmap*:
cmap is a colors.Colormap instance, eg cm.jet.
If None, default to the rc image.cmap value.
*format*:
One of the file extensions supported by the active
backend. Most backends support png, pdf, ps, eps and svg.
*origin*
[ 'upper' | 'lower' ] Indicates where the [0,0] index of
the array is in the upper left or lower left corner of
the axes. Defaults to the rc image.origin value.
"""
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
fig = Figure(figsize=arr.shape[::-1], dpi=1, frameon=False)
canvas = FigureCanvas(fig)
fig.figimage(arr, cmap=cmap, vmin=vmin, vmax=vmax, origin=origin)
fig.savefig(fname, dpi=1, format=format)
def plot_tdc_event(points, filename=None):
fig = Figure()
FigureCanvas(fig)
ax = fig.add_subplot(111, projection='3d')
xs = points[:, 0]
ys = points[:, 1]
zs = points[:, 2]
cs = points[:, 3]
p = ax.scatter(xs, ys, zs, c=cs, s=points[:, 3] ** (2) / 5., marker='o')
ax.set_xlabel('x [250 um]')
ax.set_ylabel('y [50 um]')
ax.set_zlabel('t [25 ns]')
ax.title('Track of one TPC event')
ax.set_xlim(0, 80)
ax.set_ylim(0, 336)
c_bar = fig.colorbar(p)
c_bar.set_label('charge [TOT]')
if not filename:
fig.show()
elif isinstance(filename, PdfPages):
filename.savefig(fig)
elif filename:
fig.savefig(filename)
return fig
def tBidBax_kd(mcmc_set):
""" .. todo:: document the basis for this"""
num_kds = 10000
# Get indices for the tBid/Bax binding constants
estimate_params = mcmc = mcmc_set.chains[0].options.estimate_params
tBid_iBax_kf_index = None
tBid_iBax_kr_index = None
for i, p in enumerate(estimate_params):
if p.name == 'tBid_iBax_kf':
tBid_iBax_kf_index = i
elif p.name == 'tBid_iBax_kr':
tBid_iBax_kr_index = i
# If we couldn't find the parameters, return None for the result
if tBid_iBax_kf_index is None or tBid_iBax_kr_index is None:
return Result(None, None)
# Sample the kr/kf ratio across the pooled chains
kd_dist = np.zeros(num_kds)
for i in range(num_kds):
position = mcmc_set.get_sample_position()
kd_dist[i] = ((10 ** position[tBid_iBax_kr_index]) /
(10 ** position[tBid_iBax_kf_index]))
# Calculate the mean and variance
mean = kd_dist.mean()
sd = kd_dist.std()
# Plot the Kd distribution
plot_filename = '%s_tBidiBax_kd_dist.png' % mcmc_set.name
fig = Figure()
ax = fig.gca()
ax.hist(kd_dist)
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
return MeanSdResult(mean, sd, plot_filename)
def draw_timeline(self):
fig = Figure(figsize=(7, 3))
canvas = FigureCanvas(fig)
ax = fig.add_subplot(111, axisbg="white")
xseries = range(len(TRADING_MINUTES))
pct = lambda x, _: "{0:1.1f}%".format(100*x)
xseries_show = xseries[::30]
xlabels_show = TRADING_MINUTES[::30]
ax.clear()
ax.plot(xseries, self._portfolio_timeline, label="portfolio", linewidth=1.0, color="r")
ax.plot(xseries, self._benchmark_timeline, label="benchmark", linewidth=1.0, color="b")
ax.yaxis.set_major_formatter(FuncFormatter(pct))
for item in ax.get_yticklabels():
item.set_size(10)
ax.set_xlim(0, 240)
ax.set_xticks(xseries_show)
ax.set_xticklabels(xlabels_show, fontsize=10)
ax.grid(True)
ax.legend(loc=2, prop={"size": 9})
fig.tight_layout()
fig.savefig(SNAPSHOT_IMG_FILE)
logger.info("Snapshot image saved at ./static/temp/snapshot.jpg.")
def test_repeated_save_with_alpha():
# We want an image which has a background color of bluish green, with an
# alpha of 0.25.
fig = Figure([1, 0.4])
fig.set_facecolor((0, 1, 0.4))
fig.patch.set_alpha(0.25)
# The target color is fig.patch.get_facecolor()
buf = io.BytesIO()
fig.savefig(buf,
facecolor=fig.get_facecolor(),
edgecolor='none')
# Save the figure again to check that the
# colors don't bleed from the previous renderer.
buf.seek(0)
fig.savefig(buf,
facecolor=fig.get_facecolor(),
edgecolor='none')
# Check the first pixel has the desired color & alpha
# (approx: 0, 1.0, 0.4, 0.25)
buf.seek(0)
assert_array_almost_equal(tuple(imread(buf)[0, 0]),
(0.0, 1.0, 0.4, 0.250),
decimal=3)
def residuals_at_max_likelihood(mcmc_set):
# Get the maximum likelihood parameters
try:
(max_likelihood, max_likelihood_position) = mcmc_set.maximum_likelihood()
except NoPositionsException as npe:
return Result(None, None)
# Get the residuals
residuals = mcmc_set.chains[0].get_residuals(max_likelihood_position)
# Make the residuals plot
fig = Figure()
ax = fig.gca()
plot_filename = '%s_max_likelihood_residuals.png' % mcmc_set.name
thumbnail_filename = '%s_max_likelihood_residuals_th.png' % mcmc_set.name
ax.plot(residuals[0], residuals[1])
ax.set_title('Residuals at Maximum Likelihood')
#ax.xlabel('Time')
#ax.ylabel('Residual')
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
fig.savefig(thumbnail_filename, dpi=10)
return ThumbnailResult(thumbnail_filename, plot_filename)
def acf_of_ml_residuals(mcmc_set):
# Get the maximum likelihood parameters
try:
(max_likelihood, max_likelihood_position) = mcmc_set.maximum_likelihood()
except NoPositionsException as npe:
return Result(None, None)
# Get the residuals
residuals = mcmc_set.chains[0].get_residuals(max_likelihood_position)
# Plot the autocorrelation function
acf = np.correlate(residuals[1], residuals[1], mode='full')
plot_filename = '%s_acf_of_ml_residuals.png' % mcmc_set.name
thumbnail_filename = '%s_acf_of_ml_residuals_th.png' % mcmc_set.name
fig = Figure()
ax = fig.gca()
ax.plot(acf)
ax.set_title('Autocorrelation of Maximum Likelihood Residuals')
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
fig.savefig(thumbnail_filename, dpi=10)
return ThumbnailResult(thumbnail_filename, plot_filename)
def lineChart(size, data, output):
x = data['x']
y = data['y']
fig = Figure(figsize=(size[0], size[1]), dpi=size[2])
FigureCanvas(fig) # Stores canvas on fig.canvas
axis = fig.add_subplot(111)
axis.grid(color='r', linestyle='dotted', linewidth=0.1, alpha=0.5)
for i in y:
yy = i['data']
axis.plot(x, yy, label=i.get('label'), marker='.', color='orange')
axis.fill_between(x, yy, 0)
axis.set_title(data.get('title', ''))
axis.set_xlabel(data['xlabel'])
axis.set_ylabel(data['ylabel'])
if data.get('allTicks', True) is True:
axis.set_xticks(x)
if 'xtickFnc' in data:
axis.set_xticklabels([data['xtickFnc'](v) for v in axis.get_xticks()])
axis.legend()
fig.savefig(output, format='png', transparent=True)
def write_figures(prefix, directory, dose_name, dose_data, data, ec50_coeffs, feature_set, log_transform):
"""Write out figure scripts for each measurement
prefix - prefix for file names
directory - write files into this directory
dose_name - name of the dose measurement
dose_data - doses per image
data - data per image
ec50_coeffs - coefficients calculated by calculate_ec50
feature_set - tuples of object name and feature name in same order as data
log_transform - true to log-transform the dose data
"""
from matplotlib.figure import Figure
from matplotlib.backends.backend_pdf import FigureCanvasPdf
if log_transform:
dose_data = np.log(dose_data)
for i, (object_name, feature_name) in enumerate(feature_set):
fdata = data[:, i]
fcoeffs = ec50_coeffs[i, :]
filename = "%s%s_%s.pdf" % (prefix, object_name, feature_name)
pathname = os.path.join(directory, filename)
f = Figure()
canvas = FigureCanvasPdf(f)
ax = f.add_subplot(1, 1, 1)
x = np.linspace(0, np.max(dose_data), num=100)
y = sigmoid(fcoeffs, x)
ax.plot(x, y)
dose_y = sigmoid(fcoeffs, dose_data)
ax.plot(dose_data, dose_y, "o")
ax.set_xlabel("Dose")
ax.set_ylabel("Response")
ax.set_title("%s_%s" % (object_name, feature_name))
f.savefig(pathname)
def test_moll():
from matplotlib.figure import Figure
from matplotlib.backends.backend_agg import FigureCanvasAgg
# Now make a simple example using the custom projection.
import numpy as np
fig = Figure(figsize=(6, 6))
ax = fig.add_subplot(111, projection="ast.mollweide")
# ra = np.random.uniform(size=100, low=0, high=360)
# dec = np.random.uniform(size=100, low=-90, high=90)
ra = np.random.uniform(size=10000, low=0, high=360)
dec = np.random.uniform(size=10000, low=-90, high=90)
ax.mapshow(np.arange(48), shading='flat')
ra = np.random.uniform(size=1000, low=30, high=60)
dec = np.random.uniform(size=1000, low=-50, high=50)
ax.plot(ra, dec, '*')
ax.axhline(-20)
ax.axvline(140)
ax.grid()
canvas = FigureCanvasAgg(fig)
fig.savefig('xxx-moll.png')
def barChart(size, data, output):
d = data['x']
ind = np.arange(len(d))
ys = data['y']
width = 0.60
fig = Figure(figsize=(size[0], size[1]), dpi=size[2])
FigureCanvas(fig) # Stores canvas on fig.canvas
axis = fig.add_subplot(111)
axis.grid(color='r', linestyle='dotted', linewidth=0.1, alpha=0.5)
bottom = np.zeros(len(ys[0]['data']))
for y in ys:
axis.bar(ind, y['data'], width, bottom=bottom, label=y.get('label'))
bottom += np.array(y['data'])
axis.set_title(data.get('title', ''))
axis.set_xlabel(data['xlabel'])
axis.set_ylabel(data['ylabel'])
if data.get('allTicks', True) is True:
axis.set_xticks(ind)
if 'xtickFnc' in data:
axis.set_xticklabels([data['xtickFnc'](v) for v in axis.get_xticks()])
axis.legend()
fig.savefig(output, format='png', transparent=True)
class MatplotlibWidget(QtGui.QWidget):
def __init__(self, parent=None):
super(MatplotlibWidget, self).__init__(parent)
#create figure
figwidth = 5.0 # inches
figheight = 3.5 # inches
self.figure = Figure(figsize=(figwidth, figheight))
self.canvas = FigureCanvas(self.figure)
self.axis = self.figure.add_subplot(111)
self.axis.clear()
self.layoutVertical = QtGui.QVBoxLayout(self)
self.layoutVertical.addWidget(self.canvas)
savePlotBtn = QtGui.QPushButton("Save")
self.layoutVertical.addWidget(savePlotBtn)
savePlotBtn.clicked.connect(self.onSave)
def add_data(self, values, labels):
self.axis.clear()
self.axis.pie(values, labels=labels, explode=None,
autopct='%1.1f%%', shadow=True, startangle=90)
def onSave(self):
file = QtGui.QFileDialog.getSaveFileName(self, 'Save file', '',)
fname, _ = file
self.figure.savefig(fname)
def save_as_plt(self, fname, pixel_array=None, vmin=None, vmax=None,
cmap=None, format=None, origin=None):
""" This method saves the image from a numpy array using matplotlib
:param fname: Location and name of the image file to be saved.
:param pixel_array: Numpy pixel array, i.e. ``numpy()`` return value
:param vmin: matplotlib vmin
:param vmax: matplotlib vmax
:param cmap: matplotlib color map
:param format: matplotlib format
:param origin: matplotlib origin
This method will return True if successful
"""
from matplotlib.backends.backend_agg \
import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from pylab import cm
if pixel_array is None:
pixel_array = self.numpy()
if cmap is None:
cmap = cm.bone
fig = Figure(figsize=pixel_array.shape[::-1], dpi=1, frameon=False)
canvas = FigureCanvas(fig)
fig.figimage(pixel_array, cmap=cmap, vmin=vmin,
vmax=vmax, origin=origin)
fig.savefig(fname, dpi=1, format=format)
return True
def make_reference_plot(self, file_name):
ref_fig = Figure()
FigureCanvas(ref_fig)
refFile = self.leakage_data[0]
ref_plot = ref_fig.add_subplot(111)
ref_plot.semilogy(refFile[0], np.abs(refFile[1]), 'bo-')
ref_plot.set_xlabel(r'Voltage [V]')
ref_plot.set_ylabel(r'Current [A]')
ref_plot.set_title(self.devName + "- Reference Curve - Leakage")
ref_plot.grid(True)
myaxis = ref_plot.axis()
date_deb = datetime.now()
ref_plot.axvline(self.spot, color='m', linestyle='-.', linewidth=2)
ref_plot.text(1.05 * self.spot, 0.4 * myaxis[3],
" spot: {0:.4}V ".format(self.spot),
color='m', rotation=270)
ref_plot.text(myaxis[0],
myaxis[2] * 2,
" " + date_deb.ctime())
ref_fig.savefig(file_name)
textFile = ('[<img src="reference.png"'
+ ' align="center" alt="Reference"> ](../'
+ self.devName + '_report.html)')
text_output = md.markdown(textFile, extensions=['extra'])
text_out = open(file_name[:-4] + ".html", "w")
text_out.write(text_output)
text_out.close()
def plotBatchResults(db):
'Hook called from woo.batch.writeResults'
import re,math,woo.batch,os
results=woo.batch.dbReadResults(db)
out='%s.pdf'%re.sub('\.sqlite$','',db)
from matplotlib.figure import Figure
from matplotlib.backends.backend_agg import FigureCanvasAgg
fig=Figure();
canvas=FigureCanvasAgg(fig)
ax1=fig.add_subplot(2,1,1)
ax2=fig.add_subplot(2,1,2)
ax1.set_xlabel('Time [s]')
ax1.set_ylabel('Kinetic energy [J]')
ax1.grid(True)
ax2.set_xlabel('Time [s]')
ax2.set_ylabel('Relative energy error')
ax2.grid(True)
for res in results:
series=res['series']
pre=res['pre']
if not res['title']: res['title']=res['sceneId']
ax1.plot(series['t'],series['kinetic'],label=res['title'],alpha=.6)
ax2.plot(series['t'],series['relErr'],label=res['title'],alpha=.6)
for ax,loc in (ax1,'lower left'),(ax2,'lower right'):
l=ax.legend(loc=loc,labelspacing=.2,prop={'size':7})
l.get_frame().set_alpha(.4)
fig.savefig(out)
print 'Batch figure saved to file://%s'%os.path.abspath(out)
def main(argv=None):
width = 1
for test in all_tests():
fig = Figure(figsize=(10, 5))
FigureCanvasAgg(fig) # why do i have to do this?
ax = fig.add_subplot(1, 1, 1)
x = np.array([float(i)*(len(STORAGE_DRIVERS)+1) for i in range(len(NUM_INSTANCES))])
bars = []
for driver, color in zip(STORAGE_DRIVERS, 'mbcg'):
means = []
for num_instances in NUM_INSTANCES:
means.append(average_from_file(os.path.join(
'results',
'{}.{}.{}'.format(test, num_instances, driver),
)))
bars.append(ax.bar(x, means, width, color=color))
x += width
ax.set_title(test)
ax.set_xlabel('num parallel processes' + ' ' * 90) # lol
ax.set_ylabel('seconds for completion')
ax.set_xticklabels(NUM_INSTANCES)
ax.set_xticks(x - 1.5)
box = ax.get_position()
ax.set_position([box.x0, box.y0 + box.height * 0.3, box.width, box.height * 0.7])
ax.legend((bar[0] for bar in bars), STORAGE_DRIVERS,
bbox_to_anchor=(1, -0.1),
fancybox=True, shadow=True, ncol=5)
fig.savefig(os.path.join('graphs', test + '.png'))
class Canvas(FigureCanvas):
def __init__(self, parent=None, width=5, height=4, dpi=100, nD = 2):
# plt.xkcd()
self.fig = Figure(figsize=(width, height), dpi=dpi)
FigureCanvas.__init__(self, self.fig)
self.dim = nD
if self.dim is 2:
self.axes = self.fig.add_subplot(1, 1, 1)
pass
else:
self.axes = self.fig.add_subplot(1, 1, 1, projection='3d')
pass
self.axes.hold(False)
self.compute_initial_figure()
self.setParent(parent)
FigureCanvas.setSizePolicy(self,
QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
def compute_initial_figure(self):
pass
def export_pdf(self):
fname='export.pdf'
self.fig.savefig(fname)
def export_jpg(self):
fname='export.jpg'
self.fig.savefig(fname)
def generate_scatterplot(datafname, imgfname):
"""Creates a 2D scatter plot of the specified Gocator XYZ
data and saves it in the specified image filename."""
matplotlib.rcParams['axes.formatter.limits'] = -4, 4
matplotlib.rcParams['font.size'] = 14
matplotlib.rcParams['axes.titlesize'] = 12
matplotlib.rcParams['axes.labelsize'] = 12
matplotlib.rcParams['xtick.labelsize'] = 11
matplotlib.rcParams['ytick.labelsize'] = 11
figure = Figure()
canvas = FigureCanvas(figure)
axes = figure.gca()
x,y,z = np.genfromtxt(datafname, delimiter=",", unpack=True)
xi = x[z!=-32.768]
yi = y[z!=-32.768]
zi = z[z!=-32.768]
scatter_plt = axes.scatter(xi, yi, c=zi, cmap=cm.get_cmap("Set1"), marker=',')
axes.grid(True)
axes.axis([np.min(xi), np.max(xi), np.min(yi), np.max(yi)])
axes.set_title(os.path.basename(datafname))
colorbar = figure.colorbar(scatter_plt)
colorbar.set_label("Range [mm]")
axes.set_xlabel("Horizontal Position [mm]")
axes.set_ylabel("Scan Position [mm]")
figure.savefig(imgfname)
def plot_parameter_curve(mcmc_set, p_index, p_name):
# Make sure we've already run the fits for this mcmc set!
if mcmc_set.name not in two_exp_fits_dict.keys():
raise Exception('%s not found in two_exp_fits_dict!' % mcmc_set.name)
# Make sure we've already run the fits for the data!
if 'data' not in two_exp_fits_dict.keys():
fit_data(mcmc_set)
# Get the parameter array
p_arr = two_exp_fits_dict[mcmc_set.name][p_index]
p_arr_data = two_exp_fits_dict['data'][p_index]
data = mcmc_set.chains[0].data
plot_filename = '%s_%s_curve.png' % (mcmc_set.name, p_name)
thumbnail_filename = '%s_%s_curve_th.png' % (mcmc_set.name, p_name)
# Plot of parameter
fig = Figure()
ax = fig.gca()
ax.plot(data.columns, p_arr, 'b')
ax.plot(data.columns, p_arr_data, marker='o', linestyle='', color='r')
ax.set_ylabel('%s value' % p_name)
ax.set_xlabel('[Bax] (nM)')
ax.set_title('%s for %s' % (mcmc_set.name, p_name))
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
fig.savefig(plot_filename)
fig.savefig(thumbnail_filename, dpi=10)
return ThumbnailResult(thumbnail_filename, plot_filename)
class MplCanvas(FigureCanvas):
def __init__(self, figsize=(8, 6), dpi=80):
self.fig = Figure(figsize=figsize, dpi=dpi)
self.fig.subplots_adjust(wspace=0, hspace=0, left=0, right=1.0, top=1.0, bottom=0)
self.ax = self.fig.add_subplot(111, frameon=False)
self.ax.patch.set_visible(False)
self.ax.set_axis_off()
FigureCanvas.__init__(self, self.fig)
FigureCanvas.setSizePolicy(self, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
#self.setAlpha(0.0)
def saveFig(self, str_io_buf):
self.setAlpha(0.0)
self.fig.savefig(str_io_buf, transparent=True, frameon=False, format='png')
# 140818 Save file to StringIO Buffer not disk file
def getFig(self):
return self.fig
def setAlpha(self, value):
self.fig.patch.set_alpha(value)
self.ax.patch.set_alpha(value)
self.ax.set_axis_off()
def set_face_color(self, color):
self.fig.set_facecolor(color) # "#000000"
def plotThreeWay(hist, title, filename=None, x_axis_title=None, minimum=None, maximum=None, bins=101): # the famous 3 way plot (enhanced)
if minimum is None:
minimum = 0
elif minimum == 'minimum':
minimum = np.ma.min(hist)
if maximum == 'median' or maximum is None:
median = np.ma.median(hist)
maximum = median * 2 # round_to_multiple(median * 2, math.floor(math.log10(median * 2)))
elif maximum == 'maximum':
maximum = np.ma.max(hist)
maximum = maximum # round_to_multiple(maximum, math.floor(math.log10(maximum)))
if maximum < 1 or hist.all() is np.ma.masked:
maximum = 1
x_axis_title = '' if x_axis_title is None else x_axis_title
fig = Figure()
FigureCanvas(fig)
fig.patch.set_facecolor('white')
ax1 = fig.add_subplot(311)
create_2d_pixel_hist(fig, ax1, hist, title=title, x_axis_title="column", y_axis_title="row", z_min=minimum if minimum else 0, z_max=maximum)
ax2 = fig.add_subplot(312)
create_1d_hist(fig, ax2, hist, bins=bins, x_axis_title=x_axis_title, y_axis_title="#", x_min=minimum, x_max=maximum)
ax3 = fig.add_subplot(313)
create_pixel_scatter_plot(fig, ax3, hist, x_axis_title="channel=row + column*336", y_axis_title=x_axis_title, y_min=minimum, y_max=maximum)
fig.tight_layout()
if not filename:
fig.show()
elif isinstance(filename, PdfPages):
filename.savefig(fig)
else:
fig.savefig(filename)
def plot_cluster_tot_size(hist, median=False, z_max=None, filename=None):
H = hist[0:50, 0:20]
if z_max is None:
z_max = np.ma.max(H)
if z_max < 1 or H.all() is np.ma.masked:
z_max = 1
fig = Figure()
FigureCanvas(fig)
ax = fig.add_subplot(111)
extent = [-0.5, 20.5, 49.5, -0.5]
bounds = np.linspace(start=0, stop=z_max, num=255, endpoint=True)
cmap = cm.get_cmap('jet')
cmap.set_bad('w')
norm = colors.BoundaryNorm(bounds, cmap.N)
im = ax.imshow(H, aspect="auto", interpolation='nearest', cmap=cmap, norm=norm, extent=extent) # for monitoring
ax.set_title('Cluster size and cluster ToT (' + str(np.sum(H) / 2) + ' entries)')
ax.set_xlabel('cluster size')
ax.set_ylabel('cluster ToT')
ax.invert_yaxis()
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.1)
cb = fig.colorbar(im, cax=cax, ticks=np.linspace(start=0, stop=z_max, num=9, endpoint=True))
cb.set_label("#")
fig.patch.set_facecolor('white')
if not filename:
fig.show()
elif isinstance(filename, PdfPages):
filename.savefig(fig)
else:
fig.savefig(filename)
def plot_1d_hist(hist, yerr=None, title=None, x_axis_title=None, y_axis_title=None, x_ticks=None, color='r', plot_range=None, log_y=False, filename=None, figure_name=None):
logging.info('Plot 1d histogram%s', (': ' + title) if title is not None else '')
fig = Figure()
FigureCanvas(fig)
ax = fig.add_subplot(111)
if plot_range is None:
plot_range = range(0, len(hist))
if not plot_range:
plot_range = [0]
if yerr is not None:
ax.bar(left=plot_range, height=hist[plot_range], color=color, align='center', yerr=yerr)
else:
ax.bar(left=plot_range, height=hist[plot_range], color=color, align='center')
ax.set_xlim((min(plot_range) - 0.5, max(plot_range) + 0.5))
ax.set_title(title)
if x_axis_title is not None:
ax.set_xlabel(x_axis_title)
if y_axis_title is not None:
ax.set_ylabel(y_axis_title)
if x_ticks is not None:
ax.set_xticks(range(0, len(hist[:])) if plot_range is None else plot_range)
ax.set_xticklabels(x_ticks)
ax.tick_params(which='both', labelsize=8)
if np.allclose(hist, 0.0):
ax.set_ylim((0, 1))
else:
if log_y:
ax.set_yscale('log')
ax.grid(True)
if not filename:
fig.show()
elif isinstance(filename, PdfPages):
filename.savefig(fig)
else:
fig.savefig(filename)
def plot_correlation(hist, title="Hit correlation", xlabel=None, ylabel=None, filename=None):
logging.info("Plotting correlations")
fig = Figure()
FigureCanvas(fig)
ax = fig.add_subplot(1, 1, 1)
cmap = cm.get_cmap('jet')
extent = [hist[2][0] - 0.5, hist[2][-1] + 0.5, hist[1][-1] + 0.5, hist[1][0] - 0.5]
ax.set_title(title)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
im = ax.imshow(hist[0], extent=extent, cmap=cmap, interpolation='nearest')
ax.invert_yaxis()
# add colorbar
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.05)
z_max = np.max(hist[0])
bounds = np.linspace(start=0, stop=z_max, num=255, endpoint=True)
norm = colors.BoundaryNorm(bounds, cmap.N)
fig.colorbar(im, boundaries=bounds, cmap=cmap, norm=norm, ticks=np.linspace(start=0, stop=z_max, num=9, endpoint=True), cax=cax)
if not filename:
fig.show()
elif isinstance(filename, PdfPages):
filename.savefig(fig)
else:
fig.savefig(filename)
def plot_scatter_time(x, y, yerr=None, title=None, legend=None, plot_range=None, plot_range_y=None, x_label=None, y_label=None, marker_style='-o', log_x=False, log_y=False, filename=None):
logging.info("Plot time scatter plot %s", (': ' + title) if title is not None else '')
fig = Figure()
FigureCanvas(fig)
ax = fig.add_subplot(111)
ax.format_xdata = mdates.DateFormatter('%Y-%m-%d')
times = []
for time in x:
times.append(datetime.fromtimestamp(time))
if yerr is not None:
ax.errorbar(times, y, yerr=[yerr, yerr], fmt=marker_style)
else:
ax.plot(times, y, marker_style)
ax.set_title(title)
if x_label is not None:
ax.set_xlabel(x_label)
if y_label is not None:
ax.set_ylabel(y_label)
if log_x:
ax.xscale('log')
if log_y:
ax.yscale('log')
if plot_range:
ax.set_xlim((min(plot_range), max(plot_range)))
if plot_range_y:
ax.set_ylim((min(plot_range_y), max(plot_range_y)))
if legend:
ax.legend(legend, 0)
ax.grid(True)
if not filename:
fig.show()
elif isinstance(filename, PdfPages):
filename.savefig(fig)
else:
fig.savefig(filename)
def plot_correlations(filenames, limit=None):
DataFrame = pd.DataFrame()
index = 0
for fileName in filenames:
with pd.get_store(fileName, 'r') as store:
tempDataFrame = pd.DataFrame({'Event': store.Hits.Event[:15000], 'Row' + str(index): store.Hits.Row[:15000]})
tempDataFrame = tempDataFrame.set_index('Event')
DataFrame = tempDataFrame.join(DataFrame)
DataFrame = DataFrame.dropna()
index += 1
del tempDataFrame
DataFrame["index"] = DataFrame.index
DataFrame.drop_duplicates(take_last=True, inplace=True)
del DataFrame["index"]
correlationNames = ('Row')
index = 0
for corName in correlationNames:
for colName in itertools.permutations(DataFrame.filter(regex=corName), 2):
if(corName == 'Col'):
heatmap, xedges, yedges = np.histogram2d(DataFrame[colName[0]], DataFrame[colName[1]], bins=(80, 80), range=[[1, 80], [1, 80]])
else:
heatmap, xedges, yedges = np.histogram2d(DataFrame[colName[0]], DataFrame[colName[1]], bins=(336, 336), range=[[1, 336], [1, 336]])
extent = [yedges[0] - 0.5, yedges[-1] + 0.5, xedges[-1] + 0.5, xedges[0] - 0.5]
cmap = cm.get_cmap('hot', 40)
fig = Figure()
FigureCanvas(fig)
ax = fig.add_subplot(111)
ax.imshow(heatmap, extent=extent, cmap=cmap, interpolation='nearest')
ax.invert_yaxis()
ax.set_xlabel(colName[0])
ax.set_ylabel(colName[1])
ax.set_title('Correlation plot(' + corName + ')')
fig.savefig(colName[0] + '_' + colName[1] + '.pdf')
index += 1
def plot_scatter(x, y, x_err=None, y_err=None, title=None, legend=None, plot_range=None, plot_range_y=None, x_label=None, y_label=None, marker_style='-o', log_x=False, log_y=False, filename=None):
logging.info('Plot scatter plot %s', (': ' + title) if title is not None else '')
fig = Figure()
FigureCanvas(fig)
ax = fig.add_subplot(111)
if x_err is not None:
x_err = [x_err, x_err]
if y_err is not None:
y_err = [y_err, y_err]
if x_err is not None or y_err is not None:
ax.errorbar(x, y, xerr=x_err, yerr=y_err, fmt=marker_style)
else:
ax.plot(x, y, marker_style, markersize=1)
ax.set_title(title)
if x_label is not None:
ax.set_xlabel(x_label)
if y_label is not None:
ax.set_ylabel(y_label)
if log_x:
ax.set_xscale('log')
if log_y:
ax.set_yscale('log')
if plot_range:
ax.set_xlim((min(plot_range), max(plot_range)))
if plot_range_y:
ax.set_ylim((min(plot_range_y), max(plot_range_y)))
if legend:
ax.legend(legend, 0)
ax.grid(True)
if not filename:
fig.show()
elif isinstance(filename, PdfPages):
filename.savefig(fig)
else:
fig.savefig(filename)
def make_xafs_plot(x, y, title, xlabel='Energy (eV)', ylabel='mu', x0=None,
ref_mu=None, ref_name=None):
fig = Figure(figsize=(8.5, 5.0), dpi=300)
canvas = FigureCanvas(fig)
axes = fig.add_axes([0.16, 0.16, 0.75, 0.75], axisbg='#FFFFFF')
axes.set_xlabel(xlabel, fontproperties=mpl_lfont)
axes.set_ylabel(ylabel, fontproperties=mpl_lfont)
axes.plot(x, y, linewidth=3.5)
if x0 is not None:
axes.axvline(0, ymin=min(y), ymax=max(y),
linewidth=2, color='#CCBBDD', zorder=-10)
if ref_mu is not None:
axes.plot(x, ref_mu, linewidth=4, zorder=-5, color='#AA4444')
title = "%s (%s)" % (title, ref_name)
# ymax = (0.7*max(y) + 0.3 * min(y))
# axes.text(-25.0, ymax, "%.1f eV" % x0, fontproperties=mpl_lfont)
xrange = max(x)-min(x)
yrange = max(y)-min(y)
axes.set_xlim((min(x)-xrange*0.05, max(x)+xrange*0.05), emit=True)
axes.set_ylim((min(y)-yrange*0.05, max(y)+yrange*0.05), emit=True)
axes.set_title(title, fontproperties=mpl_lfont)
figdata = io.BytesIO()
fig.savefig(figdata, format='png', facecolor='#FDFDFA')
figdata.seek(0)
return base64.b64encode(figdata.getvalue())
class CalibrationViewer(QtGui.QMainWindow):
trialsChanged = QtCore.pyqtSignal()
def __init__(self):
self.filters = list()
super(CalibrationViewer, self).__init__()
self.setWindowTitle('Olfa Calibration')
self.statusBar()
self.trial_selected_list = []
self.trialsChanged.connect(self._trial_selection_changed)
mainwidget = QtGui.QWidget(self)
self.setCentralWidget(mainwidget)
layout = QtGui.QGridLayout(mainwidget)
mainwidget.setLayout(layout)
menu = self.menuBar()
filemenu = menu.addMenu("&File")
toolsmenu = menu.addMenu("&Tools")
openAction = QtGui.QAction("&Open recording...", self)
openAction.triggered.connect(self._openAction_triggered)
openAction.setStatusTip(
"Open a HDF5 data file with calibration recording.")
openAction.setShortcut("Ctrl+O")
filemenu.addAction(openAction)
saveFigsAction = QtGui.QAction('&Save figures...', self)
saveFigsAction.triggered.connect(self._saveFiguresAction_triggered)
saveFigsAction.setShortcut('Ctrl+S')
openAction.setStatusTip("Saves current figures.")
filemenu.addAction(saveFigsAction)
exitAction = QtGui.QAction("&Quit", self)
exitAction.setShortcut("Ctrl+Q")
exitAction.setStatusTip("Quit program.")
exitAction.triggered.connect(QtGui.qApp.quit)
filemenu.addAction(exitAction)
removeTrialAction = QtGui.QAction("&Remove trials", self)
removeTrialAction.setStatusTip(
'Permanently removes selected trials (bad trials) from trial list.'
)
removeTrialAction.triggered.connect(self._remove_trials)
removeTrialAction.setShortcut('Ctrl+R')
toolsmenu.addAction(removeTrialAction)
trial_group_list_box = QtGui.QGroupBox()
trial_group_list_box.setTitle('Trial Groups')
self.trial_group_list = TrialGroupListWidget()
trial_group_layout = QtGui.QVBoxLayout()
trial_group_list_box.setLayout(trial_group_layout)
trial_group_layout.addWidget(self.trial_group_list)
layout.addWidget(trial_group_list_box, 0, 0)
self.trial_group_list.itemSelectionChanged.connect(
self._trial_group_selection_changed)
trial_select_list_box = QtGui.QGroupBox()
trial_select_list_box.setMouseTracking(True)
trial_select_list_layout = QtGui.QVBoxLayout()
trial_select_list_box.setLayout(trial_select_list_layout)
trial_select_list_box.setTitle('Trials')
self.trial_select_list = TrialListWidget()
self.trial_select_list.setMouseTracking(True)
trial_select_list_layout.addWidget(self.trial_select_list)
self.trial_select_list.setSelectionMode(
QtGui.QAbstractItemView.ExtendedSelection)
self.trial_select_list.itemSelectionChanged.connect(
self._trial_selection_changed)
layout.addWidget(trial_select_list_box, 0, 1)
self.trial_select_list.createGroupSig.connect(
self.trial_group_list.create_group)
filters_box = QtGui.QGroupBox("Trial filters.")
filters_box_layout = QtGui.QVBoxLayout(filters_box)
filters_scroll_area = QtGui.QScrollArea()
filters_buttons = QtGui.QHBoxLayout()
filters_all = QtGui.QPushButton('Select all', self)
filters_all.clicked.connect(self._select_all_filters)
filters_none = QtGui.QPushButton('Select none', self)
filters_none.clicked.connect(self._select_none_filters)
filters_buttons.addWidget(filters_all)
filters_buttons.addWidget(filters_none)
filters_box_layout.addLayout(filters_buttons)
filters_box_layout.addWidget(filters_scroll_area)
filters_wid = QtGui.QWidget()
filters_scroll_area.setWidget(filters_wid)
filters_scroll_area.setWidgetResizable(True)
filters_scroll_area.setFixedWidth(300)
self.filters_layout = QtGui.QVBoxLayout()
filters_wid.setLayout(self.filters_layout)
layout.addWidget(filters_box, 0, 2)
plots_box = QtGui.QGroupBox()
plots_box.setTitle('Plots')
plots_layout = QtGui.QHBoxLayout()
self.figure = Figure((9, 5))
self.figure.patch.set_facecolor('None')
self.canvas = FigureCanvas(self.figure)
self.canvas.setParent(plots_box)
self.canvas.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
plots_layout.addWidget(self.canvas)
plots_box.setLayout(plots_layout)
layout.addWidget(plots_box, 0, 3)
self.ax_pid = self.figure.add_subplot(2, 1, 1)
self.ax_pid.set_title('PID traces')
self.ax_pid.set_ylabel('')
self.ax_pid.set_xlabel('t (ms)')
# self.ax_pid.set_yscale('log')
self.ax_mean_plots = self.figure.add_subplot(2, 1, 2)
self.ax_mean_plots.set_title('Mean value')
self.ax_mean_plots.set_ylabel('value')
self.ax_mean_plots.set_xlabel('Concentration')
self.ax_mean_plots.autoscale(enable=True, axis=u'both', tight=False)
self.figure.tight_layout()
@QtCore.pyqtSlot()
def _list_context_menu_trig(self):
pass
@QtCore.pyqtSlot()
def _filters_changed(self):
mask = np.ones_like(self.trial_mask)
for v in self.filters:
mask *= v.trial_mask
self.trial_mask = mask
self.trial_select_list.itemSelectionChanged.disconnect(
self._trial_selection_changed)
for i in xrange(len(self.trial_mask)):
hide = not self.trial_mask[i]
it = self.trial_select_list.item(i)
it.setHidden(hide)
select = it.isSelected() * self.trial_mask[i]
it.setSelected(select)
self.trial_select_list.itemSelectionChanged.connect(
self._trial_selection_changed)
self.trial_select_list.itemSelectionChanged.emit(
) # emit that something changed so that we redraw.
@QtCore.pyqtSlot()
def _openAction_triggered(self):
filedialog = QtGui.QFileDialog(self)
if os.path.exists('D:\\experiment\\raw_data'):
startpath = 'D:\\experiment\\raw_data\\mouse_o_cal_cw\\sess_001'
else:
startpath = ''
fn = filedialog.getOpenFileName(self, "Select a data file.", startpath,
"HDF5 (*.h5)")
if fn:
data = CalibrationFile(str(fn))
self.data = data
self.trial_actions = []
trial_num_list = []
self.trial_select_list.clear()
trials = self.data.trials
for i, t in enumerate(trials):
tstr = "Trial {0}".format(i)
it = QtGui.QListWidgetItem(tstr, self.trial_select_list)
# trial = trials[i]
# odor = trial['odor']
# vialconc = trial['vialconc']
# odorconc = trial['odorconc']
# dilution = 1000 - trial['dilution'][0]
# trst = 'Odor: {0}, vialconc: {1}, odorconc: {2}, dilution: {3}'.format(odor, vialconc, odorconc,
# dilution)
# it.setStatusTip(trst)
trial_num_list.append(i)
self.trial_select_list.trial_num_list = np.array(trial_num_list)
self.trial_mask = np.ones(len(
self.trial_select_list.trial_num_list),
dtype=bool)
self.build_filters(trials)
else:
print('No file selected.')
return
def build_filters(self, trials):
while self.filters_layout.itemAt(0):
self.filters_layout.takeAt(0)
if self.filters:
for f in self.filters:
f.deleteLater()
self.filters = list()
colnames = trials.dtype.names
if 'odorconc' not in colnames:
self.error = QtGui.QErrorMessage()
self.error.showMessage(
'Data file must have "odorconc" field to allow plotting.')
start_strings = ('odorconc', 'olfas', 'dilutors')
filter_fields = []
for ss in start_strings:
for fieldname in colnames:
if fieldname.startswith(ss):
filter_fields.append(fieldname)
for field in filter_fields:
filter = FiltersListWidget(field)
filter.populate_list(self.data.trials)
filter.setVisible(False)
self.filters.append(filter)
box = QtGui.QWidget()
box.setSizePolicy(0, 0)
# box.setTitle(filter.fieldname)
show_button = QtGui.QPushButton(filter.fieldname)
show_button.setStyleSheet('text-align:left; border:0px')
show_button.clicked.connect(filter.toggle_visible)
_filt_layout = QtGui.QVBoxLayout(box)
_filt_layout.addWidget(show_button)
_filt_layout.addWidget(filter)
_filt_layout.setSpacing(0)
self.filters_layout.addWidget(box)
filter.filterChanged.connect(self._filters_changed)
for v in self.filters:
assert isinstance(v, FiltersListWidget)
# self.filters_layout.addWidget(QtGui.QSpacerItem())
self.filters_layout.addStretch()
self.filters_layout.setSpacing(0)
return
@QtCore.pyqtSlot()
def _saveFiguresAction_triggered(self):
# TODO: add figure saving functionality with filedialog.getSaveFileName.
self.saveDialog = QtGui.QFileDialog()
saveloc = self.saveDialog.getSaveFileName(
self, 'Save figure', '', 'PDF (*.pdf);;JPEG (*.jpg);;TIFF (*.tif)')
saveloc = str(saveloc)
self.figure.savefig(saveloc)
@QtCore.pyqtSlot()
def _remove_trials(self):
selected_idxes = self.trial_select_list.selectedIndexes()
remove_idxes = []
for id in selected_idxes:
idx = id.row()
remove_idxes.append(idx)
while self.trial_select_list.selectedIndexes():
selected_idxes = self.trial_select_list.selectedIndexes()
idx = selected_idxes[0].row()
self.trial_select_list.takeItem(idx)
new_trials_array = np.zeros(
len(self.trial_select_list.trial_num_list) - len(remove_idxes),
dtype=np.int)
ii = 0
remove_trialnums = []
new_trials_mask = np.zeros_like(new_trials_array, dtype=bool)
for i in xrange(len(self.trial_select_list.trial_num_list)):
if i not in remove_idxes:
new_trials_mask[ii] = self.trial_mask[i]
new_trials_array[ii] = self.trial_select_list.trial_num_list[i]
ii += 1
else:
remove_trialnums.append(
self.trial_select_list.trial_num_list[i])
self.trial_mask = new_trials_mask
self.trial_select_list.trial_num_list = new_trials_array
for f in self.filters:
f.remove_trials(remove_idxes)
self.trial_group_list._remove_trials(remove_trialnums)
@QtCore.pyqtSlot()
def _trial_selection_changed(self):
selected_idxes = self.trial_select_list.selectedIndexes()
selected_trial_nums = []
for id in selected_idxes:
idx = id.row()
trialnum = self.trial_select_list.trial_num_list[idx]
selected_trial_nums.append(trialnum)
self.update_plots(selected_trial_nums)
self.trial_group_list.blockSignals(True)
for i, g in zip(xrange(self.trial_group_list.count()),
self.trial_group_list.trial_groups):
it = self.trial_group_list.item(i)
all_in = True
group_trials = g['trial_nums']
for t in group_trials:
if t not in selected_trial_nums:
all_in = False
if not all_in:
it.setSelected(False)
elif all_in:
it.setSelected(True)
self.trial_group_list.blockSignals(False)
return
@QtCore.pyqtSlot()
def _trial_group_selection_changed(self):
selected_idxes = self.trial_group_list.selectedIndexes()
self._select_all_filters()
selected_trial_nums = []
for id in selected_idxes:
idx = id.row()
trialnums = self.trial_group_list.trial_groups[idx]['trial_nums']
selected_trial_nums.extend(trialnums)
self.trial_select_list.blockSignals(True)
for i in range(self.trial_select_list.count()):
item = self.trial_select_list.item(i)
self.trial_select_list.setItemSelected(item, False)
for i in selected_trial_nums:
idx = np.where(self.trial_select_list.trial_num_list == i)[0][0]
it = self.trial_select_list.item(idx)
if not it.isSelected():
it.setSelected(True)
self.trial_select_list.blockSignals(False)
self._trial_selection_changed()
def update_plots(self, trials):
padding = (
2000, 2000
) #TODO: make this changable - this is the number of ms before/afterr trial to extract for stream.
trial_streams = []
trial_colors = []
while self.ax_pid.lines:
self.ax_pid.lines.pop(0)
while self.ax_mean_plots.lines:
self.ax_mean_plots.lines.pop(0)
groups_by_trial = []
all_groups = set()
ntrials = len(trials)
vals = np.empty(ntrials)
concs = np.empty_like(vals)
if trials:
a = max([1. / len(trials), .25])
for i, tn in enumerate(trials):
color = self.trial_group_list.get_trial_color(tn)
groups = self.trial_group_list.get_trial_groups(tn)
trial_colors.append(color)
groups_by_trial.append(groups)
all_groups.update(groups)
trial = self.data.return_trial(tn, padding=padding)
stream = remove_stream_trend(trial.streams['sniff'],
(0, padding[0]))
stream -= stream[0:padding[0]].min()
# TODO: remove baseline (N2) trial average from this.
trial_streams.append(stream)
self.ax_pid.plot(stream, color=color, alpha=a)
conc = trial.trials['odorconc']
baseline = np.mean(stream[:2000])
val = np.mean(stream[3000:4000]) - baseline
vals[i] = val
concs[i] = conc
self.ax_mean_plots.plot(conc, val, '.', color=color)
minlen = 500000000
for i in trial_streams:
minlen = min(len(i), minlen)
streams_array = np.empty((ntrials, minlen))
for i in xrange(ntrials):
streams_array[i, :] = trial_streams[i][:minlen]
for g in all_groups:
mask = np.empty(ntrials, dtype=bool)
for i in xrange(ntrials):
groups = groups_by_trial[i]
mask[i] = g in groups
c = concs[mask]
groupstreams = streams_array[mask]
if len(np.unique(c)) < 2:
self.ax_pid.plot(groupstreams.mean(axis=0),
color='k',
linewidth=2)
else:
v = vals[mask]
a, b, _, _, _ = stats.linregress(c, v)
color = self.trial_group_list.get_group_color(g)
minn, maxx = self.ax_mean_plots.get_xlim()
x = np.array([minn, maxx])
self.ax_mean_plots.plot(x, a * x + b, color=color)
self.ax_pid.relim()
self.ax_mean_plots.set_yscale('log')
self.ax_mean_plots.set_xscale('log')
self.ax_mean_plots.relim()
self.canvas.draw()
@QtCore.pyqtSlot()
def _select_none_filters(self):
for filter in self.filters:
filter.filterChanged.disconnect(self._filters_changed)
filter.clearSelection()
filter.filterChanged.connect(self._filters_changed)
self._filters_changed()
@QtCore.pyqtSlot()
def _select_all_filters(self):
for filter in self.filters:
filter.filterChanged.disconnect(self._filters_changed)
filter.selectAll()
filter.filterChanged.connect(self._filters_changed)
self._filters_changed()
class Plotter(QMainWindow):
legends=[]
base_names=[]
database={}
def __init__(self):
super().__init__()
self.size_policy=QSizePolicy.Expanding
self.font=QFont()
self.font.setPointSize(12)
self.setWindowTitle('Calibrated Spectrum Viewer')
self.menu()
self.geometry()
self.showMaximized()
self.show()
self.figure.tight_layout()
def menu(self):
self.menuFile=self.menuBar().addMenu('&File')
self.load_new=QAction('&Load New Spectrum')
self.load_new.triggered.connect(self.new_graph)
self.load_new.setShortcut('Ctrl+O')
self.load_new.setToolTip('Load a new calibrated spectrum')
self.save_figure=QAction('&Save Spectrum Image')
self.save_figure.triggered.connect(self.save_fig)
self.save_figure.setShortcut('Ctrl+S')
self.save_figure.setEnabled(False)
self.clear=QAction('&Clear Graph')
self.clear.triggered.connect(self.clear_graph)
self.clear.setEnabled(False)
self.menuFile.addActions([self.load_new,self.save_figure,self.clear])
def geometry(self):
self.prop_label=QLabel('Detection Probability: 99%')
self.prop_label.setSizePolicy(self.size_policy, self.size_policy)
self.prop_label.setFont(self.font)
self.prob=QSlider(Qt.Horizontal)
self.prob.setSizePolicy(self.size_policy,self.size_policy)
self.prob.setFont(self.font)
self.prob.setMinimum(0)
self.prob.setMaximum(100)
self.prob.setSingleStep(1)
self.prob.setValue(99)
self.prob.setTickInterval(10)
self.prob.setTickPosition(QSlider.TicksBelow)
self.prob.valueChanged.connect(self.label_update)
self.plot_window=QWidget()
layout=QVBoxLayout()
self.figure=Figure()
self._canvas=FigureCanvas(self.figure)
self.toolbar=NavigationToolbar(self._canvas,self)
layout.addWidget(self.toolbar)
layout.addWidget(self._canvas)
self.plot_window.setLayout(layout)
topper=QDockWidget('Adjustments')
horwidget=QWidget()
hlayout=QHBoxLayout()
hlayout.addWidget(self.prop_label)
hlayout.addWidget(self.prob)
horwidget.setLayout(hlayout)
topper.setWidget(horwidget)
self.addDockWidget(Qt.TopDockWidgetArea, topper)
self.setCentralWidget(self.plot_window)
self.static_ax = self._canvas.figure.subplots()
self.static_ax.set_xlim(0,1800)
self.static_ax.set_xlabel('Time [s]')
self.static_ax.set_ylabel('Probability of Detection [%]')
def new_graph(self):
self.adder=Load_New()
self.adder.add.clicked.connect(self.new_)
def new_(self):
self.adder.process()
time,probability=self.adder.time,self.adder.probability
self.base_names.append(self.adder.name)
self.database[self.adder.name]=[time,probability]
self.replot()
def replot(self):
self.static_ax.clear()
self.static_ax.set_xlim(0,1800)
self.static_ax.set_xlabel('Time [s]')
self.static_ax.set_ylabel('Probability of Detection [%]')
# self.static_ax.set_ylim(0,100)
markers=['c+','rx','k*','m1','y.','g8','b2','mh','co','k+']
j=0
eva=int(self.prob.value())
for i in self.base_names:
time,probability=self.database[i]
try:
detect_time=np.interp(int(eva),probability,time)
self.legends.append('{}: {:.2f}s'.format(i,detect_time))
self.static_ax.plot(time,probability,markers[j],
label='{}: Time to {}% detection probability: {:.2f}s'.format(
i,eva,detect_time))
j+=1
except:
pass
self.static_ax.axhline(eva,color='r',linestyle='--',linewidth=0.5)
self.static_ax.legend(prop={'size':18})
self._canvas.draw()
self.clear.setEnabled(True)
self.save_figure.setEnabled(True)
def save_fig(self):
options='Portable Network Graphics (*.png);;'
options_='Joint Photographic Experts Group(*.jpg)'
options=options+options_
file_name,ok=QFileDialog.getSaveFileName(self,'Image Save',""
,options)
if file_name and ok:
self.figure.savefig(file_name,dpi=600,figsize=(10,10))
def clear_graph(self):
self.static_ax.clear()
self.static_ax.set_xlim(0,1800)
self.static_ax.set_xlabel('Time [s]')
self.static_ax.set_ylabel('Probability of Detection [%]')
self.static_ax.set_ylim(0,100)
self._canvas.draw()
self.clear.setEnabled(False)
self.save_figure.setEnabled(False)
def label_update(self):
val=self.prob.value()
self.prop_label.setText('Detection Probability: {}%'.format(val))
self.replot()
class MplCanvas(FigureCanvas):
"""MplCanvas class."""
def __init__(self, parent=None, width=5, height=4, dpi=100):
"""
Initialize of MatPlotLib canvas for plotter.
:param parent: the QWidget parent
:param width: the initial width of canvas
:param height: the initial height of canvas
:param dpi: the dpi of the canvas
"""
self.fig = Figure(figsize=(width, height), dpi=dpi)
self.axes = self.fig.add_subplot(111)
FigureCanvas.__init__(self, self.fig)
self.setParent(parent)
FigureCanvas.setSizePolicy(self,
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
def update_plot(
self,
data,
x_axis,
y_axis,
color,
marker,
style,
x_scale,
y_scale,
linewidth,
font_title,
font_axes):
"""
Update the data and axis range of the canvas.
:param data: a dictionary that contains the data points
:param x_axis: the ticks on X axis
:param y_axis: the ticks on Y axis
:param color: color name
:param marker : data marker
:param style: line style
:param x_scale: x-axis scale
:param y_scale: y-axis scale
:param linewidth: plot line width
:param font_title: title font size
:param font_axes: axes labels font size
:return: None
"""
self.axes.cla()
self.axes.grid(True, linestyle='-.', which='both')
if x_axis in data.keys() and y_axis in data.keys():
x_unit = ""
y_unit = ""
title = ""
self.axes.plot(
data[x_axis],
data[y_axis],
color=color,
marker=marker,
linestyle=style,
linewidth=linewidth)
if y_axis in gopem.helper.UnitTable.keys():
title += gopem.helper.UnitTable[y_axis][0] + "~"
if gopem.helper.UnitTable[y_axis][1] is not None:
y_unit = "({0})".format(gopem.helper.UnitTable[y_axis][1])
if x_axis in gopem.helper.UnitTable.keys():
if title:
title += gopem.helper.UnitTable[x_axis][0]
self.axes.set_title(title, fontsize=font_title)
if gopem.helper.UnitTable[x_axis][1] is not None:
x_unit = "({0})".format(gopem.helper.UnitTable[x_axis][1])
self.axes.set_xlabel(x_axis + x_unit, fontsize=font_axes)
self.axes.set_ylabel(y_axis + y_unit, fontsize=font_axes)
self.axes.set_yscale(y_scale)
self.axes.set_xscale(x_scale)
self.axes.tick_params(labelsize=font_axes)
self.draw()
def save_fig(self, filename, transparent):
"""
Save figure.
:param filename: file name
:param transparent: transparent flag
:return: None
"""
self.fig.savefig(filename, transparent=transparent)
class PlotCanvas(FigureCanvas):
def __init__(self,
linenumber,
ownsizes=None,
parent=None,
width=5,
height=4,
dpi=100):
self.fig = Figure(figsize=(width, height), dpi=dpi)
self.axes = self.fig.add_subplot(111)
super().__init__(self.fig)
self.setParent(parent)
FigureCanvas.setSizePolicy(self, Wid.QSizePolicy.Expanding,
Wid.QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
self.ldict = {}
lcolors = ()
lmarkers = ()
lcolors = ('purple', 'red', 'green', 'orange', 'yellow')
lmarkers = ('o', 'o', '*', 'o', 'o')
if ownsizes is None:
lsizes = (2, 2, 2, 2, 2)
else:
lsizes = ownsizes
for i in range(0, linenumber):
key = 'line' + str(i)
self.ldict[key] = lines.Line2D([], [],
marker=lmarkers[i],
color=lcolors[i],
linestyle='',
markersize=lsizes[i])
self.draw()
self.axes.grid()
self.axes.set_ylabel('y')
self.axes.set_xlabel('x')
def scalePlot(self, scale='linear'):
self.axes.set_yscale(scale)
def limitPlot(self, xvalues, yvalues):
# Replot with new scales.
self.axes.set_xlim(xvalues)
self.axes.set_ylim(yvalues)
self.fig.canvas.draw()
self.flush_events()
def getData(self):
for key in self.ldict:
print(self.ldict[key].get_data())
def updatePlot(self, *args):
for data, key in zip(args, self.ldict):
self.ldict[key].set_data(data)
self.axes.add_line(self.ldict[key])
self.fig.canvas.draw()
self.flush_events()
def updatexyLabels(self, xlabel, ylabel):
self.axes.set_xlabel(xlabel)
self.axes.set_ylabel(ylabel)
def savePlot(self, name):
self.fig.savefig(name)
label=True,
linewidths=2)
mg.pressure.plot(ax_old,
pm_original,
scale=0.01,
resolution=0.25,
levels=numpy.arange(870, 1050, 7),
colors='blue',
label=True,
linewidths=2)
mg.pressure.plot(ax_new,
pm_modified,
scale=0.01,
resolution=0.25,
levels=numpy.arange(870, 1050, 7),
colors='blue',
label=True,
linewidths=2)
# Mark the data used
mg.utils.plot_label(ax_new,
'%04d-%02d-%02d:%02d' %
(args.year, args.month, args.day, args.hour),
facecolor=fig.get_facecolor(),
x_fraction=0.98,
horizontalalignment='right')
# Render the figure as a png
fig.savefig("comparison_%04d-%02d-%02d:%02d.png" %
(args.year, args.month, args.day, args.hour))
class BackendMatplotlib(BackendBase.BackendBase):
"""Base class for Matplotlib backend without a FigureCanvas.
For interactive on screen plot, see :class:`BackendMatplotlibQt`.
See :class:`BackendBase.BackendBase` for public API documentation.
"""
def __init__(self, plot, parent=None):
super(BackendMatplotlib, self).__init__(plot, parent)
# matplotlib is handling keep aspect ratio at draw time
# When keep aspect ratio is on, and one changes the limits and
# ask them *before* next draw has been performed he will get the
# limits without applying keep aspect ratio.
# This attribute is used to ensure consistent values returned
# when getting the limits at the expense of a replot
self._dirtyLimits = True
self._axesDisplayed = True
self._matplotlibVersion = _parse_version(matplotlib.__version__)
self.fig = Figure()
self.fig.set_facecolor("w")
self.ax = self.fig.add_axes([.15, .15, .75, .75], label="left")
self.ax2 = self.ax.twinx()
self.ax2.set_label("right")
# disable the use of offsets
try:
self.ax.get_yaxis().get_major_formatter().set_useOffset(False)
self.ax.get_xaxis().get_major_formatter().set_useOffset(False)
self.ax2.get_yaxis().get_major_formatter().set_useOffset(False)
self.ax2.get_xaxis().get_major_formatter().set_useOffset(False)
except:
_logger.warning('Cannot disabled axes offsets in %s '
% matplotlib.__version__)
# critical for picking!!!!
self.ax2.set_zorder(0)
self.ax2.set_autoscaley_on(True)
self.ax.set_zorder(1)
# this works but the figure color is left
if self._matplotlibVersion < _parse_version('2'):
self.ax.set_axis_bgcolor('none')
else:
self.ax.set_facecolor('none')
self.fig.sca(self.ax)
self._overlays = set()
self._background = None
self._colormaps = {}
self._graphCursor = tuple()
self._enableAxis('right', False)
self._isXAxisTimeSeries = False
# Add methods
def addCurve(self, x, y, legend,
color, symbol, linewidth, linestyle,
yaxis,
xerror, yerror, z, selectable,
fill, alpha, symbolsize):
for parameter in (x, y, legend, color, symbol, linewidth, linestyle,
yaxis, z, selectable, fill, alpha, symbolsize):
assert parameter is not None
assert yaxis in ('left', 'right')
if (len(color) == 4 and
type(color[3]) in [type(1), numpy.uint8, numpy.int8]):
color = numpy.array(color, dtype=numpy.float) / 255.
if yaxis == "right":
axes = self.ax2
self._enableAxis("right", True)
else:
axes = self.ax
picker = 3 if selectable else None
artists = [] # All the artists composing the curve
# First add errorbars if any so they are behind the curve
if xerror is not None or yerror is not None:
if hasattr(color, 'dtype') and len(color) == len(x):
errorbarColor = 'k'
else:
errorbarColor = color
# On Debian 7 at least, Nx1 array yerr does not seems supported
if (isinstance(yerror, numpy.ndarray) and yerror.ndim == 2 and
yerror.shape[1] == 1 and len(x) != 1):
yerror = numpy.ravel(yerror)
errorbars = axes.errorbar(x, y, label=legend,
xerr=xerror, yerr=yerror,
linestyle=' ', color=errorbarColor)
artists += list(errorbars.get_children())
if hasattr(color, 'dtype') and len(color) == len(x):
# scatter plot
if color.dtype not in [numpy.float32, numpy.float]:
actualColor = color / 255.
else:
actualColor = color
if linestyle not in ["", " ", None]:
# scatter plot with an actual line ...
# we need to assign a color ...
curveList = axes.plot(x, y, label=legend,
linestyle=linestyle,
color=actualColor[0],
linewidth=linewidth,
picker=picker,
marker=None)
artists += list(curveList)
scatter = axes.scatter(x, y,
label=legend,
color=actualColor,
marker=symbol,
picker=picker,
s=symbolsize**2)
artists.append(scatter)
if fill:
artists.append(axes.fill_between(
x, FLOAT32_MINPOS, y, facecolor=actualColor[0], linestyle=''))
else: # Curve
curveList = axes.plot(x, y,
label=legend,
linestyle=linestyle,
color=color,
linewidth=linewidth,
marker=symbol,
picker=picker,
markersize=symbolsize)
artists += list(curveList)
if fill:
artists.append(
axes.fill_between(x, FLOAT32_MINPOS, y, facecolor=color))
for artist in artists:
artist.set_zorder(z)
if alpha < 1:
artist.set_alpha(alpha)
return Container(artists)
def addImage(self, data, legend,
origin, scale, z,
selectable, draggable,
colormap, alpha):
# Non-uniform image
# http://wiki.scipy.org/Cookbook/Histograms
# Non-linear axes
# http://stackoverflow.com/questions/11488800/non-linear-axes-for-imshow-in-matplotlib
for parameter in (data, legend, origin, scale, z,
selectable, draggable):
assert parameter is not None
origin = float(origin[0]), float(origin[1])
scale = float(scale[0]), float(scale[1])
height, width = data.shape[0:2]
picker = (selectable or draggable)
# All image are shown as RGBA image
image = Image(self.ax,
label="__IMAGE__" + legend,
interpolation='nearest',
picker=picker,
zorder=z,
origin='lower')
if alpha < 1:
image.set_alpha(alpha)
# Set image extent
xmin = origin[0]
xmax = xmin + scale[0] * width
if scale[0] < 0.:
xmin, xmax = xmax, xmin
ymin = origin[1]
ymax = ymin + scale[1] * height
if scale[1] < 0.:
ymin, ymax = ymax, ymin
image.set_extent((xmin, xmax, ymin, ymax))
# Set image data
if scale[0] < 0. or scale[1] < 0.:
# For negative scale, step by -1
xstep = 1 if scale[0] >= 0. else -1
ystep = 1 if scale[1] >= 0. else -1
data = data[::ystep, ::xstep]
if data.ndim == 2: # Data image, convert to RGBA image
data = colormap.applyToData(data)
image.set_data(data)
self.ax.add_artist(image)
return image
def addItem(self, x, y, legend, shape, color, fill, overlay, z,
linestyle, linewidth, linebgcolor):
if (linebgcolor is not None and
shape not in ('rectangle', 'polygon', 'polylines')):
_logger.warning(
'linebgcolor not implemented for %s with matplotlib backend',
shape)
xView = numpy.array(x, copy=False)
yView = numpy.array(y, copy=False)
linestyle = normalize_linestyle(linestyle)
if shape == "line":
item = self.ax.plot(x, y, label=legend, color=color,
linestyle=linestyle, linewidth=linewidth,
marker=None)[0]
elif shape == "hline":
if hasattr(y, "__len__"):
y = y[-1]
item = self.ax.axhline(y, label=legend, color=color,
linestyle=linestyle, linewidth=linewidth)
elif shape == "vline":
if hasattr(x, "__len__"):
x = x[-1]
item = self.ax.axvline(x, label=legend, color=color,
linestyle=linestyle, linewidth=linewidth)
elif shape == 'rectangle':
xMin = numpy.nanmin(xView)
xMax = numpy.nanmax(xView)
yMin = numpy.nanmin(yView)
yMax = numpy.nanmax(yView)
w = xMax - xMin
h = yMax - yMin
item = Rectangle(xy=(xMin, yMin),
width=w,
height=h,
fill=False,
color=color,
linestyle=linestyle,
linewidth=linewidth)
if fill:
item.set_hatch('.')
if linestyle != "solid" and linebgcolor is not None:
item = _DoubleColoredLinePatch(item)
item.linebgcolor = linebgcolor
self.ax.add_patch(item)
elif shape in ('polygon', 'polylines'):
points = numpy.array((xView, yView)).T
if shape == 'polygon':
closed = True
else: # shape == 'polylines'
closed = numpy.all(numpy.equal(points[0], points[-1]))
item = Polygon(points,
closed=closed,
fill=False,
label=legend,
color=color,
linestyle=linestyle,
linewidth=linewidth)
if fill and shape == 'polygon':
item.set_hatch('/')
if linestyle != "solid" and linebgcolor is not None:
item = _DoubleColoredLinePatch(item)
item.linebgcolor = linebgcolor
self.ax.add_patch(item)
else:
raise NotImplementedError("Unsupported item shape %s" % shape)
item.set_zorder(z)
if overlay:
item.set_animated(True)
self._overlays.add(item)
return item
def addMarker(self, x, y, legend, text, color,
selectable, draggable,
symbol, linestyle, linewidth, constraint):
legend = "__MARKER__" + legend
textArtist = None
xmin, xmax = self.getGraphXLimits()
ymin, ymax = self.getGraphYLimits(axis='left')
if x is not None and y is not None:
line = self.ax.plot(x, y, label=legend,
linestyle=" ",
color=color,
marker=symbol,
markersize=10.)[-1]
if text is not None:
if symbol is None:
valign = 'baseline'
else:
valign = 'top'
text = " " + text
textArtist = self.ax.text(x, y, text,
color=color,
horizontalalignment='left',
verticalalignment=valign)
elif x is not None:
line = self.ax.axvline(x,
label=legend,
color=color,
linewidth=linewidth,
linestyle=linestyle)
if text is not None:
# Y position will be updated in updateMarkerText call
textArtist = self.ax.text(x, 1., " " + text,
color=color,
horizontalalignment='left',
verticalalignment='top')
elif y is not None:
line = self.ax.axhline(y,
label=legend,
color=color,
linewidth=linewidth,
linestyle=linestyle)
if text is not None:
# X position will be updated in updateMarkerText call
textArtist = self.ax.text(1., y, " " + text,
color=color,
horizontalalignment='right',
verticalalignment='top')
else:
raise RuntimeError('A marker must at least have one coordinate')
if selectable or draggable:
line.set_picker(5)
# All markers are overlays
line.set_animated(True)
if textArtist is not None:
textArtist.set_animated(True)
artists = [line] if textArtist is None else [line, textArtist]
container = _MarkerContainer(artists, x, y)
container.updateMarkerText(xmin, xmax, ymin, ymax)
self._overlays.add(container)
return container
def _updateMarkers(self):
xmin, xmax = self.ax.get_xbound()
ymin, ymax = self.ax.get_ybound()
for item in self._overlays:
if isinstance(item, _MarkerContainer):
item.updateMarkerText(xmin, xmax, ymin, ymax)
# Remove methods
def remove(self, item):
# Warning: It also needs to remove extra stuff if added as for markers
self._overlays.discard(item)
try:
item.remove()
except ValueError:
pass # Already removed e.g., in set[X|Y]AxisLogarithmic
# Interaction methods
def setGraphCursor(self, flag, color, linewidth, linestyle):
if flag:
lineh = self.ax.axhline(
self.ax.get_ybound()[0], visible=False, color=color,
linewidth=linewidth, linestyle=linestyle)
lineh.set_animated(True)
linev = self.ax.axvline(
self.ax.get_xbound()[0], visible=False, color=color,
linewidth=linewidth, linestyle=linestyle)
linev.set_animated(True)
self._graphCursor = lineh, linev
else:
if self._graphCursor is not None:
lineh, linev = self._graphCursor
lineh.remove()
linev.remove()
self._graphCursor = tuple()
# Active curve
def setCurveColor(self, curve, color):
# Store Line2D and PathCollection
for artist in curve.get_children():
if isinstance(artist, (Line2D, LineCollection)):
artist.set_color(color)
elif isinstance(artist, PathCollection):
artist.set_facecolors(color)
artist.set_edgecolors(color)
else:
_logger.warning(
'setActiveCurve ignoring artist %s', str(artist))
# Misc.
def getWidgetHandle(self):
return self.fig.canvas
def _enableAxis(self, axis, flag=True):
"""Show/hide Y axis
:param str axis: Axis name: 'left' or 'right'
:param bool flag: Default, True
"""
assert axis in ('right', 'left')
axes = self.ax2 if axis == 'right' else self.ax
axes.get_yaxis().set_visible(flag)
def replot(self):
"""Do not perform rendering.
Override in subclass to actually draw something.
"""
# TODO images, markers? scatter plot? move in remove?
# Right Y axis only support curve for now
# Hide right Y axis if no line is present
self._dirtyLimits = False
if not self.ax2.lines:
self._enableAxis('right', False)
def saveGraph(self, fileName, fileFormat, dpi):
# fileName can be also a StringIO or file instance
if dpi is not None:
self.fig.savefig(fileName, format=fileFormat, dpi=dpi)
else:
self.fig.savefig(fileName, format=fileFormat)
self._plot._setDirtyPlot()
# Graph labels
def setGraphTitle(self, title):
self.ax.set_title(title)
def setGraphXLabel(self, label):
self.ax.set_xlabel(label)
def setGraphYLabel(self, label, axis):
axes = self.ax if axis == 'left' else self.ax2
axes.set_ylabel(label)
# Graph limits
def setLimits(self, xmin, xmax, ymin, ymax, y2min=None, y2max=None):
# Let matplotlib taking care of keep aspect ratio if any
self._dirtyLimits = True
self.ax.set_xlim(min(xmin, xmax), max(xmin, xmax))
if y2min is not None and y2max is not None:
if not self.isYAxisInverted():
self.ax2.set_ylim(min(y2min, y2max), max(y2min, y2max))
else:
self.ax2.set_ylim(max(y2min, y2max), min(y2min, y2max))
if not self.isYAxisInverted():
self.ax.set_ylim(min(ymin, ymax), max(ymin, ymax))
else:
self.ax.set_ylim(max(ymin, ymax), min(ymin, ymax))
self._updateMarkers()
def getGraphXLimits(self):
if self._dirtyLimits and self.isKeepDataAspectRatio():
self.replot() # makes sure we get the right limits
return self.ax.get_xbound()
def setGraphXLimits(self, xmin, xmax):
self._dirtyLimits = True
self.ax.set_xlim(min(xmin, xmax), max(xmin, xmax))
self._updateMarkers()
def getGraphYLimits(self, axis):
assert axis in ('left', 'right')
ax = self.ax2 if axis == 'right' else self.ax
if not ax.get_visible():
return None
if self._dirtyLimits and self.isKeepDataAspectRatio():
self.replot() # makes sure we get the right limits
return ax.get_ybound()
def setGraphYLimits(self, ymin, ymax, axis):
ax = self.ax2 if axis == 'right' else self.ax
if ymax < ymin:
ymin, ymax = ymax, ymin
self._dirtyLimits = True
if self.isKeepDataAspectRatio():
# matplotlib keeps limits of shared axis when keeping aspect ratio
# So x limits are kept when changing y limits....
# Change x limits first by taking into account aspect ratio
# and then change y limits.. so matplotlib does not need
# to make change (to y) to keep aspect ratio
xmin, xmax = ax.get_xbound()
curYMin, curYMax = ax.get_ybound()
newXRange = (xmax - xmin) * (ymax - ymin) / (curYMax - curYMin)
xcenter = 0.5 * (xmin + xmax)
ax.set_xlim(xcenter - 0.5 * newXRange, xcenter + 0.5 * newXRange)
if not self.isYAxisInverted():
ax.set_ylim(ymin, ymax)
else:
ax.set_ylim(ymax, ymin)
self._updateMarkers()
# Graph axes
def setXAxisTimeZone(self, tz):
super(BackendMatplotlib, self).setXAxisTimeZone(tz)
# Make new formatter and locator with the time zone.
self.setXAxisTimeSeries(self.isXAxisTimeSeries())
def isXAxisTimeSeries(self):
return self._isXAxisTimeSeries
def setXAxisTimeSeries(self, isTimeSeries):
self._isXAxisTimeSeries = isTimeSeries
if self._isXAxisTimeSeries:
# We can't use a matplotlib.dates.DateFormatter because it expects
# the data to be in datetimes. Silx works internally with
# timestamps (floats).
locator = NiceDateLocator(tz=self.getXAxisTimeZone())
self.ax.xaxis.set_major_locator(locator)
self.ax.xaxis.set_major_formatter(
NiceAutoDateFormatter(locator, tz=self.getXAxisTimeZone()))
else:
try:
scalarFormatter = ScalarFormatter(useOffset=False)
except:
_logger.warning('Cannot disabled axes offsets in %s ' %
matplotlib.__version__)
scalarFormatter = ScalarFormatter()
self.ax.xaxis.set_major_formatter(scalarFormatter)
def setXAxisLogarithmic(self, flag):
# Workaround for matplotlib 2.1.0 when one tries to set an axis
# to log scale with both limits <= 0
# In this case a draw with positive limits is needed first
if flag and self._matplotlibVersion >= _parse_version('2.1.0'):
xlim = self.ax.get_xlim()
if xlim[0] <= 0 and xlim[1] <= 0:
self.ax.set_xlim(1, 10)
self.draw()
self.ax2.set_xscale('log' if flag else 'linear')
self.ax.set_xscale('log' if flag else 'linear')
def setYAxisLogarithmic(self, flag):
# Workaround for matplotlib 2.0 issue with negative bounds
# before switching to log scale
if flag and self._matplotlibVersion >= _parse_version('2.0.0'):
redraw = False
for axis, dataRangeIndex in ((self.ax, 1), (self.ax2, 2)):
ylim = axis.get_ylim()
if ylim[0] <= 0 or ylim[1] <= 0:
dataRange = self._plot.getDataRange()[dataRangeIndex]
if dataRange is None:
dataRange = 1, 100 # Fallback
axis.set_ylim(*dataRange)
redraw = True
if redraw:
self.draw()
self.ax2.set_yscale('log' if flag else 'linear')
self.ax.set_yscale('log' if flag else 'linear')
def setYAxisInverted(self, flag):
if self.ax.yaxis_inverted() != bool(flag):
self.ax.invert_yaxis()
def isYAxisInverted(self):
return self.ax.yaxis_inverted()
def isKeepDataAspectRatio(self):
return self.ax.get_aspect() in (1.0, 'equal')
def setKeepDataAspectRatio(self, flag):
self.ax.set_aspect(1.0 if flag else 'auto')
self.ax2.set_aspect(1.0 if flag else 'auto')
def setGraphGrid(self, which):
self.ax.grid(False, which='both') # Disable all grid first
if which is not None:
self.ax.grid(True, which=which)
# Data <-> Pixel coordinates conversion
def _mplQtYAxisCoordConversion(self, y):
"""Qt origin (top) to/from matplotlib origin (bottom) conversion.
:rtype: float
"""
height = self.fig.get_window_extent().height
return height - y
def dataToPixel(self, x, y, axis):
ax = self.ax2 if axis == "right" else self.ax
pixels = ax.transData.transform_point((x, y))
xPixel, yPixel = pixels.T
# Convert from matplotlib origin (bottom) to Qt origin (top)
yPixel = self._mplQtYAxisCoordConversion(yPixel)
return xPixel, yPixel
def pixelToData(self, x, y, axis, check):
ax = self.ax2 if axis == "right" else self.ax
# Convert from Qt origin (top) to matplotlib origin (bottom)
y = self._mplQtYAxisCoordConversion(y)
inv = ax.transData.inverted()
x, y = inv.transform_point((x, y))
if check:
xmin, xmax = self.getGraphXLimits()
ymin, ymax = self.getGraphYLimits(axis=axis)
if x > xmax or x < xmin or y > ymax or y < ymin:
return None # (x, y) is out of plot area
return x, y
def getPlotBoundsInPixels(self):
bbox = self.ax.get_window_extent()
# Warning this is not returning int...
return (bbox.xmin,
self._mplQtYAxisCoordConversion(bbox.ymax),
bbox.width,
bbox.height)
def setAxesDisplayed(self, displayed):
"""Display or not the axes.
:param bool displayed: If `True` axes are displayed. If `False` axes
are not anymore visible and the margin used for them is removed.
"""
BackendBase.BackendBase.setAxesDisplayed(self, displayed)
if displayed:
# show axes and viewbox rect
self.ax.set_axis_on()
self.ax2.set_axis_on()
# set the default margins
self.ax.set_position([.15, .15, .75, .75])
self.ax2.set_position([.15, .15, .75, .75])
else:
# hide axes and viewbox rect
self.ax.set_axis_off()
self.ax2.set_axis_off()
# remove external margins
self.ax.set_position([0, 0, 1, 1])
self.ax2.set_position([0, 0, 1, 1])
self._synchronizeBackgroundColors()
self._synchronizeForegroundColors()
self._plot._setDirtyPlot()
def _synchronizeBackgroundColors(self):
backgroundColor = self._plot.getBackgroundColor().getRgbF()
dataBackgroundColor = self._plot.getDataBackgroundColor()
if dataBackgroundColor.isValid():
dataBackgroundColor = dataBackgroundColor.getRgbF()
else:
dataBackgroundColor = backgroundColor
if self.ax.axison:
self.fig.patch.set_facecolor(backgroundColor)
if self._matplotlibVersion < _parse_version('2'):
self.ax.set_axis_bgcolor(dataBackgroundColor)
else:
self.ax.set_facecolor(dataBackgroundColor)
else:
self.fig.patch.set_facecolor(dataBackgroundColor)
def _synchronizeForegroundColors(self):
foregroundColor = self._plot.getForegroundColor().getRgbF()
gridColor = self._plot.getGridColor()
if gridColor.isValid():
gridColor = gridColor.getRgbF()
else:
gridColor = foregroundColor
if self.ax.axison:
self.ax.spines['bottom'].set_color(foregroundColor)
self.ax.spines['top'].set_color(foregroundColor)
self.ax.spines['right'].set_color(foregroundColor)
self.ax.spines['left'].set_color(foregroundColor)
self.ax.tick_params(axis='x', colors=foregroundColor)
self.ax.tick_params(axis='y', colors=foregroundColor)
self.ax.yaxis.label.set_color(foregroundColor)
self.ax.xaxis.label.set_color(foregroundColor)
self.ax.title.set_color(foregroundColor)
for line in self.ax.get_xgridlines():
line.set_color(gridColor)
for line in self.ax.get_ygridlines():
line.set_color(gridColor)
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
fig = Figure()
canvas = FigureCanvas(fig)
import numpy as np
x = np.random.randn(10000)
ax = fig.add_subplot(111)
ax.hist(x, 100)
ax.set_title('Normal distribution with u=0,sigma=1')
fig.savefig('.\png\matplotlib_histogram_1.png')
def plot_zone_vector_and_atom_distance_map(image_data,
distance_data,
atom_planes=None,
distance_data_scale=1,
atom_list=None,
extra_marker_list=None,
clim=None,
atom_plane_marker=None,
plot_title='',
vector_to_plot=None,
figsize=(10, 20),
figname="map_data.jpg"):
"""
Parameters
----------
atom_list : list of Atom_Position instances
extra_marker_list : two arrays of x and y [[x_values], [y_values]]
"""
if image_data is None:
raise ValueError("Image data is None, no data to plot")
fig = Figure(figsize=figsize)
FigureCanvas(fig)
gs = GridSpec(95, 95)
image_ax = fig.add_subplot(gs[0:45, :])
distance_ax = fig.add_subplot(gs[45:90, :])
colorbar_ax = fig.add_subplot(gs[90:, :])
image_clim = to._get_clim_from_data(image_data, sigma=2)
image_cax = image_ax.imshow(image_data)
image_cax.set_clim(image_clim[0], image_clim[1])
if atom_planes:
for atom_plane_index, atom_plane in enumerate(atom_planes):
x_pos = atom_plane.get_x_position_list()
y_pos = atom_plane.get_y_position_list()
image_ax.plot(x_pos, y_pos, lw=3, color='blue')
image_ax.text(atom_plane.start_atom.pixel_x,
atom_plane.start_atom.pixel_y,
str(atom_plane_index),
color='red')
image_ax.set_ylim(0, image_data.shape[0])
image_ax.set_xlim(0, image_data.shape[1])
image_ax.set_title(plot_title)
if atom_plane_marker:
atom_plane_x = atom_plane_marker.get_x_position_list()
atom_plane_y = atom_plane_marker.get_y_position_list()
image_ax.plot(atom_plane_x, atom_plane_y, color='red', lw=2)
_make_subplot_map_from_regular_grid(
distance_ax,
distance_data,
distance_data_scale=distance_data_scale,
clim=clim,
atom_list=atom_list,
atom_plane_marker=atom_plane_marker,
extra_marker_list=extra_marker_list,
vector_to_plot=vector_to_plot)
distance_cax = distance_ax.images[0]
fig.tight_layout()
fig.colorbar(distance_cax, cax=colorbar_ax, orientation='horizontal')
fig.savefig(figname)
plt.close(fig)
def plot_complex_image_map_line_profile_using_interface_plane(
image_data,
amplitude_data,
phase_data,
line_profile_amplitude_data,
line_profile_phase_data,
interface_plane,
atom_plane_list=None,
data_scale=1,
atom_list=None,
extra_marker_list=None,
amplitude_image_lim=None,
phase_image_lim=None,
plot_title='',
add_color_wheel=False,
color_bar_markers=None,
vector_to_plot=None,
rotate_atom_plane_list_90_degrees=False,
prune_outer_values=False,
figname="map_data.jpg"):
"""
Parameters
----------
atom_list : list of Atom_Position instances
extra_marker_list : two arrays of x and y [[x_values], [y_values]]
"""
number_of_line_profiles = 2
figsize = (10, 18 + 2 * number_of_line_profiles)
fig = Figure(figsize=figsize)
FigureCanvas(fig)
gs = GridSpec(100 + 10 * number_of_line_profiles, 95)
image_ax = fig.add_subplot(gs[0:45, :])
distance_ax = fig.add_subplot(gs[45:90, :])
colorbar_ax = fig.add_subplot(gs[90:100, :])
line_profile_ax_list = []
for i in range(number_of_line_profiles):
gs_y_start = 100 + 10 * i
line_profile_ax = fig.add_subplot(gs[gs_y_start:gs_y_start + 10, :])
line_profile_ax_list.append(line_profile_ax)
image_y_lim = (0, image_data.shape[0] * data_scale)
image_x_lim = (0, image_data.shape[1] * data_scale)
image_clim = to._get_clim_from_data(image_data, sigma=2)
image_cax = image_ax.imshow(image_data,
origin='lower',
extent=[
image_x_lim[0], image_x_lim[1],
image_y_lim[0], image_y_lim[1]
])
image_cax.set_clim(image_clim[0], image_clim[1])
image_ax.set_xlim(image_x_lim[0], image_x_lim[1])
image_ax.set_ylim(image_y_lim[0], image_y_lim[1])
image_ax.set_title(plot_title)
if atom_plane_list is not None:
for atom_plane in atom_plane_list:
if rotate_atom_plane_list_90_degrees:
atom_plane_x = np.array(atom_plane.get_x_position_list())
atom_plane_y = np.array(atom_plane.get_y_position_list())
start_x = atom_plane_x[0]
start_y = atom_plane_y[0]
delta_y = (atom_plane_x[-1] - atom_plane_x[0])
delta_x = -(atom_plane_y[-1] - atom_plane_y[0])
atom_plane_x = np.array([start_x, start_x + delta_x])
atom_plane_y = np.array([start_y, start_y + delta_y])
else:
atom_plane_x = np.array(atom_plane.get_x_position_list())
atom_plane_y = np.array(atom_plane.get_y_position_list())
image_ax.plot(atom_plane_x * data_scale,
atom_plane_y * data_scale,
color='red',
lw=2)
atom_plane_x = np.array(interface_plane.get_x_position_list())
atom_plane_y = np.array(interface_plane.get_y_position_list())
image_ax.plot(atom_plane_x * data_scale,
atom_plane_y * data_scale,
color='blue',
lw=2)
_make_subplot_map_from_complex_regular_grid(
distance_ax,
amplitude_data,
phase_data,
atom_list=atom_list,
amplitude_image_lim=amplitude_image_lim,
phase_image_lim=phase_image_lim,
atom_plane_marker=interface_plane,
extra_marker_list=extra_marker_list,
vector_to_plot=vector_to_plot)
distance_ax.plot(atom_plane_x * data_scale,
atom_plane_y * data_scale,
color='red',
lw=2)
line_profile_data_list = [
line_profile_amplitude_data, line_profile_phase_data
]
for line_profile_ax, line_profile_data in zip(line_profile_ax_list,
line_profile_data_list):
_make_subplot_line_profile(line_profile_ax,
line_profile_data[:, 0],
line_profile_data[:, 1],
prune_outer_values=prune_outer_values,
scale_x=data_scale)
amplitude_delta = 0.01 * (amplitude_image_lim[1] - amplitude_image_lim[0])
phase_delta = 0.01 * (phase_image_lim[1] - phase_image_lim[0])
colorbar_mgrid = np.mgrid[
amplitude_image_lim[0]:amplitude_image_lim[1]:amplitude_delta,
phase_image_lim[0]:phase_image_lim[1]:phase_delta]
colorbar_rgb = get_rgb_array(colorbar_mgrid[1], colorbar_mgrid[0])
colorbar_ax.imshow(colorbar_rgb,
origin='lower',
extent=[
phase_image_lim[0], phase_image_lim[1],
amplitude_image_lim[0], amplitude_image_lim[1]
])
colorbar_ax.set_xlabel("Phase", size=6)
if color_bar_markers is not None:
for color_bar_marker in color_bar_markers:
colorbar_ax.axvline(color_bar_marker[0], color='white')
colorbar_ax.text(color_bar_marker[0],
amplitude_image_lim[0] * 0.97,
color_bar_marker[1],
transform=colorbar_ax.transData,
va='top',
ha='center',
fontsize=8)
if add_color_wheel:
ax_magnetic_color_wheel_gs = GridSpecFromSubplotSpec(
40, 40, subplot_spec=gs[45:90, :])[30:39, 3:12]
ax_magnetic_color_wheel = fig.add_subplot(ax_magnetic_color_wheel_gs)
ax_magnetic_color_wheel.set_axis_off()
make_color_wheel(ax_magnetic_color_wheel)
fig.tight_layout()
fig.savefig(figname)
plt.close(fig)
# Label location of a station in ax_full coordinates
def pos_right(idx):
result = {}
result['x'] = 0.668
result['y'] = 0.05 + (0.94 / len(stations)) * (idx + 0.5)
return result
for i in range(len(stations)):
p_left = pos_left(i)
if p_left['x'] < 0.335 or p_left['x'] > (0.335 + 0.323): continue
if p_left['y'] < 0.005 or p_left['y'] > (0.005 + 0.94): continue
p_right = pos_right(i)
ax_full.add_patch(
Circle((p_right['x'], p_right['y']),
radius=0.001,
facecolor=(1, 0, 0, 1),
edgecolor=(0, 0, 0, 1),
alpha=1,
zorder=1))
ax_full.add_line(
matplotlib.lines.Line2D(xdata=(p_left['x'], p_right['x']),
ydata=(p_left['y'], p_right['y']),
linestyle='solid',
linewidth=0.2,
color=(1, 0, 0, 1.0),
zorder=1))
# Output as png
fig.savefig('Leave_one_out_%04d%02d%02d%02d.png' % (year, month, day, hour))
class AbstractMultiGroupPlotPlugin(FigureCanvas):
'''
Abstract base class specifying interface of a multiple group plot plugin.
'''
def __init__(self, preferences, parent=None):
self.preferences = preferences
self.fig = Figure(facecolor='white', dpi=96)
FigureCanvas.__init__(self, self.fig)
self.setParent(parent)
FigureCanvas.setSizePolicy(self,
QtGui.QSizePolicy.Fixed,
QtGui.QSizePolicy.Fixed)
FigureCanvas.updateGeometry(self)
self.cid = None
self.type = '<none>'
self.name = '<none>'
self.bSupportsHighlight = False
self.bPlotFeaturesIndividually = True
self.bRunPostHocTest = False
def mouseEventCallback(self, callback):
if self.cid != None:
FigureCanvas.mpl_disconnect(self, self.cid)
self.cid = FigureCanvas.mpl_connect(self, 'button_press_event', callback)
def plot(self, profile, statsResults):
pass
def configure(self, profile, statsResults):
pass
def savePlot(self, filename, dpi=300):
format = filename[filename.rfind('.')+1:len(filename)]
if format in ['png', 'pdf', 'ps', 'eps','svg']:
self.fig.savefig(filename,format=format,dpi=dpi,facecolor='white',edgecolor='white')
else:
pass
def clear(self):
self.fig.clear()
def mirrorProperties(self, plotToCopy):
self.type = plotToCopy.type
self.name = plotToCopy.name
self.bSupportsHighlight = plotToCopy.bSupportsHighlight
def labelExtents(self, xLabels, xFontSize, xRotation, yLabels, yFontSize, yRotation):
self.fig.clear()
tempAxes = self.fig.add_axes([0,0,1.0,1.0])
tempAxes.set_xticks(np.arange(len(xLabels)))
tempAxes.set_yticks(np.arange(len(yLabels)))
xText = tempAxes.set_xticklabels(xLabels, size=xFontSize, rotation=xRotation)
yText = tempAxes.set_yticklabels(yLabels, size=yFontSize, rotation=yRotation)
bboxes = []
for label in xText:
bbox = label.get_window_extent(self.get_renderer())
bboxi = bbox.inverse_transformed(self.fig.transFigure)
bboxes.append(bboxi)
xLabelBounds = mtransforms.Bbox.union(bboxes)
bboxes = []
for label in yText:
bbox = label.get_window_extent(self.get_renderer())
bboxi = bbox.inverse_transformed(self.fig.transFigure)
bboxes.append(bboxi)
yLabelBounds = mtransforms.Bbox.union(bboxes)
self.fig.clear()
return xLabelBounds, yLabelBounds
def xLabelExtents(self, labels, fontSize, rotation=0):
self.fig.clear()
tempAxes = self.fig.add_axes([0,0,1.0,1.0])
tempAxes.set_xticks(np.arange(len(labels)))
xLabels = tempAxes.set_xticklabels(labels, size=fontSize, rotation=rotation)
bboxes = []
for label in xLabels:
bbox = label.get_window_extent(self.get_renderer())
bboxi = bbox.inverse_transformed(self.fig.transFigure)
bboxes.append(bboxi)
xLabelBounds = mtransforms.Bbox.union(bboxes)
self.fig.clear()
return xLabelBounds
def yLabelExtents(self, labels, fontSize, rotation=0):
self.fig.clear()
tempAxes = self.fig.add_axes([0,0,1.0,1.0])
tempAxes.set_yticks(np.arange(len(labels)))
yLabels = tempAxes.set_yticklabels(labels, size=fontSize, rotation=rotation)
bboxes = []
for label in yLabels:
bbox = label.get_window_extent(self.get_renderer())
bboxi = bbox.inverse_transformed(self.fig.transFigure)
bboxes.append(bboxi)
yLabelBounds = mtransforms.Bbox.union(bboxes)
self.fig.clear()
return yLabelBounds
def emptyAxis(self, title = ''):
self.fig.clear()
self.fig.set_size_inches(6,4)
emptyAxis = self.fig.add_axes([0.1,0.1,0.8,0.8])
emptyAxis.set_ylabel('No active features or degenerate plot', fontsize=8)
emptyAxis.set_xlabel('No active features or degenerate plot', fontsize=8)
emptyAxis.set_yticks([])
emptyAxis.set_xticks([])
emptyAxis.set_title(title)
for loc, spine in emptyAxis.spines.iteritems():
if loc in ['right','top']:
spine.set_color('none')
self.updateGeometry()
self.draw()
def formatLabels(self, labels):
formattedLabels = []
for label in labels:
value = float(label.get_text())
if value < 0.01:
valueStr = '%.2e' % value
if 'e-00' in valueStr:
valueStr = valueStr.replace('e-00', 'e-')
elif 'e-0' in valueStr:
valueStr = valueStr.replace('e-0', 'e-')
else:
valueStr = '%.3f' % value
formattedLabels.append(valueStr)
return formattedLabels
def plot_image_map_line_profile_using_interface_plane(
image_data,
heatmap_data_list,
line_profile_data_list,
interface_plane,
atom_plane_list=None,
data_scale=1,
data_scale_z=1,
atom_list=None,
extra_marker_list=None,
clim=None,
plot_title='',
vector_to_plot=None,
rotate_atom_plane_list_90_degrees=False,
prune_outer_values=False,
figname="map_data.jpg"):
"""
Parameters
----------
atom_list : list of Atom_Position instances
extra_marker_list : two arrays of x and y [[x_values], [y_values]]
"""
number_of_line_profiles = len(line_profile_data_list)
figsize = (10, 18 + 2 * number_of_line_profiles)
fig = Figure(figsize=figsize)
FigureCanvas(fig)
gs = GridSpec(95 + 10 * number_of_line_profiles, 95)
image_ax = fig.add_subplot(gs[0:45, :])
distance_ax = fig.add_subplot(gs[45:90, :])
colorbar_ax = fig.add_subplot(gs[90:95, :])
line_profile_ax_list = []
for i in range(number_of_line_profiles):
gs_y_start = 95 + 10 * i
line_profile_ax = fig.add_subplot(gs[gs_y_start:gs_y_start + 10, :])
line_profile_ax_list.append(line_profile_ax)
image_y_lim = (0, image_data.shape[0] * data_scale)
image_x_lim = (0, image_data.shape[1] * data_scale)
image_clim = to._get_clim_from_data(image_data, sigma=2)
image_cax = image_ax.imshow(image_data,
origin='lower',
extent=[
image_x_lim[0], image_x_lim[1],
image_y_lim[0], image_y_lim[1]
])
image_cax.set_clim(image_clim[0], image_clim[1])
image_ax.set_xlim(image_x_lim[0], image_x_lim[1])
image_ax.set_ylim(image_y_lim[0], image_y_lim[1])
image_ax.set_title(plot_title)
if atom_plane_list is not None:
for atom_plane in atom_plane_list:
if rotate_atom_plane_list_90_degrees:
atom_plane_x = np.array(atom_plane.get_x_position_list())
atom_plane_y = np.array(atom_plane.get_y_position_list())
start_x = atom_plane_x[0]
start_y = atom_plane_y[0]
delta_y = (atom_plane_x[-1] - atom_plane_x[0])
delta_x = -(atom_plane_y[-1] - atom_plane_y[0])
atom_plane_x = np.array([start_x, start_x + delta_x])
atom_plane_y = np.array([start_y, start_y + delta_y])
else:
atom_plane_x = np.array(atom_plane.get_x_position_list())
atom_plane_y = np.array(atom_plane.get_y_position_list())
image_ax.plot(atom_plane_x * data_scale,
atom_plane_y * data_scale,
color='red',
lw=2)
atom_plane_x = np.array(interface_plane.get_x_position_list())
atom_plane_y = np.array(interface_plane.get_y_position_list())
image_ax.plot(atom_plane_x * data_scale,
atom_plane_y * data_scale,
color='blue',
lw=2)
_make_subplot_map_from_regular_grid(distance_ax,
heatmap_data_list,
distance_data_scale=data_scale_z,
clim=clim,
atom_list=atom_list,
atom_plane_marker=interface_plane,
extra_marker_list=extra_marker_list,
vector_to_plot=vector_to_plot)
distance_cax = distance_ax.images[0]
distance_ax.plot(atom_plane_x * data_scale,
atom_plane_y * data_scale,
color='red',
lw=2)
for line_profile_ax, line_profile_data in zip(line_profile_ax_list,
line_profile_data_list):
_make_subplot_line_profile(line_profile_ax,
line_profile_data[:, 0],
line_profile_data[:, 1],
prune_outer_values=prune_outer_values,
scale_x=data_scale,
scale_z=data_scale_z)
fig.tight_layout()
fig.colorbar(distance_cax, cax=colorbar_ax, orientation='horizontal')
fig.savefig(figname)
def graph(sensor_id):
# TODO: Add date filtering options
sensor_config = current_app.config["SENSOR_CONFIG"]
data_dir = current_app.config["DATA_DIR"]
logfile = util.get_logfile_path(data_dir, sensor_id)
if sensor_id not in util.get_sensor_list(sensor_config):
abort(500, "Sensor ID is not in the sensor list.")
if not os.path.isfile(logfile):
abort(500, "No data exists for the sensor.")
json_data = util.get_json(util.get_logfile_path(data_dir, sensor_id))
args = request.args
if "field" in args:
field = args["field"]
else:
return abort(400, "Field not specified.")
if len(json_data) > 0:
valid_fields = [
field for field in json_data[next(iter(json_data))]["data"]
if field != "id"
]
if field not in valid_fields:
return abort(500, "Invalid field.")
filter_dates = False
if "hours" in request.args:
filter_dates = True
hours_back = int(request.args["hours"])
test_dates = [util.get_local_datetime(date) for date in json_data.keys()]
test_dates.sort()
latest_date = test_dates[-1]
dates = []
values = []
for date_str, all_info in json_data.items():
if not filter_dates or (latest_date - util.get_local_datetime(date_str)
).total_seconds() / 3600 < hours_back:
if field in all_info["data"]:
dates.append(util.get_local_datetime(date_str))
values.append(all_info["data"][field])
else:
print("Warning: data line did not contain {}!".format(field))
# The key to using matplotlib with flask: don't use pyplot!
# https://matplotlib.org/3.1.1/faq/howto_faq.html
fig = Figure(figsize=(13, 3))
ax = fig.subplots()
ax.plot(dates, values, util.plot_formats[field])
ax.set_title("{} vs. Time".format(util.data_units[field][0]))
ax.set_xlabel("Time")
ax.set_ylabel("{} ({})".format(
*[val for i, val in enumerate(util.data_units[field]) if i != 1]))
ax.grid()
ax.margins(x=0.01, y=0.15) # Margins are percentages
fig.tight_layout()
bg_color = "#ededed"
fig.patch.set_facecolor(bg_color)
ax.patch.set_facecolor(bg_color)
img_io = BytesIO()
fig.savefig(img_io, format='png', facecolor=fig.get_facecolor())
img_io.seek(0)
response = make_response(img_io.getvalue())
response.headers['Content-Type'] = 'image/png'
# Disable caching
response.headers['Last-Modified'] = datetime.datetime.now()
response.headers[
'Cache-Control'] = 'no-store, no-cache, must-revalidate, post-check=0, pre-check=0, max-age=0'
response.headers['Pragma'] = 'no-cache'
response.headers['Expires'] = '-1'
return response
class Plotting:
def __init__(self, fitWindow):
self.fitWindow = fitWindow
#plot display flags
self.flag_ca = True
self.flag_ra = False
self.flag_cl = False
self.flag_rl = False
self.flag_cn = False
self.flag_ecc = False
self.flag_lf = False
self.flag_zp = False
self.flag_xp = False
self.flag_ap = False
self.flag_fp = False
self.flag_st = False
self.flag_zd = False
self.x_var = 'Time' #x axis default parameter
self.legendPos = "upper right"
# self.fig1_close = True
self.show_title = True
self.showLegend2 = True
self.fontSize = 12
#fitting
# self.flag_fit = False
# self.fit_x = 'Vertical Position (μm)'
# self.fit_y = 'Vertical Force'
# self.startFit = 0
# self.endFit = 100
self.fit_pos = '0.5,0.5'
self.fit_show = False
self.slope = ''
self.slope_unit = ''
#initialize figure with random data
self.fig1 = Figure(figsize=(11, 5), dpi=100)
ax = self.fig1.add_subplot(111)
xdata = np.linspace(0, 4, 50)
ydata = np.sin(xdata)
ax.plot(xdata, ydata, 'r-', linewidth=1, markersize=1)
self.plotWidget = PlotWidget(fig=self.fig1,
cursor1_init=2,
cursor2_init=6)
def plotData(self, unit): #prepare plot
xDict = {
'Vertical Position (μm)': self.dist_vert1,
'Lateral Position (μm)': self.dist_lat1,
'Deformation (μm)': self.deform_vert,
'Time (s)': self.time1
}
xAxisData = xDict.get(self.x_var)
markerlist = ["o", "v", "^", "s", "P", "*", "D", "<", "X", ">"]
linelist = [":", "-.", "--", "-", ":", "-.", "--", "-", ":", "-."]
plt.rcParams.update({'font.size': self.fontSize})
# self.fig1 = plt.figure(num="Force/Area vs Time", figsize = [11, 5])
# self.fig1 = Figure(figsize=(11, 5), dpi=100)
# self.fig1.canvas.mpl_connect('close_event', self.handle_close)
print("fig1")
#store cursor position values before clearing plot
if self.plotWidget.wid.cursor1 == None:
c1_init = None
else:
c1_init = self.plotWidget.wid.cursor1.get_xdata()[0]
if self.plotWidget.wid.cursor2 == None:
c2_init = None
else:
c2_init = self.plotWidget.wid.cursor2.get_xdata()[0]
self.fig1.clear()
ax1 = self.fig1.add_subplot(1, 1, 1)
lns = []
# ax1.set_title('Speed = ' + str(self.speed_um) + ' μm/s')
ax1.set_xlabel(self.x_var)
ax1.set_ylabel('Vertical Force (μN)', color='r')
p1, = ax1.plot(xAxisData[self.plot_slice],
self.force_vert1_shifted[self.plot_slice],
'ro',
alpha=0.5,
linewidth=1,
markersize=1,
label="Vertical Force")
lns.append(p1)
# self.plotWidget.mpl_connect('close_event', self.handle_close)
if self.ptsnumber != 0:
## ptsperstep = int(self.ptsnumber/self.step_num)
i = 0
lns_reg = [] #region legend handle
lab_reg = [] #region legend label
speed_inview = [] #speed list in plot range
for a in self.steps: #shade step regions
if i < ((self.plot_slice.start + 1) / self.ptsperstep) - 1:
i += 1
continue
if self.ptsperstep * (i + 1) - 1 > self.plot_slice.stop:
endpoint = self.plot_slice.stop - 1
exit_flag = True
else:
endpoint = self.ptsperstep * (i + 1) - 1
exit_flag = False
if self.ptsperstep * i < self.plot_slice.start:
startpoint = self.plot_slice.start
else:
startpoint = self.ptsperstep * i
x_start = min(xAxisData[startpoint:endpoint])
x_end = max(xAxisData[startpoint:endpoint])
if a == 'Front':
v1 = ax1.axvspan(x_start,
x_end,
alpha=0.9,
color='aliceblue',
label=a)
lns_reg.append(v1)
lab_reg.append(a)
speed_inview.append(self.speed_um[i])
if exit_flag == True:
break
elif a == 'Back':
v2 = ax1.axvspan(x_start,
x_end,
alpha=0.9,
color='whitesmoke',
label=a)
lns_reg.append(v2)
lab_reg.append(a)
speed_inview.append(self.speed_um[i])
if exit_flag == True:
break
elif a == 'Up':
v3 = ax1.axvspan(x_start,
x_end,
alpha=0.9,
color='honeydew',
label=a)
lns_reg.append(v3)
lab_reg.append(a)
speed_inview.append(self.speed_um[i])
if exit_flag == True:
break
elif a == 'Down':
v4 = ax1.axvspan(x_start,
x_end,
alpha=0.9,
color='linen',
label=a)
lns_reg.append(v4)
lab_reg.append(a)
speed_inview.append(self.speed_um[i])
if exit_flag == True:
break
elif a == 'Pause':
v5 = ax1.axvspan(x_start,
x_end,
alpha=0.9,
color='lightyellow',
label=a)
lns_reg.append(v5)
lab_reg.append(a)
speed_inview.append(self.speed_um[i])
if exit_flag == True:
break
i += 1
if self.show_title == True:
ax1.set_title('Speed = ' +
str(speed_inview).replace('[', '').replace(']', '') +
' μm/s')
if self.showLegend2 == True:
dict_reg = dict(zip(lab_reg,
lns_reg)) #legend dictionary (remove dup)
self.fig1.legend(dict_reg.values(),
dict_reg.keys(),
loc='lower right',
ncol=len(lns_reg))
if self.flag_ap == True: #show adhesion calc
#fill adhesion energy region
ax1.fill_between(xAxisData[self.energy_slice],
self.forceDict["zero1"][0],
self.force_vert1_shifted[self.energy_slice],
color='black')
i = 0
for k in self.rangeDict.keys():
if len(self.rangeDict.keys()) > 1 and k == "Default":
continue
ax1.axhline(y=self.forceDict["zero1"][i],
color='y',
alpha=1,
linestyle=linelist[i],
linewidth=1)
ax1.axhline(y=self.forceDict["force_min1"][i],
color='y',
alpha=1,
linestyle=linelist[i],
linewidth=1)
ax1.axhline(y=self.forceDict["force_max1"][i],
color='y',
alpha=1,
linestyle=linelist[i],
linewidth=1)
ax1.axvline(x=xAxisData[self.time1.index(
self.indDict["time1_max"][i])],
color='y',
alpha=1,
linestyle=linelist[i],
linewidth=1)
i += 1
if self.flag_ca == True or self.flag_ra == True:
ax2 = ax1.twinx() #secondary axis
## cmap = plt.cm.get_cmap("Reds") # type: matplotlib.colors.ListedColormap
num = len(self.rangeDict.keys())
## colors = plt.cm.Reds(np.linspace(0.3,1,num))
colors = plt.cm.Greens([0.7, 0.5, 0.9, 0.3, 1])
ax2.set_prop_cycle(color=colors)
ax2.set_ylabel('Area ($' + unit + '^2$)', color='g')
if self.flag_ca == True:
i = 0
for k in self.rangeDict.keys():
if len(self.rangeDict.keys()) > 1 and k == "Default":
continue
p2, = ax2.plot(self.time2[self.plot_slice2],
self.dataDict[k][0][self.plot_slice2],
'-' + markerlist[i],
alpha=0.5,
linewidth=1,
markersize=2,
label="Contact Area: " + k)
# p2.set_animated(True) #BLIT THIS CHECK!!!
lns.append(p2)
if self.flag_ap == True: #adhesion calc
ax2.plot(self.indDict["time1_max"][i],
self.areaDict["area2_pulloff"][i],
'y' + markerlist[i],
alpha=0.8)
if self.flag_fp == True: #friction calc
ax2.plot(self.indDict["time1_lat_avg"][i],
self.areaDict["area_friction"][i],
'g' + markerlist[i],
alpha=0.8)
i += 1
if self.flag_ra == True: #consider first key since auto roi is same for all keys
colors = plt.cm.Blues([0.7, 0.5, 0.9, 0.3, 1])
ax2.set_prop_cycle(color=colors)
j = 0
for k in self.rangeDict.keys():
if len(self.rangeDict.keys()) > 1 and k == "Default":
continue
p3, = ax2.plot(self.time2[self.plot_slice2],
self.dataDict[k][3][self.plot_slice2],
'-' + markerlist[j],
alpha=0.5,
linewidth=1,
markersize=2,
label="ROI Area: " + k)
lns.append(p3)
j += 1
if self.flag_lf == True:
ax3 = ax1.twinx() #lateral force
ax3.set_ylabel('Lateral Force (μN)', color='c')
ax3.spines['left'].set_position(
('outward', int(6 * self.fontSize)))
ax3.spines["left"].set_visible(True)
ax3.yaxis.set_label_position('left')
ax3.yaxis.set_ticks_position('left')
if self.invert_latf == True:
ax3.invert_yaxis()
if self.flag_lf == True:
p4, = ax3.plot(xAxisData[self.plot_slice],
self.force_lat1_shifted[self.plot_slice],
'co',
alpha=0.5,
linewidth=1,
markersize=1,
label="Lateral Force")
## if self.flag_lf_filter == True:
## p4, = ax3.plot(self.time1[self.plot_slice], self.force_lat1_filtered_shifted[self.plot_slice], '-c',
## alpha=0.5, linewidth=1, label="Lateral Force")
if self.flag_fp == True: #show friction calc
i = 0
for k in self.rangeDict.keys():
if len(self.rangeDict.keys()) > 1 and k == "Default":
continue
ax3.axhline(y=self.forceDict["force_lat_max"][i],
color='g',
alpha=1,
linestyle=linelist[i],
linewidth=1)
ax3.axhline(y=self.forceDict["force_lat_min"][i],
color='g',
alpha=1,
linestyle=linelist[i],
linewidth=1)
ax1.axhline(y=self.forceDict["force_max2"][i],
color='g',
alpha=1,
linestyle=linelist[i],
linewidth=1)
ax3.axvline(x=xAxisData[self.time1.index(
self.indDict["time1_lat_avg"][i])],
color='g',
alpha=1,
linestyle=linelist[i],
linewidth=1)
# ax2.plot(self.indDict["time1_lat_avg"][i],
# self.areaDict["area_friction"][i],
# 'g' + markerlist[i], alpha=0.8)
i += 1
ax3.axhline(y=self.forceDict["zero2"],
color='g',
alpha=0.5,
linestyle=linelist[0],
linewidth=1)
lns.append(p4)
else:
ax3 = None
if self.flag_zp == True or self.flag_xp == True or self.flag_zd: #piezo position/deformation
ax4 = ax1.twinx() #piezo waveform
ax4.set_ylabel('Displacement (μm)', color='violet')
if self.flag_ca == True or self.flag_ra == True: #shift axis if area plotted
ax4.spines['right'].set_position(
('outward', int(7 * self.fontSize)))
## ax4.invert_yaxis()
if self.flag_zp == True:
p5, = ax4.plot(xAxisData[self.plot_slice],
self.dist_vert1[self.plot_slice],
'-',
markersize=1,
color='violet',
alpha=0.5,
label="Vertical Piezo")
lns.append(p5)
if self.flag_xp == True:
p6, = ax4.plot(xAxisData[self.plot_slice],
self.dist_lat1[self.plot_slice],
'-.',
markersize=1,
color='violet',
alpha=0.5,
label="Lateral Piezo")
lns.append(p6)
if self.flag_zd == True: #actual deformation plot
p12, = ax4.plot(xAxisData[self.plot_slice],
self.deform_vert[self.plot_slice],
'-o',
markersize=1,
color='violet',
alpha=0.5,
label="Deformation")
if self.flag_ap == True:
ax1.axvline(x=xAxisData[self.deform_tol],
color='violet',
alpha=1,
linestyle=":",
linewidth=1)
lns.append(p12)
if self.flag_cl == True or self.flag_rl == True:
ax5 = ax1.twinx()
num = len(self.rangeDict.keys())
colors = plt.cm.copper(np.linspace(0.2, 0.7, num))
ax5.set_prop_cycle(color=colors)
ax5.set_ylabel('Length ($' + unit + '$)', color='brown')
if self.flag_ca == True or self.flag_ra == True:
ax5.spines['right'].set_position(
('outward', int(7 * self.fontSize)))
if self.flag_cl == True: #contact length
i = 0
for k in self.rangeDict.keys():
if len(self.rangeDict.keys()) > 1 and k == "Default":
continue
p7, = ax5.plot(self.time2[self.plot_slice2],
self.dataDict[k][1][self.plot_slice2],
'-' + markerlist[i],
alpha=0.5,
linewidth=1,
markersize=2,
label="Contact Length: " + k)
lns.append(p7)
i += 1
if self.flag_rl == True: #roi length
## ax5 = ax1.twinx()
num = len(self.rangeDict.keys())
colors = plt.cm.Wistia(np.linspace(0.2, 0.7, num))
ax5.set_prop_cycle(color=colors)
## ax5.spines['right'].set_position(('outward', 70))
j = 0
for k in self.rangeDict.keys():
if len(self.rangeDict.keys()) > 1 and k == "Default":
continue
## ax5.set_ylabel('Length ($' + unit + '$)', color = 'brown')
p8, = ax5.plot(self.time2[self.plot_slice2],
self.dataDict[k][4][self.plot_slice2],
'-' + markerlist[j],
alpha=0.5,
linewidth=1,
markersize=2,
label="ROI Length: " + k)
lns.append(p8)
j += 1
if self.flag_cn == True: #contact number
ax5 = ax1.twinx()
num = len(self.rangeDict.keys())
colors = plt.cm.copper(np.linspace(0.2, 0.7, num))
ax5.set_prop_cycle(color=colors)
ax5.spines['right'].set_position(
('outward', int(7 * self.fontSize)))
i = 0
for k in self.rangeDict.keys():
if len(self.rangeDict.keys()) > 1 and k == "Default":
continue
ax5.set_ylabel('Number', color='brown')
p9, = ax5.plot(self.time2[self.plot_slice2],
self.dataDict[k][2][self.plot_slice2],
'-' + markerlist[i],
alpha=0.5,
linewidth=1,
markersize=2,
label="Contact Number: " + k)
lns.append(p9)
i += 1
if self.flag_ecc == True: #contact eccentricity
ax5 = ax1.twinx()
num = len(self.rangeDict.keys())
colors = plt.cm.copper(np.linspace(0.2, 0.7, num))
ax5.set_prop_cycle(color=colors)
ax5.spines['right'].set_position(
('outward', int(7 * self.fontSize)))
i = 0
for k in self.rangeDict.keys():
if len(self.rangeDict.keys()) > 1 and k == "Default":
continue
ax5.set_ylabel('Eccentricity' + unit + '$)', color='brown')
p10, = ax5.plot(self.time2[self.plot_slice2],
self.dataDict[k][5][self.plot_slice2],
'-' + markerlist[i],
alpha=0.5,
linewidth=1,
markersize=2,
label="Median Eccentricity: " + k)
lns.append(p10)
i += 1
if self.flag_st == True or self.flag_lf_filter == True: #stress CHECK!
ax6 = ax1.twinx()
ax6.set_ylabel('Stress (μN/$' + unit + '^2$)', color='c')
ax6.spines['left'].set_position(
('outward', int(6 * self.fontSize)))
ax6.spines["left"].set_visible(True)
ax6.yaxis.set_label_position('left')
ax6.yaxis.set_ticks_position('left')
if self.flag_st == True:
p11, = ax6.plot(xAxisData[self.plot_slice],
self.stress[self.plot_slice],
'co',
alpha=0.5,
linewidth=1,
markersize=1,
label="Stress")
if self.flag_lf_filter == True:
p11, = ax6.plot(xAxisData[self.plot_slice],
self.stress_filtered[self.plot_slice],
'-c',
alpha=0.5,
linewidth=1,
markersize=1,
label="Stress")
lns.append(p11)
## lns = [p1, p3, p2, p4, p5]
## else:
## lns = [p1, p2]
ax1.legend(handles=lns, loc=self.legendPos)
if self.fitWindow.enableFitting.isChecked() == True:
axDict = {'Vertical Force (μN)': ax1, 'Lateral Force (μN)': ax3}
# yDict = {'Vertical Force (μN)':self.force_vert1_shifted,
# 'Lateral Force (μN)':self.force_lat1_shifted}
# fit_slice = slice(int(self.startFit * self.ptsnumber/100),
# int(self.endFit * self.ptsnumber/100))
self.slope_unit = self.fitWindow.yFit.currentText().split('(')[1].split(')')[0] + '/' +\
self.fitWindow.xFit.currentText().split('(')[1].split(')')[0]
text_pos = self.fit_pos.split(",")
# self.slope = fitting.polyfitData(xDict.get(self.fit_x)[fit_slice], yDict.get(self.fit_y)[fit_slice],
# axDict.get(self.fit_y), xAxisData[fit_slice], unit = self.slope_unit,
# eq_pos = text_pos, fit_order = 1, fit_show = self.fit_show)
ax_fit = axDict.get(self.fitWindow.yFit.currentText())
ax_fit.plot(xAxisData[self.fitWindow.fit_slice],
self.fitWindow.fit_ydata,
color='black',
linewidth=2,
linestyle='dashed')
## print(eq_pos)
if self.fit_show == True and \
self.fitWindow.fittingFunctionType.currentText() == 'Linear':
self.slope = self.fitWindow.fitParams['m']
slope_label = "Slope: " + "%.4f"%(self.slope) + \
' (' + self.slope_unit + ')'
ax_top = self.fig1.get_axes()[-1]
ax_top.text(float(text_pos[0]),
float(text_pos[1]),
slope_label,
ha='right',
transform=ax_top.transAxes,
color='black',
bbox=dict(facecolor='white',
edgecolor='black',
alpha=0.5),
picker=5)
else:
self.slope = ''
self.slope_unit = ''
self.fig1.tight_layout()
self.fig1.canvas.draw()
self.plotWidget.wid.axes = self.fig1.get_axes()[-1]
self.plotWidget.wid.add_cursors(cursor1_init=c1_init,
cursor2_init=c2_init)
print("plot finish")
# self.plotWidget.wid.draw_idle()
# self.fig1.tight_layout()
# self.fig1.canvas.draw()
# def showPlot(self): #show plot
# ## self.fig1.show()
# try:
# # plt.pause(0.05)
# # self.axes.relim()
# # self.axes.autoscale()
# self.fig1.tight_layout()
# self.fig1.canvas.draw()
# # self.plotWidget
# # self.plotWidget.show()
# except Exception as e:
# print(e)
## plt.show(block=False)
## plt.draw()
# def handle_close(self, evt): #figure closed event
# self.fig1_close = True
# print("close")
def convertPlot(self): #convert plot to numpy
self.fig1.canvas.draw()
data = np.fromstring(self.fig1.canvas.tostring_rgb(),
dtype=np.uint8,
sep='')
data = data.reshape(self.fig1.canvas.get_width_height()[::-1] + (3, ))
return data
def savePlot(self, filepath): #save force plots
print("save plot")
self.fig1.savefig(filepath, orientation='landscape', transparent=True)
#save figure object as pickle file
with open(filepath[:-4] + '.pickle', 'wb') as f:
pickle.dump(self.fig1, f, pickle.HIGHEST_PROTOCOL)
# class PlotWindow(QWidget):
# def __init__(self, fig, *args, **kwargs):
# ## super(QWidget, self).__init__(*args, **kwargs)
# super().__init__()
# self.setGeometry(100, 100, 1000, 500)
# self.setWindowTitle("Plot")
# self.fig = fig
# self.home()
# def home(self):
# self.plotWidget = Plot2Widget(self.fig,cursor1_init=2,cursor2_init=6)
# plotToolbar = NavigationToolbar(self.plotWidget, self)
# plotGroupBox = QGroupBox()
# plotlayout=QGridLayout()
# plotGroupBox.setLayout(plotlayout)
# plotlayout.addWidget(plotToolbar, 0, 0, 1, 1)
# plotlayout.addWidget(self.plotWidget, 1, 0, 1, 1)
# layout=QGridLayout()
# layout.addWidget(plotGroupBox, 0, 0, 1, 1)
# self.setLayout(layout)
# self.show()
# startFitLabel = QLabel("Start (%):")
def make_chart_response(country, deaths_start, avg_before_deaths, df_to_show):
city = df_to_show['City'].iloc[0]
df_quar = pd.read_csv(data_dir + 'all_countries_response.csv',
parse_dates=['Quarantine'])
quarantine = df_quar[df_quar['Country'] == country]['Quarantine'].iloc[0]
week = mdates.WeekdayLocator(interval=2) # every year
months = mdates.MonthLocator() # every month
month_fmt = mdates.DateFormatter('%b-%d')
y_lim = df_to_show['TotalDeaths'].max() * 1.2
y2_lim = df_to_show['no2'].max() * 1.8
# Generate the figure **without using pyplot**.
fig = Figure(figsize=(10, 5))
ax = fig.subplots()
ax.set_title('Assessing quarantine implementation - ' + country,
fontsize=16,
loc='left')
if not pd.isnull(quarantine):
ax.axvline(x=quarantine,
color='k',
linestyle='--',
lw=3,
label='Official quarantine')
ax.scatter(df_to_show['Date'],
df_to_show['TotalDeaths'],
color='black',
alpha=0.7,
label='Confirmed deaths')
ax.xaxis.set_major_locator(week)
ax.xaxis.set_major_formatter(month_fmt)
ax.set_yscale('log')
ax.yaxis.set_major_formatter(
ticker.FuncFormatter(lambda y, _: '{:g}'.format(y)))
ax.set_ylim(1, y_lim)
ax.set(ylabel='Confirmed deaths')
ax2 = ax.twinx()
sns.lineplot(x="Date",
y='no2',
alpha=0.7,
lw=6,
label='Daily $\mathrm{{NO}}_2$ pollution *',
ax=ax2,
data=df_to_show)
sns.lineplot(x="Date",
y=avg_before_deaths,
alpha=0.7,
lw=6,
label='Average pollution **',
ax=ax2,
data=df_to_show)
ax2.grid(False)
ax2.xaxis.set_major_locator(week)
ax2.xaxis.set_major_formatter(month_fmt)
ax2.set_ylim(1, y2_lim)
ax2.set(ylabel='$\mathrm{{NO}}_2$ pollution')
# ask matplotlib for the plotted objects and their labels
lines, labels = ax.get_legend_handles_labels()
lines2, labels2 = ax2.get_legend_handles_labels()
ax2.legend(lines + lines2, labels + labels2, loc='upper left')
annotation = """* Median of $\mathrm{{NO}}_2$ measurements in the most affected city ({city}), 5 days rolling average over time series\n** Average daily $\mathrm{{NO}}_2$ measurements from the begining of 2020 until the first day after {deaths_start} deaths""".format(
city=city, deaths_start=deaths_start)
ax.annotate(annotation, (0, 0), (0, -30),
xycoords='axes fraction',
textcoords='offset points',
va='top')
logo = plt.imread('./static/img/new_logo_site.png')
ax.figure.figimage(logo, 100, 110, alpha=.35, zorder=1)
fig.tight_layout()
# Save it to a temporary buffer.
buf = BytesIO()
fig.savefig(buf, format="png")
buf.seek(0)
return buf
ax = fig.add_axes([0.04, 0.07, 0.95, 0.92])
ax.set_xlim(xmin=1926, xmax=1937),
ax.set_ylim(ymin=-5, ymax=5)
ax.set_xticks([1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1935])
ax.set_yticks([-4, -3, -2, -1, 0, 1, 2, 3, 4])
ax.set_ylabel('TMP2m anomaly')
# Mark the zero line
ax.add_line(
Line2D((1926, 1937), (0, 0),
linewidth=1.0,
color=(0, 0, 0, 0.5),
alpha=1.0,
zorder=100))
# Mark the flood period
ax.add_patch(
Rectangle((1931.5, -100), 0.3, 200, fill=True, facecolor=(0, 0, 0, 0.1)))
for member in range(80):
ax.add_line(
Line2D(dts,
tSeries[member],
linewidth=0.5,
color=(0, 0, 1, 1),
alpha=0.1,
zorder=200))
fig.savefig('TMP2m_ts.png')
frameon=False,
subplotpars=None,
tight_layout=None)
canvas=FigureCanvas(fig)
# Hidden layer
plot_hidden(autoencoder.get_weights()[1])
# Global projection
projection=ccrs.RotatedPole(pole_longitude=180.0, pole_latitude=90.0)
extent=[-180,180,-90,90]
for layer in [0,2]:
w_l=autoencoder.get_weights()[layer]
vmin=numpy.mean(w_l)-numpy.std(w_l)*3
vmax=numpy.mean(w_l)+numpy.std(w_l)*3
count=0
for channel in order:
w_in=ic.copy()
if layer==0:
w_in.data=w_l[:,channel].reshape(ic.data.shape)
else:
w_in.data=w_l[channel,:].reshape(ic.data.shape)
w_in.data *= numpy.sign(autoencoder.get_weights()[1][channel])
plot_weights(w_in,layer=layer,channel=count,nchannels=36,
vmin=vmin,vmax=vmax)
count += 1
# Render the figure as a png
fig.savefig("weights.png")
ax.set_xlim(xmin=1930,xmax=1932),
ax.set_ylim(ymin=0,ymax=170)
ax.set_xticks([1927,1928,1929,1930,1931,1932,1933,1934,1935])
#ax.set_yticks([-4,-3,-2,-1,0,1,2,3,4])
ax.set_ylabel('PRATE actual')
# Mark the flood period
ax.add_patch(
Rectangle(
(1931.5, -1), 0.3, 200, fill=True, facecolor=(0,0,0,0.1)
)
)
# Mark the climatology
ax.add_line(Line2D(dts,clim*11,
linewidth=1.5,
color=(1,0,0,1),
alpha=0.5,
zorder=100))
for member in range(80):
ax.add_line(Line2D(dts,tSeries[member],
linewidth=0.5,
color=(0,0,1,1),
alpha=0.1,
zorder=200))
fig.savefig('PRATE_ts_actuals.png')
def train(self, sess, config):
""" Training the GAN """
print('initializing...opt')
d_opt = self.d_opt
g_opt = self.g_opt
try:
init = tf.global_variables_initializer()
sess.run(init)
except AttributeError:
init = tf.intializer_all_varialble()
sess.run(init)
print('initializing...var')
# g_summaries = [self.d_fake_summary,
# self.d_fake_loss_summary,
# self.g_loss_summary,
# self.g_l2_loss_summary,
# self.g_loss_adv_summary,
# self.generated_wav_summary]
# d_summaries = [self.d_loss_summary, self.d_real_summary, self.d_real_loss_summary, self.high_wav_summary]
# if hasattr(self, 'alpha_summ'):
# g_summaries += self.alpha_summ
# self.g_sum = tf.summary.merge(g_summaries)
# self.d_sum = tf.summary.merge(d_summaries)
if not os.path.exists(os.path.join(config.save_path, 'train')):
os.makedirs(os.path.join(config.save_path, 'train'))
self.writer = tf.summary.FileWriter(
os.path.join(config.save_path, 'train'), self.sess.graph)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(coord=coord)
sample_low, sample_high, sample_z = self.sess.run(
[self.gt_low[0], self.gt_high[0], self.zz_A[0]],
feed_dict={
self.is_valid: False,
self.is_train: True,
self.is_mismatch: False
})
v_sample_low, v_sample_high, v_sample_z = self.sess.run(
[self.gt_low[0], self.gt_high[0], self.zz_A[0]],
feed_dict={
self.is_valid: True,
self.is_train: False,
self.is_mismatch: False
})
print('sample low shape: ', sample_low.shape)
print('sample high shape: ', sample_high.shape)
print('sample z shape: ', sample_z.shape)
save_path = config.save_path
counter = 0
# count of num of samples
num_examples = 0
for record in tf.python_io.tf_record_iterator(self.tfrecords):
num_examples += 1
print("total num of patches in tfrecords", self.tfrecords, ": ",
num_examples)
# last samples
# batch num
num_batches = num_examples / self.batch_size
print('batches per epoch: ', num_batches)
if self.load(self.save_path):
print('load success')
else:
print('load failed')
batch_idx = 0
current_epoch = 0
batch_timings = []
g_losses = []
d_A_losses = []
d_B_losses = []
g_adv_losses = []
g_l1_losses_BAB = []
g_l1_losses_AB = []
g_l1_losses_ABA = []
g_l1_losses_BA = []
try:
while not coord.should_stop():
start = timeit.default_timer()
if counter % config.save_freq == 0:
for d_iter in range(self.disc_updates):
_d_opt, d_A_loss, d_B_loss = self.sess.run(
[d_opt, self.d_A_losses[0], self.d_B_losses[0]],
feed_dict={
self.is_valid: False,
self.is_train: True,
self.is_mismatch: True
})
_d_opt, d_A_loss, d_B_loss = self.sess.run(
[d_opt, self.d_A_losses[0], self.d_B_losses[0]],
feed_dict={
self.is_valid: False,
self.is_train: True,
self.is_mismatch: False
})
#_d_sum, d_fake_loss, d_real_loss = self.sess.run(
# [self.d_sum, self.d_fake_losses[0], self.d_real_losses[0]], feed_dict={self.is_valid: False})
if self.d_clip_weights:
self.sess.run(self.d_clip,
feed_dict={
self.is_valid: False,
self.is_train: True
})
#_g_opt, _g_sum, g_adv_loss, g_l2_loss = self.sess.run([g_opt, self.g_sum, self.g_adv_losses[0], self.g_l2_losses[0]], feed_dict={self.is_valid:False})
_g_opt, g_adv_loss, g_AB_loss, g_BA_loss, g_ABA_loss, g_BAB_loss = self.sess.run(
[
g_opt, self.g_adv_losses[0], self.g_losses_AB[0],
self.g_losses_BA[0], self.g_l1_losses_ABA[0],
self.g_l1_losses_BAB[0]
],
feed_dict={
self.is_valid: False,
self.is_train: True,
self.is_mismatch: True
})
_g_opt, g_adv_loss, g_AB_loss, g_BA_loss, g_ABA_loss, g_BAB_loss = self.sess.run(
[
g_opt, self.g_adv_losses[0], self.g_losses_AB[0],
self.g_losses_BA[0], self.g_l1_losses_ABA[0],
self.g_l1_losses_BAB[0]
],
feed_dict={
self.is_valid: False,
self.is_train: True,
self.is_mismatch: False
})
# _phase_opt, phase_loss = self.sess.run([phase_opt, self.phase_losses[0]], feed_dict={self.is_valid:False,self.is_train: True})
else:
for d_iter in range(self.disc_updates):
_d_opt, d_A_loss, d_B_loss = self.sess.run(
[d_opt, self.d_A_losses[0], self.d_B_losses[0]],
feed_dict={
self.is_valid: False,
self.is_train: True,
self.is_mismatch: True
})
_d_opt, d_A_loss, d_B_loss = self.sess.run(
[d_opt, self.d_A_losses[0], self.d_B_losses[0]],
feed_dict={
self.is_valid: False,
self.is_train: True,
self.is_mismatch: False
})
#d_fake_loss, d_real_loss = self.sess.run(
# [self.d_fake_losses[0], self.d_real_losses[0]], feed_dict={self.is_valid: False})
if self.d_clip_weights:
self.sess.run(self.d_clip,
feed_dict={
self.is_valid: False,
self.is_train: True
})
_g_opt, g_adv_loss, g_AB_loss, g_BA_loss, g_ABA_loss, g_BAB_loss = self.sess.run(
[
g_opt, self.g_adv_losses[0], self.g_losses_AB[0],
self.g_losses_BA[0], self.g_l1_losses_ABA[0],
self.g_l1_losses_BAB[0]
],
feed_dict={
self.is_valid: False,
self.is_train: True,
self.is_mismatch: True
})
_g_opt, g_adv_loss, g_AB_loss, g_BA_loss, g_ABA_loss, g_BAB_loss = self.sess.run(
[
g_opt, self.g_adv_losses[0], self.g_losses_AB[0],
self.g_losses_BA[0], self.g_l1_losses_ABA[0],
self.g_l1_losses_BAB[0]
],
feed_dict={
self.is_valid: False,
self.is_train: True,
self.is_mismatch: False
})
# _phase_opt, phase_loss = self.sess.run([phase_opt, self.phase_losses[0]], feed_dict={self.is_valid:False,self.is_train: True})
end = timeit.default_timer()
batch_timings.append(end - start)
d_A_losses.append(d_A_loss)
d_B_losses.append(d_B_loss)
g_adv_losses.append(g_adv_loss)
g_l1_losses_BAB.append(g_BAB_loss) # clean - reverb - clean
g_l1_losses_AB.append(g_AB_loss) # reverb - clean
g_l1_losses_ABA.append(g_ABA_loss) # reverb - clean - reverb
g_l1_losses_BA.append(g_BA_loss) # clean - reverb
print(
'{}/{} (epoch {}), d_A_loss = {:.5f}, '
'd_B_loss = {:.5f}, ' #d_nfk_loss = {:.5f}, '
'g_adv_loss = {:.5f}, g_AB_loss = {:.5f}, g_BAB_loss = {:.5f}, '
'g_BA_loss = {:.5f}, g_ABA_loss = {:.5f}, '
' time/batch = {:.5f}, '
'mtime/batch = {:.5f}'.format(
counter, config.epoch * num_batches, current_epoch,
d_A_loss, d_B_loss, g_adv_loss, g_AB_loss, g_BAB_loss,
g_BA_loss, g_ABA_loss, end - start,
np.mean(batch_timings)))
batch_idx += 1
counter += 1
if (counter) % 2000 == 0 and (counter) > 0:
self.save(config.save_path, counter)
if (counter % config.save_freq == 0) or (counter == 1):
# self.writer.add_summary(_g_sum, counter)
# self.writer.add_summary(_d_sum, counter)
#feed_dict = {self.gt_high[0]:v_sample_high, self.gt_low[0]:v_sample_low, self.zz[0]:v_sample_z, self.is_valid:True}
s_A, s_B, s_reverb, s_gt, r_phase, f_phase = self.sess.run(
[
self.GG_A[0][0, :, :, :], self.GG_B[0][0, :, :, :],
self.gt_low[0][0, :, :, :],
self.gt_high[0][0, :, :, :],
self.ori_phase_[0][0, :, :, :],
self.rev_phase_[0][0, :, :, :]
],
feed_dict={
self.is_valid: True,
self.is_train: False,
self.is_mismatch: False
})
if not os.path.exists(save_path + '/wav'):
os.makedirs(save_path + '/wav')
if not os.path.exists(save_path + '/txt'):
os.makedirs(save_path + '/txt')
if not os.path.exists(save_path + '/spec'):
os.makedirs(save_path + '/spec')
print(str(counter) + 'th finished')
x_AB = s_A
x_BA = s_B
x_reverb = s_reverb
x_gt = s_gt
Sre = self.get_spectrum(x_reverb).reshape(512, 128)
Sgt = self.get_spectrum(x_gt).reshape(512, 128)
SAB = self.get_spectrum(x_AB).reshape(512, 128)
SBA = self.get_spectrum(x_BA).reshape(512, 128)
S = np.concatenate((Sre, Sgt, SAB, SBA), axis=1)
fig = Figure(figsize=S.shape[::-1], dpi=1, frameon=False)
canvas = FigureCanvas(fig)
fig.figimage(S, cmap='jet')
fig.savefig(save_path + '/spec/' + 'valid_batch_index' +
str(counter) + '-th_pr.png')
x_pr = librosa.istft(self.inv_magphase(s_A, f_phase))
librosa.output.write_wav(
save_path + '/wav/' + str(counter) +
'_AB(dereverb).wav', x_pr, 16000)
x_pr = librosa.istft(self.inv_magphase(s_B, r_phase))
librosa.output.write_wav(
save_path + '/wav/' + str(counter) + '_BA(reverb).wav',
x_pr, 16000)
x_lr = librosa.istft(self.inv_magphase(s_reverb, f_phase))
librosa.output.write_wav(
save_path + '/wav/' + str(counter) + '_reverb.wav',
x_lr, 16000)
x_hr = librosa.istft(self.inv_magphase(s_gt, r_phase))
librosa.output.write_wav(
save_path + '/wav/' + str(counter) + '_orig.wav', x_hr,
16000)
s_AB, s_BA, s_reverb, s_gt = self.sess.run(
[
self.GG_A[0][0, :, :, :], self.GG_B[0][0, :, :, :],
self.gt_low[0][0, :, :, :],
self.gt_high[0][0, :, :, :]
],
feed_dict={
self.is_valid: False,
self.is_train: True,
self.is_mismatch: False
})
x_AB = s_AB
x_BA = s_BA
x_reverb = s_reverb
x_gt = s_gt
Sre = self.get_spectrum(x_reverb).reshape(512, 128)
Sgt = self.get_spectrum(x_gt).reshape(512, 128)
SAB = self.get_spectrum(x_AB).reshape(512, 128)
SBA = self.get_spectrum(x_BA).reshape(512, 128)
S = np.concatenate((Sre, Sgt, SAB, SBA), axis=1)
fig = Figure(figsize=S.shape[::-1], dpi=1, frameon=False)
canvas = FigureCanvas(fig)
fig.figimage(S, cmap='jet')
fig.savefig(save_path + '/spec/' + 'train_batch_index' +
str(counter) + '-th_pr.png')
#np.savetxt(os.path.join(save_path, '/txt/d_real_losses.txt'), d_real_losses)
#np.savetxt(os.path.join(save_path, '/txt/d_fake_losses.txt'), d_fake_losses)
#np.savetxt(os.path.join(save_path, '/txt/g_adv_losses.txt'), g_adv_losses)
#np.savetxt(os.path.join(save_path, '/txt/g_l2_losses.txt'), g_l2_losses)
if batch_idx >= num_batches:
current_epoch += 1
#reset batch idx
batch_idx = 0
if current_epoch >= config.epoch:
print(str(self.epoch), ': epoch limit')
print('saving last model at iteration', str(counter))
self.save(config.save_path, counter)
# self.writer.add_summary(_g_sum, counter)
# self.writer.add_summary(_d_sum, counter)
break
except tf.errors.InternalError:
print('InternalError')
pass
except tf.errors.OutOfRangeError:
print('done training')
pass
finally:
coord.request_stop()
coord.join(threads)
def make_chart_comparison(df_places_to_show,
level='countries',
scale='log',
y='total',
mode='static'):
week = mdates.WeekdayLocator(interval=2) # every year
months = mdates.MonthLocator() # every month
month_fmt = mdates.DateFormatter('%b-%d')
var_y_suffix = '' if y == 'total' else 'Per100k'
label_y_scale = ' (log)' if scale == 'log' else ''
label_y_y = '' if y == 'total' else ' per 100k'
# get last date from dataframe
date = df_places_to_show['Date'].max(
) # datetime.today().strftime('%Y-%m-%d')
gap = int(df_places_to_show['gap'].min())
y_lim = df_places_to_show['Total' + var_y_suffix].max() #* 1.2
# Generate the figure **without using pyplot**.
fig = Figure(figsize=(8, 5))
ax = fig.subplots()
places_to_show = df_places_to_show['Name'].unique()[:2]
place_name = 'Country' if level == 'countries' else 'City'
df_places_to_show = df_places_to_show.rename(columns={'Name': place_name})
ax.set_title('{} Comparison - COVID-19 Cases vs. Deaths - {}'.format(
place_name, date),
fontsize=14)
sns.scatterplot(x="DayAdj",
y='Total' + var_y_suffix,
hue=place_name,
lw=6,
alpha=0.8,
data=df_places_to_show,
ax=ax)
ax.xaxis.set_major_locator(months)
ax.xaxis.set_major_formatter(month_fmt)
ax.legend(loc='upper left', title="Confirmed cases", frameon=True)
ax.set(
ylabel='Total confirmed cases{}{}'.format(label_y_y, label_y_scale),
xlabel="Date for {} ({}'s data shifted {} days to align death curves)".
format(places_to_show[0], places_to_show[1], gap))
ax.set_ylim(0.5, y_lim) if scale == 'log' else ax.set_ylim(-5, y_lim)
ax2 = ax.twinx()
if scale == 'log':
ax.set_yscale('log')
ax2.set_yscale('log')
ax.yaxis.set_major_formatter(
ticker.FuncFormatter(lambda y, _: '{:g}'.format(y)))
ax2.yaxis.set_major_formatter(
ticker.FuncFormatter(lambda y, _: '{:g}'.format(y)))
ax2.grid(False)
sns.lineplot(x="DayAdj",
y='TotalDeaths' + var_y_suffix,
hue=place_name,
alpha=0.7,
lw=6,
ax=ax2,
data=df_places_to_show)
ax2.legend(loc='lower right', title="Deaths", frameon=True)
ax2.set(ylabel='Total deaths{}{}'.format(label_y_y, label_y_scale))
ax2.set_ylim(0.5, y_lim) if scale == 'log' else ax2.set_ylim(-5, y_lim)
logo = plt.imread('./static/img/new_logo_site.png')
ax.figure.figimage(logo, 95, 70, alpha=.35, zorder=1)
fig.tight_layout()
# display(fig)
# Save it to a temporary buffer.
buf = BytesIO()
fig.savefig(buf, format="png")
buf.seek(0)
return buf
def visualize_manipulation_training(flow, epoch, save_dir=None):
"""
Visualize progress of manipulation training.
:param nip: the neural imaging pipeline
:param fan: the forensic analysis network
:param dcn: the compression model (e.g., deep compression network)
:param conf: confusion matrix (see 'confusion()')
:param epoch: epoch counter to be appended to the output filename
:param save_dir: path to the directory where figures should be generated (figure handle returned otherwise)
:param classes: labels for the classes to be used for plotting the confusion matrix
:return: None (if output to file requested) or figure handle
"""
# Basic figure setup
images_x = 3
images_y = 3 if isinstance(flow.codec, DCN) else 2
fig = Figure(figsize=(18, 10 / images_x * images_y))
conf = np.array(flow.fan.performance['confusion'])
# Draw the plots
ax = fig.add_subplot(images_y, images_x, 1)
ax.plot(flow.nip.performance['loss']['training'], '.', alpha=0.25)
ax.plot(helpers.stats.ma_conv(flow.nip.performance['loss']['training'], 0))
ax.set_ylabel('{} NIP loss'.format(flow.nip.class_name))
ax.set_title('Loss')
ax = fig.add_subplot(images_y, images_x, 2)
ax.plot(flow.nip.performance['psnr']['validation'], '.', alpha=0.25)
ax.plot(
helpers.stats.ma_conv(flow.nip.performance['psnr']['validation'], 0))
ax.set_ylabel('{} NIP psnr'.format(flow.nip.class_name))
ax.set_title('PSNR')
ax.set_ylim([30, 50])
ax = fig.add_subplot(images_y, images_x, 3)
ax.plot(flow.nip.performance['ssim']['validation'], '.', alpha=0.25)
ax.plot(
helpers.stats.ma_conv(flow.nip.performance['ssim']['validation'], 0))
ax.set_ylabel('{} NIP ssim'.format(flow.nip.class_name))
ax.set_title('SSIM')
ax.set_ylim([0.8, 1])
ax = fig.add_subplot(images_y, images_x, 4)
ax.plot(flow.fan.performance['loss']['training'], '.', alpha=0.25)
ax.plot(helpers.stats.ma_conv(flow.fan.performance['loss']['training'], 0))
ax.set_ylabel('FAN loss')
ax = fig.add_subplot(images_y, images_x, 5)
ax.plot(flow.fan.performance['accuracy']['validation'], '.', alpha=0.25)
ax.plot(
helpers.stats.ma_conv(flow.fan.performance['accuracy']['validation'],
0))
ax.set_ylabel('FAN accuracy')
ax.set_ylim([0, 1])
# The confusion matrix
ax = fig.add_subplot(images_y, images_x, 6)
ax.imshow(conf, vmin=0, vmax=1)
ax.set_xticks(range(flow.n_classes))
ax.set_xticklabels(flow._forensics_classes, rotation='vertical')
ax.set_yticks(range(flow.n_classes))
ax.set_yticklabels(flow._forensics_classes)
for r in range(flow.n_classes):
ax.text(r,
r,
'{:.2f}'.format(conf[r, r]),
horizontalalignment='center',
color='b' if conf[r, r] > 0.5 else 'w')
ax.set_xlabel('PREDICTED class')
ax.set_ylabel('TRUE class')
ax.set_title('Accuracy: {:.2f}'.format(np.mean(np.diag(conf))))
# If the compression model is a trainable DCN, include it's validation metrics
if images_y == 3:
ax = fig.add_subplot(images_y, images_x, 7)
ax.plot(flow.codec.performance['loss']['validation'], '.', alpha=0.25)
ax.plot(
helpers.stats.ma_conv(flow.codec.performance['loss']['validation'],
0))
ax.set_ylabel('DCN loss')
ax = fig.add_subplot(images_y, images_x, 8)
ax.plot(flow.codec.performance['ssim']['validation'], '.', alpha=0.25)
ax.plot(
helpers.stats.ma_conv(flow.codec.performance['ssim']['validation'],
0))
ax.set_ylabel('DCN ssim')
ax.set_ylim([0.8, 1])
ax = fig.add_subplot(images_y, images_x, 9)
ax.plot(flow.codec.performance['entropy']['validation'],
'.',
alpha=0.25)
ax.plot(
helpers.stats.ma_conv(
flow.codec.performance['entropy']['validation'], 0))
ax.set_ylabel('DCN entropy')
if save_dir is not None:
if not os.path.exists(save_dir):
os.makedirs(save_dir)
fig.savefig('{}/manip_validation_{:05d}.jpg'.format(save_dir, epoch),
bbox_inches='tight',
dpi=100)
del fig
else:
return fig
def vis_points(run=None,
d=None,
sdata_file=None,
y_target=0,
seed=None,
blocksize=None,
highlight_block=None):
if d is None:
d = exp_dir(run)
if sdata_file is not None:
with open(sdata_file, 'rb') as f:
sdata = pickle.load(f)
for fname in [
"true.xxx",
] + sorted(os.listdir(d)):
if fname == "true.xxx":
X = sdata.SX
elif not fname.startswith("step") or not fname.endswith("_X.npy"):
continue
else:
X = np.load(os.path.join(d, fname))
try:
ix_fname = fname.replace("_X", "_IX")
IX = np.load(os.path.join(d, ix_fname))
except:
IX = None
fig = Figure(dpi=144, figsize=(14, 14))
fig.patch.set_facecolor('white')
ax = fig.add_subplot(111)
cmap = "jet"
sargs = {}
if y_target == -1:
# plot "wrongness"
c = np.sqrt(np.sum((X - sdata.SX)**2, axis=1))
cmap = "hot"
elif y_target == -2 or y_target == -3:
# plot blocks
c = np.zeros((X.shape[0]))
if y_target == -2:
np.random.seed(seed)
sdata.cluster_rpc(blocksize)
else:
centers = grid_centers(blocksize)
sdata.set_centers(centers)
cmap = "prism"
if highlight_block is not None:
block_colors = np.ones((len(sdata.block_idxs), )) * 0.4
block_colors[highlight_block] = 0.0
else:
block_colors = np.linspace(0.0, 1.0, len(sdata.block_idxs))
block_idxs = sdata.reblock(X)
for i, idxs in enumerate(block_idxs):
c[idxs] = block_colors[i]
#c = np.sqrt(np.sum((X - sdata.SX)**2, axis=1))
elif sdata_file is None:
c = None
else:
c = sdata.SY[:, y_target:y_target + 1].flatten()
sargs['vmin'] = -3.0
sargs['vmax'] = 3.0
npts = len(X)
xmax = np.sqrt(npts)
X *= xmax
if IX is not None:
IX *= xmax
ax.scatter(IX[:, 0],
IX[:, 1],
alpha=1.0,
c="black",
s=25,
marker='o',
linewidths=0.0,
**sargs)
ax.scatter(X[:, 0],
X[:, 1],
alpha=1.0,
c=c,
cmap=cmap,
s=70,
marker='.',
linewidths=0.0,
**sargs)
ax.set_xlim((0, xmax))
ax.set_ylim((0, xmax))
ax.set_yticks([20, 40, 60, 80, 100])
ax.tick_params(axis='x', labelsize=30)
ax.tick_params(axis='y', labelsize=30)
canvas = FigureCanvasAgg(fig)
out_name = os.path.join(d, fname[:-4] + ".png")
fig.savefig(out_name, bbox_inches="tight")
print "wrote", out_name
print "generating movie...:"
cmd = "avconv -f image2 -r 5 -i step_%05d_X.png -qscale 28 gprf.mp4".split(
" ")
import subprocess
p = subprocess.Popen(cmd, cwd=d)
p.wait()
print "done"
# add a label to the x axis
#ax.set_xlabel('Year')
# add a label to the y axis
ax.set_ylabel('Temperature in Celsius')
# add a title
ax.set_title(
'Yearly Average Temperatures measured in Santacruz, Bombay for the years 1973-2019'
)
[s.set_visible(False) for s in ax.spines.values()]
DefaultSize = fig.get_size_inches()
fig.set_size_inches((DefaultSize[0] * 1.5, DefaultSize[1] * 1.5))
fig.savefig('weatherplot.png')
#Plotting daily average temperatures over different decades
santacruz_df80s = santacruz_df[(santacruz_df['YEAR'] >= '1980')
& (santacruz_df['YEAR'] < '1990')]
print(santacruz_df80s)
santacruz_df80s = santacruz_df80s.drop(
santacruz_df80s[(santacruz_df80s['MONTH'] == '02')
& (santacruz_df80s['DAY'] == '29')].index)
daily_avg_80s = santacruz_df80s.groupby(
['MONTH', 'DAY'])['TAVG'].agg(AVERAGE='mean').reset_index()
print(daily_avg_80s)
def matplotlib(pltid):
"""Generate a random image using Matplotlib and display it"""
# in the future create a private function __import__ to import third-party
# libraries, so that it can respond gracefully. See for example the
# Examples section at https://docs.python.org/2/library/imp.html
user = root.authorized()
import StringIO
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
app = request.query.app
cid = request.query.cid
fig = Figure()
fig.set_tight_layout(True)
ax = fig.add_subplot(111)
# get info about plot from db
p = Plot()
result = db(plots.id == pltid).select().first()
plot_title = result['title']
plottype = result['ptype']
options = result['options']
# parse plot options to extract and set x- and y-axis labels
m = re.search("xaxis:\s*{(.*)}", options)
if m:
n = re.search("axisLabel:\s*\"(\w*)\"", m.group(1))
if n: ax.set_xlabel(n.group(1))
m = re.search("yaxis:\s*{(.*)}", options)
if m:
n = re.search("axisLabel:\s*\"(\w*)\"", m.group(1))
if n: ax.set_ylabel(n.group(1))
# get info about data source
# fix in the future to handle multiple data sources
result = db(datasource.pltid == pltid).select()
for r in result:
plotfn = r['filename']
cols = r['cols']
line_range = r['line_range']
(col1str, col2str) = cols.split(":")
col1 = int(col1str)
col2 = int(col2str)
if line_range is not None:
# to prevent breaking current spc apps, still support
# expressions like 1:1000, but in the future this should
# be changed to a range 1-1000. Therefore, using : is deprecated
# and will be removed in the future.
(line1str, line2str) = re.split("[-:]", line_range)
plotfn = re.sub(r"<cid>", cid, plotfn)
sim_dir = os.path.join(user_dir, user, app, cid)
plotpath = os.path.join(sim_dir, plotfn)
xx = p.get_column_of_data(plotpath, col1)
yy = p.get_column_of_data(plotpath, col2)
# convert elements from strings to floats
xx = [float(i) for i in xx]
yy = [float(i) for i in yy]
# plot
if plottype == 'mpl-line':
ax.plot(xx, yy)
elif plottype == 'mpl-bar':
ax.bar(xx, yy)
else:
return "ERROR: plottype not supported"
canvas = FigureCanvas(fig)
png_output = StringIO.StringIO()
canvas.print_png(png_output)
# save file
tmp_dir = "static/tmp"
if not os.path.exists(tmp_dir):
os.makedirs(tmp_dir)
fn = plot_title + '.png'
fig.set_size_inches(7, 4)
img_path = os.path.join(sim_dir, fn)
fig.savefig(img_path)
# get list of all plots for this app
query = (apps.id == plots.appid) & (apps.name == app)
list_of_plots = db(query).select()
stats = compute_stats(plotpath)
params = {
'image': fn,
'app': app,
'cid': cid,
'pltid': pltid,
'plotpath': plotpath,
'img_path': img_path,
'plot_title': plot_title,
'rows': list_of_plots,
'stats': stats
}
return template('plots/matplotlib', params)
def thumbnail(infile,
thumbfile,
scale=0.1,
interpolation='bilinear',
preview=False):
"""
make a thumbnail of image in *infile* with output filename
*thumbfile*.
*infile* the image file -- must be PNG or PIL readable if you
have `PIL <http://www.pythonware.com/products/pil/>`_ installed
*thumbfile*
the thumbnail filename
*scale*
the scale factor for the thumbnail
*interpolation*
the interpolation scheme used in the resampling
*preview*
if True, the default backend (presumably a user interface
backend) will be used which will cause a figure to be raised
if :func:`~matplotlib.pyplot.show` is called. If it is False,
a pure image backend will be used depending on the extension,
'png'->FigureCanvasAgg, 'pdf'->FigureCanvasPdf,
'svg'->FigureCanvasSVG
See examples/misc/image_thumbnail.py.
.. htmlonly::
:ref:`misc-image_thumbnail`
Return value is the figure instance containing the thumbnail
"""
basedir, basename = os.path.split(infile)
baseout, extout = os.path.splitext(thumbfile)
im = imread(infile)
rows, cols, depth = im.shape
# this doesn't really matter, it will cancel in the end, but we
# need it for the mpl API
dpi = 100
height = float(rows) / dpi * scale
width = float(cols) / dpi * scale
extension = extout.lower()
if preview:
# let the UI backend do everything
import matplotlib.pyplot as plt
fig = plt.figure(figsize=(width, height), dpi=dpi)
else:
if extension == '.png':
from matplotlib.backends.backend_agg \
import FigureCanvasAgg as FigureCanvas
elif extension == '.pdf':
from matplotlib.backends.backend_pdf \
import FigureCanvasPdf as FigureCanvas
elif extension == '.svg':
from matplotlib.backends.backend_svg \
import FigureCanvasSVG as FigureCanvas
else:
raise ValueError("Can only handle "
"extensions 'png', 'svg' or 'pdf'")
from matplotlib.figure import Figure
fig = Figure(figsize=(width, height), dpi=dpi)
canvas = FigureCanvas(fig)
ax = fig.add_axes([0, 0, 1, 1],
aspect='auto',
frameon=False,
xticks=[],
yticks=[])
basename, ext = os.path.splitext(basename)
ax.imshow(im, aspect='auto', resample=True, interpolation=interpolation)
fig.savefig(thumbfile, dpi=dpi)
return fig
def validate_nip(model,
data,
save_dir=False,
epoch=0,
show_ref=False,
loss_type='L2'):
"""
Develops image patches using the given NIP and returns standard image quality measures.
If requested, resulting patches are visualized as thumbnails and saved to a directory.
:param model: the NIP model
:param data: the dataset (instance of Dataset)
:param data: the dataset (instance of Dataset)
:param save_dir: path to the directory where figures should be generated
:param epoch: epoch counter to be appended to the output filename
:param show_ref: whether to show only the developed image or also the GT target
:param loss_type: L1 or L2
:return: tuple of lists with per-image measurements of (ssims, psnrs, losss)
"""
ssims = []
psnrs = []
losss = []
# If requested, plot a figure with output/target pairs
if save_dir is not None:
images_x = np.minimum(data.count_validation, 10 if not show_ref else 5)
images_y = np.ceil(data.count_validation / images_x)
fig = Figure(figsize=(20, 20 / images_x * images_y *
(1 if not show_ref else 0.5)))
developed_out = np.zeros_like(data['validation']['y'], dtype=np.float32)
for b in range(data.count_validation):
example_x, example_y = data.next_validation_batch(b, 1)
developed = model.process(example_x).numpy().clip(0, 1)
developed_out[b, :, :, :] = developed
developed = developed[:, :, :, :].squeeze()
reference = example_y.squeeze()
# Compute stats
ssim = metrics.ssim(reference, developed).mean()
psnr = metrics.psnr(reference, developed).mean()
if loss_type == 'L2':
loss = np.mean(np.power(reference - developed, 2.0))
elif loss_type == 'L1':
loss = np.mean(np.abs(reference - developed))
else:
raise ValueError('Invalid loss! Use either L1 or L2.')
ssims.append(ssim)
psnrs.append(psnr)
losss.append(loss)
# Add images to the plot
if save_dir is not None:
ax = fig.add_subplot(images_y, images_x, b + 1)
plots.image(np.concatenate(
(reference, developed), axis=1) if show_ref else developed,
'{:.1f} dB / {:.2f}'.format(psnr, ssim),
axes=ax)
if save_dir is not None:
if not os.path.exists(save_dir):
os.makedirs(save_dir)
fig.savefig('{}/nip_validation_{:05d}.jpg'.format(save_dir, epoch),
bbox_inches='tight',
dpi=100,
quality=90)
del fig
return ssims, psnrs, losss
- scripting layer: user layer
"""
# example 1
# generate histo with random number using artist layer
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas # import figure canvas from back end layer (agg -> anty grain geometry that is high performance lib)
from matplotlib.figure import Figure # import figure artist
fig = Figure()
canvas = FigureCanvas(fig) # attach the Figure artist to Figure canvas
import numpy as np # to generate random number
x = np.random.randn(10000)
ax = fig.add_subplot(
111
) # it create an axis artist obj (the axes artist is added automatically to the figure axes container)
ax.hist(x, 100) # generate the histogram of 10000 points
ax.set_title('Histo Example')
fig.savefig('matplotlib_histogram.png')
# example 2
# generate histo with random number using scripting layer
import matplotlib.pyplot as plt
import numpy as np
x = np.random.randn(10000)
plt.hist(x, 100)
plt.title('Histo example using script layer')
plt.show()
def specphot_acs_and_wfc3(
id=69,
grism_root='ibhm45030',
MAIN_OUTPUT_FILE='cosmos-1.v4.6',
OUTPUT_DIRECTORY='/Users/gbrammer/research/drg/PHOTZ/EAZY/NEWFIRM/v4.6/OUTPUT_KATE/',
CACHE_FILE='Same',
Verbose=False,
SPC=None,
cat=None,
grismCat=None,
zout=None,
fout=None,
OUT_PATH='/tmp/',
OUT_FILE_FORMAT=True,
OUT_FILE='junk.png',
GET_SPEC_ONLY=False,
GET_WFC3=False,
WFC3_DIR='/3DHST/Spectra/Release/v2.0/GOODS-S'):
"""
specphot_acs_and_wfc3(id)
Get photometry/SED fit as well as WFC3 spectrum when available and overplot G141 spectrum.
This is different from unicorn.analysis.specphot() which does not get the WFC3 spectrum.
"""
import threedhst.eazyPy as eazy
import threedhst.catIO as catIO
import pyfits
#### Get G141 spectrum
if Verbose:
print 'Read SPC'
if SPC is None:
SPC = threedhst.plotting.SPCFile(grism_root + '_2_opt.SPC.fits',
axe_drizzle_dir='DRIZZLE_G141')
spec = SPC.getSpec(id)
if spec is False:
return False
xmin = 3000
xmax = 2.4e4
lam = spec.field('LAMBDA')
flux = spec.field('FLUX')
ffix = flux - spec.field('CONTAM')
ferr = spec.field('FERROR') #*0.06/0.128254
if Verbose:
print 'Read grism catalog'
#### Read the grism catalog and get coords of desired object
if grismCat is None:
grismCat = threedhst.sex.mySexCat('DATA/' + grism_root + '_drz.cat')
#### Source size
R = np.sqrt(np.cast[float](grismCat.A_IMAGE) *
np.cast[float](grismCat.B_IMAGE))
grism_idx = np.where(grismCat.id == id)[0][0]
Rmatch = R[grism_idx] * 1.
ra0 = grismCat.ra[grismCat.id == id][0]
de0 = grismCat.dec[grismCat.id == id][0]
#### Read EAZY outputs and get info for desired object
if cat is None:
cat = catIO.ReadASCIICat(OUTPUT_DIRECTORY + '../' + MAIN_OUTPUT_FILE +
'.cat')
dr = np.sqrt((cat.ra - ra0)**2 * np.cos(de0 / 360. * 2 * np.pi)**2 +
(cat.dec - de0)**2) * 3600.
photom_idx = np.where(dr == np.min(dr))[0][0]
drMatch = dr[photom_idx] * 1.
if drMatch > 2:
return False
if Verbose:
print 'Read zout'
if zout is None:
zout = catIO.ReadASCIICat(OUTPUT_DIRECTORY + '/' + MAIN_OUTPUT_FILE +
'.zout')
if fout is None:
fout = catIO.ReadASCIICat(OUTPUT_DIRECTORY +
'/../cosmos-1.m05.v4.6.fout')
if Verbose:
print 'Read binaries'
lambdaz, temp_sed, lci, obs_sed, fobs, efobs = \
eazy.getEazySED(photom_idx, MAIN_OUTPUT_FILE=MAIN_OUTPUT_FILE, \
OUTPUT_DIRECTORY=OUTPUT_DIRECTORY, \
CACHE_FILE = CACHE_FILE)
try:
lambdaz, temp_sed_sm = unicorn.analysis.convolveWithThumb(
id, lambdaz, temp_sed, SPC)
except:
temp_sed_sm = temp_sed * 1.
wfc3_exist = False
if GET_WFC3:
wfc3_file_path = WFC3_DIR + "/*/1D/FITS/*%05d.1D.fits" % (
cat.id[photom_idx])
wfc3_file = glob.glob(wfc3_file_path)
if wfc3_file != []:
wfc3_spec = pyfits.open(wfc3_file[0])
wfc3_exist = True
else:
print 'No WFC3 spectrum.'
if Verbose:
print 'Normalize spectrum'
q = np.where((lam > 0.55e4) & (lam < 1.0e4) & (flux > 0))[0]
if len(q) == 0:
return False
yint = np.interp(lam[q], lambdaz, temp_sed_sm)
anorm = np.sum(yint * ffix[q]) / np.sum(ffix[q]**2)
if np.isnan(anorm):
anorm = 1.
total_err = np.sqrt((ferr)**2 + (1.0 * spec.field('CONTAM'))**2) * anorm
if GET_SPEC_ONLY:
if drMatch > 1:
return False
else:
return lam, ffix * anorm, total_err, lci, fobs, efobs, photom_idx
if Verbose:
print 'Start plot'
#### Make the plot
threedhst.plotting.defaultPlotParameters()
xs = 5.8
ys = xs / 4.8 * 3.2
if USE_PLOT_GUI:
fig = plt.figure(figsize=[xs, ys], dpi=100)
else:
fig = Figure(figsize=[xs, ys], dpi=100)
fig.subplots_adjust(wspace=0.2,
hspace=0.2,
left=0.13 * 4.8 / xs,
bottom=0.15 * 4.8 / xs,
right=1. - 0.02 * 4.8 / xs,
top=1 - 0.10 * 4.8 / xs)
ax = fig.add_subplot(111)
ymax = np.max((ffix[q]) * anorm)
if Verbose:
print 'Make the plot'
ax.plot(lambdaz, temp_sed_sm, color='red')
ax.plot(lam[q], ffix[q] * anorm, color='blue', alpha=0.2, linewidth=1)
#### Show own extraction
sp1d = threedhst.spec1d.extract1D(id,
root=grism_root,
path='./HTML',
show=False,
out2d=False) #, GRISM_NAME='G800L')
lam = sp1d['lam']
flux = sp1d['flux']
ffix = sp1d['flux'] - sp1d['contam']
ferr = sp1d['error']
anorm = np.sum(yint * ffix[q]) / np.sum(ffix[q]**2)
ax.plot(lam[q], ffix[q] * anorm, color='blue', alpha=0.6, linewidth=1)
#### Show photometry + eazy template
ax.errorbar(lci,
fobs,
yerr=efobs,
color='orange',
marker='o',
markersize=10,
linestyle='None',
alpha=0.4)
ax.plot(lambdaz, temp_sed_sm, color='red', alpha=0.4)
if wfc3_exist:
q_wfc3 = np.where((wfc3_spec[1].data.wave > 1.08e4)
& (wfc3_spec[1].data.wave < 1.68e4)
& (wfc3_spec[1].data.flux > 0))[0]
yint_wfc3 = np.interp(wfc3_spec[1].data.wave[q_wfc3], lambdaz,
temp_sed_sm)
spec_wfc3 = (wfc3_spec[1].data.flux -
wfc3_spec[1].data.contam) / wfc3_spec[1].data.sensitivity
anorm_wfc3 = np.sum(yint_wfc3 * spec_wfc3[q_wfc3]) / np.sum(
spec_wfc3[q_wfc3]**2)
if np.isnan(anorm_wfc3): anorm_wfc3 = 1.
print 'Scaling factors: ', anorm, anorm_wfc3
ax.plot(wfc3_spec[1].data.wave[q_wfc3],
spec_wfc3[q_wfc3] * anorm_wfc3,
color='blue',
alpha=0.6,
linewidth=1)
ax.set_ylabel(r'$f_{\lambda}$')
if plt.rcParams['text.usetex']:
ax.set_xlabel(r'$\lambda$ [\AA]')
ax.set_title(
'%s: \#%d, z=%4.1f' % (SPC.filename.split('_2_opt')[0].replace(
'_', '\_'), id, zout.z_peak[photom_idx]))
else:
ax.set_xlabel(r'$\lambda$ [$\AA$]')
ax.set_title(
'%s: #%d, z=%4.1f' % (SPC.filename.split('_2_opt')[0].replace(
'_', '\_'), id, zout.z_peak[photom_idx]))
#kmag = 25-2.5*np.log10(cat.ktot[photom_idx])
kmag = cat.kmag[photom_idx]
##### Labels
label = 'ID=' + r'%s K=%4.1f $\log M$=%4.1f' % (np.int(
cat.id[photom_idx]), kmag, fout.field('lmass')[photom_idx])
ax.text(5e3,
1.08 * ymax,
label,
horizontalalignment='left',
verticalalignment='bottom')
label = 'R=%4.1f"' % (drMatch)
if drMatch > 1.1:
label_color = 'red'
else:
label_color = 'black'
ax.text(2.2e4,
1.08 * ymax,
label,
horizontalalignment='right',
color=label_color,
verticalalignment='bottom')
ax.set_xlim(xmin, xmax)
ax.set_ylim(-0.1 * ymax, 1.2 * ymax)
if Verbose:
print 'Save the plot'
if OUT_FILE_FORMAT:
out_file = '%s_%05d_SED.png' % (grism_root, id)
else:
out_file = OUT_FILE
if USE_PLOT_GUI:
fig.savefig(OUT_PATH + '/' + out_file, dpi=100, transparent=False)
plt.close()
else:
canvas = FigureCanvasAgg(fig)
canvas.print_figure(OUT_PATH + '/' + out_file,
dpi=100,
transparent=False)
print unicorn.noNewLine + OUT_PATH + '/' + out_file
if Verbose:
print 'Close the plot window'
class MPLPlot(FCanvas):
"""
This is the basic matplotlib canvas widget we are using for matplotlib
plots. This canvas only provides a few convenience tools for automatic
sizing and creating subfigures, but is otherwise not very different
from the class ``FCanvas`` that comes with matplotlib (and which we inherit).
It can be used as any QT widget.
"""
def __init__(self,
parent: Optional[QtWidgets.QWidget] = None,
width: float = 4.0,
height: float = 3.0,
dpi: int = 150,
nrows: int = 1,
ncols: int = 1):
"""
Create the canvas.
:param parent: the parent widget
:param width: canvas width (inches)
:param height: canvas height (inches)
:param dpi: figure dpi
:param nrows: number of subplot rows
:param ncols: number of subplot columns
"""
self.fig = Figure(figsize=(width, height), dpi=dpi)
super().__init__(self.fig)
self.axes: List[Axes] = []
self._tightLayout = False
self._showInfo = False
self._infoArtist = None
self._info = ''
self.clearFig(nrows, ncols)
self.setParent(parent)
def autosize(self) -> None:
"""
Sets some default spacings/margins.
:return:
"""
if not self._tightLayout:
self.fig.subplots_adjust(left=0.125,
bottom=0.125,
top=0.9,
right=0.875,
wspace=0.35,
hspace=0.2)
else:
self.fig.tight_layout(rect=[0, 0.03, 1, 0.95])
self.draw()
def clearFig(self,
nrows: int = 1,
ncols: int = 1,
naxes: int = 1) -> List[Axes]:
"""
Clear and reset the canvas.
:param nrows: number of subplot/axes rows to prepare
:param ncols: number of subplot/axes column to prepare
:param naxes: number of axes in total
:returns: the created axes in the grid
"""
self.fig.clear()
setMplDefaults()
self.axes = []
iax = 1
if naxes > nrows * ncols:
raise ValueError(
f'Number of axes ({naxes}) larger than rows ({nrows}) x '
f'columns ({ncols}).')
for i in range(1, naxes + 1):
kw = {}
if iax > 1:
kw['sharex'] = self.axes[0]
kw['sharey'] = self.axes[0]
self.axes.append(self.fig.add_subplot(nrows, ncols, i))
iax += 1
self.autosize()
return self.axes
def resizeEvent(self, event: QtGui.QResizeEvent) -> None:
"""
Re-implementation of the widget resizeEvent method.
Makes sure we resize the plots appropriately.
"""
self.autosize()
super().resizeEvent(event)
def setTightLayout(self, tight: bool) -> None:
"""
Set tight layout mode.
:param tight: if true, use tight layout for autosizing.
"""
self._tightLayout = tight
self.autosize()
def setShowInfo(self, show: bool) -> None:
"""Whether to show additional info in the plot"""
self._showInfo = show
self.updateInfo()
def updateInfo(self) -> None:
if self._infoArtist is not None:
self._infoArtist.remove()
self._infoArtist = None
if self._showInfo:
self._infoArtist = self.fig.text(
0,
0,
self._info,
fontsize='x-small',
verticalalignment='bottom',
)
self.draw()
def toClipboard(self) -> None:
"""
Copy the current canvas to the clipboard.
"""
buf = io.BytesIO()
self.fig.savefig(buf,
dpi=300,
facecolor='w',
format='png',
transparent=True)
QtWidgets.QApplication.clipboard().setImage(
QtGui.QImage.fromData(buf.getvalue()))
buf.close()
def setFigureTitle(self, title: str) -> None:
"""Add a title to the figure."""
self.fig.text(0.5,
0.99,
title,
horizontalalignment='center',
verticalalignment='top',
fontsize='small')
self.draw()
def setFigureInfo(self, info: str) -> None:
"""Display an info string in the figure"""
self._info = info
self.updateInfo()
# Re-map to highlight small differences
s = t2m.data.shape
t2m.data = qcut(t2m.data.flatten(), 20, labels=False).reshape(s)
# Plot as a colour map
lats = t2m.coord('latitude').points
lons = t2m.coord('longitude').points
t2m_img = ax.pcolorfast(lons,
lats,
t2m.data,
cmap='coolwarm',
vmin=0,
vmax=20,
alpha=0.5)
# Also pressure
prmsl = twcr.load('prmsl', dte, version='4.5.1')
prmsl = prmsl.extract(iris.Constraint(member=1))
mg.pressure.plot(ax, prmsl, scale=0.01, resolution=0.25, linewidths=1)
# Also precip
prate = twcr.load('prate', dte, version='4.5.1')
prate = prate.extract(iris.Constraint(member=1))
mg.precipitation.plot(ax, prate, resolution=0.25, vmin=-0.01, vmax=0.04)
# Add a label showing the date
label = "Surface weather test plot"
mg.utils.plot_label(ax, label, facecolor=fig.get_facecolor())
# Render the figure as a png
fig.savefig('%s/tst2_v3.png' % args.opdir)
