def serialize(dataset):
fix_map_attributes(dataset)
fig = Figure(figsize=figsize, dpi=dpi)
fig.figurePatch.set_alpha(0.0)
ax = fig.add_axes([0.05, 0.05, 0.45, 0.85])
ax.axesPatch.set_alpha(0.5)
# Plot requested grids.
layers = [layer for layer in query.get('LAYERS', '').split(',')
if layer] or [var.id for var in walk(dataset, GridType)]
layer = layers[0]
names = [dataset] + layer.split('.')
grid = reduce(operator.getitem, names)
actual_range = self._get_actual_range(grid)
norm = Normalize(vmin=actual_range[0], vmax=actual_range[1])
cb = ColorbarBase(ax, cmap=get_cmap(cmap), norm=norm,
orientation='vertical')
for tick in cb.ax.get_yticklabels():
tick.set_fontsize(14)
tick.set_color('white')
#tick.set_fontweight('bold')
# Save to buffer.
canvas = FigureCanvas(fig)
output = StringIO()
canvas.print_png(output)
if hasattr(dataset, 'close'): dataset.close()
return [ output.getvalue() ]
def print_xcf(self, filename_or_obj, *args, **kwargs):
"Writes the figure to a GIMP XCF image file"
# If filename_or_obj is a file-like object we need a temporary file for
# GIMP's output too...
if is_string(filename_or_obj):
out_temp_handle, out_temp_name = None, filename_or_obj
else:
out_temp_handle, out_temp_name = tempfile.mkstemp(suffix='.xcf')
try:
# Create a temporary file and write the "layer" to it as a PNG
in_temp_handle, in_temp_name = tempfile.mkstemp(suffix='.png')
try:
FigureCanvasAgg.print_png(self, in_temp_name, *args, **kwargs)
run_gimp_script(
SINGLE_LAYER_SCRIPT.format(
input=quote_string(in_temp_name),
output=quote_string(out_temp_name)))
finally:
os.close(in_temp_handle)
os.unlink(in_temp_name)
finally:
if out_temp_handle:
os.close(out_temp_handle)
# If we wrote the XCF to a temporary file, write its content to
# the file-like object we were given (the copy is chunked as
# XCF files can get pretty big)
with open(out_temp_name, 'rb') as source:
for chunk in iter(lambda: source.read(131072), ''):
filename_or_obj.write(chunk)
os.unlink(out_temp_name)
def plot(title='title',xlab='x',ylab='y',mode='plot',
data={'xxx':[(0,0),(1,1),(1,2),(3,3)],
'yyy':[(0,0,.2,.2),(2,1,0.2,0.2),(2,2,0.2,0.2),(3,3,0.2,0.3)]}):
fig=Figure()
fig.set_facecolor('white')
ax=fig.add_subplot(111)
if title: ax.set_title(title)
if xlab: ax.set_xlabel(xlab)
if ylab: ax.set_ylabel(ylab)
legend=[]
keys=sorted(data)
for key in keys:
stream = data[key]
(x,y)=([],[])
for point in stream:
x.append(point[0])
y.append(point[1])
if mode=='plot':
ell=ax.plot(x, y)
legend.append((ell,key))
if mode=='hist':
ell=ax.hist(y,20)
if legend:
ax.legend([x for (x,y) in legend], [y for (x,y) in legend],
'upper right', shadow=True)
canvas=FigureCanvas(fig)
stream=cStringIO.StringIO()
canvas.print_png(stream)
return stream.getvalue()
def team_wp(request, manager):
manager = manager.replace('-', ' ')
try:
team = Team.objects.get(manager__iexact=manager)
except Team.DoesNotExist:
raise Http404()
week = WeekPoints.objects.latest_week()
points = team.weekly_points.values_list('points', flat=True)
weeks = range(1, week + 1)
teams = list(WeekPoints.objects.values_list('points', flat=True))
shape = (Team.objects.count(), week)
avgs = mean(reshape(array(teams), shape), axis=0)
fig = Figure(figsize=(7, 3), dpi=100, facecolor='white')
ax = fig.add_subplot(111)
rects = ax.bar(weeks, points, align='center', linewidth=1, color='#008ad1', width=1)
ax.set_xlabel("Week")
ax.set_ylabel("Points")
ax.set_xticks(weeks) # add a tick for every week
for rect in rects:
height = rect.get_height()
ax.text(rect.get_x() + rect.get_width() / 2., height / 2., str(height),
fontsize=10, color="#ffffff", ha='center')
ax.set_xlim((0.5, max(10, week) + 0.5))
ax.plot(weeks, avgs, color='blue', marker='*', label='Week average score')
ax.legend(markerscale=0, handlelength=3)
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def __get_column_width(self):
max_length = 0
max_column_text = ''
flag = self.prefs.get('legend_numbers',True)
unit = self.prefs.get('legend_unit',False)
for label,num in self.labels:
if not flag: num = None
if num is not None:
column_length = len(str(label)+str(num)) + 1
else:
column_length = len(str(label)) + 1
if column_length > max_length:
max_length = column_length
if flag:
if type(num) == types.IntType or type(num) == types.LongType:
numString = str(num)
else:
numString = "%.1f" % float(num)
max_column_text = '%s %s' % (str(label),numString)
if unit:
max_column_text += "%"
else:
max_column_text = '%s ' % str(label)
figure = Figure()
canvas = FigureCanvasAgg(figure)
dpi = self.prefs['dpi']
figure.set_dpi( dpi )
l_size,l_padding = self.__get_legend_text_size()
self.text_size = pixelToPoint(l_size,dpi)
text = Text(0.,0.,text=max_column_text,size=self.text_size)
text.set_figure(figure)
bbox = text.get_window_extent(canvas.get_renderer())
self.column_width = bbox.width+6*l_size
def graph_prices(x, y, gname):
'''make a plot of the prices over time for a specific game'
x is be the dates of the bins
y is the prices
gname is the name of the game
'''
x_list = list(x)
x_dt = [datetime.fromtimestamp(xx) for xx in x_list]
fig=Figure(facecolor='white')
ax=fig.add_subplot(111)
ax.plot(x_dt,y,'r-')
ax.set_ylim([0,np.max(y) + np.max(y) * 0.10])
#ax.set_title(gname)
#ax.set_axis_bgcolor('red')
formatter = FuncFormatter(money_format)
ax.yaxis.set_major_formatter(formatter)
#fig.autofmt_xdate()
#xfmt = md.DateFormatter('%Y-%m-%d %H:%M:%S')
#ax.xaxis.set_major_formatter(xfmt)
ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
fig.autofmt_xdate()
canvas=FigureCanvas(fig)
png_output = StringIO.StringIO()
canvas.print_png(png_output)
response=make_response(png_output.getvalue())
response.headers['Content-Type'] = 'image/png'
return response
def payee_boxplot(request, payee):
data_parameters = ytd + ['-w', '-E', '-F', '%(amount)\n', '-M', 'reg', 'Expenses', 'and', 'payee', payee]
output = runledger(data_parameters)
values = [float(sanatize(line)) for line in output.split('\n') if line != ""]
if(len(values) <= 0): values.append(0)
fig = plt.figure()
ax = fig.add_subplot(111)
boxplot(values)
title('Boxplot of ' + payee)
ax.yaxis.set_major_formatter(moneyFmt)
ax.format_ydata = price
ax.set_xticklabels([prettyname(payee)])
ax.set_ylim(min(values + [-1.0]) * 1.1, max(values + [1.0]) * 1.1)
fig.autofmt_xdate()
canvas=FigureCanvas(fig)
response=HttpResponse(content_type='image/png')
canvas.print_png(response)
plt.close(fig)
return response
def simple():
# import datetime
# import StringIO
#get the polyline map using api:
get_activity_map()
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
# from matplotlib.dates import DateFormatter
import polyline
m = session['map']
summary_lat_lon = polyline.decode(m.summary_polyline)
fig=Figure()
ax=fig.add_subplot(111)
lats = [i[0] for i in summary_lat_lon]
lons = [i[1] for i in summary_lat_lon]
# x=[]
# y=[]
# now=datetime.datetime.now()
# delta=datetime.timedelta(days=1)
# for i in range(10):
# x.append(now)
# now+=delta
# y.append(random.randint(0, 1000))
# ax.plot_date(x, y, '-')
# ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
ax.scatter(lons,lats)
fig.autofmt_xdate()
canvas=FigureCanvas(fig)
png_output = StringIO.StringIO()
canvas.print_png(png_output)
response=make_response(png_output.getvalue())
response.headers['Content-Type'] = 'image/png'
return response
def getImage(self):
ddict=self.fitresult
try:
fig = Figure(figsize=(6,3)) # in inches
canvas = FigureCanvas(fig)
ax = fig.add_axes([.15, .15, .8, .8])
ax.set_axisbelow(True)
logplot = self.plotDict.get('logy', True)
if logplot:
axplot = ax.semilogy
else:
axplot = ax.plot
axplot(ddict['result']['energy'], ddict['result']['ydata'], 'k', lw=1.5)
axplot(ddict['result']['energy'], ddict['result']['continuum'], 'g', lw=1.5)
legendlist = ['spectrum', 'continuum', 'fit']
axplot(ddict['result']['energy'], ddict['result']['yfit'], 'r', lw=1.5)
fontproperties = FontProperties(size=8)
if ddict['result']['config']['fit']['sumflag']:
axplot(ddict['result']['energy'],
ddict['result']['pileup'] + ddict['result']['continuum'], 'y', lw=1.5)
legendlist.append('pileup')
if matplotlib_version < '0.99.0':
legend = ax.legend(legendlist,0,
prop = fontproperties, labelsep=0.02)
else:
legend = ax.legend(legendlist,0,
prop = fontproperties, labelspacing=0.02)
except ValueError:
fig = Figure(figsize=(6,3)) # in inches
canvas = FigureCanvas(fig)
ax = fig.add_axes([.15, .15, .8, .8])
ax.set_axisbelow(True)
ax.plot(ddict['result']['energy'], ddict['result']['ydata'], 'k', lw=1.5)
ax.plot(ddict['result']['energy'], ddict['result']['continuum'], 'g', lw=1.5)
legendlist = ['spectrum', 'continuum', 'fit']
ax.plot(ddict['result']['energy'], ddict['result']['yfit'], 'r', lw=1.5)
fontproperties = FontProperties(size=8)
if ddict['result']['config']['fit']['sumflag']:
ax.plot(ddict['result']['energy'],
ddict['result']['pileup'] + ddict['result']['continuum'], 'y', lw=1.5)
legendlist.append('pileup')
if matplotlib_version < '0.99.0':
legend = ax.legend(legendlist,0,
prop = fontproperties, labelsep=0.02)
else:
legend = ax.legend(legendlist,0,
prop = fontproperties, labelspacing=0.02)
ax.set_xlabel('Energy')
ax.set_ylabel('Counts')
legend.draw_frame(False)
outfile = self.outdir+"/"+self.outfile+".png"
try:
os.remove(outfile)
except:
pass
canvas.print_figure(outfile)
return self.__getFitImage(self.outfile+".png")
def simple(request):
import random
import django
import datetime
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
print "hello"
#print form['subject'].value()
fig=Figure()
ax=fig.add_subplot(111)
x=[]
y=[]
now=datetime.datetime.now()
delta=datetime.timedelta(days=1)
for i in range(10):
x.append(now)
now+=delta
y.append(random.randint(0, 1000))
ax.plot_date(x, y, '-')
ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
fig.autofmt_xdate()
canvas=FigureCanvas(fig)
response=django.http.HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def figure_to_response(f):
""" Creates a png image to be displayed in an html file """
canvas = FigureCanvasAgg(f)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
matplotlib.pyplot.close(f)
return response
def player_wp(request, code):
try:
player = Player.objects.get(code=code)
except Player.DoesNotExist:
raise Http404
points = player.weekly_points.values_list('points', flat=True)
response = HttpResponse(content_type='image/png')
if points:
weeks = list(player.weekly_points.values_list('week', flat=True))
fig = Figure(figsize=(0.4 * min(max(10, weeks[-1]), 22), 3),
dpi=100, facecolor='white')
ax = fig.add_subplot(111)
rects = ax.bar(weeks, points, align='center', linewidth=1, color='#008ad1', width=1)
ax.set_xlabel("Week")
ax.set_ylabel("Points")
ax.set_xticks(weeks) # add a tick for every week
for p, rect in zip(points, rects):
if p != 0:
if p < 0:
h = p * 2 - 1
elif p > 0:
h = p + 1
ax.text(rect.get_x() + rect.get_width() / 2., h, str(p),
fontsize=10, color='black', ha='center')
ax.set_xlim((0.5, max(10, weeks[-1]) + 0.5))
else:
fig = Figure(figsize=(1, 1), dpi=1, facecolor='white') # return one white pixel
canvas = FigureCanvas(fig)
canvas.print_png(response)
return response
def plot_activity(values):
daysFmt = DateFormatter("%d-%B %H:00")
fig=Figure()
ax=fig.add_subplot(111)
times = values.keys()
times.sort()
number_found = [values[key] for key in times]
ax.plot_date(times, number_found, '-')
#assert 0, '%s'%(values)
# format the ticks
ax.xaxis.set_major_locator(HourLocator(byhour=range(0,24,4)))
ax.xaxis.set_major_formatter(daysFmt)
ax.autoscale_view()
ax.grid(True)
ax.set_title('All devices')
fig.autofmt_xdate()
canvas=FigureCanvas(fig)
response=HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def draw(self):
"""
Draw the figure using the agg renderer
"""
self.canvas.clear()
FigureCanvasAgg.draw(self)
if self.blitbox is None:
l, b, w, h = self.figure.bbox.bounds
w, h = int(w), int(h)
buf_rgba = self.get_renderer().buffer_rgba()
else:
bbox = self.blitbox
l, b, r, t = bbox.extents
w = int(r) - int(l)
h = int(t) - int(b)
t = int(b) + h
reg = self.copy_from_bbox(bbox)
buf_rgba = reg.to_string()
texture = Texture.create(size=(w, h))
texture.flip_vertical()
with self.canvas:
Color(1.0, 1.0, 1.0, 1.0)
self.img_rect = Rectangle(texture=texture, pos=self.pos, size=(w, h))
texture.blit_buffer(bytes(buf_rgba), colorfmt="rgba", bufferfmt="ubyte")
self.img_texture = texture
def save(self, name, log=False, vrange=None):
if self.imdict['X'].sum() == 0.0 and log:
warn("can't plot {}, in log mode".format(name), RuntimeWarning,
stacklevel=2)
return
fig = Figure(figsize=(8,6))
canvas = FigureCanvas(fig)
ax = fig.add_subplot(1,1,1)
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", "5%", pad="1.5%")
if log:
norm=LogNorm()
else:
norm=Normalize()
if vrange:
self.imdict['vmin'], self.imdict['vmax'] = vrange
im = ax.imshow(norm=norm,**self.imdict)
cb_dict = {'cax':cax}
if log:
cb_dict['ticks'] = LogLocator(10, np.arange(0.1,1,0.1))
cb_dict['format'] = LogFormatterMathtext(10)
try:
cb = plt.colorbar(im, **cb_dict)
except ValueError:
print self.imdict['X'].sum()
raise
ax.set_xlabel(self.x_label, x=0.98, ha='right')
ax.set_ylabel(self.y_label, y=0.98, ha='right')
if self.cb_label:
cb.set_label(self.cb_label, y=0.98, ha='right')
canvas.print_figure(name, bbox_inches='tight')
def plot_demo():
import numpy as np
import matplotlib
matplotlib.use('Agg')
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
import matplotlib.mlab as mlab
import matplotlib.pyplot as plt
mu, sigma = 100, 15
x = mu + sigma*np.random.randn(10000)
# the histogram of the data
n, bins, patches = plt.hist(x, 50, normed=1, facecolor='green', alpha=0.75)
# add a 'best fit' line
y = mlab.normpdf( bins, mu, sigma)
l = plt.plot(bins, y, 'r--', linewidth=1)
plt.xlabel('Smarts')
plt.ylabel('Probability')
plt.title(r'$\mathrm{Histogram\ of\ IQ:}\ \mu=100,\ \sigma=15$')
plt.axis([40, 160, 0, 0.03])
plt.grid(True)
# Write to the canvas
fig = plt.gcf()
fig.set_size_inches(6,5)
canvas = FigureCanvas(fig)
output = StringIO.StringIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def plot_sfh(model_sfh, mock_sfh, plot_path):
labels = {'lewis': r'ACS-MS', 'oir_all': r'OIR-ALL'}
colors = {'lewis': 'dodgerblue', 'oir_all': 'maroon'}
fig = Figure(figsize=(3.5, 3.5), frameon=False)
canvas = FigureCanvas(fig)
gs = gridspec.GridSpec(1, 1,
left=0.18, right=0.95, bottom=0.15, top=0.95,
wspace=None, hspace=None,
width_ratios=None, height_ratios=None)
ax = fig.add_subplot(gs[0])
for plane_key in ['lewis', 'oir_all']:
if plane_key not in model_sfh['sfh'].keys():
continue
plot_single_sfh_line(ax, model_sfh['sfh'][plane_key],
label=labels[plane_key],
color=colors[plane_key],
drawstyle='steps-mid')
_plot_mean_age(ax, model_sfh['sfh'][plane_key].attrs['mean_age'],
c=colors[plane_key])
# plot_single_sfh_line(ax, model_sfh, label='Model', color='k')
# print model_sfh['sfr']
_plot_mock_sfh(ax, mock_sfh, lw=1.5, c='k', label='Mock')
_plot_mean_age(ax, mock_sfh.attrs['mean_age'])
ax.legend(loc='lower left', fontsize=8, frameon=True)
gs.tight_layout(fig, pad=1.08, h_pad=None, w_pad=None, rect=None)
canvas.print_figure(plot_path + ".pdf", format="pdf")
def bar_plot(d, labels):
colors = itertools.cycle(['b', 'g', 'r', 'c', 'm', 'y', 'k'])
fig=Figure(figsize=(8, 6), dpi=200)
fig.set_facecolor('white')
fig.subplots_adjust(bottom=0.30)
ax=fig.add_subplot(111)
ax.set_title("")
ax.set_ylabel('Factor values')
#ax.grid(which='major')
bottom = None
for col in d.columns:
if bottom is None:
bottom = 0*d[col]
ax.bar(range(len(d[col])), d[col], align='center', bottom=bottom,
label=labels[col], color=colors.next(), alpha=0.6)
bottom += d[col]
ax.set_xticks(range(len(d[col])))
ax.set_xlim([-0.5, len(d[col])])
ax.set_xticklabels([unicode(el) for el in d[col].index], size='x-small',
rotation='vertical')
leg = ax.legend(loc='best', fancybox=True, prop={'size':9})
leg.get_frame().set_alpha(0.5)
canvas=FigureCanvas(fig)
stream=cStringIO.StringIO()
canvas.print_png(stream, bbox_inches='tight')
return stream.getvalue()
def plot_hist(spec="10_100_500"):
import numpy as np
import matplotlib
matplotlib.use('Agg')
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
import matplotlib.pyplot as plt
spec = request.args.get("spec", spec, type=str).split("_")
assert(len(spec) == 3)
k = int(spec[0])
n = int(spec[1])
p = float(spec[2])/1000.
res = get_coin_ensemble(k, n, p)
avgs = [np.average(i) for i in res]
plt.clf()
fig = plt.figure()
l = plt.hist(avgs)
fig.set_size_inches(5,4)
canvas = FigureCanvas(fig)
output = StringIO.StringIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def save_plotSpectrum(y,Fs,image_name):
"""
Plots a Single-Sided Amplitude Spectrum of y(t)
"""
fig = Figure(linewidth=0.0)
fig.set_size_inches(fig_width,fig_length, forward=True)
Figure.subplots_adjust(fig, left = fig_left, right = fig_right, bottom = fig_bottom, top = fig_top, hspace = fig_hspace)
n = len(y) # length of the signal
_subplot = fig.add_subplot(2,1,1)
print "Fi"
_subplot.plot(arange(0,n),y)
xlabel('Time')
ylabel('Amplitude')
_subploti_2=fig.add_subplot(2,1,2)
k = arange(n)
T = n/Fs
frq = k/T # two sides frequency range
frq = frq[range(n/2)] # one side frequency range
Y = fft(y)/n # fft computing and normalization
Y = Y[range(n/2)]
_subplot_2.plot(frq,abs(Y),'r') # plotting the spectrum
xlabel('Freq (Hz)')
ylabel('|Y(freq)|')
print "here"
canvas = FigureCanvasAgg(fig)
if '.eps' in outfile_name:
canvas.print_eps(outfile_name, dpi = 110)
if '.png' in outfile_name:
canvas.print_figure(outfile_name, dpi = 110)
def plotSolarRadiationAgainstMonth(filename):
trainRowReader = csv.reader(open(filename, 'rb'), delimiter=',')
month_most_common_list = []
Solar_radiation_64_list = []
for row in trainRowReader:
month_most_common = row[3]
Solar_radiation_64 = row[6]
month_most_common_list.append(month_most_common)
Solar_radiation_64_list.append(Solar_radiation_64)
#convert all elements in the list to float while skipping the first element for the 1st element is a description of the field.
month_most_common_list = [float(i) for i in prepareList(month_most_common_list)[1:] ]
Solar_radiation_64_list = [float(i) for i in prepareList(Solar_radiation_64_list)[1:] ]
fig=Figure()
ax=fig.add_subplot(111)
title='Scatter Diagram of solar radiation against month of the year'
ax.set_xlabel('Most common month')
ax.set_ylabel('Solar Radiation')
fig.suptitle(title, fontsize=14)
try:
ax.scatter(month_most_common_list, Solar_radiation_64_list)
#it is possible to make other kind of plots e.g bar charts, pie charts, histogram
except ValueError:
pass
canvas = FigureCanvas(fig)
canvas.print_figure('solarRadMonth.png',dpi=500)
def make_1d_overlay(in_file_name, out_dir, ext, subset, b_effs=[0.1, 0.2]):
textsize = _text_size - 2
b_eff_styles = _b_eff_styles
taggers = {x:{} for x in b_effs}
with h5py.File(in_file_name, 'r') as in_file:
for b_eff in taggers:
for tag in (subset or _default_overlay_1d):
taggers[b_eff][tag] = get_c_vs_u_const_beff(
in_file, tag, b_eff=b_eff)
fig = Figure(figsize=_fig_size)
canvas = FigureCanvas(fig)
ax = fig.add_subplot(1,1,1)
for b_eff, linestyle in zip(b_effs, b_eff_styles):
for tname, (vc, vu) in taggers[b_eff].items():
label, color = leg_labels_colors.get(tname, (tname, 'k'))
lab = '$1 / \epsilon_{{ b }} = $ {rej:.0f}, {tname}'.format(
rej=1/b_eff, tname=label)
ax.plot(vc, vu, label=lab, color=color, linewidth=_line_width,
linestyle=linestyle)
ax.set_xlim(0.1, 0.5)
legprops = {'size':textsize}
leg = ax.legend(prop=legprops)
leg.get_title().set_fontsize(textsize)
setup_1d_ctag_legs(ax, textsize)
fig.tight_layout(pad=0, h_pad=0, w_pad=0)
if not isdir(out_dir):
os.mkdir(out_dir)
file_name = '{}/ctag-1d-brej-overlay{}'.format(
out_dir, ext)
canvas.print_figure(file_name, bbox_inches='tight')
def draw_simple_rejrej(in_file, out_dir, ext='.pdf', tagger='gaia',
official=False, approval='Internal', points=[]):
"""
Draw iso-efficiency contours for one tagger (no colors).
"""
fig = Figure(figsize=_fig_size)
canvas = FigureCanvas(fig)
ax = fig.add_subplot(1,1,1)
ds = in_file[tagger + '/all']
label_rejrej_axes(ax, ds)
levels = np.linspace(0.2, 0.5, 7)
add_contour(ax, ds, opts=dict(levels=levels, textsize=10))
zax = long_particle_names[ds.attrs['xyz'][2]]
if official:
_add_rejrej_official(ax, approval, zax=zax, size=9)
for y, x, z in points:
ax.scatter(x, y, s=20, c='yellow')
ax.annotate(
r'$\epsilon_{{c}}$ = {:.2f}'.format(z), (x,y), xytext=(-8,0),
textcoords='offset points', size='x-small',
bbox = dict(boxstyle = 'round', fc = 'yellow', alpha = 1),
# arrowprops = dict(arrowstyle = '->'),
ha='right', va='top')
out_name = '{}/rejrej-simple{}'.format(out_dir, ext)
canvas.print_figure(out_name, bbox_inches='tight')
def startup_cost():
import datetime
import StringIO
import random
import base64
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
fig=Figure(facecolor='#ffffff')
ax=fig.add_subplot(211)
ax2=fig.add_subplot(212, axisbg='y')
x=[]
y=[]
now=datetime.datetime.now()
delta=datetime.timedelta(days=1)
for i in range(10):
x.append(now)
now+=delta
y.append(random.randint(0, 1000))
ax.plot_date(x, y, '-')
ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
ax2.plot_date(x, y, '-')
ax2.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
fig.autofmt_xdate()
canvas=FigureCanvas(fig)
png_output = StringIO.StringIO()
canvas.print_png(png_output)
image=make_response(png_output.getvalue())
response.headers['Content-Type'] = 'image/png'
return response
def draw_ctag_rejrej(in_file, out_dir, ext='.pdf'):
"""
Basic heatmap of efficiency vs two rejections.
"""
fig = Figure(figsize=_fig_size)
canvas = FigureCanvas(fig)
ax = fig.add_subplot(1,1,1)
ds = in_file['gaia/all']
eff_array, extent = _get_arr_extent(ds)
label_rejrej_axes(ax, ds)
im = ax.imshow(eff_array.T, extent=extent,
origin='lower', aspect='auto')
ax.set_xscale('log')
ax.set_yscale('log')
ax.grid(which='both')
# add_contour(ax,ds)
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.05)
cb = Colorbar(ax=cax, mappable=im)
out_name = '{}/rejrej{}'.format(out_dir, ext)
# ignore complaints about not being able to log scale images
with warnings.catch_warnings():
warnings.simplefilter("ignore")
canvas.print_figure(out_name, bbox_inches='tight')
def plot_normprob(d, snrs, outroot):
""" Normal quantile plot compares observed SNR to expectation given frequency of occurrence.
Includes negative SNRs, too.
"""
outname = os.path.join(d["workdir"], "plot_" + outroot + "_normprob.png")
# define norm quantile functions
Z = lambda quan: n.sqrt(2) * erfinv(2 * quan - 1)
quan = lambda ntrials, i: (ntrials + 1 / 2.0 - i) / ntrials
# calc number of trials
npix = d["npixx"] * d["npixy"]
if d.has_key("goodintcount"):
nints = d["goodintcount"]
else:
nints = d["nints"]
ndms = len(d["dmarr"])
dtfactor = n.sum([1.0 / i for i in d["dtarr"]]) # assumes dedisperse-all algorithm
ntrials = npix * nints * ndms * dtfactor
logger.info("Calculating normal probability distribution for npix*nints*ndms*dtfactor = %d" % (ntrials))
# calc normal quantile
if len(n.where(snrs > 0)[0]):
snrsortpos = n.array(sorted(snrs[n.where(snrs > 0)], reverse=True)) # high-res snr
Zsortpos = n.array([Z(quan(ntrials, j + 1)) for j in range(len(snrsortpos))])
logger.info("SNR positive range = (%.1f, %.1f)" % (snrsortpos[-1], snrsortpos[0]))
logger.info("Norm quantile positive range = (%.1f, %.1f)" % (Zsortpos[-1], Zsortpos[0]))
if len(n.where(snrs < 0)[0]):
snrsortneg = n.array(sorted(n.abs(snrs[n.where(snrs < 0)]), reverse=True)) # high-res snr
Zsortneg = n.array([Z(quan(ntrials, j + 1)) for j in range(len(snrsortneg))])
logger.info("SNR negative range = (%.1f, %.1f)" % (snrsortneg[-1], snrsortneg[0]))
logger.info("Norm quantile negative range = (%.1f, %.1f)" % (Zsortneg[-1], Zsortneg[0]))
# plot
fig3 = plt.Figure(figsize=(10, 10))
ax3 = fig3.add_subplot(111)
if len(n.where(snrs < 0)[0]) and len(n.where(snrs > 0)[0]):
logger.info("Plotting positive and negative cands")
ax3.plot(snrsortpos, Zsortpos, "k.")
ax3.plot(snrsortneg, Zsortneg, "kx")
refl = n.linspace(
min(snrsortpos.min(), Zsortpos.min(), snrsortneg.min(), Zsortneg.min()),
max(snrsortpos.max(), Zsortpos.max(), snrsortneg.max(), Zsortneg.max()),
2,
)
elif len(n.where(snrs > 0)[0]):
logger.info("Plotting positive cands")
refl = n.linspace(min(snrsortpos.min(), Zsortpos.min()), max(snrsortpos.max(), Zsortpos.max()), 2)
ax3.plot(snrsortpos, Zsortpos, "k.")
elif len(n.where(snrs < 0)[0]):
logger.info("Plotting negative cands")
refl = n.linspace(min(snrsortneg.min(), Zsortneg.min()), max(snrsortneg.max(), Zsortneg.max()), 2)
ax3.plot(snrsortneg, Zsortneg, "kx")
ax3.plot(refl, refl, "k--")
ax3.set_xlabel("SNR")
ax3.set_ylabel("Normal quantile SNR")
canvas = FigureCanvasAgg(fig3)
canvas.print_figure(outname)
def plot_lm(d, snrs, l1s, m1s, outroot):
""" Plot the lm coordinates (relative to phase center) for all candidates.
"""
outname = os.path.join(d["workdir"], "plot_" + outroot + "_impeak.png")
snrmin = 0.8 * min(d["sigma_image1"], d["sigma_image2"])
fig4 = plt.Figure(figsize=(10, 10))
ax4 = fig4.add_subplot(111)
# plot positive
good = n.where(snrs > 0)
sizes = (snrs[good] - snrmin) ** 5 # set scaling to give nice visual sense of SNR
xarr = 60 * n.degrees(l1s[good])
yarr = 60 * n.degrees(m1s[good])
ax4.scatter(xarr, yarr, s=sizes, facecolor="none", alpha=0.5, clip_on=False)
# plot negative
good = n.where(snrs < 0)
sizes = (n.abs(snrs[good]) - snrmin) ** 5 # set scaling to give nice visual sense of SNR
xarr = 60 * n.degrees(l1s[good])
yarr = 60 * n.degrees(m1s[good])
ax4.scatter(xarr, yarr, s=sizes, marker="x", edgecolors="k", alpha=0.5, clip_on=False)
ax4.set_xlabel("Dec Offset (amin)")
ax4.set_ylabel("RA Offset (amin)")
fov = n.degrees(1.0 / d["uvres"]) * 60.0
ax4.set_xlim(fov / 2, -fov / 2)
ax4.set_ylim(-fov / 2, fov / 2)
canvas4 = FigureCanvasAgg(fig4)
canvas4.print_figure(outname)
def make_1d_plots(in_file_name, out_dir, ext, b_eff=0.1, reject='U'):
textsize=_text_size
taggers = {}
with h5py.File(in_file_name, 'r') as in_file:
for tag in ['gaia', mv1uc_name, 'jfc', 'jfit']:
taggers[tag] = get_c_vs_u_const_beff(
in_file, tag, b_eff=b_eff, reject=reject)
fig = Figure(figsize=_fig_size)
canvas = FigureCanvas(fig)
ax = fig.add_subplot(1,1,1)
for tname, (vc, vu) in taggers.items():
label, color = leg_labels_colors.get(tname, (tname, 'k'))
ax.plot(vc, vu, label=label, color=color, linewidth=_line_width)
leg = ax.legend(title='$b$-rejection = {}'.format(1/b_eff),
prop={'size':textsize})
leg.get_title().set_fontsize(textsize)
setup_1d_ctag_legs(ax, textsize, reject=reject)
fig.tight_layout(pad=0, h_pad=0, w_pad=0)
if not isdir(out_dir):
os.mkdir(out_dir)
file_name = '{}/{rej}Rej-vs-cEff-brej{}{}'.format(
out_dir, int(1.0/b_eff), ext, rej=reject.lower())
canvas.print_figure(file_name, bbox_inches='tight')
def simple():
import datetime
import StringIO
import random
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
fig=Figure()
ax=fig.add_subplot(111)
x=[]
y=[]
now=datetime.datetime.now()
delta=datetime.timedelta(days=1)
for i in range(10):
x.append(now)
now+=delta
y.append(random.randint(0, 1000))
ax.plot_date(x, y, '-')
ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
fig.autofmt_xdate()
canvas=FigureCanvas(fig)
png_output = StringIO.StringIO()
canvas.print_png(png_output)
data = png_output.getvalue().encode('base64')
data_url = 'data:image/png;base64,{}'.format(urllib.quote(data.rstrip('\n')))
response=make_response(png_output.getvalue())
response.headers['Content-Type'] = 'image/png'
return response
def _plot_baseline_subtracted(self, x, y, raw=True, baseline=True):
"""Plot the baseline-subtracted data"""
from matplotlib.figure import Figure
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
figure = Figure()
canvas = FigureCanvas(figure)
axes1 = figure.add_subplot(1, 1, 1, axisbg='whitesmoke')
# Points for fit
axes1.plot(x, y, 'o', color='deepskyblue', markersize=2, alpha=1, label='Baseline-subtracted data')
axes1.set_xlabel('time (s)')
axes1.set_ylabel(r' corr. differential power ($\mu$cal / s)')
axes1.legend(loc='upper center', bbox_to_anchor=(0.2, 0.95), ncol=1, fancybox=True, shadow=True, markerscale=3,
prop={'size': 6})
if raw:
axes2 = axes1.twinx()
axes2.plot(x, self.differential_power, 'o', color='gray', markersize=2, alpha=.3, label='Raw data')
axes2.set_ylabel(r'raw differential power ($\mu$cal / s)')
axes2.legend(loc='upper center', bbox_to_anchor=(0.8, 0.95), ncol=1, fancybox=True, shadow=True,
markerscale=3,
prop={'size': 6})
if baseline:
axes2.plot(x, self.baseline_power, '-', color='black', alpha=.3, label='baseline')
axes1.set_title(self.data_filename)
canvas.print_figure(self.name + '-subtracted.png', dpi=500)
def plot_sample_preds(self, images, labels, calnet_preds, pred_dist,
gt_dist, n_preds, dataset):
n_plotted_preds = 5 if n_preds > 5 else n_preds
n_cols = n_plotted_preds + 4
n_rows = pred_dist.shape[1]
fig = plt.figure(figsize=(n_cols + 2, n_rows + 2))
canvas = FigureCanvasAgg(fig)
if dataset == "LIDC":
lidc_norm = matplotlib.colors.Normalize(vmin=0, vmax=1)
# plot sample predictions
for i in range(n_rows):
# plot input
plt.subplot(n_rows, n_cols, i * n_cols + 1)
plottable_images = move_color_channel(de_torch(
(images[i] + 1) / 2))
if plottable_images.shape[-1] == 1:
plottable_images = plottable_images.squeeze()
plt.imshow(plottable_images, interpolation="none")
if i == 0: plt.title("Input")
plt.xticks([])
plt.yticks([])
for j in range(n_cols - 4):
plottable_pred = _recolour_label(de_torch(
_1hot_2_2d(pred_dist[j, i, :, :], sample=True)),
dataset=dataset)
plt.subplot(n_rows, n_cols, i * n_cols + j + 2)
if dataset == "LIDC":
plt.imshow(plottable_pred,
norm=lidc_norm,
interpolation="none")
else:
plt.imshow(plottable_pred, interpolation="none")
if i == 0: plt.title(f"Pred {j + 1}")
plt.xticks([])
plt.yticks([])
# plot average predictions
plt.subplot(n_rows, n_cols, i * n_cols + n_cols - 2)
plottable_avg_pred = _recolour_label(de_torch(
_1hot_2_2d(pred_dist[:, i, :, :].mean(0), sample=True)),
dataset=dataset)
if dataset == "LIDC":
plt.imshow(plottable_avg_pred,
norm=lidc_norm,
interpolation="none")
else:
plt.imshow(plottable_avg_pred, interpolation="none")
if i == 0: plt.title(f"Avg Pred\nN = {pred_dist.shape[0]}")
plt.xticks([])
plt.yticks([])
# plot calibration net predictions
plt.subplot(n_rows, n_cols, i * n_cols + n_cols - 1)
plottable_calnet_pred = _recolour_label(de_torch(
_1hot_2_2d(calnet_preds[i], sample=True)),
dataset=dataset)
if dataset == "LIDC":
plt.imshow(plottable_calnet_pred,
norm=lidc_norm,
interpolation="none")
else:
plt.imshow(plottable_calnet_pred, interpolation="none")
if i == 0: plt.title("CalNet Pred")
plt.xticks([])
plt.yticks([])
# plot actual predictions
plt.subplot(n_rows, n_cols, i * n_cols + n_cols)
if gt_dist is None:
if labels.shape[1] != LABELS_CHANNELS:
label = torch.eye(
LABELS_CHANNELS)[labels[:, 1, :, :].long()].permute(
0, 3, 1, 2)[i] # convert rgb label to one-hot
else:
label = labels[i]
plottable_label = _recolour_label(de_torch(
_1hot_2_2d(label, sample=True)),
dataset=dataset)
else:
pad = lambda x: np.pad(x.cpu().numpy(),
pad_width=2,
mode='constant',
constant_values=1)
glued_top = np.concatenate(
(pad(gt_dist[i, 0]), pad(gt_dist[i, 1])), axis=1)
glued_bottom = np.concatenate(
(pad(gt_dist[i, 2]), pad(gt_dist[i, 3])), axis=1)
plottable_label = np.concatenate([glued_top, glued_bottom],
axis=0)
if dataset == "LIDC":
plt.imshow(plottable_label,
norm=lidc_norm,
interpolation="none")
else:
plt.imshow(plottable_label, interpolation="none")
if i == 0: plt.title("Label 0")
plt.xticks([])
plt.yticks([])
fig.suptitle('Sample predictions')
# convert figure to array
canvas.draw()
_, (width, height) = canvas.print_to_buffer()
s = canvas.tostring_rgb()
plt.close(fig)
return np.fromstring(s, dtype='uint8').reshape((height, width, 3))
def get_plot(params):
time_min = dt.datetime.strptime(params['time_min'],
'%Y-%m-%dT%H:%M:00.000Z')
time_max = dt.datetime.strptime(params['time_max'],
'%Y-%m-%dT%H:%M:00.000Z')
barbs = 'barbs' in params.keys() and params['barbs'] == 'True'
pbl = 'pbl' in params.keys() and params['pbl'] == 'True'
var = params['var']
lgd = None
has_barbs = var == 'barbs' or barbs
if var == 'barbs':
lidars = get_barb_data(params)
else:
lidars = get_lidar_data(params)
if barbs:
ds_barbs = get_barb_data(params)
nds = len(lidars)
figsize = (10, 3.5 * nds)
sharey = False
f, axarr = plt.subplots(nds, #sharex=True,
sharey=sharey,
squeeze=False,
figsize=figsize)
cbar_kwargs = {'label': cb_dict[var]}
is_centered = centered_dict[var]
graph_center = 0 if is_centered else False
cmap = 'coolwarm' if is_centered else 'jet'
for i, ds in enumerate(lidars):
ax = axarr[i][0]
title = ds.attrs['lidar'] + ' (' + ds.attrs['scan'] + ')'
if has_barbs: # get nice range intervals
# find the scan range_res
ranges = ds.coords['Range'].values
ydelta = ranges[1] - ranges[0]
# get the desired average barb height locations
ysteps = np.arange(1, 10)
yloc = MaxNLocator(nbins=barb_heights, steps=ysteps)
heights = yloc._raw_ticks(0, len(ranges))
dheight = (heights[1] - heights[0]) * ydelta
if var == 'barbs':
ds['windspeed'].rasp.plot_barbs(x='Time', y='Range',
components=['x', 'y'],
# resample=barb_resample,
# resampley=barb_bins,
resampley=dheight,
ax=ax,
length=barb_length)
ax.set_title(title)
ax.set_xlim([time_min, time_max])
ax.set_xlabel('Time (UTC)')
ax.set_ylabel('Range (km)')
else:
vmin = vmin_dict[var] if var in vmin_dict.keys() else None
vmax = vmax_dict[var] if var in vmax_dict.keys() else None
try:
da = ds[var]
da.plot.pcolormesh(x='Time', y='Range', center=graph_center,
robust=True, cmap=cmap, ax=ax,
vmin=vmin, vmax=vmax,
cbar_kwargs=cbar_kwargs)
except:
# this happens occasionally when all data is NA, or
# there's only one profile of data
Z = np.zeros((ds.dims['Time'], ds.dims['Range'])).transpose()
# Z = da.values.transpose()
Zm = np.ma.masked_where(np.isnan(Z), Z)
ax.pcolormesh(ds.coords['Time'].values,
ds.coords['Range'].values, Zm)
if pbl:
# add pbl
ds['pbl'] = estimate_residual_layer(ds['cnr_whole'])
ax.scatter(ds.coords['Time'].values, ds['pbl'], 50, marker='.', color='red',
edgecolor='gray', lw=.5, label='PBL (Residual Layer)')
ax.legend(loc=1)
ax.set_title(title)
ax.set_xlim([time_min, time_max])
ax.set_xlabel('Time (UTC)')
ax.set_ylabel('Range (km)')
if barbs and ds_barbs[i] is not None:
ds = ds_barbs[i]
ds['windspeed'].rasp.plot_barbs(x='Time', y='Range',
components=['x', 'y'],
# resample=barb_resample,
# resampley=barb_bins,
resampley=dheight,
ax=ax,
length=barb_length,
lw=barb_lw)
png_output = BytesIO()
if lgd is None:
plt.tight_layout()
canvas = FigureCanvas(plt.gcf())
canvas.print_png(png_output)
else:
plt.savefig(png_output, format='png',
bbox_extra_artists=(lgd,),
bbox_inches='tight')
response = png_output.getvalue()
# have to make sure to close things duh
plt.close()
png_output.close()
return response
def get(self, request):
f = matplotlib.figure.Figure()
FigureCanvasAgg(f)
A = io.BytesIO()
df = pd.read_csv("D:\heart-disease-uci\heart.csv")
response = HttpResponse('data unfetched')
try:
image_type = request.GET['image_name']
print(image_type)
if image_type.lower() == "heartdiagpostive":
df['Age_Category'] = pd.cut(df['age'],
bins=list(np.arange(25, 85, 5)))
df[df['target'] == 1].groupby(
'Age_Category')['age'].count().plot(kind='bar')
plt.title(
'Age Distribution of Patients with +ve Heart Diagonsis')
A = io.BytesIO()
plt.savefig(A, format='png')
plt.close(f)
response = HttpResponse(A.getvalue(), content_type='image/png')
elif image_type.lower() == "heartdiagnegative":
df['Age_Category'] = pd.cut(df['age'],
bins=list(np.arange(25, 85, 5)))
df[df['target'] == 0].groupby(
'Age_Category')['age'].count().plot(kind='bar')
plt.title(
'Age Distribution of Patients with -ve Heart Diagonsis')
B = io.BytesIO()
plt.savefig(B, format='png')
plt.close(f)
response = HttpResponse(B.getvalue(), content_type='image/png')
elif image_type.lower() == "blood":
sns.countplot(x='fbs', data=df, hue='target')
plt.xlabel('< 120mm/Hg >120 mm/Hg')
plt.ylabel('Fasting blood sugar')
plt.legend(['No disease', ' disease'])
c = io.BytesIO()
plt.savefig(c, format='png')
plt.close(f)
response = HttpResponse(c.getvalue(), content_type='image/png')
elif image_type.lower() == "excercise":
sns.countplot(x='exang', data=df, hue='target')
plt.xlabel(
'No ex Exercise')
plt.title(' Excercise effect on Heart diease')
plt.legend(['No disease', ' disease'])
d = io.BytesIO()
plt.savefig(d, format='png')
plt.close(f)
response = HttpResponse(d.getvalue(), content_type='image/png')
elif image_type.lower() == "default":
sns.countplot(x='target', data=df, hue='sex')
plt.legend(['Female ', 'Male'])
plt.xlabel('No Heart disease Heart Disease')
E = io.BytesIO()
plt.savefig(E, format='png')
plt.close(f)
response = HttpResponse(E.getvalue(), content_type='image/png')
except KeyError:
response = HttpResponse('unable fetch')
return response
In this example, the contents of the agg canvas are extracted to a
string, which can in turn be passed off to PIL or put in a numeric
array
"""
from matplotlib.backends.backend_agg import FigureCanvasAgg
from matplotlib.figure import Figure
from matplotlib.mlab import normpdf
from numpy.random import randn
import numpy
fig = Figure(figsize=(5, 4), dpi=100)
ax = fig.add_subplot(111)
canvas = FigureCanvasAgg(fig)
mu, sigma = 100, 15
x = mu + sigma * randn(10000)
# the histogram of the data
n, bins, patches = ax.hist(x, 50, normed=1)
# add a 'best fit' line
y = normpdf(bins, mu, sigma)
line, = ax.plot(bins, y, 'r--')
line.set_linewidth(1)
ax.set_xlabel('Smarts')
ax.set_ylabel('Probability')
ax.set_title(r'$\mathrm{Histogram of IQ: }\mu=100, \sigma=15$')
def plot(self, title, scol, logT=False, ylim=False, pw=3, ph=4):
""" Return boxplot from the given tables.
"""
self.xtickrotation, self.xtickalign = 0, "center"
if len(self.group_tags) < 2:
ticklabelsize = pw * 1.5
else:
ticklabelsize = pw * 6
tw = len(self.group_tags) * pw
th = ph
f, axarr = plt.subplots(1,
len(self.group_tags),
dpi=300,
sharey=scol,
figsize=(tw, th))
# f, axarr = plt.subplots(1, len(self.group_tags), dpi=300, sharey = scol)
# nm = len(self.group_tags) * len(self.color_tags) * len(self.sort_tags)
# if nm > 30:
# f.set_size_inches(nm * 0.25 ,nm * 0.15)
# legend_x = 1.2
# self.xtickrotation, self.xtickalign = 70,"right"
canvas = FigureCanvas(f)
canvas.set_window_title(title)
try:
axarr = axarr.reshape(-1)
except:
axarr = [axarr]
# plt.subplots_adjust(bottom=0.3)
if logT:
if self.df:
axarr[0].set_ylabel("Read number difference (log)",
fontsize=ticklabelsize + 1)
else:
axarr[0].set_ylabel("Read number (log)",
fontsize=ticklabelsize + 1)
else:
if self.df:
axarr[0].set_ylabel("Read number difference",
fontsize=ticklabelsize + 1)
else:
axarr[0].set_ylabel("Read number", fontsize=ticklabelsize + 1)
for i, g in enumerate(self.sortDict.keys()):
# if self.df:
# axarr[i].set_title(g + "_df", y=1.02, fontsize=ticklabelsize + 2)
# else:
axarr[i].set_title(g, y=1.02, fontsize=ticklabelsize + 2)
if logT and not self.df:
axarr[i].set_yscale('log')
else:
axarr[i].locator_params(axis='y', nbins=4)
axarr[i].tick_params(axis='y', direction='out')
axarr[i].yaxis.tick_left()
axarr[i].yaxis.grid(True,
linestyle='-',
which='major',
color='lightgrey',
alpha=0.7,
zorder=1)
if ylim:
axarr[i].set_ylim([-ylim, ylim])
d = [] # Store data within group
color_t = [] # Store tag for coloring boxes
x_ticklabels = [] # Store ticklabels
for j, a in enumerate(self.sortDict[g].keys()):
# if len(a) > 10:
# print(a)
self.xtickrotation = 70
self.xtickalign = "right"
for k, c in enumerate(self.sortDict[g][a].keys()):
if not numpy.any(
self.sortDict[g][a]
[c]): # When there is no matching data, skip it
continue
else:
if self.df:
d.append(self.sortDict[g][a][c])
else:
d.append([x + 1 for x in self.sortDict[g][a][c]])
color_t.append(self.colors[k])
x_ticklabels.append(a) # + "." + c
# Fine tuning boxplot
# print(d)
bp = axarr[i].boxplot(d,
notch=False,
sym='o',
vert=True,
whis=1.5,
positions=None,
widths=None,
patch_artist=True,
bootstrap=None)
z = 10 # zorder for boxplot
plt.setp(bp['whiskers'],
color='black',
linestyle='-',
linewidth=0.8,
zorder=z)
plt.setp(bp['fliers'],
markerfacecolor='gray',
color='white',
alpha=0.3,
markersize=1.8,
zorder=z)
plt.setp(bp['caps'], color='white', zorder=z)
plt.setp(bp['medians'], color='black', linewidth=1.5, zorder=z + 1)
legends = []
for patch, color in zip(bp['boxes'], color_t):
patch.set_facecolor(
color
) # When missing the data, the color patch will exceeds
patch.set_edgecolor("none")
patch.set_zorder(z)
legends.append(patch)
# Fine tuning subplot
axarr[i].set_xticks([
len(self.color_tags) * n + 1 + (len(self.color_tags) - 1) / 2
for n, s in enumerate(self.sortDict[g].keys())
])
# plt.xticks(xlocations, sort_tags, rotation=90, fontsize=10)
axarr[i].set_xticklabels(self.sortDict[g].keys(),
rotation=self.xtickrotation,
ha=self.xtickalign)
# axarr[i].set_xticklabels(self.sortDict[g].keys(), rotation=70, ha=self.xtickalign, fontsize=10)
# axarr[i].set_ylim(bottom=0.95)
for spine in ['top', 'right', 'left', 'bottom']:
axarr[i].spines[spine].set_visible(False)
axarr[i].tick_params(axis='x',
which='both',
bottom=False,
top=False,
labelbottom=True)
axarr[i].tick_params(labelsize=ticklabelsize + 1)
if scol:
# plt.setp(axarr[i].get_yticklabels(),visible=False)
axarr[i].minorticks_off()
# axarr[i].tick_params(axis='y', which='both', left='off', right='off', labelbottom='off')
else:
plt.setp(axarr[i].get_yticklabels(), visible=True)
axarr[i].tick_params(axis='y',
which='both',
left=True,
right=False,
labelbottom=True)
# plt.setp(axarr[i].get_yticks(),visible=False)
axarr[-1].legend(legends[0:len(self.color_tags)],
self.color_tags,
loc='center left',
handlelength=1,
handletextpad=1,
columnspacing=2,
borderaxespad=0.,
prop={'size': ticklabelsize + 1},
bbox_to_anchor=(1.05, 0.5))
# f.tight_layout(pad=2, h_pad=None, w_pad=None)
# f.tight_layout()
self.fig = f
def doChooch(self, elt, edge, scan_directory, archive_directory, prefix):
symbol = "_".join((elt, edge))
scan_file_prefix = os.path.join(scan_directory, prefix)
archive_file_prefix = os.path.join(archive_directory, prefix)
if os.path.exists(scan_file_prefix + ".raw"):
i = 1
while os.path.exists(scan_file_prefix + "%d.raw" % i):
i = i + 1
scan_file_prefix += "_%d" % i
archive_file_prefix += "_%d" % i
scan_file_raw_filename = \
os.path.extsep.join((scan_file_prefix, "raw"))
archive_file_raw_filename = \
os.path.extsep.join((archive_file_prefix, "raw"))
scan_file_efs_filename = \
os.path.extsep.join((scan_file_prefix, "efs"))
archive_file_efs_filename = \
os.path.extsep.join((archive_file_prefix, "efs"))
scan_file_png_filename = \
os.path.extsep.join((scan_file_prefix, "png"))
archive_file_png_filename = \
os.path.extsep.join((archive_file_prefix, "png"))
try:
if not os.path.exists(scan_directory):
os.makedirs(scan_directory)
if not os.path.exists(archive_directory):
os.makedirs(archive_directory)
except:
logging.getLogger("HWR").exception(\
"EMBLEnergyScan: could not create results directory.")
self.store_energy_scan()
self.emit("energyScanFailed", ())
return
try:
scan_file_raw = open(scan_file_raw_filename, "w")
archive_file_raw = open(archive_file_raw_filename, "w")
except:
logging.getLogger("HWR").exception(\
"EMBLEnergyScan: could not create results raw file")
self.store_energy_scan()
self.emit("energyScanFailed", ())
return
else:
scanData = []
for i in range(len(self.scan_data)):
x = float(self.scan_data[i][0])
x = x < 1000 and x * 1000.0 or x
y = float(self.scan_data[i][1])
scanData.append((x, y))
scan_file_raw.write("%f,%f\r\n" % (x, y))
archive_file_raw.write("%f,%f\r\n" % (x, y))
scan_file_raw.close()
archive_file_raw.close()
self.scan_info["scanFileFullPath"] = str(scan_file_raw_filename)
pk, fppPeak, fpPeak, ip, fppInfl, fpInfl, chooch_graph_data = \
PyChooch.calc(scanData, elt, edge, scan_file_efs_filename)
rm = (pk + 30) / 1000.0
pk = pk / 1000.0
savpk = pk
ip = ip / 1000.0
comm = ""
#IK TODO clear this
self.scan_info['edgeEnergy'] = 0.1
self.th_edge = self.scan_info['edgeEnergy']
logging.getLogger("HWR").info(\
"th. Edge %s ; chooch results are pk=%f, ip=%f, rm=%f" % \
(self.th_edge, pk, ip, rm))
#should be better, but OK for time being
"""
self.th_edgeThreshold = 0.01
if math.fabs(self.th_edge - ip) > self.thEdgeThreshold:
pk = 0
ip = 0
rm = self.th_edge + 0.03
comm = "Calculated peak (%f) is more that 10eV away from the " + \
"theoretical value (%f). Please check your scan" % \
(savpk, self.th_edge)
logging.getLogger("HWR").warning("EnergyScan: calculated peak " + \
"(%f) is more that 20eV %s the theoretical value (%f). " + \
"Please check your scan and choose the energies manually" % \
(savpk, (self.th_edge - ip) > 0.02 and "below" or "above", self.thEdge))
"""
try:
fi = open(scan_file_efs_filename)
fo = open(archive_file_efs_filename, "w")
except:
self.store_energy_scan()
self.emit("energyScanFailed", ())
return
else:
fo.write(fi.read())
fi.close()
fo.close()
self.scan_info["peakEnergy"] = pk
self.scan_info["inflectionEnergy"] = ip
self.scan_info["remoteEnergy"] = rm
self.scan_info["peakFPrime"] = fpPeak
self.scan_info["peakFDoublePrime"] = fppPeak
self.scan_info["inflectionFPrime"] = fpInfl
self.scan_info["inflectionFDoublePrime"] = fppInfl
self.scan_info["comments"] = comm
self.scan_info["choochFileFullPath"] = scan_file_efs_filename
self.scan_info["filename"] = archive_file_raw_filename
self.scan_info["workingDirectory"] = archive_directory
chooch_graph_x, chooch_graph_y1, chooch_graph_y2 = zip(
*chooch_graph_data)
chooch_graph_x = list(chooch_graph_x)
for i in range(len(chooch_graph_x)):
chooch_graph_x[i] = chooch_graph_x[i] / 1000.0
#logging.getLogger("HWR").info("EMBLEnergyScan: Saving png" )
# prepare to save png files
title = "%s %s %s\n%.4f %.2f %.2f\n%.4f %.2f %.2f" % \
("energy", "f'", "f''", pk, fpPeak, fppPeak, ip, fpInfl, fppInfl)
fig = Figure(figsize=(15, 11))
ax = fig.add_subplot(211)
ax.set_title("%s\n%s" % (scan_file_efs_filename, title))
ax.grid(True)
ax.plot(*(zip(*scanData)), **{"color": 'black'})
ax.set_xlabel("Energy")
ax.set_ylabel("MCA counts")
ax2 = fig.add_subplot(212)
ax2.grid(True)
ax2.set_xlabel("Energy")
ax2.set_ylabel("")
handles = []
handles.append(ax2.plot(chooch_graph_x, chooch_graph_y1, color='blue'))
handles.append(ax2.plot(chooch_graph_x, chooch_graph_y2, color='red'))
canvas = FigureCanvasAgg(fig)
self.scan_info["jpegChoochFileFullPath"] = str(
archive_file_png_filename)
try:
logging.getLogger("HWR").info("Rendering energy scan and Chooch " + \
"graphs to PNG file : %s", scan_file_png_filename)
canvas.print_figure(scan_file_png_filename, dpi=80)
except:
logging.getLogger("HWR").exception("could not print figure")
try:
logging.getLogger("HWR").info("Saving energy scan to archive " +\
"directory for ISPyB : %s", archive_file_png_filename)
canvas.print_figure(archive_file_png_filename, dpi=80)
except:
logging.getLogger("HWR").exception("could not save figure")
self.store_energy_scan()
logging.getLogger("HWR").info("<chooch> returning")
self.emit('choochFinished',
(pk, fppPeak, fpPeak, ip, fppInfl, fpInfl, rm,
chooch_graph_x, chooch_graph_y1, chooch_graph_y2, title))
return pk, fppPeak, fpPeak, ip, fppInfl, fpInfl, rm, chooch_graph_x, \
chooch_graph_y1, chooch_graph_y2, title
#TODO: remove all the ticks (both axes), and tick labels on the Y axis
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.backends.backend_agg import FigureCanvasAgg
fig = plt.figure()
canvas = FigureCanvasAgg(fig)
languages = np.array(['Python','SQL','Java','C++','JavaScript'])
pos = np.arange(len(languages))
popularity = [56,39,34,34,29]
plt.bar(pos, popularity, align = 'center')
plt.xticks(pos, languages)
plt.ylabel('% popularity')
plt.title('Top 5 Languages for Math & Data \n by % popularity on Stack Overflow', alpha=0.8)
plt.tick_params(top=False, bottom=False, left=False, right=False, labelleft=False, labelbottom=True)
canvas.print_figure('images/week2_finaltest1.png')
def analyse_couleurs():
import io
import urllib
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
global progress
progress = 10
n_colors = int(request.form['nbbins'])
nbsamples = int(request.form['nbsamples'])
opacity = float(request.form['opacity'])
satlum = request.form['satlum']
ct = float(request.form['sizecoef'])
srcimage = request.form['srcimage']
if (srcimage[:4] == "http"):
srcimage = io.StringIO.StringIO(urllib.urlopen(srcimage).read())
# Opens image to an array of RGB colors
img = Image.open(srcimage)
# Convert to floats instead of the default 8 bits integer coding. Dividing by
# 255 is important so that plt.imshow behaves works well on float data (need to
# be in the range [0-1])
img = np.array(img, dtype=np.uint8)
# Convert to HSV color space
imgHSV = color.rgb2hsv(img)
# Load Image and transform to a 2D numpy array.
w, h, d = original_shape = tuple(imgHSV.shape)
assert d == 3
image_array = np.reshape(imgHSV, (w * h, d))
# print("Fitting model on a small sub-sample of the data")
t0 = time()
image_array_sample = shuffle(image_array,
random_state=0,
n_samples=nbsamples)[:1000]
kmeans = KMeans(n_clusters=n_colors,
random_state=0,
n_jobs=1,
max_iter=200,
init='k-means++',
algorithm='elkan',
precompute_distances=True).fit(image_array_sample)
#print("done in %0.3fs." % (time() - t0))
progress = 50
# Get labels for all points
#print("Predicting color indices on the full image (k-means)")
t0 = time()
labels = kmeans.predict(image_array)
couleurs = kmeans.cluster_centers_
print("done in %0.3fs." % (time() - t0))
# Counting pixels in color bins, for sorting and circles dimensioning
unique, counts = np.unique(labels, return_counts=True)
progress = 60
ro = math.pi / 2
maxc = max(counts)
rcmc = math.sqrt(maxc)
fig = plt.figure()
ax = plt.subplot(111, projection='polar')
ax.set_theta_zero_location("N")
ax.set_rmax(1)
ax.set_rticks([0.25, 0.5, 0.75, 1]) # less radial ticks
ax.set_rlabel_position(-22.5) # get radial labels away from plotted line
ax.grid(True)
cp = dict(zip(range(0, n_colors), counts))
co = sorted(cp.items(), key=operator.itemgetter(1), reverse=True)
# Figure-drawing loop
for i in range(0, n_colors):
ht = -((math.pi * 2) *
couleurs[co[i][0]][0]) + ro # Color hue coefficient
if (satlum == "sat"): # Radial axis : sat or lum component
ar = couleurs[co[i][0]][1]
else:
ar = couleurs[co[i][0]][2]
x = ar * math.cos(ht) # Conversion of ht to X pos
y = ar * math.sin(ht) # Conversion of ht to Y pos
va = counts[co[i][0]] # Raw size of color bin
ra = ((math.sqrt(va) / rcmc) /
2) * ct # Adapted size for display, relative to the max size
at = (np.array([[couleurs[co[i][0]]]]) * 255).astype(np.uint8)
c = color.hsv2rgb(at) # Retro-conversion to RGB for plotting
tc = plt.Circle((x, y),
ra,
transform=ax.transProjectionAffine + ax.transAxes,
color=c[0][0].astype(np.float),
alpha=opacity,
clip_on=False) # Circle drawing
ax.add_artist(tc)
# Figure to PNG export
progress = 70
canvas = FigureCanvas(fig)
png_output = io.StringIO.StringIO()
canvas.print_png(png_output)
progress = 80
data = png_output.getvalue().encode('base64')
data_url = 'data:image/png;base64,{}'.format(
urllib.quote(data.rstrip('\n')))
progress = 100
return data_url
def figure_response(fig, request, adjust=None, **kwargs):
canvas = FigureCanvasAgg(fig)
figdata = io.BytesIO()
canvas.print_png(figdata, bbox_inches='tight', pad_inches=0.1, **kwargs)
response = HttpResponse(figdata.getvalue(), content_type='image/png')
return response
"""
Example of matplotlib colormaps
http://matplotlib.org/api/figure_api.html#matplotlib.figure.Figure.colorbar
"""
import numpy as np
import matplotlib
from matplotlib import figure
from matplotlib.backends.backend_agg import (FigureCanvasAgg as FigureCanvas)
data = np.random.randn(50, 50)
fig = figure.Figure()
canvas = FigureCanvas(fig)
ax1 = fig.add_subplot(1, 1, 1)
plt1 = ax1.imshow(data, cmap='RdBu')
cbar = fig.colorbar(plt1, ax=ax1, fraction=0.045)
cbar.set_label("Random Data")
canvas.print_figure('../figures/cmapaxis.png', facecolor='lightgray')
def plot_flu_prediction8(fig_root_dir, images, gt_maps, pr_maps, cut_folder, unet_fl1_dir, unet_fl2_dir, image_ids, nb_images, rand_seed = 3, colorbar = True):
import matplotlib.pyplot as plt
from matplotlib.backends.backend_agg import FigureCanvasAgg
from matplotlib.figure import Figure
from skimage import io
import random
seed = rand_seed #3
random.seed(seed)
font_size = 28; label_size = 18
#indices = random.sample(range(gt_maps.shape[0]),nb_images)
rows, cols, size = nb_images,4,6
pre_select_fnames = ['f0_t0_i0_ch0_c2_r3_z1_mhilbert.png', 'f0_t4_i0_ch0_c4_r1_z0_mhilbert.png',
'f0_t4_i0_ch0_c2_r2_z1_mhilbert.png', 'f0_t4_i0_ch0_c1_r0_z1_mhilbert.png']
indices = [image_ids.index(fname) for fname in pre_select_fnames]
for i in range(len(indices)):
example_folder = os.path.join(fig_root_dir, 'example_{:03d}'.format(i)); generate_folder(example_folder)
cols, rows = 1, 1
fig1 = Figure(tight_layout=True,figsize=(size-1.0, size-1.2))
fig2 = Figure(tight_layout=True,figsize=(size, size-1.2))
fig3 = Figure(tight_layout=True,figsize=(size, size-1.2))
fig4 = Figure(tight_layout=True,figsize=(size, size-1.2))
fig5 = Figure(tight_layout=True,figsize=(size, size-1.2))
fig6 = Figure(tight_layout=True,figsize=(size, size-1.2))
fig7 = Figure(tight_layout=True,figsize=(size, size-1.2))
ax = fig1.subplots(nrows=rows,ncols=cols); #ax.set_xticks([]);ax.set_yticks([])
bx = fig2.subplots(nrows=rows,ncols=cols); #ax.set_xticks([]);ax.set_yticks([])
cx = fig3.subplots(nrows=rows,ncols=cols); #ax.set_xticks([]);ax.set_yticks([])
dx = fig4.subplots(nrows=rows,ncols=cols); #ax.set_xticks([]);ax.set_yticks([])
ex = fig5.subplots(nrows=rows,ncols=cols);
fx = fig6.subplots(nrows=rows,ncols=cols);
gx = fig7.subplots(nrows=rows,ncols=cols);
idx = indices[i]
image, gt_map, pr_map = images[idx,:].squeeze(), gt_maps[idx,:].squeeze(), pr_maps[idx,:].squeeze()
image = np.uint8((image-image.min())/(image.max()-image.min())*255)
err_map = np.abs(gt_map-pr_map)*255; err_map_rgb = np.zeros(image.shape).astype(np.uint8); err_map_rgb[:,:,:-1] = err_map
gt_map_rgb = np.zeros(image.shape,dtype=np.uint8); # gt_map_rgb[:,:,:-1]=np.uint8((gt_map-gt_map.min())/(gt_map.max()-gt_map.min())*255)
gt_map_rgb[:,:,:-1]=np.uint8(gt_map*255)
pr_map_rgb = np.zeros(image.shape,dtype=np.uint8); # pr_map_rgb[:,:,:-1]=np.uint8((pr_map-pr_map.min())/(pr_map.max()-pr_map.min())*255)
pr_map_rgb[:,:,:-1]=np.uint8(pr_map*255)
unpaired_map = io.imread(cut_folder+'/{}'.format(image_ids[idx]))
unet_fl1 = io.imread(unet_fl1_dir+'/pred_{}'.format(image_ids[idx].replace('png','tif'))); unet_fl2 = io.imread(unet_fl2_dir+'/pred_{}'.format(image_ids[idx].replace('png','tif')))
unet_fl1 = unet_fl1/unet_fl1.max(); unet_fl2 = unet_fl2/unet_fl2.max()
unet_map = np.stack([unet_fl1, unet_fl2], axis = -1); print(unet_map.min(), unet_map.max())
unet_err_map = np.abs(gt_map-unet_map)*255; unet_err_map_rgb = np.zeros(image.shape).astype(np.uint8); unet_err_map_rgb[:,:,:-1] = unet_err_map
unet_map_rgb = np.zeros(image.shape,dtype=np.uint8);
unet_map_rgb[:,:,:-1]=np.uint8(unet_map*255)
cax = ax.imshow(image); #cbar = fig1.colorbar(cax, ax = ax, shrink = 0.68); cbar.ax.tick_params(labelsize=label_size)
cbx = bx.imshow(gt_map_rgb); cbar = fig2.colorbar(cbx, ax = bx, shrink = 0.97); cbar.ax.tick_params(labelsize=label_size)
ccx = cx.imshow(pr_map_rgb); cbar = fig3.colorbar(ccx, ax = cx, shrink = 0.97); cbar.ax.tick_params(labelsize=label_size)
cdx = dx.imshow(err_map_rgb); cbar = fig4.colorbar(cdx, ax = dx, shrink = 0.97); cbar.ax.tick_params(labelsize=label_size)
cex = ex.imshow(unpaired_map); cbar = fig5.colorbar(cdx, ax = ex, shrink = 0.97); cbar.ax.tick_params(labelsize=label_size)
cfx = fx.imshow(unet_map_rgb); cbar = fig6.colorbar(cdx, ax = fx, shrink = 0.97); cbar.ax.tick_params(labelsize=label_size)
cgx = gx.imshow(unet_err_map_rgb); cbar = fig7.colorbar(cdx, ax = gx, shrink = 0.97); cbar.ax.tick_params(labelsize=label_size)
ax.tick_params(axis = 'x', labelsize = label_size); ax.tick_params(axis = 'y', labelsize = label_size);
bx.tick_params(axis = 'x', labelsize = label_size); bx.tick_params(axis = 'y', labelsize = label_size);
cx.tick_params(axis = 'x', labelsize = label_size); cx.tick_params(axis = 'y', labelsize = label_size);
dx.tick_params(axis = 'x', labelsize = label_size); dx.tick_params(axis = 'y', labelsize = label_size);
ex.tick_params(axis = 'x', labelsize = label_size); ex.tick_params(axis = 'y', labelsize = label_size);
fx.tick_params(axis = 'x', labelsize = label_size); fx.tick_params(axis = 'y', labelsize = label_size);
gx.tick_params(axis = 'x', labelsize = label_size); gx.tick_params(axis = 'y', labelsize = label_size);
canvas = FigureCanvasAgg(fig1); canvas.print_figure(example_folder+'/Image.png', dpi=120)
canvas = FigureCanvasAgg(fig2); canvas.print_figure(example_folder+'/Ground_truth.png', dpi=120)
canvas = FigureCanvasAgg(fig3); canvas.print_figure(example_folder+'/EfficientNet_Prediction.png', dpi=120)
canvas = FigureCanvasAgg(fig4); canvas.print_figure(example_folder+'/EfficientNet_Error_map.png', dpi=120)
canvas = FigureCanvasAgg(fig5); canvas.print_figure(example_folder+'/Unpaired_pred.png', dpi=120)
canvas = FigureCanvasAgg(fig6); canvas.print_figure(example_folder+'/UNet_Prediction.png', dpi=120)
canvas = FigureCanvasAgg(fig7); canvas.print_figure(example_folder+'/UNet_Error_map.png', dpi=120)
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.backends.backend_agg import FigureCanvasAgg
import pandas as pd
linear_data = np.array([1, 2, 3, 4, 5, 6, 7, 8])
quadratic_data = linear_data**2
fig = plt.figure()
canvas = FigureCanvasAgg(fig)
observation_dates = np.arange('2017-01-01',
'2017-01-09',
dtype='datetime64[D]')
observation_dates = list(map(pd.to_datetime, observation_dates))
plt.plot(observation_dates, linear_data, '-o', observation_dates,
quadratic_data, '-o')
x = plt.gca().xaxis
for item in x.get_ticklabels():
item.set_rotation(45) #rotates the tick labels for readablility
plt.subplots_adjust(
bottom=0.25) #adjusts the image bc its running off of the screen
canvas.print_figure('images/week2_14.png')
def airmassplot(request, transient_id, obs_id, telescope_id):
import random
import django
import datetime
from astroplan.plots import plot_airmass
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
from matplotlib import rcParams
rcParams['figure.figsize'] = (7, 7)
transient = Transient.objects.get(pk=transient_id)
if int(obs_id):
obsnight = ClassicalObservingDate.objects.get(pk=obs_id)
obs_date = obsnight.obs_date
else:
obs_date = datetime.date.today() #time.now()
telescope = Telescope.objects.get(pk=telescope_id)
target = SkyCoord(transient.ra, transient.dec, unit=u.deg)
time = Time(str(obs_date).split('+')[0], format='iso')
location = EarthLocation.from_geodetic(telescope.longitude * u.deg,
telescope.latitude * u.deg,
telescope.elevation * u.m)
tel = Observer(location=location, name=telescope.name, timezone="UTC")
fig = Figure()
ax = fig.add_subplot(111)
canvas = FigureCanvas(fig)
ax.set_title("%s, %s, %s" %
(telescope.tostring(), transient.name, obs_date))
night_start = tel.twilight_evening_astronomical(time, which="previous")
night_end = tel.twilight_morning_astronomical(time, which="previous")
if night_end < night_start:
night_end = tel.twilight_morning_astronomical(time, which="next")
delta_t = night_end - night_start
observe_time = night_start + delta_t * np.linspace(0, 1, 75)
plot_airmass(target, tel, observe_time, ax=ax)
yr, mn, day, hr, minu, sec = night_start.iso.replace(':', ' ').replace(
'-', ' ').split()
starttime = datetime.datetime(int(yr), int(mn), int(day), int(hr),
int(minu))
if int(hr) == 0:
xlow = datetime.datetime(int(yr), int(mn), int(day) - 1, 23, int(minu))
else:
xlow = datetime.datetime(int(yr), int(mn), int(day),
int(hr) - 1, int(minu))
yr, mn, day, hr, minu, sec = night_end.iso.replace(':', ' ').replace(
'-', ' ').split()
endtime = datetime.datetime(int(yr), int(mn), int(day), int(hr), int(minu))
xhi = datetime.datetime(int(yr), int(mn), int(day), int(hr) + 1, int(minu))
ax.axvline(starttime, color='r',
label='18 deg twilight') #night_start.iso)
ax.axvline(endtime, color='r')
ax.legend(loc='lower right')
ax.set_xlim([xlow, xhi])
response = django.http.HttpResponse(content_type='image/png')
canvas.print_jpg(response)
return response
def plot_flu_prediction2(fig_root_dir, images, gt_maps, pr_maps, nb_images, rand_seed = 3, colorbar = True):
import matplotlib.pyplot as plt
from matplotlib.backends.backend_agg import FigureCanvasAgg
from matplotlib.figure import Figure
import random
from skimage import io
seed = rand_seed #3
random.seed(seed)
font_size = 28; label_size = 18
indices = random.sample(range(gt_maps.shape[0]),nb_images)
rows, cols, size = nb_images,4,6
for i in range(len(indices)):
example_folder = os.path.join(fig_root_dir, 'example_{:03d}'.format(i)); generate_folder(example_folder)
cols, rows = 1, 1
fig1 = Figure(tight_layout=True,figsize=(size-1.0, size-1.2))
fig2 = Figure(tight_layout=True,figsize=(size, size-1.2))
fig3 = Figure(tight_layout=True,figsize=(size, size-1.2))
fig4 = Figure(tight_layout=True,figsize=(size, size-1.2))
ax = fig1.subplots(nrows=rows,ncols=cols); #ax.set_xticks([]);ax.set_yticks([])
bx = fig2.subplots(nrows=rows,ncols=cols); #ax.set_xticks([]);ax.set_yticks([])
cx = fig3.subplots(nrows=rows,ncols=cols); #ax.set_xticks([]);ax.set_yticks([])
dx = fig4.subplots(nrows=rows,ncols=cols); #ax.set_xticks([]);ax.set_yticks([])
idx = indices[i]
image, gt_map, pr_map = images[idx,:].squeeze(), gt_maps[idx,:].squeeze(), pr_maps[idx,:].squeeze()
image = np.uint8((image-image.min())/(image.max()-image.min())*255)
err_map = np.abs(gt_map-pr_map)*255; err_map_rgb = np.zeros(image.shape).astype(np.uint8); err_map_rgb[:,:,:-1] = err_map
gt_map_rgb = np.zeros(image.shape,dtype=np.uint8); # gt_map_rgb[:,:,:-1]=np.uint8((gt_map-gt_map.min())/(gt_map.max()-gt_map.min())*255)
gt_map_rgb[:,:,:-1]=np.uint8(gt_map*255)
pr_map_rgb = np.zeros(image.shape,dtype=np.uint8); # pr_map_rgb[:,:,:-1]=np.uint8((pr_map-pr_map.min())/(pr_map.max()-pr_map.min())*255)
pr_map_rgb[:,:,:-1]=np.uint8(pr_map*255)
cax = ax.imshow(image); #cbar = fig1.colorbar(cax, ax = ax, shrink = 0.68); cbar.ax.tick_params(labelsize=label_size)
cbx = bx.imshow(gt_map_rgb); cbar = fig2.colorbar(cbx, ax = bx, shrink = 0.97); cbar.ax.tick_params(labelsize=label_size)
ccx = cx.imshow(pr_map_rgb); cbar = fig3.colorbar(ccx, ax = cx, shrink = 0.97); cbar.ax.tick_params(labelsize=label_size)
cdx = dx.imshow(err_map_rgb); cbar = fig4.colorbar(cdx, ax = dx, shrink = 0.97); cbar.ax.tick_params(labelsize=label_size)
ax.tick_params(axis = 'x', labelsize = label_size); ax.tick_params(axis = 'y', labelsize = label_size);
bx.tick_params(axis = 'x', labelsize = label_size); bx.tick_params(axis = 'y', labelsize = label_size);
cx.tick_params(axis = 'x', labelsize = label_size); cx.tick_params(axis = 'y', labelsize = label_size);
dx.tick_params(axis = 'x', labelsize = label_size); dx.tick_params(axis = 'y', labelsize = label_size);
canvas = FigureCanvasAgg(fig1); canvas.print_figure(example_folder+'/Image.png', dpi=120)
canvas = FigureCanvasAgg(fig2); canvas.print_figure(example_folder+'/Ground_truth.png', dpi=120)
canvas = FigureCanvasAgg(fig3); canvas.print_figure(example_folder+'/Prediction.png', dpi=120)
canvas = FigureCanvasAgg(fig4); canvas.print_figure(example_folder+'/Error_map.png', dpi=120)
def satellite_track_variability_plot(request,
track_id=0,
width=800,
type='fold'):
track = SatelliteTracks.objects.get(id=track_id)
records = track.satelliterecords_set.order_by('time')
if track.satellite.catalogue == 2:
assert_permission(request, 'fweb.access_satellites_all')
fig = Figure(facecolor='white',
figsize=(width / 72, width * 0.5 / 72),
tight_layout=True)
ax = fig.add_subplot(111)
ax.autoscale()
time_start = satellite_track_start(track)
time_end = satellite_track_end(track)
T = (time_end - time_start).total_seconds()
if track.variability == 2:
P = track.variability_period
else:
P = None
xs = []
ys = []
fs = []
for r in records:
x = (r.time - time_start).total_seconds()
y = r.stdmag
color = favor2_filters[
r.filter_id] if r.filter_id else favor2_filters[0]
if r.penumbra:
f = color + [0.3]
else:
f = color + [1.0]
xs.append(x)
ys.append(y)
fs.append(f)
x = np.array(xs)
y = np.array(ys)
fit = np.polyfit(x, y, 2)
y0 = np.polyval(fit, x)
# ax.plot((0,0), (min(ys), max(ys)), c='lightgray')
# ax.plot((track.variability_period,track.variability_period), (min(ys), max(ys)), c='lightgray')
#ax.scatter(xs, ys, c=fs, marker='.', edgecolors=f)
if type == 'fold' and P:
#P = refine_period(x, y-y0, P, detrend=False)
if int(request.GET.get('refine', 0)):
P = refine_track_period(track)
px = np.mod(x, P)
ax.scatter(px, y - y0, c=fs, marker='.', edgecolors=fs)
ax.scatter(px - P, y - y0, c=fs, marker='.', edgecolors=fs)
ax.scatter(px + P, y - y0, c=fs, marker='.', edgecolors=fs)
ax.axvline(0, c='gray', alpha=0.5)
ax.axvline(P, c='gray', alpha=0.5)
if P != track.variability_period:
ax.set_xlabel(
"Time, seconds, folded to period %g (original %g) s" %
(P, track.variability_period))
else:
ax.set_xlabel("Time, seconds, folded to period %g s" % (P))
ax.set_ylabel("Standard Magnitude")
ax.invert_yaxis()
elif type == 'ls':
freq = np.arange(1.0 / T, 5.0, 1.0 / T)
ls = signal.lombscargle(x, y, 2 * np.pi * freq)
#ax.semilogx(freq, ls)
ax.loglog(freq, ls, drawstyle='steps')
if P:
ax.axvline(1.0 / P, c='gray', alpha=0.5)
ax.set_xlabel("Frequency, Hz")
ax.set_ylabel("Lomb-Scargle periodogram")
elif type == 'pdm':
pp = np.arange(P * 0.9, P * 1.1, P * 0.001)
pdm = PDM(x, y - y0, 1.0 / pp)
ax.plot(pp, pdm, drawstyle='steps')
ax.set_xlabel("Period, seconds")
ax.set_ylabel("Phase Dispersion Minimization")
ax.xaxis.set_major_formatter(ScalarFormatter(useOffset=False))
ax.yaxis.set_major_formatter(ScalarFormatter(useOffset=False))
#fig.autofmt_xdate()
# 10% margins on both axes
ax.margins(0.0, 0.1)
time_start_str = time_start.strftime(
'%Y-%m-%d %H:%M:%S') + '.%03d' % np.round(
1e-3 * time_start.microsecond)
ax.set_title(
"%s %d / %s, track at %s" %
(satellite_catalogue(track.satellite.catalogue),
track.satellite.catalogue_id, track.satellite.name, time_start_str))
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def plot_flu_prediction7(file_name, images, gt_maps, pr_maps, cut_folder, unet_fl1_dir, unet_fl2_dir, image_ids, nb_images, rand_seed = 3, colorbar = True):
import matplotlib.pyplot as plt
from matplotlib.backends.backend_agg import FigureCanvasAgg
from matplotlib.figure import Figure
from skimage import io
import random
seed = rand_seed #3
random.seed(seed)
font_size = 28; label_size = 20
indices = random.sample(range(gt_maps.shape[0]),nb_images)
pre_select_fnames = ['f0_t0_i0_ch0_c2_r3_z1_mhilbert.png', 'f0_t4_i0_ch0_c4_r1_z0_mhilbert.png',
'f0_t4_i0_ch0_c2_r2_z1_mhilbert.png', 'f0_t4_i0_ch0_c1_r0_z1_mhilbert.png']
indices = [image_ids.index(fname) for fname in pre_select_fnames]
rows, cols, size = nb_images,7,6
widths = [0.8, 1, 1, 1, 1,1,1]; heights = [1, 1, 1, 1]; gs_kw = dict(width_ratios=widths, height_ratios=heights)
fig = Figure(tight_layout=True,figsize=(size*cols, size*rows)); ax = fig.subplots(nrows=rows,ncols=cols, gridspec_kw=gs_kw)
for i in range(len(indices)):
idx = indices[i]
image, gt_map, pr_map = images[idx,:].squeeze(), gt_maps[idx,:].squeeze(), pr_maps[idx,:].squeeze()
image = np.uint8((image-image.min())/(image.max()-image.min())*255)
err_map = np.abs(gt_map-pr_map)*255; err_map_rgb = np.zeros(image.shape).astype(np.uint8); err_map_rgb[:,:,:-1] = err_map
gt_map_rgb = np.zeros(image.shape,dtype=np.uint8); # gt_map_rgb[:,:,:-1]=np.uint8((gt_map-gt_map.min())/(gt_map.max()-gt_map.min())*255)
gt_map_rgb[:,:,:-1]=np.uint8(gt_map*255)
pr_map_rgb = np.zeros(image.shape,dtype=np.uint8); # pr_map_rgb[:,:,:-1]=np.uint8((pr_map-pr_map.min())/(pr_map.max()-pr_map.min())*255)
pr_map_rgb[:,:,:-1]=np.uint8(pr_map*255)
cut_map = io.imread(cut_folder+'/{}'.format(image_ids[idx]))
cx0 = ax[i,0].imshow(image); cx1 = ax[i,1].imshow(gt_map_rgb);
cx2 = ax[i,2].imshow(pr_map_rgb); cx3 = ax[i,3].imshow(err_map_rgb); cx4 = ax[i,6].imshow(cut_map);
unet_fl1 = io.imread(unet_fl1_dir+'/pred_{}'.format(image_ids[idx].replace('png','tif'))); unet_fl2 = io.imread(unet_fl2_dir+'/pred_{}'.format(image_ids[idx].replace('png','tif')))
# unet_fl2 = np.zeros(unet_fl1.shape)
unet_fl1 = unet_fl1/unet_fl1.max(); unet_fl2 = unet_fl2/unet_fl2.max()
unet_map = np.stack([unet_fl1, unet_fl2], axis = -1); print(unet_map.min(), unet_map.max())
#unet_map = unet_map/unet_map.max(); print(unet_map.min(), unet_map.max())
unet_err_map = np.abs(gt_map-unet_map)*255; unet_err_map_rgb = np.zeros(image.shape).astype(np.uint8); unet_err_map_rgb[:,:,:-1] = unet_err_map
unet_map_rgb = np.zeros(image.shape,dtype=np.uint8);
unet_map_rgb[:,:,:-1]=np.uint8(unet_map*255)
cx5 = ax[i,4].imshow(unet_map_rgb); cx6 = ax[i,5].imshow(unet_err_map_rgb);
ax[i,0].set_xticks([]);ax[i,0].set_yticks([]);
#ax[i,0].tick_params(axis = 'x', labelsize = label_size);ax[i,0].tick_params(axis = 'y', labelsize = label_size);
ax[i,1].set_xticks([]);ax[i,2].set_xticks([]);ax[i,3].set_xticks([]); ax[i,4].set_xticks([]); ax[i,5].set_xticks([]); ax[i,6].set_xticks([]);
ax[i,1].set_yticks([]);ax[i,2].set_yticks([]);ax[i,3].set_yticks([]); ax[i,4].set_yticks([]); ax[i,5].set_yticks([]); ax[i,6].set_yticks([]);
if colorbar:
#fig.colorbar(cx0, ax = ax[i,0], shrink = 0);
cbar = fig.colorbar(cx1, ax = ax[i,1], shrink = 0.68); cbar.ax.tick_params(labelsize=label_size)
cbar = fig.colorbar(cx2, ax = ax[i,2], shrink = 0.68); cbar.ax.tick_params(labelsize=label_size)
cbar = fig.colorbar(cx3, ax = ax[i,3], shrink = 0.68); cbar.ax.tick_params(labelsize=label_size)
cbar = fig.colorbar(cx4, ax = ax[i,4], shrink = 0.68); cbar.ax.tick_params(labelsize=label_size)
cbar = fig.colorbar(cx5, ax = ax[i,5], shrink = 0.68); cbar.ax.tick_params(labelsize=label_size)
cbar = fig.colorbar(cx6, ax = ax[i,6], shrink = 0.68); cbar.ax.tick_params(labelsize=label_size)
if i == 0:
ax[i,0].set_title('Image',fontsize=font_size);
ax[i,1].set_title('Ground Truth',fontsize=font_size);
ax[i,2].set_title('E-Net (Paired)',fontsize=font_size);
ax[i,3].set_title('Err Map (E-Net)',fontsize=font_size);
ax[i,4].set_title('U-Net (Paired)',fontsize=font_size);
ax[i,5].set_title('Err Map (U-Net)',fontsize=font_size);
ax[i,6].set_title('Unpaired Method',fontsize=font_size);
fig.tight_layout(pad=-2)
canvas = FigureCanvasAgg(fig); canvas.print_figure(file_name, dpi=120)
def satellite_track_plot(request, track_id=0, width=800, type='stdmag'):
if type in ['fold', 'ls', 'pdm']:
return satellite_track_variability_plot(request, track_id, width, type)
track = SatelliteTracks.objects.get(id=track_id)
records = track.satelliterecords_set.order_by('time')
if track.satellite.catalogue == 2:
assert_permission(request, 'fweb.access_satellites_all')
fig = Figure(facecolor='white',
figsize=(width / 72, width * 0.5 / 72),
tight_layout=True)
ax = fig.add_subplot(111)
ax.autoscale()
#time_start = track.satelliterecords_set.aggregate(Min('record__time')).get('record__time__min')
time_start = satellite_track_start(track)
for channel_id in [
r.channel_id
for r in track.satelliterecords_set.distinct('channel_id')
]:
records = track.satelliterecords_set.filter(
channel_id=channel_id).order_by('time')
xs = []
ys = []
x_prev = None
f_prev = None
channel_prev = None
for r in records:
x = (r.time - time_start).total_seconds()
if type == 'stdmag':
y = r.stdmag
elif type == 'mag':
y = r.mag
elif type == 'distance':
y = r.distance
elif type == 'phase':
y = r.phase
else:
y = 0
color = favor2_filters[
r.filter_id] if r.filter_id else favor2_filters[0]
if r.penumbra:
f = color + [0.3]
else:
f = color + [1.0]
channel = r.channel_id
if (x_prev and x - x_prev > 0.5) or (f_prev and f != f_prev) or (
channel_prev and channel != channel_prev):
ax.plot(xs, ys, marker='.', color=f_prev, lw=0.1, ms=3)
xs = []
ys = []
xs.append(x)
ys.append(y)
x_prev = x
f_prev = f
channel_prev = channel
# Finalize
if x and y and f_prev:
ax.plot(xs, ys, marker='.', color=f_prev, lw=0.1, ms=3)
#ax.scatter(x, y, c=f, marker='.', edgecolors=f)
#ax.plot(x, y, marker='.')
#ax.xaxis.set_major_formatter(DateFormatter('%Y.%m.%d %H:%M:%S'))
#ax.xaxis.set_major_formatter(DateFormatter('%H:%M:%S'))
ax.xaxis.set_major_formatter(ScalarFormatter(useOffset=False))
ax.yaxis.set_major_formatter(ScalarFormatter(useOffset=False))
ax.set_xlabel("Time since track start, seconds")
if type == 'stdmag':
ax.set_ylabel("Standard Magnitude")
ax.invert_yaxis()
elif type == 'mag':
ax.set_ylabel("Apparent Magnitude")
ax.invert_yaxis()
elif type == 'distance':
ax.set_ylabel("Distance, km")
elif type == 'phase':
ax.set_ylabel("Phase angle, degrees")
#fig.autofmt_xdate()
# 10% margins on both axes
ax.margins(0.1, 0.1)
time_start_str = time_start.strftime(
'%Y-%m-%d %H:%M:%S') + '.%03d' % np.round(
1e-3 * time_start.microsecond)
ax.set_title(
"%s %d / %s, track at %s" %
(satellite_catalogue(track.satellite.catalogue),
track.satellite.catalogue_id, track.satellite.name, time_start_str))
canvas = FigureCanvas(fig)
if request.GET.get('format', 'png') == 'pdf':
response = HttpResponse(content_type='application/pdf')
canvas.print_figure(response, format='pdf')
elif request.GET.get('format', 'png') == 'eps':
response = HttpResponse(content_type='application/postscript')
canvas.print_figure(response, format='eps')
else:
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
from mpl_toolkits.basemap import Basemap
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.collections import LineCollection
import csv
# requires pyshapelib from Thuban (http://thuban.intevation.org/).
# cd to libraries/pyshapelib in Thuban source distribution, run
# 'python setup.py install'.
# Lambert Conformal map of lower 48 states.
m = Basemap(llcrnrlon=-119,llcrnrlat=22,urcrnrlon=-64,urcrnrlat=49,
projection='lcc',lat_1=33,lat_2=45,lon_0=-95)
fig=p.figure(figsize=(10,m.aspect*8))
canvas = FigureCanvas(fig)
# draw state boundaries.
shp_info = m.readshapefile('statesp020','states',drawbounds=True)
#generate empty lats and longs lists
latsList=[]
lonsList=[]
#Import previously generated CSV File, Write to a new list of lats and longs
with open('MapPlaces.csv') as csvfile:
spamreader = csv.reader(csvfile, delimiter=',')
for row in spamreader:
list(row)
lons = float(row[0])
lonsList.append(lons)
def spectrum_command_finished(self):
"""
Descript. :
"""
with cleanup(self.ready_event.set):
self.spectrum_info['endTime'] = time.strftime("%Y-%m-%d %H:%M:%S")
self.spectrum_running = False
xmin = 0
xmax = 0
mca_data = []
calibrated_data = []
try:
spectrum_file_raw = open(
self.spectrum_info["scanFileFullPath"], "w")
archive_file_raw = open(self.spectrum_info["scanFilePath"],
"w")
except:
logging.getLogger("HWR").exception(
"XRFSpectrum: could not create spectrum result raw file %s" % \
self.spectrum_info["scanFileFullPath"])
for n, value in enumerate(self.spectrum_data):
energy = (self.mca_calib[2] + \
self.mca_calib[1] * n + \
self.mca_calib[0] * n * n) / 1000
if energy < 20:
if energy > xmax:
xmax = value
if energy < xmin:
xmin = value
calibrated_data.append([energy, value])
mca_data.append((n / 1000.0, value))
if spectrum_file_raw:
spectrum_file_raw.write("%f,%f\r\n" % (energy, value))
if archive_file_raw:
archive_file_raw.write("%f,%f\r\n" % (energy, value))
if spectrum_file_raw:
spectrum_file_raw.close()
if archive_file_raw:
archive_file_raw.close()
calibrated_array = numpy.array(calibrated_data)
if self.transmission_hwobj is not None:
self.spectrum_info["beamTransmission"] = \
self.transmission_hwobj.getAttFactor()
self.spectrum_info["energy"] = self.get_current_energy()
if self.beam_info_hwobj is not None:
beam_size = self.beam_info_hwobj.get_beam_size()
self.spectrum_info["beamSizeHorizontal"] = int(beam_size[0] *
1000)
self.spectrum_info["beamSizeVertical"] = int(beam_size[1] *
1000)
mca_config = {}
mca_config["legend"] = self.spectrum_info["filename"]
mca_config["file"] = self.config_filename
mca_config["min"] = xmin
mca_config["max"] = xmax
mca_config["htmldir"] = self.spectrum_info["htmldir"]
self.spectrum_info.pop("htmldir")
self.spectrum_info.pop("scanFilePath")
fig = Figure(figsize=(15, 11))
ax = fig.add_subplot(111)
ax.set_title(self.spectrum_info["jpegScanFileFullPath"])
ax.grid(True)
ax.plot(*(zip(*calibrated_array)), **{"color": 'black'})
ax.set_xlabel("Energy")
ax.set_ylabel("Counts")
canvas = FigureCanvasAgg(fig)
logging.getLogger().info("XRFSpectrum: Rendering spectrum to PNG file : %s", \
self.spectrum_info["jpegScanFileFullPath"])
canvas.print_figure(self.spectrum_info["jpegScanFileFullPath"],
dpi=80)
#logging.getLogger().debug("Copying .fit file to: %s", a_dir)
#tmpname=filename.split(".")
#logging.getLogger().debug("finished %r", self.spectrum_info)
self.store_xrf_spectrum()
self.emit('xrfSpectrumFinished',
(mca_data, self.mca_calib, mca_config))
def satellite_plot(request, id=0, width=800, type='stdmag'):
satellite = Satellites.objects.get(id=id)
if satellite.catalogue == 2:
assert_permission(request, 'fweb.access_satellites_all')
x = []
y = []
f = []
if type == 'period':
tracks = satellite.satellitetracks_set.all()
for t in tracks:
if t.variability == 2:
x.append(t.satelliterecords_set.all()[0].time)
y.append(t.variability_period)
else:
records = satellite.satelliterecords_set.all()
for r in records:
if type == 'phase_stdmag':
if r.penumbra:
continue
x.append(r.phase)
else:
x.append(r.time)
if type == 'stdmag' or type == 'phase_stdmag':
y.append(r.stdmag)
elif type == 'mag':
y.append(r.mag)
elif type == 'distance':
y.append(r.distance)
elif type == 'phase':
y.append(r.phase)
else:
y.append(0)
color = favor2_filters[
r.filter_id] if r.filter_id else favor2_filters[0]
if r.penumbra:
f.append(color + [0.3])
else:
f.append(color + [1.0])
fig = Figure(facecolor='white',
figsize=(width / 72, width * 0.5 / 72),
tight_layout=True)
ax = fig.add_subplot(111)
ax.autoscale()
if type == 'period':
ax.scatter(x, y, c='r', marker='o')
else:
ax.scatter(x, y, c=f, marker='.', edgecolors=f, s=1)
if type == 'phase_stdmag':
ax.xaxis.set_major_formatter(ScalarFormatter(useOffset=False))
ax.set_xlabel("Phase angle, degrees")
else:
ax.xaxis.set_major_formatter(DateFormatter('%Y.%m.%d'))
ax.set_xlabel("Time, UT")
ax.yaxis.set_major_formatter(ScalarFormatter(useOffset=False))
if type == 'stdmag' or type == 'phase_stdmag':
ax.set_ylabel("Standard Magnitude")
ax.invert_yaxis()
elif type == 'mag':
ax.set_ylabel("Apparent Magnitude")
ax.invert_yaxis()
elif type == 'distance':
ax.set_ylabel("Distance, km")
elif type == 'phase':
ax.set_ylabel("Phase angle, degrees")
elif type == 'period':
ax.set_ylabel("Light curve period, s")
fig.autofmt_xdate()
# 10% margins on both axes
ax.margins(0.1, 0.1)
ax.set_title("%s %d / %s" % (satellite_catalogue(
satellite.catalogue), satellite.catalogue_id, satellite.name))
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def visualize_object(x,
y,
z,
transformation,
obj='stick',
ax=None,
fix_axes=True,
plot_origin=False,
plot_axis=False,
no_plot=False):
if obj == 'cube':
obj = CUBE
elif obj == 'stick':
obj = STICK
else:
raise Exception('No such object: Use either "stick" or "cube".')
line_width = 6. if ax == None else 2.
if ax == None:
fig = plt.figure()
canvas = FigureCanvas(fig)
ax = fig.add_subplot(111,
projection='3d',
aspect='equal',
proj_type='ortho')
else:
fig = ax.figure
canvas = FigureCanvas(fig)
axis = transformation[:-1]
axis /= np.linalg.norm(axis)
quaternion = Quaternion(*axis, transformation[-1])
rot_obj = []
for i, p in enumerate(obj):
new_point = quaternion.rotate(p)
new_point += [x, y, z]
rot_obj.append(new_point)
rot_obj = np.array(rot_obj)
for (fx, fy, fz), (tx, ty, tz) in zip(rot_obj[:-1], rot_obj[1:]):
ax.plot([fx, tx], [fy, ty], [fz, tz], linewidth=line_width)
ax.axis('off')
if fix_axes:
ax.set_xlim((-1.6, 1.6))
ax.set_ylim((-1.6, 1.6))
ax.set_zlim((-1.6, 1.6))
if plot_origin:
ax.scatter([0.], [0.], [0.], c='b', marker=',')
if plot_axis:
ax.quiver([0], [0], [0], [axis[0]], [axis[1]], [axis[2]])
canvas.draw()
s, (width, height) = canvas.print_to_buffer()
im = np.fromstring(s, np.uint8).reshape(height, width, 4)
min_col = np.min(np.where((im[:, :, 3] != 0.).any(axis=0)))
max_col = np.max(np.where((im[:, :, 3] != 0.).any(axis=0)))
min_row = np.min(np.where((im[:, :, 3] != 0.).any(axis=1)))
max_row = np.max(np.where((im[:, :, 3] != 0.).any(axis=1)))
im = im[min_row:max_row, min_col:max_col]
im = cv2.resize(im,
tuple((np.array(im.shape)[[1, 0]] * 0.3).astype(np.int32)))
if no_plot:
plt.close()
return im
def print_figure(fig, *args, **kwargs):
canvas = FigureCanvasAgg(fig)
canvas.print_figure(*args, **kwargs)
def htmlReport(S,repFmt,headline,afterHead='',figures=[],dialect=None,figFmt=None,svgEmbed=False,show=False):
'''
Generate (X)HTML report for simulation.
:param S: :obj:`Scene` object; must contain :obj:`Scene.pre`
:param repFmt: format for the output file; will be expanded using :obj:`Scene.tags`; it should end with `.html` or `.xhtml`.
:param headline: title of the report, used as HTML title and the first ``<h1>`` heading.
:param afterHead: contents (XHTML fragment) to be added verbatim after the header (title, woo config table, preprocessor parameters)
:param figs: figures included in the report; they are either embedded (SVG, optionally ) or saved to files in the same directory as the report, using its name as prefix, and referenced via relative links from the XHTML. Figures are given as list of 2- or 3-tuples, where each item contains:
1. name of the figure (will generate a ``<h2>`` heading)
2. figure object (`Matplotlib <http://matplotlib.org>`__ figure object)
3. optionally, format to save the figure to (`svg`, `png`, ...)
:param figFmt: format of figures, if the format is not specified by the figure itself; if None, choose format appropriate for given dialect (png for html4, svg for html5 and xhtml)
:param dialect: one of "xhtml", "html5", "html4"; if not given (*None*), selected from file suffix (``.html`` for ``html4``, ``.xhtml`` for ``xhtml``). ``html4`` will save figures as PNG (even if something else is specified) so that the resulting file is easily importable into LibreOffice (which does not import HTML with SVG correctly now).
:param svgEmbed: don't save SVG as separate files, embed them in the report instead.
:param show: open the report in browser via the webbrowser module, unless running in batch.
:return: (filename of the report, list of external figures)
'''
import codecs, re, os.path
import woo,woo.batch
dialects=set(['html5','html4','xhtml'])
if not dialect:
if repFmt.endswith('.xhtml'): dialect='xhtml'
elif repFmt.endswith('.html'): dialect='html4'
else: raise ValueError("Unable to guess dialect (not given) from *repFmt* '%s' (not ending in .xhtml or .html)")
if dialect not in dialects: raise ValueError("Unknown dialect '%s': must be one of "+', '.join(dialects)+'.')
if figFmt==None: figFmt={'html5':'png','html4':'png','xhtml':'svg'}[dialect]
if dialect in ('html5',) and svgEmbed and figFmt=='svg':
svgEmbed=False
warnings.warn("Dialect '%s' does not support embedded SVG -- will not be embedded."%dialect)
if dialect in ('html4',) and not figFmt=='png':
warnings.warn("Dialect '%s' will save images as 'png', not '%s'"%(dialect,figFmt))
figFmt='png'
repName=unicode(repFmt).format(S=S,**(dict(S.tags)))
rep=codecs.open(repName,'w','utf-8','replace')
print 'Writing report to file://'+os.path.abspath(repName)
repBase=re.sub('\.x?html$','',repName)
s=htmlReportHead(S,headline,dialect=dialect,repBase=repBase)
s+=afterHead
if figures: s+='<h2>Figures</h2>\n'
extFiles=[]
from matplotlib.backends.backend_agg import FigureCanvasAgg
for ith,figspec in enumerate(figures):
if len(figspec)==2: figspec=(figspec[0],figspec[1],figFmt)
figName,figObj,figSuffix=figspec
if not figName: figName='Figure %i'%(ith+1)
s+='<h3>'+figName+'</h3>'
canvas=FigureCanvasAgg(figObj)
if figSuffix=='svg' and svgEmbed:
figFile=woo.master.tmpFilename()+'.'+figSuffix
figObj.savefig(figFile)
s+=svgFileFragment(figFile)
else:
figFile=repBase+'.'+re.sub('[^a-zA-Z0-9_-]','_',figName)+'.'+figSuffix
figObj.savefig(figFile)
s+='<img src="%s" alt="%s"/>'%(os.path.basename(figFile),figName)
extFiles.append(os.path.abspath(figFile))
s+='</body></html>'
rep.write(s)
rep.close() # flushed write buffers
# attempt conversion to ODT, not under Windows
if False and sys.platform!='win32':
# TODO TODO TODO: have timeout on the abiword call; some versions stall forever
def convertToOdt(html,odt):
try:
import subprocess
# may raise OSError if the executable is not found
out=subprocess.check_output(['abiword','--to=ODT','--to-name='+odt,html])
print 'Report converted to ODT via Abiword: file://'+os.path.abspath(odt)
except subprocess.CalledProcessError as e:
print 'Report conversion to ODT failed (error when running Abiword), returning %d; the output was: %s.'%(e.returncode,e.output)
except:
print 'Report conversion to ODT not done (Abiword not installed?).'
# if this is run in the background, main process may finish before that thread, leading potentially to some error messages??
import threading
threading.Thread(target=convertToOdt,args=(repName,repBase+'.odt')).start()
if show and not woo.batch.inBatch():
import webbrowser
webbrowser.open('file://'+os.path.abspath(repName))
return repName,extFiles
def postsubmit(request):
if request.method == 'POST':
df2 = request.POST['loicfile']
df = pd.read_csv(str(df2), header=None)
start = timeit.default_timer()
y1 = df.iloc[0:100, 4].values
y1 = np.where(y1 == 'Iris-setosa', -1, 1)
x = df.iloc[0:100, [0, 2]].values
pn = Perceptron(0.1, 10)
pn.fit(x, y1)
predictions = pn.predict(x)
print(pn.score(x, y1))
def plot_decision_regions(x, y1, classifier, resolution=0.02):
markers = ('s', 'x', 'o', '^', 'v')
colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
cmap = ListedColormap(colors[:len(np.unique(y1))])
x1_min, x1_max = x[:, 0].min() - 1, x[:, 0].max() + 1
x2_min, x2_max = x[:, 1].min() - 1, x[:, 1].max() + 1
xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),
np.arange(x2_min, x2_max, resolution))
Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
Z = Z.reshape(xx1.shape)
plt.contourf(xx1, xx2, Z, alpha=0.4, cmap=cmap)
plt.xlim(xx1.min(), xx1.max())
plt.ylim(xx2.min(), xx2.max())
for idx, cl in enumerate(np.unique(y1)):
plt.scatter(x=x[y1 == cl, 0],
y=x[y1 == cl, 1],
alpha=0.8,
c=cmap(idx),
marker=markers[idx],
label=cl)
plot_decision_regions(x, y1, classifier=pn)
plt.xlabel('sepal length')
plt.ylabel('petal length')
stop = timeit.default_timer()
print("CPU Utilization: ")
print(str(psutil.cpu_percent()))
process = psutil.Process(os.getpid())
mem = process.memory_percent()
print("Memory Utilization for this process: ")
print(mem)
print("Running time: ")
print(stop - start)
s0 = "sepal-length"
n = '\n'
sd = psutil.cpu_percent()
s1 = "CPU Utilization: "
s2 = str(sd)
s3 = "Memory Utilization: "
s4 = str(mem)
s5 = "Running time: "
s6 = str(stop - start)
s = s1 + s2 + n + s3 + s4 + "," + s5 + s6
plt.title(s)
#plt.figure(figsize=(20, 10))
canvas = FigureCanvas(plt.figure(1))
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def prepare_args_multiprocessing(cubes,
last_day_idx=None,
regions=REGIONS,
bounds=BOUNDS,
figh=FIGH):
"""Initiate data for multiprocessing
Initiate all data such that plotting jobs using :func:`plot_all_days` can
be performed parallel, where each job corresponds to a certain region
(e.g. EUROPE) and parameter (e.g. od550aer).
Loops over all cubes found in :param:`cubes` (e.g. N=5) and over all
regions in dictionary :param:`regions` (e.g. M=10) and crops cube
correspondingly within defined lon / lat region and between first and last
day (defined using :param:`last_day_idx`). That makes a list of length
MxN containing the prepared cubes for each species and region. Further,
corresponding lists of all other required input parameters for
:func:`plot_all_days` are created for each of the cropped cubes, that is,
lists of length MxN of matplotlib figure instances, longitude range,
latitude range, lower and upper range of colorbar and the corresponding ID
of the region).
In order to prepared the input
Parameters
----------
cubes : iris.cube.CubeList
list containing cubes of different species
last_day_idx : :obj:`int`, optional
index of last day that is supposed to be plotted
regions : dict
dictionary specifying region IDs (keys) and corresponding lon / lat
ranges
bounds : dict
dictionary specifying min / max ranges (values) for plotting of
different species (keys). The latter must correspond to the species
IDs as defined in the :attr:`var_name` of the different
:class:`iris.cube.Cube` instances in :param:`cubes`.
Returns
-------
tuple
7-element tuple, containing the following lists of length MxN
- list: cropped cubes for each species (n (m $$\in{N}$$)) and\
region (m $$\in{M}$$)
- list: corresponding Figure instances for plotting
- list: corresponding longitude ranges (tuple containing min / max)
- list: corresponding latitude ranges (tuple containing min / max)
- list: lower value for color-range (depends on species)
- list: upper value for color-range (depends on species)
- list: string ID of corresponding region
"""
args = []
if last_day_idx is None:
last_day_idx = cubes[0].coord("time").points[-1]
for cube in cubes:
print(cube.var_name)
for region, val in regions.items():
print(region)
lon_range, lat_range = val
t0 = time()
dat = funs.crop_cube_lonlat(cube, lon_range, lat_range)
dat = dat[:last_day_idx]
print("Elapsed time crop: %.4f" % (time() - t0))
wfac = dat.coord("longitude").shape[0] / dat.coord(
"latitude").shape[0]
figw = figh * wfac + 2
t0 = time()
fig = Figure(figsize=(figw, figh), dpi=100)
# create canvas to draw onto
FigureCanvasAgg(fig)
print("Elapsed time figure: %.4f" % (time() - t0))
vmin, vmax = bounds[cube.var_name]
args.append((dat, fig, lon_range, lat_range, float(vmin),
float(vmax), region))
return tuple(args)
def fig_to_png(fig):
""" Converts a matplotlib figure to a png (byte stream). """
canvas = FigureCanvas(fig)
output = io.BytesIO()
canvas.print_png(output)
return output
"""
使用matploamlib进行数据绘图
"""
from matplotlib.figure import Figure
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
# matplotlib命令与格式包括：画布和图像 Figure and Axis
# 创建自定义图像
# figure(num=None,figsize=None,dpi=None,facecolor=None,edgecolor=None,edgecolor=None,frameON=tRUE)
# NUM:图像编号或名称，数字为编号，字符串为名称
# figsize:指定figure的宽和高，单位为英寸
# dpi参数指定绘图对象的分辨率，即每英寸多少个像素，缺省值为80
# facecolor 背景颜色
# edgecolor 边框颜色
# frameon 是否显示边框
fig = Figure()
# 获得绘图对象
canvas = FigureCanvas(fig)
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
line, = ax.plot([0, 2], [0, 2])
# 图表标题
ax.set_title("a straight line ")
# x和 y 轴的标签
ax.set_xlabel("x label")
ax.set_ylabel("y label")
# 指定位置绘制图片
canvas.print_figure('./语法基础/res/image/chatpic1.jpg')
def saveGraph(self):
"""Saves the data as a picture,
after creating it"""
colors = []
'Creates the color array'
for i in range(len(self.datasets)):
colors.append([])
for j in range(0, len(self.diskServers)):
'Checks if there will be a divide by 0 error'
if not self.accessesInDataset[i] == 0:
'''Divides the accesses by the number in its dataset,
to get the amount'''
amount = float(self.accesses[i][j]) / float(
self.accessesInDataset[i])
else:
'else sets the amount to 0'
amount = 0
if self.noOfFiles[i][j] == 0 and not (i == 0 and j == 0):
'''If the noOfFiles is 0, uses green as the color,
due to the colors not diplaying if all rgb values.
The green color cannot be the first in the array,
as this also causes an error'''
colors[i].append('g')
else:
if not amount == 0:
'Calculates a log value for the amount'
amount = (math.log10(amount) / 4) + 1
colors[i].append([1.0, 1.0 - amount, 1.0 - amount])
my_dpi = 100
'''Create the size of the image.
This is for ffmpeg (see animation.py) as it requires images
with even heights and widths.
As the backend is being used directly,
a figure and a canvas is needed'''
fig = Figure(figsize=(8, 6), dpi=my_dpi)
canvas = FigureCanvas(fig)
'matplotlib requires numpy arrays'
data_array = np.array(self.noOfFiles)
colors = np.array(colors)
'Add a 3d subplot to the image'
ax = fig.add_subplot(111, projection='3d')
for i in range(len(self.diskServers)):
'Gets rid of the start and end, so they will fit on the graph'
self.diskServers[i] = self.diskServers[i].replace('gdss', '')
self.diskServers[i] = self.diskServers[i].replace(
'.gridpp.rl.ac.uk', '')
'Sets the number of ticks on the x axis, the their names'
ax.set_xticks(range(len(self.diskServers)))
ax.set_xticklabels(self.diskServers, fontsize=6, rotation='vertical')
'Adds the date to the graph'
ax.text2D(0.05,
0.95,
"Date: " + str(date.today()) + ' ' +
str(datetime.now().hour) + ':00',
transform=ax.transAxes)
'Set the axes labels'
ax.set_xlabel('Disk server')
ax.set_ylabel('Datasets')
ax.set_zlabel('Count')
'Create two arrays for the x and y positions of the bar'
xpos, ypos = np.meshgrid(np.arange(data_array.shape[1]),
np.arange(data_array.shape[0]))
'matplotlib also requires flattened arrays'
xpos = xpos.flatten()
ypos = ypos.flatten()
colors = colors.flatten()
dz = data_array.flatten()
zpos = np.zeros(len(dz))
'set the bar width and height to 0.2'
dx = 0.2 * np.ones_like(zpos)
dy = dx.copy()
'create the histogram'
ax.bar3d(xpos, ypos, zpos, dx, dy, dz, colors)
'create a color map for the sidebar'
cdict2 = {
'red': ((0.0, 1.0, 1.0), (1.0, 1.0, 1.0)),
'green': ((0.0, 1.0, 1.0), (1.0, 0.0, 0.0)),
'blue': ((0.0, 1.0, 1.0), (1.0, 0.0, 0.0))
}
red2 = LinearSegmentedColormap('Red2', cdict2)
'Register the colormap'
plt.register_cmap(cmap=red2)
norm = mpl.colors.Normalize(vmin=0, vmax=100)
'Get the colormap back again'
cmap = plt.get_cmap('Red2')
'Create some axes for the sidebar'
cax = fig.add_axes([0.905, 0.2, 0.02, 0.6])
'Create the colorbar'
cb = mpl.colorbar.ColorbarBase(cax,
cmap=cmap,
norm=norm,
spacing='proportional')
cb.set_label('% of accesses to diskserver in dataset')
'Set where the ticks are'
cb.set_ticks([0, 25, 50, 75, 100])
'Set the ticks on the colorbar'
cb.set_ticklabels(['0', '0.1', '1', '10', '100'])
'Update what the ticks show'
cb.update_ticks()
'Save the image'
canvas.print_figure('images/graph_%s_%02d.png' %
(str(date.today()), datetime.now().hour),
bbox_inches='tight')
'''This close the picture.
Needed so the program does not use all the computers memory'''
fig.clf()
plt.close()
def graph1():
# 【AWS IAM関連情報】
# IAMユーザーに割り当てたポリシー
# AmazonDynamoDBFullAccess
# AWSLambdaDynamoDBExecutionRole
# profile名
# 環境編巣にAWS_DEFAULT_PROFILE, AWS_PROFILEとして定義した。
dynamodb = boto3.resource("dynamodb")
# TODO 2回DBにアクセスする理由はないので後で修正する
# 1日前の時間表記(yyyyMMddhhmmss)を取得する
yesterday = (datetime.now(timezone(timedelta(hours=+9), 'JST')) -
timedelta(days=1)).strftime('%Y%m%d%H%M%S')
# 1日前までのデータをDynamoDBより取得する
entries = Entry.scan(Entry.MeasureDateTime >= yesterday)
entries = sorted(entries, key=lambda x: x.MeasureDateTime)
df = pd.DataFrame(columns=["人数"])
for entry in entries:
df.loc[entry.MeasureDateTime] = entry.value
#table = dynamodb.Table(os.environ['table_name'])
#response = table.scan()
#df = pd.json_normalize(response["Items"])
# YYYYMMDDHHMMSS形式を日付として認識させる
df.index = pd.to_datetime(df.index)
#df.MeasureDateTime = pd.to_datetime(df.MeasureDateTime)
# data["value"]はDecimalで入っているが。
# Decimalは直接表示できないので、floatに変換
df = df.astype({"人数": float})
#df = df.astype({"value": float})
# 日付でソートする。戻り値を受け取らないとソートされないので注意
#df = df.sort_values(by='MeasureDateTime')
fig, ax = plt.subplots()
# x軸の目盛りは1時間ごとにする（set_major_locatorで目盛りを打つ場所を決める）
ax.xaxis.set_major_locator(mdates.HourLocator(interval=4))
# x軸の目盛りの表示形式を設定する（set_major_formatterで目盛りに書く内容を決める）
ax.xaxis.set_major_formatter(mdates.DateFormatter('%m/%d\n%H:%M'))
# 補助目盛線を付加する
ax.xaxis.set_minor_locator(mdates.HourLocator())
plt.plot(df.index, df["人数"])
#plt.plot(df.MeasureDateTime, df.value)
# ax.plot(df.MeasureDateTime, df.value)というのもある
plt.title('時間と人数の推移')
# plt.xlabel('X軸ラベル')
# plt.ylabel('人数')
plt.ylabel("人数", rotation=0, labelpad=20)
# 縦書きにする場合
# ax.set_ylabel("人\n数", rotation=0, va='center')
plt.grid()
# 補助目盛は点線にする
plt.grid(True, which="minor", linestyle="--")
# 主目盛は実線
# plt.grid(True, which="major", linestyle="-")
canvas = FigureCanvasAgg(fig)
png_output = BytesIO()
canvas.print_png(png_output)
data = png_output.getvalue()
response = make_response(data)
response.headers['Content-Type'] = 'image/png'
response.headers['Content-Length'] = len(data)
return response
def plot_day_logspacing(cube,
fig,
day_idx=0,
lon_range=(-180, 180),
lat_range=(-90, 90),
vmin=None,
vmax=None,
cmap_id=CMAP):
"""Plot variable on map using pcolormesh
Parameters
----------
cube : iris.cube.Cube
cube containing data. Note that the input cube must correspond 2D cube
containing data from one time stamp (i.e. ndim=2).
day_idx : int
index of timestamp that is to be plotted
lon_range : tuple
tuple specifying plotted longitude range
lat_range : tuple
tuple specifying plotted latitude range
vmin : float
lower limit for AOD display
vmax : float
upper limit for AOD display
cmap_id : str
string ID of matplotlib colormap supposed to be used
"""
if fig.canvas is None:
FigureCanvasAgg(fig)
if cube.ndim != 3:
msg = ("Invalid dimension %d of input cube, need ndim=2 (i.e. data "
"corresponding to one timestamp" % cube.ndim)
raise ValueError(msg)
dat = cube[day_idx]
geo_ax = fig.add_axes([0.1, .1, .8, .8], projection=ccrs.PlateCarree())
ax_cbar = fig.add_axes([0.85, .1, .02, .8])
lvls = funs.init_cmap_levels(vmin, vmax)
cmap = get_cmap(cmap_id)
norm = BoundaryNorm(lvls, ncolors=cmap.N, clip=True)
lons, lats = dat.coord("longitude").points, dat.coord("latitude").points
X, Y = np.meshgrid(lons, lats)
mesh = geo_ax.pcolormesh(X, Y, dat.data, cmap=cmap,
norm=norm) #, figure=fig)
#mesh = iplt.pcolormesh(cube,cmap=cmap, norm=norm, figure=fig)
geo_ax.coastlines(color=COASTLINE_COLOR)
#things that do not need to be done when day is updated
ticks = funs.get_cmap_ticks(lvls)
# =============================================================================
# try:
# ax_cbar = fig.axes[1]
# [x.remove for x in ax_cbar.artists]
# =============================================================================
cbar = fig.colorbar(mesh, norm=norm, boundaries=lvls, cax=ax_cbar)
# =============================================================================
# except:
# cbar = fig.colorbar(mesh, norm=norm, boundaries=lvls)
# =============================================================================
# Set some suitable fixed "logarithmic" colourbar tick positions.
cbar.set_ticks(ticks)
cbar.set_label(funs.var_str(dat))
# Modify the tick labels so that the centre one shows "+/-<minumum-level>".
#tick_levels[3] = r'$\pm${:g}'.format(minimum_log_level)
cbar.set_ticklabels(["%.3f" % x for x in ticks])
geo_ax.set_xlim([lon_range[0], lon_range[1]])
geo_ax.set_ylim([lat_range[0], lat_range[1]])
geo_ax.set_xticks(np.linspace(lon_range[0], lon_range[1], 7),
crs=ccrs.PlateCarree())
geo_ax.set_yticks(np.linspace(lat_range[0], lat_range[1], 7),
crs=ccrs.PlateCarree())
lon_formatter = LongitudeFormatter(number_format='.1f',
degree_symbol='',
dateline_direction_label=True)
lat_formatter = LatitudeFormatter(number_format='.1f', degree_symbol='')
geo_ax.xaxis.set_major_formatter(lon_formatter)
geo_ax.yaxis.set_major_formatter(lat_formatter)
geo_ax.set_xlabel("Longitude", fontsize=12)
geo_ax.set_ylabel("Latitude", fontsize=12)
# Label the colourbar to show the units.
#bar.set_label('[{}, log scale]'.format(anomaly.units))
tit = ("%s %s mean: %.3f" %
(funs.var_str(dat), funs.daystring(
cube, day_idx), funs.area_weighted_mean(dat)))
geo_ax.set_title(tit)
return fig
