def category_bar_charts():
sns.set(style="whitegrid")
sns.set_context("notebook", font_scale=1.5, rc={"lines.linewidth": 2.5})
f, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 7), sharex=False)
retirement_sums = sorted(retirement_class_sums(), reverse=True)
x = [a[1] for a in retirement_sums]
y = [a[0] for a in retirement_sums]
sns.barplot(x, y, palette="YlOrRd_d", ax=ax1)
ax1.set_ylabel("By Category")
account_type_sums = sorted(account_by_type_sums(), reverse=True)
x = [a[1] for a in account_type_sums]
y = [a[0] for a in account_type_sums]
sns.barplot(x, y, palette="BuGn_d", ax=ax2)
ax2.set_ylabel("By Category")
account_owner_sums = sorted(account_by_owner_sums(), reverse=True)
x = [a[1] for a in account_owner_sums]
y = [a[0] for a in account_owner_sums]
sns.barplot(x, y, palette="Blues_d", ax=ax3)
ax3.set_ylabel("By Owner")
sns.despine(left=True)
f.tight_layout()
canvas = FigureCanvas(plt.gcf())
png_output = io.BytesIO()
canvas.print_png(png_output)
response=make_response(png_output.getvalue())
response.headers['Content-Type'] = 'image/png'
return response
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
fig = Figure(figsize=(5, 5), dpi=80)
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 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 end_use(request):
N=12
ind = np.arange(N) # the x locations for the groups
width=0.35
fig=Figure(figsize=(9,5),facecolor='w', edgecolor='w')
ax=fig.add_subplot(221)
actual=[9,9,6,3,1,0,0,0,1,2,6,9]
ax.bar(ind,actual,0.35,alpha=1,color='b')
ax.set_xticks(ind+width)
ax.set_xticklabels(('E','F','M','A','M','J','J','A','S','O','N','D'))
ax=fig.add_subplot(222)
actual=[0,0,0,0,2,3,6,6,3,2,1,0]
ax.bar(ind,actual,0.35,alpha=1,color='r')
ax.set_xticks(ind+width)
ax.set_xticklabels(('E','F','M','A','M','J','J','A','S','O','N','D'))
ax=fig.add_subplot(223)
actual=[4,4,5,5,6,6,7,6,5,4,4,4]
ax.bar(ind,actual,0.35,alpha=1,color='y')
ax.set_xticks(ind+width)
ax.set_xticklabels(('E','F','M','A','M','J','J','A','S','O','N','D'))
ax=fig.add_subplot(224)
actual=[2,3,2,3,3,3,3,3,2,3,2,2]
ax.bar(ind,actual,0.35,alpha=1,color='m')
ax.set_xticks(ind+width)
ax.set_xticklabels(('E','F','M','A','M','J','J','A','S','O','N','D'))
canvas=FigureCanvas(fig)
response=HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
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 konto_graph(request, year, konto_id):
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
# Collect data
konto = Konto.objects.get(pk = konto_id)
innslags = konto.innslag.order_by('bilag__dato').filter(bilag__dato__year = year)
# make plot
fig=Figure()
fig.suptitle(u"%s (År:%s)"% (konto, unicode(year)))
ax=fig.add_subplot(111)
x=[]
y=[]
sum = Decimal(0)
for innslag in innslags:
x.append(innslag.bilag.dato)
y.append(sum)
x.append(innslag.bilag.dato)
sum += innslag.value
y.append(sum)
ax.plot_date(x, y, '-')
if x: # if there is transactions on the konto in the period
# fill the period from the end of the year with a red line
ax.plot_date([x[-1],date(int(year),12,31)],[y[-1],y[-1]],"r")
if x[0].day != 1 or x[0].month != 1:
ax.plot_date([date(int(year),1,1),x[0]],[0,0],"r")
else:
ax.plot_date([date(int(year),1,1),date(int(year),12,31)],[0,0],"r")
ax.xaxis.set_major_formatter(DateFormatter('%b'))
fig.autofmt_xdate()
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def hist(request, sym):
"""create a histogram plot"""
data = Data(syms=[sym], start=start)
r = data.panel.r.copy()
r = r.dropna()
fig, axes = plt.subplots(nrows=2, ncols=3, figsize=(12, 7))
ax = axes[0,0]
ax.hist(r[sym].values, bins=30)
r.plot(kind="kde", ax=ax,grid=True)
r.boxplot(ax=axes[0,1],grid=True)
r.plot(kind="kde", ax=axes[1,0],grid=True)
sm.qqplot(r[sym], line='r', fit=True, ax=axes[1,1])
r['mean'] = pandas.rolling_mean(r[sym], 12)
r['std'] = pandas.rolling_std(r[sym], 12)
r['cum_ret'] = r[sym].cumsum()
r[['mean', 'std']].plot(ax=axes[0,2], grid=True, rot=45)
r[['cum_ret']].plot(ax=axes[1,2], grid=True, rot=45)
fig.tight_layout()
fig.set_facecolor((1,.8,.6,0))
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def clicks_chart(request, pk):
# TODO: Add a stats page for each link where you can see the traffic for that link for the last 30 days in a line chart.
# FIXME: Add error checking if 0 clicks
thirty_days_ago = timezone.now() - timedelta(days=30)
clicks = Click.objects.filter(bookmark_id=pk).filter(
timestamp__gte=thirty_days_ago) # .annotate(count_recent=Count('click'))
df = pd.DataFrame(model_to_dict(click) for click in clicks)
df['count'] = 1
df.index = df['timestamp']
counts = df['count']
counts = counts.sort_index()
series = pd.expanding_count(counts).resample('D', how=np.max,
fill_method='pad')
response = HttpResponse(content_type='image/png')
fig = plt.figure()
# ax = fig.add_subplot(111)
# ax.plot(series)
series.plot()
plt.title("Total clicks over past 30 days")
plt.xlabel("")
plt.xlim(thirty_days_ago, timezone.now())
canvas = FigureCanvas(fig)
# ax = fig.add_subplot(1, 1, 1, axisbg='red')
# ax.plot(series)
canvas.print_png(response)
return response
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 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_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 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 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 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 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 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 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 show_temperature_graph(response, siteLocation=None):
import random
import os
import tempfile
os.environ['MPLCONFIGDIR'] = tempfile.mkdtemp()
import django
import datetime
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)
response=django.http.HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def serve_matplotlib_fig(fig):
canvas = FigureCanvas(fig)
png_output = BytesIO()
canvas.print_png(png_output)
response = make_response(png_output.getvalue())
response.headers['Content-Type'] = 'image/png'
return response
def get(self, req, *args, **kwargs):
json = 'application/json' in req.META.get('HTTP_ACCEPT')
if not json and not Figure:
raise Http404("Can't generate image")
context = self.get_context_data(**kwargs)
data = self.data_from_context(context)
if json:
# convert to list of lists
data[:,0] = num2epoch(data[:,0])
data[:,0] *= 1000 # to ms
ret = [None]*data.shape[0]
for i in range(data.shape[0]):
ret[i] = list(data[i,:])
return JsonResponse({'data':ret})
tz = get_current_timezone()
fig = Figure(dpi=96, figsize=(4,3))
ax = fig.add_subplot(111)
ax.plot_date(data[:,0], data[:,1])
ax.set(**self.set_axis)
ax.xaxis.set_major_formatter(DateFormatter('%H:%M:%S', tz=tz))
fig.autofmt_xdate()
canva = FigureCanvas(fig)
resp = HttpResponse(content_type='image/png')
canva.print_png(resp)
return resp
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 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 chart_timeseries(request, data):
"""Draws a timeseries chart
data=array of dictionaries, each dictionary must contain keys: time, value
"""
fig = Figure()
ax = fig.add_subplot(111)
x = []
y = []
#now = datetime.datetime.now()
#delta = datetime.timedelta(days=1)
for row in data:
x.append(row['time'])
y.append(row['value'])
ax.plot_date(x, y, '-')
ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
fig.autofmt_xdate()
ax.grid(True)
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
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 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 ScatterPlotData(request, GeneticDataRecords, GeneticAttributeNameA, GeneticAttributeNameB, ClusterCutOff, PlotXLabel, PlotYLabel, PlotTitle):
"""
This plotting option is for creating a scatter plot.
"""
plt.xlabel(PlotXLabel)
plt.ylabel(PlotYLabel)
plt.title(PlotTitle)
fig = Figure(figsize=[8,8])
ax = fig.add_subplot(1,1,1)
# A color swtich is added below for any data past the threshold inputted into this method.
for GeneticAttributeEntry in GeneticDataRecords:
if (float(getattr(GeneticAttributeEntry, GeneticAttributeNameA)) < float(ClusterCutOff)):
ax.scatter(float(getattr(GeneticAttributeEntry, GeneticAttributeNameA)),float(getattr(GeneticAttributeEntry, GeneticAttributeNameB)),c="blue")
else:
ax.scatter(float(getattr(GeneticAttributeEntry, GeneticAttributeNameA)),float(getattr(GeneticAttributeEntry, GeneticAttributeNameB)),c="red")
canvas = FigureCanvasAgg(fig)
ax.set_xlabel(PlotXLabel)
ax.set_ylabel(PlotYLabel)
ax.set_title(PlotTitle)
# write image data to a string buffer and get the PNG image bytes
buf = cStringIO.StringIO()
canvas.print_png(buf)
data = buf.getvalue()
img = Image.open(StringIO.StringIO(data))
response = HttpResponse(mimetype="image/png")
img.save(response, 'PNG')
return (response)
def PlotData(request, GeneticDataRecords, GeneticAttributeName, PlotXLabel, PlotYLabel, PlotTitle):
"""
This is the standard genetic module plotting option and a histogram is created. The plot is written to
a string buffer and later rendered as a png image which is returned in a html response. The image is not
needed to be saved as a file in the hard disk each time it is created.
"""
AttributeGroupGeneticDataRecords = []
for RecordEntry in GeneticDataRecords:
AttributeGroupGeneticDataRecords.append(float(getattr(RecordEntry, GeneticAttributeName)))
plt.xlabel(PlotXLabel)
plt.ylabel(PlotYLabel)
plt.title(PlotTitle)
fig = Figure(figsize=[8,8])
ax = fig.add_subplot(1,1,1)
ax.hist(AttributeGroupGeneticDataRecords, 23, normed=1, facecolor='green', alpha=0.75)
canvas = FigureCanvasAgg(fig)
ax.set_xlabel(PlotXLabel)
ax.set_ylabel(PlotYLabel)
ax.set_title(PlotTitle)
# write image data to a string buffer and get the PNG image bytes
buf = cStringIO.StringIO()
canvas.print_png(buf)
data = buf.getvalue()
img = Image.open(StringIO.StringIO(data))
response = HttpResponse(mimetype="image/png")
img.save(response, 'PNG')
return (response)
def searchstringPieChart(request):
page_title='Search String Pie Chart'
year=stat.getYear()
searchList = list(SearchTerm.objects.values_list('q', flat=True))
search_string = ' '.join(searchList)
result = Counter(search_string.split()).most_common(10)
searchDict = {}
for key,val in result:
searchDict[key] = val
fig=Figure()
ax=fig.add_subplot(111)
title='Top Ten search string submitted by user ({0})'.format(year)
fig.suptitle(title, fontsize=14)
try:
x = searchDict.values()
labels = searchDict.keys()
ax.pie(x, labels=labels);
except ValueError:
pass
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def displayrankedItemwithBidsPieChart(request):
page_title='Pie Chart on Ranked Item'
year=stat.getYear()
itemBidDict, bidtotalSum = stat.createItemIDBidCountDict()
top_ten_dict = stat.sortedItemDictionary(itemBidDict)
itemobjDict = {}
for key,value in top_ten_dict:
itemObj = get_object_or_404(Item, pk=key)
itemobjDict[itemObj.name] = value
fig=Figure()
ax=fig.add_subplot(111)
title='Top Ten ranked items with the highest bids ({0})'.format(year)
fig.suptitle(title, fontsize=14)
try:
x = itemobjDict.values()
labels = itemobjDict.keys()
ax.pie(x, labels=labels);
except ValueError:
pass
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def plot_hum():
lock.acquire(True)
dates, temps, hums = getHistData()
ys = hums
fig = Figure()
axes = fig.add_subplot(1, 1, 1)
axes.set_title("Humidity Rel. [%]")
axes.set_xlabel("Samples: " + str(numSamples()))
axes.set_ylim([1, 100])
axes.grid(True)
xs = range(numSamples())
axes.plot(xs, ys)
canvas = FigureCanvas(fig)
output = io.BytesIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
lock.release()
return response
def coefficient_spectrum_png(cannon, term, lambda_min, lambda_max):
path_json = os_path.join(args.path, cannon)
path_cannon = re.sub(".full.json.gz", ".cannon", path_json)
y = pickle.load(file=open(path_cannon, "rb"))
fig = Figure(figsize=(16, 6))
ax = fig.add_subplot(111)
ax.set_xlabel('Wavelength / A')
ax.set_ylabel('Value')
ax.set_xlim([float(lambda_min), float(lambda_max)])
ax.grid(True)
ax.plot(y['dispersion'], y['theta'][:, int(term)])
canvas = FigureCanvas(fig)
png_output = io.BytesIO()
canvas.print_png(png_output)
response = make_response(png_output.getvalue())
response.headers['Content-Type'] = 'image/png'
return response
def index():
dataset =pd.read_csv('Salary_Data.csv') #use the correct data set
x=dataset.iloc[:,:-1].values
y=dataset.iloc[:,1].values
X_train, X_test, Y_train, Y_test=train_test_split(x,y,test_size=1/3,random_state=0)
regressor = LinearRegression()
regressor.fit(X_train,Y_train)
fig = Figure()
axis = fig.add_subplot(1, 1, 1)
axis.scatter(X_train,Y_train,color='red')
axis.plot(X_train,regressor.predict(X_train),color='blue')
axis.set_title('asd')
canvas = FigureCanvas(fig)
output = io.BytesIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def pg2(func): fig = Figure(dpi=120) #figsize=(8, 8) fig.subplots_adjust(left=0.075, bottom=0.05, right=0.95, top=0.97, wspace=0.15, hspace=0.15) ax = fig.add_subplot(1,1,1) xs = np.linspace(-np.pi, np.pi, 100) if func == 'sin': ys = np.sin(xs) elif func == 'cos': ys = np.cos(xs) elif func == 'tan': ys = np.tan(xs) else: ys = xs ax.plot(xs, ys) canvas = FigureCanvasAgg(fig) png_output = BytesIO() canvas.print_png(png_output) img_data = urllib.parse.quote(png_output.getvalue()) return img_data
def plot_graph(func='sin'):
fig = Figure()
ax = fig.add_subplot(111)
xs = np.linspace(-np.pi, np.pi, 100)
if func == 'sin':
ys = np.sin(xs)
elif func == 'cos':
ys = np.cos(xs)
elif func == 'tan':
ys = np.tan(xs)
else:
ys = xs
ax.plot(xs, ys)
canvas = FigureCanvasAgg(fig)
png_output = BytesIO()
canvas.print_png(png_output)
img_data = urllib.parse.quote(png_output.getvalue())
return img_data
def graph_display6(league=None, season=None, teamid=None):
other, df = get_team_foulcommits(league, season, teamid)
teamName = get_team_name(teamid)
#df['foul50T'] = 50.00 - df['FoulT']
#df['foul50O'] = 50.00 - df['FoulO']
labels = df.Opponent.tolist()
x = np.arange(len(labels))
y1 = df.FoulT.tolist()
y2 = df.FoulO.tolist()
plt.close('all')
fig, ax = plt.subplots()
#ax.grid(True)
ax.set_xlim([0, len(labels)])
#ax.bar(x, y1, color='green', label='Opponent', bottom=50.00, alpha=.80)
#ax.bar(x, y2, color='red', label=teamName, bottom=50.00, alpha=.80)
#ax.axhline(y=50.00, color='k',linewidth=1,linestyle='-')
ax.bar(x, y1, color='#d62728', label=teamName)
ax.bar(x, y2, label='Opponent', bottom=y1)
ax.legend()
ax.set_xticks(x, minor=True)
plt.xticks(x, labels)
ax.set_xticklabels(labels, rotation=90)
#plt.xticks(rotation=90)
# for label in ax.xaxis.get_ticklabels():
# label.set_rotation(90)
plt.xlabel('Opponent')
plt.ylabel('Fouls')
plt.title(teamName + ' - Fouls Commited During The Season ' + season)
fig = plt.gcf()
fig.tight_layout()
canvas = FigureCanvas(fig)
output = BytesIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
plt.clf()
return response
def staralt(date=None, observatory='OT'):
"""
Create a basic altitude plot for the indicated date. Location is OT.
Parameters
----------
date : str format YYYY-MM-DD
Observation date.
observatory : str
Observation code, from the locations available at staralt.get_location.
Default OT.
Returns
-------
response : image/png
Altitude plot in png format
"""
from app.staralt import staralt
import pytz
if not date:
# Current date
date = datetime.datetime.now(pytz.UTC).date()
else:
# Convert date str YYYY-MM-DD to datatime.date
date = datetime.datetime.strptime(date, "%Y-%m-%d").date()
# Add UTC timezone to date
date = date.replace(tzinfo=pytz.UTC)
# matplotlib figure
fig = staralt(observatory, date, [])
canvas = FigureCanvas(fig)
output = StringIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def plot_soil():
num_samples = get_count()
times, measurements = get_historical_data(num_samples)
ys = measurements
figure = Figure()
axis = figure.add_subplot(1, 1, 1)
axis.set_title("Soil Moisture [%]")
axis.set_xlabel("Samples")
axis.grid(True)
xs = range(num_samples)
axis.plot(xs, ys)
canvas = FigureCanvas(figure)
output = io.BytesIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def GET(self, jobId, param):
cfg = Configurator().read()
import cStringIO
from matplotlib.figure import Figure
from matplotlib.backends.backend_agg import FigureCanvasAgg
fig = Figure(figsize=[4, 4])
ax = fig.add_axes([.1, .1, .8, .8])
ax.scatter([1, 2], [3, 4])
canvas = FigureCanvasAgg(fig)
# write image data to a string buffer and get the PNG image bytes
buf = cStringIO.StringIO()
canvas.print_png(buf)
data = buf.getvalue()
web.header("Content-Type", "image/png")
web.header("Content-Length", len(data))
return data
def graph(formula_1, lower_end_x, upper_end_x):
x, y = symbols('x y')
formula_1 = sympify(formula_1)
lower_end_x = float(lower_end_x)
upper_end_x = float(upper_end_x)
fig = plt.figure(figsize=(7, 4))
# データ作成
dx = diff(formula_1, x)
dy = diff(formula_1, y)
if ((dx == 0) or (dy == 0)):
X = np.linspace(lower_end_x, upper_end_x, 300)
if ((dx == 0) and (dy == 0)):
Y = lambdify(x, formula_1, "numpy")(lower_end_x) * np.ones(300)
elif (dy == 0):
Y = lambdify(x, formula_1, "numpy")(X)
elif (dx == 0):
Y = lambdify(y, formula_1, "numpy")(X)
ax = fig.add_subplot(111)
ax.plot(X, Y)
else:
s = np.linspace(lower_end_x, upper_end_x, 50)
X, Y = np.meshgrid(s, s)
Z = lambdify((x, y), formula_1, "numpy")(X, Y)
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(X, Y, Z, cmap=cm.coolwarm)
ax.set_xlabel('x')
ax.set_ylabel('y')
plt.title("$f(x)=" + LATEX(formula_1) + "(" + str(lower_end_x) + "<x,y<" +
str(upper_end_x) + ")$")
# canvasにプロットした画像を出力
canvas = FigureCanvasAgg(fig)
png_output = BytesIO()
canvas.print_png(png_output)
data = png_output.getvalue()
# HTML側に渡すレスポンスを生成する
response = make_response(data)
response.headers['Content-Type'] = 'image/png'
response.headers['Content-Length'] = len(data)
return response
def plot(request):
# dummy data
T_test,T_pre,std_mmse,mean_mmse,std_adas,mean_adas,std_cdr,mean_cdr,time_scale,base_age,Me,Y1_test,Y2_test,Y5_test,mmse_scale,adas_scale,cd_scale = cm.train_model()
fig = Figure()
ax=fig.add_subplot(3,1,1)
ax.plot(T_test[0,0:Me]*time_scale+base_age,Y1_test[0,0:Me]*mmse_scale,'ro')
ax.plot(T_pre[0,:]*time_scale+base_age, mean_mmse+std_mmse,'r--',linewidth=1)
ax.plot(T_pre[0,:]*time_scale+base_age, mean_mmse,'r',linewidth=4)
ax.plot(T_pre[0,:]*time_scale+base_age, mean_mmse-std_mmse,'r--',linewidth=1)
ax.fill_between(T_pre[0,:]*time_scale+base_age, mean_mmse-std_mmse, mean_mmse+std_mmse, color='r', alpha=0.2)
ax.set_xlabel('Age(Years)')
ax.set_ylabel('MMSE')
print('plot 1')
ax=fig.add_subplot(3,1,2)
ax.plot(T_test[0,0:Me]*time_scale+base_age,Y2_test[0,0:Me]*adas_scale,'go')
ax.plot(T_pre[0,:]*time_scale+base_age, mean_adas+std_adas,'g--',linewidth=1)
ax.plot(T_pre[0,:]*time_scale+base_age, mean_adas,'g',linewidth=4)
ax.plot(T_pre[0,:]*time_scale+base_age, mean_adas-std_adas,'g--',linewidth=1)
ax.fill_between(T_pre[0,:]*time_scale+base_age, mean_adas-std_adas, mean_adas+std_adas, color='g', alpha=0.2)
ax.set_xlabel('Age(Years)')
ax.set_ylabel('ADAS-COG')
print('plot 2')
ax=fig.add_subplot(3,1,3)
ax.plot(T_test[0,0:Me]*time_scale+base_age,Y5_test[0,0:Me]*cd_scale,'bo')
ax.plot(T_pre[0,:]*time_scale+base_age, mean_cdr+std_cdr,'b--',linewidth=1)
ax.plot(T_pre[0,:]*time_scale+base_age, mean_cdr,'b',linewidth=4)
ax.plot(T_pre[0,:]*time_scale+base_age, mean_cdr-std_cdr,'b--',linewidth=1)
ax.fill_between(T_pre[0,:]*time_scale+base_age, mean_cdr-std_cdr, mean_cdr+std_cdr, color='b', alpha=0.2)
ax.set_xlabel('Age(Years)')
ax.set_ylabel('CDR-SB')
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
print('plot 3')
myfile = "/home/zyy/Documents/kdd-master/myweb/doc-django-master/media/documents/test_data.txt"
if os.path.isfile(myfile):
os.remove(myfile)
else: ## Show an error ##
print("%s file not found1" % myfile)
return response
def sysio_matrix(matrix_A, matrix_B, matrix_C, matrix_D, matrix_X, formula,
lower_end, upper_end, type):
A, Ar, Ac = MATRIX(matrix_A)
B, Br, Bc = MATRIX(matrix_B)
C, Cr, Cc = MATRIX(matrix_C)
D, Dr, Dc = MATRIX(matrix_D)
X, Xr, Xc = MATRIX(matrix_X)
formula = simplify(formula)
lower_end, upper_end = [float(lower_end), float(upper_end)]
inverse = (s * eye(Ar) - A).inv()
matrix_T = inverse_laplace_transform(inverse, s, t)
print(matrix_T)
anser_1 = matrix_T * X
Integrand = (matrix_T.subs(t, t - τ)) * B * formula
T = integrate(Integrand, τ)
anser_2 = T.subs(τ, t) - T.subs(τ, 0)
anser = LATEX(anser_1 + anser_2)
title = str(factor(anser)).replace("Heaviside(", "u_s(")
# データ作成
T = np.linspace(lower_end, upper_end, num)
Y = np.array([anser.subs(t, T[i]) for i in range(len(T))])
fig = plt.figure(figsize=(7, 4))
plt.plot(T, Y)
plt.xlim(lower_end, upper_end)
plt.title("$y(t)=" + LATEX(title) + "(" + str(lower_end) + "<t<" +
str(upper_end) + ")$")
# canvasにプロットした画像を出力
canvas = FigureCanvasAgg(fig)
png_output = BytesIO()
canvas.print_png(png_output)
data = png_output.getvalue()
# HTML側に渡すレスポンスを生成する
response = make_response(data)
response.headers['Content-Type'] = 'image/png'
response.headers['Content-Length'] = len(data)
return response
def make_graph(name, stats):
import numpy as np
import matplotlib
matplotlib.use('TkAgg')
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
import ast
import math
from textwrap import wrap
from io import StringIO, BytesIO
# Setup data
stats_obj=ast.literal_eval(stats)
objects = [ stat[0] for stat in stats_obj.items() ]
objects = [ o.title().replace('_', ' ') for o in objects]
objects = [ '\n'.join(wrap(o, 11)) for o in objects ]
amt = [ int(stat[1]) for stat in stats_obj.items() ]
y_ticks = np.arange(len(amt))
# Setup graph
fig=Figure()
ax=fig.add_subplot(111)
ax.bar(y_ticks, amt, align='center', alpha=0.5)
ax.set_yticks(y_ticks, amt)
ax.set_ylabel('Number of candidates')
ax.set_xticks(np.arange(len(objects)))
ax.set_xticklabels(objects, rotation = 0, ha='center')
ax.set_title('Graph for {}'.format(name))
# Add labels to inside of bars
for i, v in enumerate(amt):
if v != 0:
ax.text(i, v * 0.8, str(v), color='gray')
# Convert to png
canvas=FigureCanvas(fig)
png_output=BytesIO()
canvas.print_png(png_output)
response=make_response(png_output.getvalue())
response.headers['Content-Type'] = 'image/png'
return response
def probplot(indx):
"""
Creates bar plots for the website by passing features through the
classification model stored in the pickle.
"""
cnt_features = ri.getimagefeatures(indx)
probs = model.predict_proba(cnt_features.reshape(1, -1))
labels = model.classes_()
fig, ax = plt.subplots(figsize=(15, 15))
sortargs = probs.argsort()[0][-3:]
lbl = labels[sortargs]
fig, ax = plt.subplots()
y_pos = np.arange(len(lbl))
y = probs[0][sortargs]
N = len(y)
x = range(N)
width = 1 / 2.
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
ax.set_xlim([0, 1])
rects = ax.barh(x, y, width, color="#AAAAAA", alpha=0.5)
ax.vlines(x=0.005, ymin=-1.0, ymax=3.0, linewidth=2, color='k')
ax.set_yticks(np.arange(3) + width / 20.)
for i, rect in enumerate(rects):
length = round(rect.get_width(), 4)
ax.text(.5,
rect.get_y() + rect.get_height() / 10,
'{} - {}%'.format(labelmaker[lbl[i]], int(100 * length)),
ha='center',
va='bottom',
size=20)
fig.figurePatch.set_alpha(0)
plt.grid(False)
ax.set_facecolor('white')
plt.tight_layout
canvas = FigureCanvas(fig)
png_output = StringIO()
canvas.print_png(png_output)
plt.close(fig)
response = make_response(png_output.getvalue())
response.headers['Content-Type'] = 'image/png'
return response
def plot():
fig = Figure()
axis = fig.add_subplot(1, 1, 1)
xs = dataset.sampledata[:, 0]
ys = dataset.sampledata[:, 1]
color = ['red', 'green', 'blue', 'orange', 'cyan', 'violet']
for i in range(len(xs)):
if request.args.get('distance') == 'euclidean':
# centroid_akhir = np.array(session['centroid_akhir_euclidean'])
axis.scatter(
xs[i],
ys[i],
color=color[session['cluster_euclidean']['cluster_baru'][i]])
# axis.scatter(centroid_akhir[:,0],centroid_akhir[:,1], color = '#ff00ff')
elif request.args.get('distance') == 'manhattan':
# centroid_akhir = np.array(session['centroid_akhir_manhattan'])
axis.scatter(
xs[i],
ys[i],
color=color[session['cluster_manhattan']['cluster_baru'][i]])
# axis.scatter(centroid_akhir[:,0],centroid_akhir[:,1], color = '#ff00ff')
elif request.args.get('distance') == 'minkowsky':
# centroid_akhir = np.array(session['centroid_akhir_minkowsky'])
axis.scatter(
xs[i],
ys[i],
color=color[session['cluster_minkowsky']['cluster_baru'][i]])
# axis.scatter(centroid_akhir[:,0],centroid_akhir[:,1], color = '#ff00ff')
# centroid_awal = np.array(session['centroid_awal'])
# axis.scatter(centroid_awal[:,0],centroid_awal[:,1], color = 'black')
axis.grid()
canvas = FigureCanvas(fig)
output = io.BytesIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def stat(request, key):
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
from marketing.models import Stat
from django.utils import timezone
limit = 10
weekly_stats = Stat.objects.filter(key=key).order_by('created_on')
weekly_stats = weekly_stats.filter(
created_on__hour=1, created_on__week_day=1).filter(
created_on__gt=(timezone.now() -
timezone.timedelta(weeks=7))) #weekly stats only
daily_stats = Stat.objects.filter(key=key).filter(
created_on__gt=(timezone.now() -
timezone.timedelta(days=7))).order_by('created_on')
daily_stats = daily_stats.filter(created_on__hour=1) #daily stats only
stats = weekly_stats if weekly_stats.count() < limit else daily_stats
fig = Figure(figsize=(1.6, 1.5), dpi=80, facecolor='w', edgecolor='k')
ax = fig.add_subplot(111)
x = []
y = []
for stat in stats:
x.append(stat.created_on)
y.append(stat.val)
x = x[-1 * limit:]
y = y[-1 * limit:]
ax.plot_date(x, y, '-')
ax.set_axis_off()
ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
if stats.count() > 1:
ax.set_title("Usage over time", y=0.9)
else:
ax.set_title("(Not enough data)", y=0.3)
fig.autofmt_xdate()
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def genGraph(graph_filename):
dtStart = (dt.datetime.strptime("2016-08-01", '%Y-%m-%d'))
my_stocks = tbMyStocks.objects.all()
main_df = pd.DataFrame()
df = pd.DataFrame()
print('Number of Stocks:',len(my_stocks))
if len(my_stocks)==0:
return False
else:
for sym in my_stocks:
if main_df.empty:
main_df = (data.get_data_google(sym.Symbol, dtStart)['Close'])
main_df = main_df.to_frame()
main_df.rename(columns = {'Close' : sym.Symbol}, inplace=True)
#print(main_df.head())
else:
main_df = main_df.join((data.get_data_google(sym.Symbol, dtStart)['Close']), how='outer')
main_df.rename(columns = {'Close' : sym.Symbol}, inplace=True)
#print(main_df)
else:
pass
fig = Figure()
ax1 = fig.add_subplot(1,1,1)
#ax2 = fig.add_subplot(1,1,1)
#lines, labels = ax.legend_handles_labels()
#plt.legend(my_stocks)
ax1.plot(main_df.index, main_df)
ax1.legend(main_df.columns[:], loc='upper left')
#ax2.plot(main_df)
canvas = FigureCanvas(fig)
canvas.print_png(graph_filename)
return True
def plotResults(request):
#arg=siteid
import matplotlib
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(1, 1, 1)
#p = get_object_or_404(Profits, sitename = '124_Villa-Park') # Get the poll object from django
profits = Profits.objects.filter(sitename='124_Villa-Park')
numTests = profits.count()
x = matplotlib.numpy.arange(1, numTests)
prices = [profit.price for profit in profits]
updates = [profit.update for profit in profits]
ind = matplotlib.numpy.arange(numTests) # the x locations for the groups
cols = ['red', 'orange', 'yellow', 'green', 'blue', 'purple', 'indigo'
] * 10
cols = cols[0:len(ind)]
ax.bar(ind, prices, color=cols)
ax.set_xticks(ind + 0.5)
ax.set_xticklabels(updates)
ax.set_xlabel("Updates")
ax.set_ylabel("Prices")
#ax.set_xticklabels(names)
site = '124_Villa-Park'
title = u"Dynamically Generated Results Plot for poll: %s" % site
ax.set_title(title)
#ax.grid(True)
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def prices(request, id):
data = Stock.objects.filter(symbol=id)
if not data:
return HttpResponseNotFound('<h1>Prices not found</h1>')
else:
fig = Figure()
canvas = FigureCanvas(fig)
axes1 = fig.add_subplot(2, 2, 1)
axes2 = fig.add_subplot(2, 2, 2)
axes3 = fig.add_subplot(2, 2, 3)
axes4 = fig.add_subplot(2, 2, 4)
l = []
for stock in data:
l.append(stock.openp)
ls = np.array(l)
axes1.plot(ls)
l = []
for stock in data:
l.append(stock.closep)
ls = np.array(l)
axes2.plot(ls)
l = []
for stock in data:
l.append(stock.low)
ls = np.array(l)
axes3.plot(ls)
l = []
for stock in data:
l.append(stock.high)
ls = np.array(l)
axes4.plot(ls)
axes2.set_title('closep prices')
axes3.set_title('Low prices')
axes4.set_title('High prices')
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def stat1(request):
f = plt.figure()
co = sqlite3.connect('./db.sqlite3')
data = pd.read_sql_query('SELECT DISTINCT(type),count(type) FROM forms_demande GROUP BY type;',co)
df = pd.DataFrame(data)
f, ax = plt.subplots()
df.plot(kind = 'bar', color = 'firebrick',ax=ax, x = 'type',figsize=(11,11), title = "Nombre de commandes par type de produits" )
plt.xlabel('Type de produits')
plt.ylabel("Nombre de commandes")
plt.legend('')
fig, ax = plt.subplots()
df.plot(ax=ax)
plt.close(f)
#plt.savefig('output.png')
canvas = FigureCanvasAgg(f)
response = HttpResponse(content_type='image\png')
canvas.print_png(response)
plt.close(f)
return response
def pandasgraph(request): # 메모리에서 이미지 생성
fig = plt.figure(figsize=(6, 4.5), dpi=80, facecolor='w', edgecolor='w')
ax = fig.add_subplot(111) # 화면분활 223 - 도화지
f = pd.DataFrame(
{
'y': np.random.randn(10),
'z': np.random.randn(10)
}, # normal 정규분포
index=pd.period_range('1-2000', periods=10))
f.plot(ax=ax) # 산포도
# plt.show()
buf = io.BytesIO() # 메모리에 화일을 출력
canvas = FigureCanvasAgg(fig) # 이미지를 화일로 변경하려면 agg 버퍼를 사용해야 함
canvas.print_png(buf) # 메모리에다 화일을 만들어라
fig.clear()
# canvas=FigureCanvas(fig)
response = HttpResponse(buf.getvalue(),
content_type='image/png') # 이미지를 전송할 때는 사이즈도 같이 전송
response['Content-Length'] = str(len(response.content)) # 숫자를 문자로 생성
return response
def plot_hum():
timeStamps, temps, hums = getHistData(43000,"SOGGIORNO",beTime,enTime)
formatter = dat.DateFormatter('%d-%m %H:%M')
ys = temps
xs=timeStamps
fig = Figure()
ax = fig.add_subplot(1, 1, 1)
ax.set_title("Humidity [%]")
ax.xaxis.set_major_formatter(formatter)
ax.xaxis.set_tick_params(rotation=30, labelsize=10)
ax.grid(True)
ax.plot_date(xs, ys,'o-')
fig.autofmt_xdate()
fig.tight_layout()
canvas = FigureCanvas(fig)
output = io.BytesIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def custom_plots(filepath, txtFuture_periods, txtChangepoints,
txtChangepoint_range, txtChangepoint_scale,
ckbCountry_holidays, txtHolidays_scale,
ckbMonthly_seasonality, txtSeasonality_days,
txtFourier_monthly):
forecast_fig, components_fig = get_custom_figures(
filepath, txtFuture_periods, txtChangepoints, txtChangepoint_range,
txtChangepoint_scale, ckbCountry_holidays, txtHolidays_scale,
ckbMonthly_seasonality, txtSeasonality_days, txtFourier_monthly)
forecast_canvas = FigureCanvasAgg(forecast_fig)
components_canvas = FigureCanvasAgg(components_fig)
buf1 = BytesIO()
buf2 = BytesIO()
with open('static/img/img1.png', 'wb') as forecast_file:
forecast_canvas.print_png(buf1)
forecast_file.write(buf1.getvalue())
with open('static/img/img2.png', 'wb') as components_file:
components_canvas.print_png(buf2)
components_file.write(buf2.getvalue())
def graph_view():
fig, ax = plt.subplots()
x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
y = np.array([2, 3, 2, 4, 5, 5, 4, 2, 7])
ax.plot(x, y, color="black")
canvas = FigureCanvasAgg(fig)
buf = io.StringIO()
canvas.print_png("/root/app/web_test/tmp.png")
# data = buf.getvalue()
# response = make_response(data)
# response.headers['Content-Type'] = 'image/png'
# response.headers['Content-Length'] = len(data)
# return response
print("<img src='./../tmp.png' alt='graph_image'>")
def candlestick1(stock):
ts = TimeSeries(key='QBGZM8IV1P2X2VJQ', output_format='pandas')
data, meta_data = ts.get_intraday(symbol=stock,
interval='60min',
outputsize='compact')
fig, ax1 = plt.subplots()
ax1.plot(data, 'b')
ax1.set_xlabel('Time(s)')
ax1.set_ylabel(stock.upper(), color='b')
plt.title('Stock Value of ' + stock.upper())
for tick in ax1.get_xticklabels():
tick.set_rotation(45)
canvas = FigureCanvas(fig)
output = io.BytesIO()
fig.tight_layout()
canvas.print_png(output)
response = base64.b64encode(output.getvalue()).decode('ascii')
return response
def plot_hum():
times, temps, hums = getHistData(numSamples)
ys = hums
timec = []
for thing in times:
timec.append(datetime.datetime.strptime(thing, "%Y-%m-%d %H:%M:%S"))
fig = Figure()
axis = fig.add_subplot(1, 1, 1)
axis.set_title("Humidity [%]")
axis.set_xlabel("Time of day")
axis.grid(True)
xs = timec
plt.setp(axis.xaxis.get_majorticklabels(), rotation=90)
axis.plot(xs, ys)
canvas = FigureCanvas(fig)
output = io.BytesIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def lineplot(request, sensor):
fig=Figure()
fig.suptitle(sensor)
ax=fig.add_subplot(111)
data = Sensordata.objects.all()[4:]
x = data.values_list("date", flat=True)
y = data.values_list(sensor, flat=True)
print(x)
print(y)
ax.plot_date(x, y, '-')
ax.xaxis.set_major_formatter(DateFormatter('%m.%d %H'))
fig.autofmt_xdate()
buf = io.BytesIO()
canvas=FigureCanvas(fig)
canvas.print_png(buf)
response=HttpResponse(buf.getvalue(), content_type='image/png')
return response
def getIOCSignalPlot(prefix):
fig = Figure()
axis = fig.add_subplot(1, 1, 1)
#xs = range(100)
#ys = [random.randint(1, 50) for x in xs]
ys = epics.caget(f'{prefix}:signal', timeout=0.5)
if ys is not None:
xs = range(len(ys))
axis.plot(xs, ys)
axis.legend([f'{prefix}:signal'])
canvas = FigureCanvas(fig)
output = BytesIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def linearReg():
engine = create_engine(dbURI)
connection = engine.connect()
fig = Figure()
axis = fig.add_subplot(1, 1, 1)
query = "select * from " + str(request.args.get('table'))
frame = pd.read_sql(query, connection)
column1 = str(request.args.get('column1'))
column2 = str(request.args.get('column2'))
xs = frame[column1]
ys = frame[column2]
m, b = np.polyfit(xs, ys, 1)
axis.scatter(xs, ys)
axis.plot(xs, m * xs + b)
canvas = FigureCanvas(fig)
output = StringIO.StringIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def graph_create(points, title, xlabel, ylabel):
fig = Figure(facecolor = 'white', edgecolor = 'white')
graph = fig.add_subplot(111)
graph.set_title(title)
graph.set_xlabel(xlabel)
graph.set_ylabel(ylabel)
graph.grid()
# graph.legend(["hello"]) Выдает ошибку Division by Zero
for x, y, f in points:
graph.plot_date(x, y, f) #Если нужны даты по оси x, если обычные данные, используйте graph.plot(x, y, f)
graph.xaxis.set_major_formatter(DateFormatter("%Y.%m.%d %H:%M")) #Опять же, если даты.
fig.autofmt_xdate()
output = StringIO()
canvas = FigureCanvas(fig)
canvas.print_png(output)
return output.getvalue()
