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_loads_devs(response, start, alldata, allmeans, meandates, maxload, notesets):
fig = Figure(figsize=(12,8), dpi=72)
rect = fig.patch
rect.set_facecolor('white')
canvas = FigureCanvas(fig)
ax = fig.add_subplot(111)
colorlist = ['b', 'g', 'r', 'y', 'c']
plts = []
labels = []
colorlist_count = 0
for dev in alldata.keys():
labels.append(dev)
plt = ax.plot(alldata[dev]['dates'], alldata[dev]['loads'], colorlist[colorlist_count] + 'x')[0]
plts.append(plt)
colorlist_count += 1
ax.plot(meandates, allmeans, 'ks')
for i in range(len(meandates)):
outstr = "%.03f ug/cm^2\n" % (allmeans[i])
for j in notesets[i]:
outstr += j + "\n"
ax.text(meandates[i], allmeans[i], outstr)
ax.set_ylabel('$ug/cm^2$')
ax.set_xlabel('Image Record Time (from EXIF)')
ax.set_title("%s" % (str(start)))
fig.autofmt_xdate()
ax.legend(plts, labels, numpoints=1, loc='lower right')
fig.subplots_adjust(left=0.07, bottom=0.10, right=0.91, \
top=0.95, wspace=0.20, hspace=0.00)
canvas.print_png(response)
def plot(request, id_sensor, days, pltype):
check_url(days=days, id_sensor=id_sensor)
if pltype != 'moist' and pltype != 'temp':
raise NotFound(detail='only \'moist\' and \'temp\' are available',
code=404)
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 = []
y1 = []
y2 = []
now = datetime.now()
for el in Sensor.objects.filter(date__gte=now - timedelta(days=days),
date__lte=now,
sensor_id__exact=id_sensor):
x.append(el.date)
if pltype == 'moist':
y1.append(el.vw_30cm)
y2.append(el.vw_60cm)
else:
y1.append(el.t_30cm)
y2.append(el.t_60cm)
ax.plot_date(x, y1, 'r-', label='глубина 30 см')
ax.plot_date(x, y2, '-', label='глубина 60 см')
ax.legend()
ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
fig.autofmt_xdate()
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/jpg')
canvas.print_jpg(response)
return response
class skinnerplot:
def __init__(self):
self.fig = Figure(figsize=(5, 4), dpi=100)
self.ax = self.fig.add_subplot(111)
days = mdates.DayLocator(interval = 10)
days_fmt = mdates.DateFormatter('%m-%d')
self.ax.xaxis.set_major_formatter(days_fmt)
self.ax.xaxis.set_major_locator(days)
def draw(self, d):
# remove the old data points
while(len(self.ax.lines) > 0):
self.ax.lines[0].remove()
for s in d.task.unique():
temp = d[d.task == s]
self.ax.plot(temp.time, temp.trigger_delay, 'o', color = tcol[s], label = s, markersize = 4)
#self.ax.legend()
self.ax.set_xlim(d.time.min() - datetime.timedelta(days=1), d.time.max() + datetime.timedelta(days=1))
self.ax.set_ylim(d.trigger_delay.min() - 10, d.trigger_delay.max() + 10)
self.fig.autofmt_xdate()
return self.fig
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 graph():
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)
response = make_response(png_output.getvalue())
response.headers['Content-Type'] = 'image/png'
return response
class PlotAdapter() :
__glob_init_flag = False
def __init__( self ):
PlotAdapter.InitMatPlot()
# Matplotlib 的一些全局性设置
@staticmethod
def InitMatPlot( self ):
if PlotAdapter.__glob_init_flag:
return
# Global 设置
# mpl.rcParams['font.sans-serif'] = ['SimHei'] #指定默认字体
# mpl.rcParams['axes.unicode_minus'] = False #解决保存图像是负号'-'显示为方块的问题
# mpl.rcParams['grid.color'] = 'r'
PlotAdapter.__glob_init_flag = True
def CreateFigure( self ):
# self.bgColor = '#31312E' # 黑色
bgColor = UIConfig.bgColor
edgeColor = UIConfig.edgeColor
self.figure = Figure(facecolor=bgColor, edgecolor=edgeColor, tight_layout=False)
self.figure.autofmt_xdate()
self.canvas = FigureCanvas(self, -1, self.figure)
# self.sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
outer_grid = gridspec.GridSpec(16,1)
outer_grid.update()
left_cell = outer_grid[:10, :1]
inner_grid = gridspec.GridSpecFromSubplotSpec( 16, 1, left_cell )
def plot_supply(request):
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
currency = request.GET['currency']
genesis = crypto_data[currency.lower()]['genesis_date']
currency_name = crypto_data[currency.lower()]['name']
s = SupplyEstimator(currency)
try:
max_block = crypto_data[
currency.lower()]['supply_data']['reward_ends_at_block']
end = s.estimate_date_from_height(max_block)
except KeyError:
end = genesis + datetime.timedelta(days=365 * 50)
x = list(date_generator(genesis, end))
y = [s.calculate_supply(at_time=z) / 1e6 for z in x]
fig = Figure()
ax = fig.add_subplot(111)
ax.plot_date(x, y, '-')
ax.set_title("%s Supply" % currency_name)
ax.grid(True)
ax.xaxis.set_label_text("Date")
ax.yaxis.set_label_text("%s Units (In millions)" % currency.upper())
ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
fig.autofmt_xdate()
canvas = FigureCanvas(fig)
response = http.HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def plot_temperature():
con = db.create_connection()
df = pd.read_sql_query('SELECT timestamp, temp FROM DHT_data ORDER BY timestamp', con, parse_dates=['timestamp'], index_col=['timestamp'])
con.close()
resampled = df.resample('10T').mean()
fig = Figure()
axis = fig.add_subplot(1, 1, 1)
axis.plot(resampled.index.values, resampled['temp'])
date_format = mpl_dates.DateFormatter('%Y-%m-%d %H:%M')
axis.xaxis_date()
axis.xaxis.set_major_formatter(date_format)
axis.set_xlabel('Time')
axis.set_ylabel('Temperature ($^\circ$C)')
axis.set_title('Temperature PGU')
axis.grid(True)
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 get_data_from_strava():
'''
Generate a random image.
A sleep makes this task take artifically longer.
'''
current_task.update_state(state='PROGRESS', meta={'current':0.1})
time.sleep(2)
current_task.update_state(state='PROGRESS', meta={'current':0.3})
fig = Figure()
ax_handle = fig.add_subplot(111)
x_axis = []
y_axis = []
now = datetime.datetime.now()
delta = datetime.timedelta(days=1)
current_task.update_state(state='PROGRESS', meta={'current':0.5})
for _ in range(10):
x_axis.append(now)
now += delta
y_axis.append(random.randint(0, 1000))
ax_handle.plot_date(x_axis, y_axis, '-')
ax_handle.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
fig.autofmt_xdate()
canvas = FigureCanvas(fig)
current_task.update_state(state='PROGRESS', meta={'current':0.8})
png_output = BytesIO()
canvas.print_png(png_output)
out = png_output.getvalue()
return out
def tiled_axis( ts, filename=None ):
fig = Figure( ( 2.56 * 4, 2.56 * 4), 300 )
canvas = FigureCanvas(fig)
#ax = fig.add_subplot(111)
grid = ImageGrid(fig, 111, # similar to subplot(111)
nrows_ncols = (3, 1),
axes_pad = 0.5,
add_all=True,
label_mode = "L",
)
# pad half a day so that major ticks show up in the middle, not on the edges
delta = dates.relativedelta( days=2, hours=12 )
# XXX: gets a list of days.
timestamps = glucose.get_days( ts.time )
xmin, xmax = ( timestamps[ 0 ] - delta,
timestamps[ -1 ] + delta )
fig.autofmt_xdate( )
def make_plot( ax, limit ):
preferspan = ax.axhspan( SAFE[0], SAFE[1],
facecolor='g', alpha=0.2,
edgecolor = '#003333',
linewidth=1
)
def draw_title( ax, limit ):
ax.set_title('glucose history')
#ax.set_ylabel('glucose mm/dL')
return canvas
def img(request):
import random
import matplotlib as mpl
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
mpl.rcParams['timezone'] = 'Asia/Seoul'
latest_data = HumidTemp.objects.all().order_by('-id')[:1440]
fig = Figure()
ax=fig.add_subplot(211)
x=[]
y=[]
tempy=[]
for data in latest_data:
x.append(data.collect_datetime)
y.append(data.humidity)
tempy.append(data.temperature)
# ax.plot_date(x, y, '-')
#ax.xaxis.set_major_formatter(DateFormatter('%m-%d %H:%M'))
ax.plot(x, y, '-')
ax.xaxis.set_major_formatter(DateFormatter('%m-%d %H:%M'))
ax2 = fig.add_subplot(212)
ax2.plot(x, tempy, '-')
ax2.xaxis.set_major_formatter(DateFormatter('%m-%d %H:%M'))
fig.autofmt_xdate()
canvas=FigureCanvas(fig)
response= HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def plot_grads(response, start, thedate, thedata, sampled):
fig = Figure(figsize=(12,8), dpi=72)
rect = fig.patch
rect.set_facecolor('white')
canvas = FigureCanvas(fig)
ax = fig.add_subplot(111)
pout = ax.plot(thedate, sampled, 'ok')
pout = ax.plot(
thedate, thedata[0], 'bx',
thedate, thedata[1], 'gx',
thedate, thedata[2], 'rx',
thedate, thedata[3], 'cx',
thedate, thedata[4], 'mx',
thedate, thedata[5], 'yx',
thedate, thedata[6], 'kx',
thedate, thedata[7], 'bx',
thedate, thedata[8], 'gx',
thedate, thedata[9], 'rx',
thedate, thedata[10], 'cx',
thedate, thedata[11], 'mx'
)
fig.autofmt_xdate()
ax.fmt_xdata = mdates.DateFormatter('%Y-%m-%d %H:%M')
ax.set_ylim(0,300)
ax.set_title(start.strftime("%Y-%m-%d %H:%M:%S"))
canvas.print_png(response)
def creatDiagramCategory(self, totals, counts):
# basic setting
fig = Figure()
axis = fig.add_subplot(111)
canvas = FigureCanvas(fig)
self.verticalLayoutDraw.addWidget(canvas)
toolbar = NavigationToolbar(canvas, self.widgetDraw)
self.verticalLayoutDraw.addWidget(toolbar)
# cook data
name = "category " + str(totals[1][0]).split()[-1]
x = totals[2]
t_sale = totals[3]
t_save = totals[4]
c_sale = counts[3]
c_save = counts[4]
price_ratio = [
round(t_sale[i] / (t_sale[i] + t_save[i]), 2)
for i in range(len(x))
]
count_ratio = [round(c_save[i] / c_sale[i], 2) for i in range(len(x))]
# 设置x轴为日期
try:
date_range = (x[-1] - x[1]).days
except:
date_range = 0
axis.xaxis.set_major_locator(
mdates.DayLocator(interval=(1 + date_range // 12)))
axis.xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m-%d %a"))
axis.set_title(name)
y1, = axis.plot(x, count_ratio, 'xg-', label='line1')
y2, = axis.plot(x, price_ratio, '+r-', label='line2')
axis.legend([y1, y2], ['save/total count', 'sale/total $'], loc=1)
fig.autofmt_xdate()
def ai_back_test_plot():
fig = Figure()
axis = fig.add_subplot(1, 1, 1)
line = np.zeros(n)
t = range(n)
axis.plot(t, portfolio_ys[0:n], 'ro')
axis.plot(t, spy_ys[0:n], 'bd')
axis.plot(t, line, 'b')
axis.set(xlabel="Date",
ylabel="Cumulative Returns",
title="Portfolio Back Test (2020-01-01 to 2020-06-30)",
xlim=[0, n])
axis.text(0.2, 0.9, 'Red - Portfolio, Blue - SPY',
verticalalignment='center',
horizontalalignment='center',
transform=axis.transAxes,
color='black', fontsize=10)
axis.grid(True)
fig.autofmt_xdate()
canvas = FigureCanvas(fig)
output = io.BytesIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def images(datatype):
db = TinyDB("sensor_log.json")
Data = Query()
data = db.search(Data.type == datatype)
times = [
datetime.datetime.strptime(i[1]['time'], "%Y-%m-%d %H:%M:%S")
for i in enumerate(data)
]
datas = [i[1]['value'] for i in enumerate(data)]
fig = Figure()
ax = fig.add_subplot(111)
ax.plot_date(times, datas, '-')
ax.xaxis.set_major_locator(DayLocator())
ax.xaxis.set_major_formatter(DateFormatter("%m-%d %H:%M"))
ax.xaxis.set_minor_locator(HourLocator())
ax.autoscale_view()
ax.grid(True)
fig.autofmt_xdate()
canvas = FigureCanvas(fig)
png_output = io.BytesIO()
fig.savefig(png_output, format='png')
response = make_response(png_output.getvalue())
response.headers['Content-Type'] = 'image/png'
return response
def display_visualization():
"""Display a visualization of the activities stored to the database."""
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
dates = Activity.query.with_entities(Activity.start_date).all()
aerobic_values = Activity.query.with_entities(Activity.aerobic_value).all()
try:
# Add axis labels
fig = Figure()
ax = fig.add_subplot(111)
ax.plot_date(dates, aerobic_values, "-")
ax.xaxis.set_major_formatter(DateFormatter('%m-%d-%Y'))
fig.autofmt_xdate()
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
except:
return "{} {}".format(dates, aerobic_values)
class ChartCanvas():
"""
Container for the matplotlib (or any other) chart object
"""
def __init__(self, container, config):
# Create the matplotlib figure and attach it to a canvas
self.figure = Figure(
(config.chart_width, config.chart_height),
dpi=config.chart_dpi)
self.canvas = FigureCanvasWxAgg(container, -1, self.figure)
self.chart = self.figure.add_subplot(111)
def layout(self):
return self.canvas
def draw(self, data, _):
"""
Redraw figure
"""
logging.debug('Redrawing time series')
self.chart.clear()
# self.axes.grid(self.cb_grid.IsChecked())
self.chart.plot(data['dates'], data['values'])
self.figure.autofmt_xdate()
self.canvas.draw()
def drawPlot(property, unit, interval):
if unit in ("hours", "minutes"):
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter, HourLocator, MinuteLocator, SecondLocator
from io import BytesIO
last = (
db.session.query(Measurement)
.filter(Measurement.property == property)
.order_by(Measurement.id.desc())
.first()
)
if not last:
return abort(404)
# Get measurement data
if unit == "hours":
ms = Measurement.query.filter(
Measurement.property == property, Measurement.time > last.time - datetime.timedelta(hours=int(interval))
).all()
elif unit == "minutes":
ms = Measurement.query.filter(
Measurement.property == property,
Measurement.time > last.time - datetime.timedelta(minutes=int(interval)),
).all()
t = []
T = []
# organize.. could this be done smarter?
for m in ms:
t.append(m.time)
T.append(m.value)
# Make plot
fig = Figure()
ax = fig.add_subplot(111)
ax.plot_date(t, T, "-")
if unit == "hours":
ax.xaxis.set_major_locator(MinuteLocator(interval=10 * int(interval)))
ax.xaxis.set_minor_locator(MinuteLocator(interval=int(interval)))
elif unit == "minutes":
ax.xaxis.set_major_locator(SecondLocator(interval=10 * int(interval)))
ax.xaxis.set_minor_locator(SecondLocator(interval=int(interval)))
ax.xaxis.set_major_formatter(DateFormatter("%h %d, %H:%M"))
x1, x2, y1, y2 = ax.axis()
ax.axis((x1, x2, y1 - 1, y2 + 1))
fig.autofmt_xdate()
# Return plot
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 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 svm_plot(request):
if request.method == 'POST':
which_form = request.POST.get('which-form', '').strip()
if which_form == 'svm-plot':
symbol = request.POST.get('stock-symbol', '').strip()
conn = sqlite3.connect('PyFolio.sqlite3')
cur = conn.cursor()
sql = ''' SELECT svm_prediction FROM stockapp_prediction_svm_all WHERE symbol LIKE "%''' + symbol + '''%" '''
cur.execute(sql)
result = cur.fetchall()
fig = Figure()
ax = fig.add_subplot(111)
x = []
y = []
now = datetime.datetime.now()
delta = datetime.timedelta(days=1)
for i in range(30):
x.append(now)
now += delta
y.append(result[i][0])
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 random_graph():
"""
Matplot image view simple example
From tutorial:
https://scipy-cookbook.readthedocs.io/items/Matplotlib_Django.html
"""
fig = Figure()
ax = fig.add_subplot(111)
x = []
y = []
now = datetime.datetime.now()
delta = datetime.timedelta(days=1)
for _ 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)
buffer = io.BytesIO()
canvas = FigureCanvas(fig)
canvas.print_png(buffer)
# set MIME type
response = HttpResponse(buffer.getvalue(), content_type='image/png')
# I recommend to add Content-Length for Django
response['Content-Length'] = str(len(response.content))
plt.close('all')
return response
def create_figure():
hours_tick = mdates.HourLocator()
minute_tick = mdates.MinuteLocator(byminute=30)
the_look = mdates.DateFormatter("%H:%M")
fig = Figure(figsize=(8,6))
axis = fig.add_subplot(1, 1, 1)
xs =[]
ys = []
xs_query = measure.query.with_entities(measure.curr_temp).order_by(measure.read_date.desc()).all()
for x in xs_query:
xs.append(x)
xs = np.asarray(xs)
ys_query = measure.query.with_entities(measure.read_date).order_by(measure.read_date.desc()).all()
for y in ys_query:
ys.append(y)
ys = np.asarray(ys)
axis.plot(ys, xs)
axis.xaxis.set_major_locator(hours_tick)
axis.xaxis.set_major_formatter(the_look)
axis.xaxis.set_minor_locator(minute_tick)
fig.autofmt_xdate()
return fig
def charts_graph(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=(4, 4))
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'))
ax.annotate('metric: {}'.format(request.GET['metric']),
xy=(x[0], y[0]),
xytext=(x[0], y[0]))
ax.annotate('rep: {}'.format(request.GET['rep_id']),
xy=(x[1], y[1]),
xytext=(x[1], y[1]))
fig.autofmt_xdate()
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def schedule_view():
projects_list = Project.query.filter_by(active=True).all()
fig = Figure(figsize=(13, 4.4), dpi=100)
ax = fig.add_subplot()
y_ticks = []
y_tick_value = 10
colors = list(np.random.rand(len(projects_list), 3))
for project in projects_list:
start_date = datetime.strptime(project.start_date, "%Y-%m-%d").date()
end_date = datetime.strptime(project.end_date, "%Y-%m-%d").date()
delta = end_date - start_date
ax.broken_barh([(start_date, delta)], (y_tick_value, 9),
facecolors=colors.pop())
y_ticks.append(y_tick_value + 5)
y_tick_value += 10
ax.grid(True)
ax.set_yticks(y_ticks)
ax.set_yticklabels([project.name for project in projects_list])
fmt_month = mdates.MonthLocator(interval=1)
ax.xaxis.set_major_locator(fmt_month)
fig.autofmt_xdate()
fig.suptitle("Projects start and end dates", fontsize=20)
fig.supxlabel("Start and end dates", fontsize=14)
fig.supylabel("Project name", fontsize=14)
png_image = io.BytesIO()
FigureCanvas(fig).print_png(png_image)
pngImageB64String = "data:image/png;base64,"
pngImageB64String += base64.b64encode(png_image.getvalue()).decode("utf8")
return render_template("schedule.html",
user=current_user,
image=pngImageB64String)
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 simple():
import datetime
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)
data, shape = canvas.print_to_buffer()
y, x = shape
array = frombuffer(data, dtype=uint8, count=x*y*4)
return array.reshape((x, y, 4))
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 simple(request):
simpleimgdata = StringIO.StringIO()
simpleimgdata.buf=""
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()
plt.savefig(simpleimgdata, format='png')
simpleimgdata.seek(0)
uri = 'data:image/png;base64,' + urllib.quote(base64.b64encode(simpleimgdata.buf))
# element= '<img src = "%s"/>' % uri
simpleimgdata.truncate()
simpleimgdata.seek(0)
simpleimgdata.close()
response = HttpResponse()
response.write(uri)
return response
def creatDiagramProduct(self, product):
# basic setting
fig = Figure()
axis = fig.add_subplot(111)
canvas = FigureCanvas(fig)
self.verticalLayoutDraw.addWidget(canvas)
toolbar = NavigationToolbar(canvas, self.widgetDraw)
self.verticalLayoutDraw.addWidget(toolbar)
# cook data
name = str(product[1][0])
# x = [datetime.datetime.strptime(d, '%Y-%m-%d').date() for d in product[2]]
x = product[2]
sale = product[3]
save = product[4]
total = [sale[i] + save[i] for i in range(len(x))]
# 设置x轴为日期
try:
date_range = (x[-1] - x[1]).days
except:
date_range = 0
axis.xaxis.set_major_locator(
mdates.DayLocator(interval=(1 + date_range // 12)))
axis.xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m-%d %a"))
axis.set_title(name)
y1, = axis.plot(x, total, '+k--', label='line1')
y2, = axis.plot(x, sale, 'or-', label='line2')
y3, = axis.plot(x, save, 'xg-', label='line3')
axis.legend([y1, y2, y3], ['total', 'sale', 'save'], loc=4)
fig.autofmt_xdate()
def plot_supply(request):
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
currency = request.GET['currency']
genesis = crypto_data[currency.lower()]['genesis_date']
currency_name = crypto_data[currency.lower()]['name']
s = SupplyEstimator(currency)
try:
max_block = crypto_data[currency.lower()]['supply_data']['reward_ends_at_block']
end = s.estimate_date_from_height(max_block)
except KeyError:
end = genesis + datetime.timedelta(days=365 * 50)
x = list(date_generator(genesis, end))
y = [s.calculate_supply(at_time=z)/1e6 for z in x]
fig = Figure()
ax = fig.add_subplot(111)
ax.plot_date(x, y, '-')
ax.set_title("%s Supply" % currency_name)
ax.grid(True)
ax.xaxis.set_label_text("Date")
ax.yaxis.set_label_text("%s Units (In millions)" % currency.upper())
ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
fig.autofmt_xdate()
canvas = FigureCanvas(fig)
response = http.HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
class CanvasPanel(wx.Panel):
def __init__(self, parent):
wx.Panel.__init__(self, parent)
self.figure = Figure()
self.axes = self.figure.add_subplot(111)
self.canvas = FigureCanvas(self, -1, self.figure)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
self.SetSizer(self.sizer)
self.Fit()
def show_data(self,fbfile,fields=['cond','imu_a']):
if fbfile.data is None:
return
self.figure.clear()
axs=[]
for axi,varname in enumerate(fields):
if axi==0:
sharex=None
else:
sharex=axs[0]
ax=self.figure.add_subplot(len(fields),1,axi+1,sharex=sharex)
axs.append(ax)
ax.plot_date( fbfile.data['dn_py'],
fbfile.data[varname],
'g-')
self.figure.autofmt_xdate()
# Not sure how to trigger it to actually draw things.
self.canvas.draw()
self.Fit()
class CoffeeCanvas(FigureCanvas):
def __init__(self):
self.fig = Figure()
self.ax = self.fig.add_subplot(1, 1, 1)
super().__init__(self.fig)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.fig.canvas.draw()
def show_bar_graph(self, data, date):
self.ax.clear()
data_dict = dict(data)
for i, key in enumerate(data_dict):
self.ax.bar(i, data_dict[key])
self.ax.set_xticks(np.arange(len(data_dict)) + 0.4)
self.ax.set_xticklabels(list(data_dict.keys()))
self.fig.autofmt_xdate()
self.ax.set_title("Total Sales for {0}".format(date))
self.ax.set_xlabel("Product")
self.ax.set_ylabel("Amount (£)")
self.fig.canvas.draw()
def show_pie_chart(self, data, date):
self.ax.clear()
data_dict = dict(data)
data = list(data_dict.values())
labels = list(data_dict.keys())
self.ax.pie(data, labels=labels, autopct='%1.1f%%')
self.ax.set_title("Percentage Sales for {0}".format(date))
self.fig.canvas.draw()
def plot_linear_graph(labels, _values, _values_l_y, label1, label2,
show_last_year, annotate, title): #plot linear graph
# Generate the figure **without using pyplot**.
fig = Figure()
canvas = FigureCanvas(fig)
ax = fig.subplots()
values = np.array(_values)
ax.plot(labels, values, label=label1)
if annotate: #annotate graphs
for i, j in zip(labels, values):
ax.annotate(str(j), xy=(i, j))
ax.set_title(title)
if show_last_year:
values_l_y = np.array(_values_l_y)
ax.plot(labels, values_l_y, label=label2)
ax.legend(loc='best')
if annotate:
for i, j in zip(labels, values_l_y):
ax.annotate(str(j), xy=(i, j))
fig.autofmt_xdate()
# Save it to a temporary buffer.
output = io.BytesIO()
canvas.print_png(output)
return Response(output.getvalue(), mimetype='image/png')
def index(request):
# list_unixtimes_values = sorted([(data.measure.unixtime, data.value) for data in DataType.objects.all()[0].data_set.all()])
list_unixtimes_values = sorted([
(data.measure.unixtime, data.value)
# for measure in Unit.objects.filter(name='temp1')[0].measure_set.all()
for measure in Unit.objects.filter(
name='y4k_temp1_noised')[0].measure_set.all()
for data in measure.data_set.all()
])
list_unixtimes, list_values = zip(*list_unixtimes_values)
list_datetimes = list(map(dt.fromtimestamp, list_unixtimes))
# return HttpResponse(str([list_unixtimes, list_values]))
fig = Figure(facecolor='white')
ax = fig.add_subplot(1, 1, 1)
# ax.plot(list_unixtimes, list_values)
ax.plot(list_datetimes, list_values)
ax.grid()
fig.autofmt_xdate()
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def bc_generate_bar_graph(PdfReport, image_info, outfile, item_dict):
fig = Figure()
canvas = FigureCanvas(fig)
ax = fig.add_subplot(1, 1, 1)
y = []
group_labels = []
## print("D: Generate_bar_graph: Dict:Length: %d, %s"
## % (len(item_dict), item_dict.items()))
# Simple lambda expression to sort the items in ascending order (then reverse it)
sorted_items = sorted(item_dict.items(), key=lambda x: x[1])
sorted_items.reverse()
num_items = 0
for i in sorted_items:
y.append(i[1])
group_labels.append(i[0])
num_items += 1
if num_items >= PdfReport.bc_max_formats_in_bar_graph:
## print("D: Reporting only %d formats in the bargraph" %num_items)
break
# calculate the number of bars required
N = len(y)
# generate a range of numbers (just a placeholder before we relabel)
ind = range(N)
# Make the font small and the xticks vertical
for label in ax.yaxis.get_ticklabels():
# label is a Text instance
label.set_fontsize(6)
for label in ax.xaxis.get_ticklabels():
label.set_fontsize(7)
# set up the actual graphing
ax.bar(ind, y, width=0.1, facecolor='#888888', ecolor='black')
ax.set_ylabel('Counts')
imgname = 'image_filename: ' + str(image_info['image_filename'])
imgname = 'Disk Image: ' + filename_from_path(imgname)
ax.set_title(imgname + ' File counts (by format)')
rects = ax.bar(ind, y, width=0.3, facecolor='#888888', ecolor='black')
# Write the frequency on top of each bar
for rect in rects:
height = rect.get_height()
ax.text(rect.get_x() + rect.get_width() / 2.,
height + 1.0,
'%d' % int(height),
ha='center',
va='bottom')
ax.set_xticks(ind)
ax.set_xticklabels(group_labels)
fig.autofmt_xdate()
#pp = PdfPages(outfile)
canvas.print_figure(outfile)
bc_addToReportFileList(outfile, PdfReport)
def water_use_cumulative():
dts, counts = read_data(path + 'counts.log', debug=False)
fig = Figure()
ax = fig.add_subplot(1, 1, 1)
cumulative = (counts*GAL).cumsum()
ax.step(dts, cumulative)
locator = dates.HourLocator(interval=12)
ax.xaxis.set_major_locator(locator)
fmt = dates.DateFormatter("%b%e %R")
ax.xaxis.set_major_formatter(fmt)
ax.set_xlabel('Time')
ax.set_ylabel('Cumulative Usage [Gal]')
ax.set_title('Water Usage, Cumulative')
ax.grid('on')
fig.autofmt_xdate()
total = (counts * GAL).sum()
ax.text(ax.get_xlim()[0], 0.9*total, 'Total Usage: %d Gal' %(total))
canvas = FigureCanvas(fig)
# output = BytesIO()
output = StringIO() # python 2.7x
canvas.print_png(output)
pic = output.getvalue() # 640px x 480px
response = make_response(pic)
response.mimetype = 'image/png'
# app.logger.info("Generated Cumulative Plot")
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 water_use_rate():
dts, counts = read_data(path + 'counts.log', debug=True)
fig = Figure()
ax = fig.add_subplot(1, 1, 1)
ax.step(dts, counts * GAL)
ax.set_ylim(0,8)
locator = dates.HourLocator(interval=6)
ax.xaxis.set_major_locator(locator)
fmt = dates.DateFormatter("%b%e %R")
ax.xaxis.set_major_formatter(fmt)
ax.set_xlabel('Time')
ax.set_ylabel('Usage [Gal/min]')
fig.autofmt_xdate()
ax.set_title('Water Use Rate')
ax.grid('on')
rate_max = (counts * GAL).max()
total = (counts * GAL).sum()
ax.text(ax.get_xlim()[0], 0.9*rate_max, 'Total Usage: %d Gal' %(total))
fig.autofmt_xdate()
canvas = FigureCanvas(fig)
# output = BytesIO()
output = StringIO() # python 2.7x
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = '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():
cant = []
marcas = []
marcas_obj = Marca.objects.all().order_by("idMarca")
for m in marcas:
cant.append(Fraccionamiento.objects.filter(marca=marca).count())
marcas.append(m.pk)
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=HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
def plot_graph(symbol):
for item in gv.graph_frame.winfo_children():
item.destroy()
fig = Figure(figsize=(5, 2), dpi=85)
fig.patch.set_facecolor('black')
x = []
y = []
symbol_index = gv.user_input_list.index(symbol)
for entry in gv.master_datapoint_list[symbol_index].symbol_json['Time Series (Daily)']:
x.append(entry)
for entry in gv.master_datapoint_list[symbol_index].symbol_json['Time Series (Daily)']:
y.append(float(gv.master_datapoint_list[symbol_index].symbol_json['Time Series (Daily)'][entry]['4. close']))
plt.style.use('dark_background')
plot = fig.add_subplot(111)
fig.autofmt_xdate()
plot.plot(x, y)
plot.invert_xaxis()
n = int(gv.total_count / 25)
for index, label in enumerate(plot.xaxis.get_ticklabels()):
if index % n != 0:
label.set_visible(False)
canvas = FigureCanvasTkAgg(fig, master=gv.graph_frame)
canvas.draw()
canvas.get_tk_widget().place(relx=0, rely=0, relheight=.9, relwidth=1)
toolbar = NavigationToolbar2Tk(canvas, gv.graph_frame, pack_toolbar=False)
toolbar.place(relx=0, rely=.9, relheight=.1, relwidth=1)
toolbar.update()
def dailyMaxMin(self):
[datesA, wattsA] = self.building.dailyData
fig = Figure(facecolor='white', edgecolor='none')
ax = fig.add_subplot(111)
dailyMax = self.building.dailyStats['max'] / 1000
dailyMin = self.building.dailyStats['min'] / 1000
dailyMean = self.building.dailyStats['mean'] / 1000
dts = self.building.days
ax.fill_between(dts,
dailyMin,
dailyMax,
facecolor='#e6e6e6',
edgecolor='#e6e6e6')
ax.plot(dts, dailyMax, color='#aa2222', alpha=0.2, label='Daily max')
ax.plot(dts, dailyMean, color='#000000', label='Daily mean')
ax.plot(dts,
dailyMin,
color='#2222aa',
alpha=0.2,
label='Daily minimum')
monthFmt = mpld.DateFormatter('%m/%d/%y')
ax.set_title('Daily min, mean, and max (kW)')
ax.xaxis.set_major_formatter(monthFmt)
fig.autofmt_xdate()
ax.set_ylabel('kW')
ax.set_xlabel('Date')
ax.grid(True)
# rotate lables
#for l in ax.xaxis.get_majorticklabels(): l.set_rotation(70)
ax.legend(loc='upper right')
ax.yaxis.set_major_formatter(mplt.FormatStrFormatter('%0.1f'))
return fig
class GraphCanvas(FigureCanvas):
def __init__(self, data_frame, parent=None):
"""data_frame is Pandas DataFrame"""
if data_frame is None:
self.generate_data()
else:
self.data = data_frame
self.fig = Figure()
# TODO change to dynamic ylim
self.axes = self.fig.add_subplot(111, ylim=(0.0, 200.0))
self.axes.hold(False)
FigureCanvas.__init__(self, self.fig)
self.plot(data_frame)
def plot(self, data_frame):
"""takes a Pandas DataFrame and plots it"""
self.axes.plot(data_frame, 'o-')
self.axes.set_ylim(0.0, 200.0)
self.fig.autofmt_xdate()
self.draw()
def generate_data(self):
"""for debugging purposes"""
self.data = np.random.randint(1, 10, 10)
def printGraphPNG_Cases(data):
if location in area_Names_Cases:
fig = Figure(figsize=[10.0, 8.0])
ax = fig.add_subplot()
x = [datetime.datetime.strptime(d, '%Y-%m-%d').date() for d in dates_Cases]
y = cumulative_Cases
ax.xaxis.set_major_formatter(mdates.DateFormatter('%d-%b'))
ax.xaxis.set_major_locator(mdates.WeekdayLocator(MO))
ax.plot(x,y)
fig.autofmt_xdate()
ax.set_ylabel('Cumulative Cases', fontsize = 12, fontweight ='bold')
ax.set_title('Total Cases in ' + str(location) + ': ' + str(cumulative_Cases[0]) + ' - Last updated ' + str((datetime.datetime.strptime(dates_Cases[0], '%Y-%m-%d')).strftime('%a %d-%b-%Y')), fontsize = 12, fontweight ='bold')
ax.set_xlabel('Date', fontsize = 12, fontweight ='bold')
FigureCanvasAgg(fig).print_png(f'cases_for_{location}.png', dpi=200)
if location not in area_Names_Cases:
print(str(location) + " not found. Graph PNG not shown")
if location not in area_Names_Cases and location not in area_Names_Deaths:
print("Please choose from the following:")
areas = []
for areaName,_,_,_,_,_,_,_,_ in cases:
if areaName not in areas:
areas.append(areaName)
for area in sorted(areas):
print(area)
main()
def statistics(request):
from matplotlib.figure import Figure
fig = Figure()
now = datetime.datetime.now()
delta = datetime.timedelta(days=1)
value = np.random.standard_normal(40)
index = range(len(value))
# 여기서 그림1이 출력됨
plt.plot(index, value) # 선이나 마커를 플롯하는 함수
plt.xlim(0, 20) # x축 범위 설정
plt.ylim(np.min(value) - 1,
np.min(value) + 1) # y축 범위 설정 value 변수의 최솟값보다 하나 작은 값으로 아래 한계를 정하고, 최대값보다 하나 큰 값으로 위의 한계를 정함
# Plot 옵션 설정 및 꾸미기
plt.figure(figsize=(7, 4)) # plot의 모양. 가로 세로가 7인치, 4인치 비로 설정
plt.plot(value.cumsum(), 'b', lw=1.5) # plot 함수 호출 numpy.cumsum() : plot의 새로운 figure을 생성하는 함수. 'b' : 파란색, w=1.5(표시할 스타일)
plt.plot(value.cumsum(), 'ro') # plot 함수 호출 'ro'는 빨간색 동그라미를 의미
plt.xlabel('index') # x축 이름 설정
plt.ylabel('value') # y축 이름 설정
plt.title("Line Plot1") # 플롯의 제목을 설정하는 함수
plt.savefig("../.media/graphic/graphic.png", format='png')
fig.autofmt_xdate()
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
mpl.pyplot.close(fig)
return render(request, 'statistics/statistics.html')
def plot():
import io
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
fig = Figure()
ax1 = fig.add_subplot(211)
ax2 = fig.add_subplot(212)
ax1.plot_date(x, y, '-',color='green')
ax2.plot_date(x, z, '-',color='blue')
ax1.grid()
ax2.grid()
ax1.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
ax2.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
ax1.set_xlabel('Date')
ax1.set_ylabel('Price ($)')
ax1.set_title('Linear')
ax2.set_title('RBF')
fig.autofmt_xdate()
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 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 save_plot(fname, plot_name, plot):
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)
ax.xaxis.set_major_formatter(DateFormatter('%H:%M'))
ax.set_xlabel("Time")
ax.set_ylabel(plot_name)
fig.set_figheight(20)
fig.set_figwidth(30)
fig.autofmt_xdate()
handles = []
labels = []
for graph in plot:
x, y = plot[graph]
handles.append(ax.plot(x, y))
labels.append(graph)
fig.legend(handles, labels, 1, shadow=True)
canvas = FigureCanvas(fig)
canvas.print_figure(fname, dpi=80)
def simple_chart(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()
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 seizureDistribution(request):
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
seizures = Seizure.objects.all()
context = {'seizures': seizures}
time = sorted([seizure.time for seizure in seizures])
duration = [seizure.duration for seizure in seizures]
fig = Figure(facecolor="white", figsize=(12, 6))
ax = fig.add_subplot(111)
# ax.set_xlabel("Time")
ax.set_ylabel("Seizure Duration [s]")
ax.grid(True)
ax.plot_date(time, duration, '-', marker='o')
ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d %H:%M'))
fig.autofmt_xdate()
canvas = FigureCanvas(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
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 seizureFrequency(request, week=None):
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
from numpy import mean, array, max, nan_to_num
import seaborn as sns
sns.set(style="darkgrid", palette="Set2")
if not week:
seizures = Seizure.objects.all()
days = Seizure.objects.getDaysWithSeizures()
else:
seizures, days = getWeekSeizures(week)
seizureFrequency = [
len(sI) for sI in Seizure.objects.getSeizuresPerNight(days)
]
time = [seizure.time for seizure in seizures]
durationMean = []
for seizure in Seizure.objects.getSeizuresPerNight(days):
durationMean.append(mean([sI.duration for sI in seizure]))
# Get rid of nan
durationMean = nan_to_num(durationMean)
durationMeanNorm = durationMean / max(durationMean)
error_config = {'ecolor': '0.3'}
fig = Figure(facecolor="white", figsize=(12, 6))
ax = fig.add_subplot(111)
ax.set_xlabel("Time")
ax.set_ylabel("Seizures [-]")
ax.grid(True)
p = ax.bar(days,
seizureFrequency,
yerr=durationMeanNorm,
error_kw=error_config)
i = 0
for pI in p:
height = pI.get_height()
ax.text(
pI.get_x() + pI.get_width() / 2.,
height + durationMeanNorm[i],
'%1.2fs' % durationMean[i],
ha='center', # vertical alignment
va='bottom' # horizontal alignment
)
i += 1
ax.xaxis_date()
ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
fig.autofmt_xdate()
canvas = FigureCanvas(fig)
response = 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
class CoffeeCanvas(FigureCanvas):
def __init__(self):
self.fig = Figure() # Creates page
self.ax = self.fig.add_subplot(1,1,1) #Creates axis (rows/columns)
super().__init__(self.fig)
self.setSizePolicy(QSizePolicy.Expanding,QSizePolicy.Expanding) #Expand widget correctly
self.fig.canvas.draw() #draws the code
def show_bar_graph(self,data,date):
self.ax.clear() #clears previous plot
data_dict = dict(data)
for i, key in enumerate(data_dict):
self.ax.bar(i,data_dict[key]) #Convert data to a dictionary
self.ax.set_xticks(np.arange(len(data_dict))+0.4) #positioning for each tick on x-axis
self.ax.set_xticklabels(list(data_dict.keys())) #Sets labels
self.fig.autofmt_xdate() #formats labels so they don't overlap
self.ax.set_title("Total Sales for {0}".format(date))
self.ax.set_xlabel("Product")
self.ax.set_ylabel("Amount (£)")
self.fig.canvas.draw() #redraws widgets
def show_pie_chart(self,data,date):
self.ax.clear()
data_dict = dict(data)
data = list(data_dict.values())
labels = list(data_dict.keys()) #generate lists for dictionaries
self.ax.pie(data,labels=labels,autopct='%1.1f%%')#creates pie chart
self.ax.set_title("Percentage Sales for {0}".format(date))#title
self.fig.canvas.draw() #draws
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 draw_chart():
global canvas_chart
f = Figure(figsize=(12,6))
a = f.add_subplot(111)
f.autofmt_xdate(rotation=45)
a.set_ylabel("Total vehicle")
a.grid()
xs = []
ys = []
a.plot(xs,ys)
canvas_chart = FigureCanvasTkAgg(f, master=frame4)
canvas_chart.get_tk_widget().pack(side=LEFT)
def animate(xs, ys):
while True:
xs.append(dt.datetime.now().strftime('%H:%M:%S'))
ys.append(len(curr_trackers))
#gioi han list
xs = xs[-20:]
ys = ys[-20:]
a.clear()
a.grid()
a.plot(xs, ys)
f.autofmt_xdate(rotation=45)
canvas_chart.draw_idle()
print(xs)
print(ys)
time.sleep(1)
animate(xs,ys)
#animation.FuncAnimation(f, animate, interval=100)
'''toolbar = NavigationToolbar2Tk(canvas_chart, frame3)
class CoffeeCanvas(FigureCanvas):
def __init__(self):
self.fig = Figure()
self.ax = self.fig.add_subplot(1,1,1)
super().__init__(self.fig)
self.setSizePolicy(QSizePolicy.Expanding,QSizePolicy.Expanding)
self.fig.canvas.draw()
def show_bar_graph(self,data,date):
self.ax.clear()
data_dict = dict(data)
for i, key in enumerate(data_dict):
self.ax.bar(i,data_dict[key])
self.ax.set_xticks(np.arange(len(data_dict))+0.4)
self.ax.set_xticklabels(list(data_dict.keys()))
self.fig.autofmt_xdate()
self.ax.set_title("Total Sales for {0}".format(date))
self.ax.set_xlabel("Product")
self.ax.set_ylabel("Amount (£)")
self.fig.canvas.draw()
def show_pie_chart(self,data,date):
self.ax.clear()
data_dict = dict(data)
data = list(data_dict.values())
labels = list(data_dict.keys())
self.ax.pie(data,labels=labels,autopct='%1.1f%%')
self.ax.set_title("Percentage Sales for {0}".format(date))
self.fig.canvas.draw()
def simple_plot(request):
from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas
from matplotlib.figure import Figure
from matplotlib.dates import DateFormatter
c = Country.objects.all().order_by('?')[:1].get()
res=[]
year=[]
aids = Aid.objects.filter(pcountry=c)
for aid in aids:
res.append(aid.dollars)
year.append(aid.datesigned)
fig=Figure(facecolor="#f4faf6")
fig.set_figsize_inches( ( 4.50 ,3.472) )
ax=fig.add_subplot(111)
ax.set_axis_bgcolor("#f4faf6")
x=[]
y=[]
ax.plot_date(year, res, '.-')
ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
ax.set_xlabel('date received', alpha=0.5)
ax.set_ylabel('amount in Dollars', alpha=0.5)
ax.set_title('Total amount of USAID tenders for work in '+c.country)
fig.autofmt_xdate()
canvas=FigureCanvas(fig)
response=HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
