def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
f=Figure(figsize=(5, 5), dpi=100)
a=f.add_subplot(111)
x=range(len(df1['Actual']))
t0, =a.plot(x, df1['Actual'], color="red", marker="o", linestyle="-")
t1, =a.plot(x, df1['Predicted'], color="blue", marker="x", linestyle="-")
a.set_ylabel('Solar power Generated in KW/H')
a.set_xlabel('Hours')
a.grid()
f.legend((t0, t1), ('Actual', 'Predicted'), 'upper right')
canvas=FigureCanvasTkAgg(f, self)
canvas.draw()
canvas.get_tk_widget().pack()
toolbar=NavigationToolbar2Tk(canvas, self)
toolbar.update()
canvas._tkcanvas.pack()
label=tk.Label(self, text=txt)
label.pack()
btn=tk.Button(self, text="Back", command=lambda : controller.show_frame(pageone))
btn.pack()
btn1=tk.Button(self, text='Go to Home', command=lambda : controller.show_frame(startpage))
btn1.pack()
def history_graph(log, width, unit):
dpi = 100
figsize = (width / dpi, 0.3 * width / dpi)
fg = '#cccccc'
bg = '#000000'
fig = Figure(figsize=figsize, dpi=dpi, facecolor=bg, frameon=False)
taxis = fig.add_axes((0.08, 0.1, 0.68, 0.9), facecolor=bg)
lines = []
for sensor in log:
lines.append(taxis.plot(log[sensor]['time'], log[sensor]['value']))
taxis.set_ylabel('Temp (%s)' % unit, color=fg)
taxis.xaxis.set_tick_params(color=fg, labelcolor=fg)
taxis.yaxis.set_tick_params(color=fg, labelcolor=fg)
formatter = taxis.xaxis.get_major_formatter()
formatter.scaled[1. / 24] = '%-I%P'
formatter.scaled[1.0] = '%e'
formatter.scaled[30.] = '%b'
formatter.scaled[365.] = '%Y'
fig.legend(labels=log.keys())
canvas = FigureCanvas(fig)
output = io.BytesIO()
canvas.print_png(output)
return output
def _mixing_layer_depth_timeseries(self):
"""Create a time series graph figure object of the mixing
layer depth on the wind data date and the 6 days preceding it.
"""
fig = Figure((8, 3), facecolor='white')
ax = fig.add_subplot(1, 1, 1)
ax.set_position((0.125, 0.1, 0.775, 0.75))
predicate = np.logical_and(
self.mixing_layer_depth['avg_forcing'].mpl_dates >
date2num(self.config.data_date - datetime.timedelta(days=6)),
self.mixing_layer_depth['avg_forcing'].mpl_dates <=
date2num(self.config.data_date + datetime.timedelta(days=1)))
mpl_dates = self.mixing_layer_depth['avg_forcing'].mpl_dates[predicate]
dep_data = self.mixing_layer_depth['avg_forcing'].dep_data[predicate]
ax.plot(mpl_dates, dep_data, color='magenta')
ax.set_ylabel('Mixing Layer Depth [m]',
color='magenta',
size='x-small')
# Add line to mark profile time
profile_datetime = datetime.datetime.combine(self.config.data_date,
datetime.time(12))
profile_datetime_line = ax.axvline(date2num(profile_datetime),
color='black')
ax.xaxis.set_major_locator(DayLocator())
ax.xaxis.set_major_formatter(DateFormatter('%j\n%d-%b'))
ax.xaxis.set_minor_locator(HourLocator(interval=6))
for label in ax.get_xticklabels() + ax.get_yticklabels():
label.set_size('x-small')
ax.set_xlim((int(mpl_dates[0]), math.ceil(mpl_dates[-1])))
ax.set_xlabel('Year-Day', size='x-small')
fig.legend([profile_datetime_line], ['Profile Time'],
loc='upper right',
prop={'size': 'xx-small'})
return fig
class MatplotlibWidget(FigureCanvas):
def __init__(self, parent=None):
super(MatplotlibWidget, self).__init__(Figure())
#self.hide()
self.setParent(parent)
self.figure = Figure()
self.canvas = FigureCanvas(self.figure)
self.ax = self.figure.add_subplot(111)
self.ax.yaxis.grid(color='gray', linestyle='dashed')
def add_plot_line(self, x, y):
self.ax.plot(x, y, 'r')
def add_legend(self, list):
#list of strings like "X1 = blaghlbah"
self.figure.legend([x for x in list], loc='upper left')
def draw_graph(self):
self.figure.draw()
def show_graph(self):
self.figure.show()
def plot_bar_graph(self):
pass
def RMP_RHT():
if len(Frame2.winfo_children()) > 1:
for i in range(len(Frame2.winfo_children()) - 1):
Frame2.winfo_children()[1].destroy()
#Rendement malhonnete pratique
x = np.linspace(0, 0.5, 100)
y = np.linspace(0, 0.5, 100)
for i in range(len(y)):
RT = simulation_selfish_mining(float(valider()[1]), x[i],
float(valider()[2]))
y[i] = (RT[0]) / (RT[1])
#plt.plot(x,y)
#Rendement honnete theorique
x1 = np.linspace(0, 0.5, 100)
y1 = np.linspace(0, 0.5, 100)
for i in range(len(y1)):
y1[i] = (x1[i] * 6.25) / 600
fig = Figure(figsize=(6, 5), dpi=100)
fig.add_subplot(111).plot(x, y, x1, y1)
fig.legend(["Rendement malhonnete Pratique", "Rendement Honnete"])
#fig.add_subplot(111).plot(x1,y1)
canvas = FigureCanvasTkAgg(fig, master=Frame2) # A tk.DrawingArea.
canvas.draw()
#canvas.get_tk_widget().grid(row=13,column=1)
toolbar = NavigationToolbar2Tk(canvas, Frame2)
toolbar.update()
canvas.get_tk_widget().pack(side=tkinter.TOP, fill=tkinter.BOTH, expand=1)
def draw_labels(figure: Figure,
axes: Axes,
y_label: str,
label_rotation=90,
axes_position='bottom'):
# text and text parameters
xlabel_text = r'$incubation\ time\ \slash\ days$'
ylabel_text = y_label
ylabel_rotation = label_rotation
is_bottom = True if ('bottom' in axes_position
or axes_position == 'single') else False
# MRE notation,
if is_bottom:
MRE_notation_marks(axes) # add arrows where MRE was applied
# remove x axis from top and middle axes
if not is_bottom:
axes.get_xaxis().set_visible(False)
# x label
figure.text(0.5, 0.03, xlabel_text, ha='center')
# y label
figure.text(0.05, 0.5, ylabel_text, va='center', rotation=ylabel_rotation)
# legend
axes.get_lines()
handles = axes.get_lines()
labels = SOILS
figure.legend(handles, labels, 'center right')
def create_kde_figure():
# Draw Plot
fig = Figure(figsize=(13, 10), dpi=80)
axes = fig.add_subplot(111,
ylim=(0, 0.35),
title='Density Plot of City Mileage by n_Cylinders')
sns.kdeplot(mpg_df.loc[mpg_df['cyl'] == 4, "cty"],
shade=True,
color="g",
label="Cyl=4",
alpha=.7,
ax=axes)
sns.kdeplot(mpg_df.loc[mpg_df['cyl'] == 5, "cty"],
shade=True,
color="deeppink",
label="Cyl=5",
alpha=.7,
ax=axes)
sns.kdeplot(mpg_df.loc[mpg_df['cyl'] == 6, "cty"],
shade=True,
color="dodgerblue",
label="Cyl=6",
alpha=.7,
ax=axes)
sns.kdeplot(mpg_df.loc[mpg_df['cyl'] == 8, "cty"],
shade=True,
color="orange",
label="Cyl=8",
alpha=.7,
ax=axes)
# Decoration
fig.legend()
return fig
def _wchbl_tunujuch(x, tzij, rubi, ochochibäl):
fig = Figura()
TelaFigura(fig)
etajuch = fig.subplots(1, 2)
etajuch[0].set_title('Jachonem')
etajuch[1].set_title("Tunujuch'")
def ruyaik_juch(tz, rb_tz=None):
y = estad.gaussian_kde(tz)(x)
etajuch[0].plot(x, y, 'b-', lw=2, alpha=0.6, label=rb_tz, color=None)
etajuch[1].plot(tz)
if isinstance(tzij, dict):
for rb, tzj in tzij.items():
ruyaik_juch(tzj, rb)
fig.legend()
else:
ruyaik_juch(tz=tzij)
fig.suptitle(rubi)
rubi_wuj = 'wchbl_' + rubi + '.png'
if len(ochochibäl) and not os.path.isdir(ochochibäl):
os.makedirs(ochochibäl)
fig.savefig(os.path.join(ochochibäl, rubi_wuj))
def add_unique_figure_legend(fig: Figure, axes: Axes) -> None:
"""Add a legend with unique elements sorted by label to a figure.
The handles and labels are extracted from the ``axes``
Parameters
----------
fig : Figure
Figure to add the legend to.
axes : Axes
Axes plotted on the figure.
See Also
--------
plot_fit_overview
"""
handles = []
labels = []
for ax in axes.flatten():
ax_handles, ax_labels = ax.get_legend_handles_labels()
handles += ax_handles
labels += ax_labels
unique = [(h, l) for i, (h, l) in enumerate(zip(handles, labels))
if l not in labels[:i]]
unique.sort(key=lambda entry: entry[1])
fig.legend(*zip(*unique))
def create_dotbox_figure():
sns.set_style("white")
# Draw Plot
fig = Figure(figsize=(13, 10), dpi=80)
axes = fig.add_subplot(
111, title="Box Plot of Highway Mileage by Vehicle Class")
sns.boxplot(x='class', y='hwy', data=mpg_df, hue='cyl', ax=axes)
sns.stripplot(x='class',
y='hwy',
data=mpg_df,
color='black',
size=3,
jitter=1,
ax=axes)
for i in range(len(mpg_df['class'].unique()) - 1):
axes.vlines(i + .5,
10,
45,
linestyles='solid',
colors='gray',
alpha=0.2)
# Decoration
fig.legend(title='Cylinders')
return fig
def create_palive_figure(path, path_dates, sp_trans):
red = '#B6324F'
blue = '#176BA0' # '#4580A9'
lg = 'grey'
fig = Figure(figsize=(8, 5))
ax = fig.subplots()
ax.plot(path_dates, path, c=blue, label='probability of being alive')
ax.vlines(sp_trans['event_time'], 0, 1, colors=red, label='purchase events', linestyles='dashed')
ax.set_xlabel('Time', color=lg, fontsize='large')
ax.set_ylabel('probability of being alive', color=lg, fontsize='large')
ax.xaxis.set_major_formatter(mdates.DateFormatter("%m-%d"))
ax.tick_params(axis='x', length=5, colors=lg)
ax.tick_params(axis='y', length=5, colors=lg)
ax.spines['bottom'].set_color(lg)
ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.spines['bottom'].set_linewidth(.5)
ax.spines['left'].set_linewidth(.5)
ax.spines['left'].set_color(lg)
ax.spines['bottom'].set_color(lg)
fig.legend(edgecolor='w', labelcolor=lg, fontsize='large')
buf = BytesIO()
fig.savefig(buf, format="png")
fig_data = base64.b64encode(buf.getbuffer()).decode("utf8")
return fig_data
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
#setting up label for the graph
Label(self, text="Displaying the Graph",
font=('Arial Bold', 20)).pack()
f = Figure(figsize=(5, 5), dpi=100)
a = f.add_subplot(111)
#plotting the x_values in the graph
x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#Plotting the lines of the graph
t0, = a.plot(x, [2, 3, 5, 2, 1, 9, 4, 2, 1, 3],
color="red",
marker="o",
linestyle="-")
t1, = a.plot(x, [5, 5, 3, 2, 8, 1, 9, 3, 2, 1],
color="blue",
marker="x",
linestyle="-")
#setting up labels for the graph
a.set_ylabel('y_scattered')
a.set_xlabel('x_scattered')
a.grid()
#creating the legends for the graph
f.legend((t0, t1), ('line-1', 'line-2'), 'upper right')
#creating the canvas for the graph
canvas = FigureCanvasTkAgg(f, self)
#drawing the canvas
canvas.draw()
canvas.get_tk_widget().pack()
#creating the navigation tool bar for the graph using matplotlib
toolbar = NavigationToolbar2Tk(canvas, self)
toolbar.update()
#packing the whole canvas with navigation tool bar and the graph diagram
canvas._tkcanvas.pack()
def evolution_fallecidos():
datamodel.updater(data) # Call to update
fig = Figure(figsize=(12, 7))
ax = fig.add_subplot(1, 1, 1)
xss = [str(i) for i in range(1, len(data.muertes_acc) + 1)]
xs = range(0, len(data.muertes_acc))
ax.plot(xss, data.muertes_acc, 'o-', label='Casos acumulados')
ax.plot(xss, data.muertes, 'o-', label='Casos en el d铆a')
for x, y in zip(xs, data.muertes_acc):
label = "{}".format(y)
ax.annotate(label, (x, y),
textcoords='offset points',
xytext=(0, 10),
ha='center')
for x, y in zip(xs, data.muertes):
label = "{}".format(y)
ax.annotate(label, (x, y),
textcoords='offset points',
xytext=(0, -15),
ha='center')
ax.set_title('Evoluci贸n de casos por d铆as (Fallecidos)', fontsize=15)
fig.legend(frameon=True, fontsize=12)
FigureCanvasAgg(fig).print_png('fallecidos.png')
return send_file('fallecidos.png')
def RMT_RHT():
if len(Frame2.winfo_children()) > 1:
for i in range(len(Frame2.winfo_children()) - 1):
Frame2.winfo_children()[1].destroy()
#Rendement theorique en fonction de q
x = np.linspace(0, 0.5, 100)
y = np.linspace(0, 0.5, 100)
for i in range(len(y)):
y[i] = attacker_revenue_ratio(float(valider()[2]), float(valider()[4]),
x[i])
#Rendement honnete theorique en fonction de q
x1 = np.linspace(0, 0.5, 100)
y1 = np.linspace(0, 0.5, 100)
for i in range(len(y1)):
y1[i] = (x1[i] * 6.25) / 600
fig = Figure(figsize=(6, 5), dpi=100)
fig.suptitle('Comparison of theoritical honest and dishonest performance')
fig.add_subplot(111).plot(x, y, x1, y1)
fig.legend(["Rendement malhonnete Theorique", "Rendement Honnete"])
#fig.add_subplot(111).plot(x1,y1)
canvas = FigureCanvasTkAgg(fig, master=Frame2) # A tk.DrawingArea.
canvas.draw()
#canvas.get_tk_widget().grid(row=13,column=1)
toolbar = NavigationToolbar2Tk(canvas, Frame2)
toolbar.update()
canvas.get_tk_widget().pack(side=tkinter.TOP, fill=tkinter.BOTH, expand=1)
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)
class PageThree(tk.Frame):
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
label = tk.Label(self, text="Correlation tool", font=FONT_TITLE)
label.pack(pady=10, padx=10, side=tk.LEFT)
self.figframe = tk.Frame(self)
self.figframe.pack()
self.values = []
button1 = ttk.Button(
self,
text="Add random obs",
command=lambda: self.addObservations(
random.choice(["sugar", "bean", "peanuts", "dew", "apple"]),
[randrange(1, 23, 1)
for i in range(8)], [randrange(1, 23, 1) for i in range(8)],
color=random.choice([
'green', 'red', 'blue', 'yellow', 'black', 'orange', 'grey'
])))
button1.pack()
self.addObservations("coffee", [randrange(1, 23, 1) for i in range(8)],
[randrange(1, 23, 1) for i in range(8)],
color=random.choice([
'green', 'red', 'blue', 'yellow', 'black',
'orange', 'grey'
]))
def addvaluesandlabel(self, label, x, y):
self.values.append((label, x, y))
def addObservations(self, name, x, y, color="red", alpha=0.5):
self.figframe.pack_forget()
self.figframe.destroy()
self.figframe = tk.Frame(self)
self.figframe.pack()
self.f = Figure(figsize=(5, 5), dpi=100)
self.values.append((name, x, y, color, alpha))
for row in self.values:
a = self.f.add_subplot(1, 1, 1)
rowname, x, y, color, alpha = row
a.scatter(x,
y,
alpha=alpha,
color=color,
edgecolors='none',
s=30,
label=rowname)
self.f.legend(rowname)
canvas = FigureCanvasTkAgg(self.f, self.figframe)
canvas.draw()
canvas.get_tk_widget().pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True)
toolbar = NavigationToolbar2Tk(canvas, self.figframe)
toolbar.update()
canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
print(self.values)
def graphs2(exercises):
""" Scatter (time-distance) plot from exercises"""
fig = Figure()
ax = fig.add_subplot(111)
distances = []
times = []
sports = []
sport_types = []
for e in exercises:
distances.append(e.distance)
times.append(e.time_as_hours)
sports.append(e.sport)
sport_types.append(e.sub_sport)
recs = []
sport_names = list(set(sports))
nsports = len(sport_names)
color_dict = get_color_dict(sport_names)
if nsports > 1:
sport_list = get_sport_list()
coloring_sports = sports
else:
s_type = sport_names[0]
coloring_sports = make_sub_sport_list(sport_types, s_type)
sub_sport_names = list(set(coloring_sports))
sport_list = get_sub_sport_list(s_type)
try:
# ax.scatter(d,t, c=[ color_dict[i] for i in cc])
ax.scatter(distances, times, c=[color_dict[i] for i in coloring_sports])
except KeyError:
# plot without colors
ax.scatter(distances, times)
if nsports > 1:
for i in sport_names: # range(0,len(set(cc))): # legend color for unique sport values
recs.append(mpatches.Rectangle((0, 0), 1, 1, fc=color_list[sport_list.index(i)]))
fig.legend(recs, sport_names, 'right')
else:
for i in sub_sport_names:
recs.append(mpatches.Rectangle((0, 0), 1, 1, fc=color_list[sport_list.index(i)]))
fig.legend(recs, sub_sport_names, 'right')
title = get_date_title(exercises)
fig.suptitle(title)
ax.set_xlabel(dist_label)
ax.set_ylabel(time_label)
ax.get_xaxis().get_major_formatter().set_useOffset(False)
ax.get_yaxis().get_major_formatter().set_useOffset(False)
# fig.axes(x='distance', y='time')
return graph_response(fig)
def make_fig(self, start_time, end_time):
fig = Figure(figsize=(8,8), dpi=72)
self.lines = []
N = len(self.channels)
self.ax = fig.add_subplot(1,1,1) #new singleplot configuration
colordict = ['#A6D1FF','green','red','cyan','magenta','yellow','white']
minx = 0
maxx = 0
graph = []
for i, channel in enumerate(self.channels):
#subplot syntax is numrows, numcolumns, subplot ID
print "ArrayMapper.make_fig(): self.X is is " , self.X, type(self.X), len(self.X)
print "ArrayMapper.make_fig(): channel is ", channel
print "ArrayMapper.make_fig(): self.numSamples=", self.numSamples
time_range = arange(self.numSamples)
#print "start_time= ", start_time, "end_time =", end_time
if ((start_time != None) & (end_time != None)):
time_range = arange(start_time, end_time, (end_time - start_time)/self.numSamples)
#print "time_range is ", time_range
x = self.X[channel-1,:]
if minx > min(x):
minx = copy.deepcopy(min(x))
if maxx < max(x):
maxx = copy.deepcopy(max(x))
color = colordict[((i-1)%7)]
newp = self.ax.plot(time_range, x, color, label=("channel " + str(i+1)))
newp[0].set_linewidth(4)
graph.append(newp)
self.ax.set_xlabel('index')
self.ax.set_title('Evoked response')
#self.ax.legend()
fig.legend(graph,self.channels,'upper right')
if ((start_time != None) & (end_time != None)):
mid = start_time + (end_time - start_time)/2.0
else:
mid = self.numSamples/2.0
#print "setting up line at (([%d, %d], [%d, %d])[0]" % (mid, mid, min(x), max(x))
LO = self.view3.newLength/2
#line = self.ax.plot([mid, mid], [minx, maxx],'w')[0]
#left edge of window:
line = self.ax.plot([mid-LO, mid-LO], [minx, maxx],'y')[0]
self.ax.add_line(line)
self.lines.append(line)
#middle of window, where the scalar data comes from:
line = self.ax.plot([mid, mid], [minx, maxx],'r')[0]
self.ax.add_line(line)
self.lines.append(line)
#right edge of window
line = self.ax.plot([mid+LO, mid+LO], [minx, maxx],'y')[0]
self.ax.add_line(line)
self.lines.append(line)
self.ax.patch.set_facecolor('black') #transparency
self.finishedFigure = fig
return fig
def plot_africa_totals(data, colors=['blue', 'orangered', 'lawngreen']):
"""Create lineplots of coronavirus case totals in Africa.
Parameters:
----------
data: pd.DateFrame
A dataframe of historic coronavirus cases in Africa.
colors: str, valid matplotlib color input
Colors to apply to the 'confirmed', 'deaths', and 'recovered'
lineplots, respectively'.
"""
# Convert Date column values to Timestamps
data['Date'] = data['Date'].astype('datetime64')
# Calculate totals for each day. After this, only the columns 'Confirmed'
# 'Deaths' and 'Recovered' remain, with 'Date' becoming the index.
data = data.groupby('Date').sum()
latest_date = data.index.max().strftime('%h %d, %Y') # used in title
# Create a matplotlib Figure, with lineplots for 'confirmed', 'recovered',
# and 'deaths'
fig = Figure(figsize=(10, 5), dpi=200)
fig.suptitle(f'Total Coronavirus Cases in Africa as at {latest_date}',
size=18)
ax = fig.subplots()
for idx, label in enumerate(['Confirmed', 'Deaths', 'Recovered']):
ax.plot(data[label].index,
data[label],
lw=2,
color=colors[idx],
label=label)
# Annotate lineplots with current totals
for line in ax.lines:
x_coord, y_coord = line.get_xydata()[-1] # position of latest totals
ax.annotate(
f'{line.get_ydata().max():,}', # latest total
xy=(x_coord + 4, y_coord),
style='oblique')
ax.tick_params(axis='x', rotation=60) # rotate x-axis ticks (dates) by 60°
ax.yaxis.grid() # draw horizontal gridlines
ax.set_ylabel('Total Cases', size=14)
despine(ax) # remove bordering box
# Show y-axis ticks as full plain text, instead of in scientific notation
ax.ticklabel_format(axis='y', style='plain')
# Set the x-axis to show dates in 2-week intervals
ax.xaxis.set_major_locator(mdates.WeekdayLocator(interval=2))
ax.xaxis.set_major_formatter(mdates.DateFormatter('%h %d')) # e.g. Jan 20
fig.legend(loc='right')
fig.savefig('images/africa_totals.png',
bbox_inches='tight',
transparent=True)
def evolution():
datamodel.updater(data) # Call to update
fig = Figure(figsize=(12, 8))
ax = fig.add_subplot(1, 1, 1)
xss = [str(i) for i in range(1, len(data.diagnosticados_acc) + 1)]
xs = range(0, len(data.diagnosticados_acc))
ax.plot(xss,
data.diagnosticados_acc,
'o-',
label='Casos acumulados',
color=red,
alpha=0.5)
ax.plot(xss, data.activos_acc, 'o-', label='Casos activos', color=red)
ax.plot(xss,
data.diagnosticados,
'o-',
label='Casos en el d铆a',
color=cyan)
for x, y in zip(xs, data.diagnosticados_acc):
label = "{}".format(y)
ax.annotate(label, (x, y),
textcoords='offset points',
xytext=(0, 10),
ha='center')
for x, y in zip(xs, data.activos_acc):
label = "{}".format(y)
ax.annotate(label, (x, y),
textcoords='offset points',
xytext=(0, 10),
ha='center')
for x, y in zip(xs, data.diagnosticados):
label = "{}".format(y)
ax.annotate(label, (x, y),
textcoords='offset points',
xytext=(0, -17),
ha='center')
ax.set_title('Evoluci贸n de casos por d铆as', fontsize=20)
fig.legend(frameon=True, fontsize=12)
FigureCanvasAgg(fig).print_png('evolution.png')
apiurl = config.SERVER_URI + '/evolution'
watermark_text('evolution.png', 'evolution.png', apiurl, (0, 0))
return send_file('evolution.png')
def evolution_graph(data):
filename = 'evolution_graph.png'
fig = Figure(figsize=(18, 10))
ax = fig.add_subplot(1, 1, 1)
xss = [str(i) for i in range(1, len(data['diagnosticados_acc']) + 1)]
xs = range(0, len(data['diagnosticados_acc']))
ax.plot(xss,
data['diagnosticados_acc'],
'o-',
label='Casos acumulados',
color=red,
alpha=0.5)
ax.plot(xss, data['activos_acc'], 'o-', label='Casos activos', color=red)
ax.plot(xss,
data['diagnosticados'],
'o-',
label='Casos en el día',
color=cyan)
for x, y in zip(xs, data['diagnosticados_acc']):
label = "{}".format(y)
ax.annotate(label, (x, y),
textcoords='offset points',
xytext=(0, 10),
ha='center')
for x, y in zip(xs, data['activos_acc']):
label = "{}".format(y)
ax.annotate(label, (x, y),
textcoords='offset points',
xytext=(0, 10),
ha='center')
for x, y in zip(xs, data['diagnosticados']):
label = "{}".format(y)
ax.annotate(label, (x, y),
textcoords='offset points',
xytext=(0, -17),
ha='center')
ax.set_title('Evolución de casos por días', fontsize=18)
fig.legend(frameon=True, fontsize=12)
FigureCanvasAgg(fig).print_png(filename)
apiurl = config.SERVER_URI + '/evolution_graph'
watermark_text(filename, filename, apiurl, (0, 0))
return filename
def graph():
"""
Endpoint for generating a graph from the database
Takes to optional form arguments
start_time: UNIX timestamp
earliest data point to retrieve
end time: UNIX timestamp
latest data point to retrieve
"""
# Try to get params request
params = extract_variables(['start_time', 'end_time', 'sensor_id'],
request)
# Fetch data from database
results = query_climate_range(**params)
# Turn it in to lists which can be graphed
dates = []
humids = []
temps = []
pressures = []
for result in results:
dates.append(datetime.datetime.fromtimestamp(result['time']))
humids.append(result['humid'])
temps.append(result['temp'])
pressures.append(result['pressure'])
# Graph it
fig = Figure()
# First y axis (temp and humid)
axis = fig.add_subplot(1, 1, 1)
# Plot humidity and temp on the same scale
axis.plot_date(dates, humids, '-', color=COLORS['blue'])
axis.plot_date(dates, temps, '-', color=COLORS['red'])
axis.xaxis.set_major_formatter(DateFormatter('%d/%m/%y %H:%M'))
axis.set_ylabel('Humidity in % & Temps in C')
axis.set_xlabel('Time')
# Second y axis (pressure)
axis_pressure = axis.twinx()
# Plot pressure
axis_pressure.plot_date(dates, pressures, '-', color=COLORS['green'])
axis_pressure.xaxis.set_major_formatter(DateFormatter('%d/%m/%y %H:%M'))
axis_pressure.set_ylabel('Pressure in mbar')
# Configure the figure
fig.autofmt_xdate()
fig.legend(['Humidity', 'Temperature', 'Pressure'], loc='lower right')
fig.set_tight_layout(True)
canvas = FigureCanvas(fig)
# Save output
png_output = BytesIO()
canvas.print_png(png_output)
# Create the response and send it
response = make_response(png_output.getvalue())
response.headers['Content-Type'] = 'image/png'
return response
def PlotResults (self, plot_frame, excel_frame):
popup_window = Toplevel(self.window)
popup_window.title("Results")
plot_frame = plot_frame.sort_values(by='Cluster Count',ascending=False)
plot_frame["Cumulative Percentage"] = plot_frame['Cluster Count'].cumsum()/plot_frame['Cluster Count'].sum()*100
# print (f'{plot_frame["Cluster Count"]} {plot_frame["Cumulative Percentage"]}')
fig = Figure(figsize=(40,5))
ax = fig.add_subplot(111)
ax.bar(plot_frame['Cluster'], plot_frame["Cluster Count"], color="C0")
ax2 = ax.twinx()
ax2.plot(plot_frame['Cluster'], plot_frame["Cumulative Percentage"], color="C1", marker="D", ms=7)
ax2.yaxis.set_major_formatter(PercentFormatter())
ax.tick_params(axis="y", colors="C0")
ax2.tick_params(axis="y", colors="C1")
fig.legend()
ax.set_title ("RESULTS - Summary of categorized Ticket Data (Most contributing to least contributing categories)", fontsize=20)
ax.set_ylabel("# of Tickets", fontsize=10)
ax.set_xlabel("Category #", fontsize=10)
canvas = FigureCanvasTkAgg(fig, master=popup_window )
tree = ttk.Treeview(popup_window)
tree["columns"]=("one","two")
tree.column("one", width=500 )
tree.column("two", width=500)
tree.heading("one", text="Formatted Input Data")
tree.heading("two", text="Raw Input Data")
i = 0
for clusterindex, row in plot_frame.iterrows():
try:
id2 = tree.insert("", i, row["Cluster"], text="Category "+ str(clusterindex + 1) + " -> " + str(row["Cluster Count"]) + " tickets" +" - " + row["Machine Tag"].upper())
for excelindex, excelrow in excel_frame.iterrows():
if (clusterindex == excelrow['Machine Cluster'] ):
tree.insert(id2, "end", excelindex, text=excelindex, values=(excelrow['Transformed Data'],excelrow['Issue']))
# handles parameters in different way
except:
id2 = tree.insert("", i, row["Cluster"], text="Tag -> " + row["Machine Tag"].upper() +" - " + str(row["Cluster Count"]) + " tickets")
for excelindex, excelrow in excel_frame.iterrows():
if (clusterindex == excelrow['Machine Tag'] ):
tree.insert(id2, "end", excelindex, text=excelindex, values=(excelrow['Transformed Data'],excelrow['Issue']))
i+= 1
exportbutton = Button(popup_window, text="Export the Results", command=lambda : self.ExportData(excel_frame))
canvas.get_tk_widget().pack()
tree.pack()
exportbutton.pack()
def graph():
button_graph.config(state=tk.DISABLED)
def enable():
button_graph.config(state=tk.NORMAL)
graphwin.destroy()
conn = sqlite3.connect('CSVDB1.db')
# create a database connection
cur = conn.cursor()
cur.execute("SELECT * FROM record")
rows = cur.fetchall()
# list = [i.replace('(','') for i in rows]
df = pd.DataFrame(rows)
time = df[0].tolist()
total = df[1].tolist()
car = df[2].tolist()
bus = df[3].tolist()
person = df[4].tolist()
bike = df[5].tolist()
cycle = df[6].tolist()
truck = df[7].tolist()
# car = df[1].tolist()
# bike = df[2].tolist()
# bus = df[3].tolist()
# cycle = df[4].tolist()
# truck = df[5].tolist()
# --------------------------------------------------------------
fig = Figure(figsize=(10, 6), facecolor='white')
# --------------------------------------------------------------
axis = fig.add_subplot(111)
axis.set_title("Graph plot of different vehicles and their count")
t0, = axis.plot(time, car)
t1, = axis.plot(time, bike)
t2, = axis.plot(time, bus)
t3, = axis.plot(time, cycle)
t4, = axis.plot(time, truck)
# axis.xticks(rotation=90)
axis.set_ylabel('COUNT')
axis.set_xlabel('TIME')
axis.xaxis.set_major_locator(plt.MaxNLocator(4))
# axis.set_xticklabels(time, rotation=45, ha='right')
axis.grid()
fig.legend((t0, t1, t2, t3, t4), ('CAR', 'BIKE', 'BUS', 'CYCLE', 'TRUCK'), 'upper right')
graphwin = tk.Toplevel()
graphwin.protocol("WM_DELETE_WINDOW", enable)
canvas = FigureCanvasTkAgg(fig, master=graphwin)
canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
graphwin.update()
graphwin.deiconify()
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
label = ttk.Label(self, text="Facebook Stock (Graph)", font=LARGE_FONT)
label.pack(pady=10, padx=10)
button1 = ttk.Button(self, text="Back to Home", command=lambda: controller.show_frame(InitialPage))
button1.pack()
# GRAPHSSSS
f = Figure(figsize=(14, 8), dpi=100)
ax = f.add_subplot(111, label="1")
ax2 = f.add_subplot(111, label="2", frame_on=False)
ax3 = f.add_subplot(111, label="3", frame_on=False)
title = "Facebook Stock Prices\nCurennt Price: " + FacebookCurrentPrice
# REGULAR PRICE LINE
ax.plot(FacebookDates, FacebookPrices, 'b', label="Stock Price", linewidth=2)
ax.set_title(title)
ax.tick_params('x', labelrotation=90)
ax.set_ylim([140, 205])
# 13 DAY MOVING AVERAGE LINE
ax2.plot(FacebookDailyDates[12:], facebook_moving_averages13, 'g--', label="13 Day Moving Average")
ax2.axes.get_xaxis().set_visible(False)
ax2.set_ylim([140, 205])
# 52 DAY MOVING AVERAGE LINE
ax3.plot(FacebookDailyDates[51:], facebook_moving_averages52, 'r--', label="52 Day Moving Average")
ax3.axes.get_xaxis().set_visible(False)
ax3.set_ylim([140, 205])
f.legend()
canvas = FigureCanvasTkAgg(f, self)
canvas.draw()
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)
toolbar = NavigationToolbar2TkAgg(canvas, self)
toolbar.update()
canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
# ALGORITHM
intersections = intersection(facebook_moving_averages13, facebook_moving_averages52, FacebookDailyDates)
# ALGORITHM FINDINGS
def clicked():
messagebox.showinfo('Algorithm Findings',
'Crossing Average Intersections: ' + str(len(intersections)) + '\n'
+ "Intersection Dates: " + '\n' + str( intersections))
button2 = ttk.Button(self, text="Algorithm Findings", command=clicked)
button2.pack()
def buildActivityGraph(year):
con = db.create_connection()
df = pd.read_sql_query(
'SELECT date, activity FROM arrivals WHERE strftime(\'%Y\', date) = "{}" AND activity <> "" ORDER BY date'
.format(year),
con,
parse_dates=['date'],
index_col=['date'])
con.close()
fig = Figure(figsize=(12, 12))
axis = fig.subplots(1)
if df.empty == False:
df_activity = df.groupby(
'date').activity.value_counts().unstack().fillna(0)
resampled = df_activity.resample('W').sum()
columns = resampled.columns
labels = columns.values.tolist()
colour_map = cm.get_cmap('tab20', len(columns) + 1)
x = resampled.index
bottom = np.zeros(resampled.shape[0])
for i, column in enumerate(columns, start=0):
axis.bar(x,
resampled[column].values.tolist(),
bottom=bottom,
label=column,
color=colour_map.colors[i])
bottom += resampled[column].values.tolist()
date_format = mpl_dates.DateFormatter('%d %b %Y')
axis.xaxis_date()
axis.xaxis.set_major_formatter(date_format)
axis.set_title('Weekly arrival activity at Aberdeen {}'.format(year))
fig.legend(loc='center right',
fancybox=True,
shadow=True,
fontsize=10,
ncol=2)
fig.autofmt_xdate()
fig.tight_layout()
fig.subplots_adjust(right=0.75)
canvas = FigureCanvas(fig)
output = io.BytesIO()
canvas.print_png(output)
response = make_response(output.getvalue())
response.mimetype = 'image/png'
return response
def plot_yahoo(root):
global file_dir
global ticker_var
global date_var
ticker = ticker_var.get()
file_path = file_dir.get()
date = date_var.get()
try:
prices = pd.read_csv(file_path+'/'+date+'_'+ticker+'.csv')
prices['formatted_date']=pd.to_datetime(prices['formatted_date'])
prices.set_index('formatted_date', inplace=True)
sentiments = pd.read_csv(file_path+'/'+ticker+'_sentiments.csv')
except:
messagebox.showerror(title='File Select Error', message='No file present!')
return
sentiments['Filing Date'] = pd.to_datetime(sentiments['Filing Date'])
sentiments.sort_values(by=['Filing Date'], inplace=True, ascending=True)
info = pd.merge(prices,sentiments,left_index=True,right_on='Filing Date')
info.set_index('Filing Date', inplace=True)
info = info.drop(columns=['high','low','open','close','volume','1d returns','2d returns','3d returns','5d returns','10d returns','Symbol_x','Symbol_y','Report Type'])
info['Total Words'] = info['Positive']+info['Negative']+info['Uncertainty']+info['Litigious']+info['Constraining']+info['Superfluous']+info['Interesting']+info['Modal']
info[['Positive','Negative','Uncertainty','Litigious','Constraining','Superfluous','Interesting','Modal']]=info[['Positive','Negative','Uncertainty','Litigious','Constraining','Superfluous','Interesting','Modal']].div(info['Total Words'], axis=0)
normalised_prices=(info['adjclose']-info['adjclose'].min())/(info['adjclose'].max()-info['adjclose'].min())
normalised_Positive=(info['Positive']-info['Positive'].min())/(info['Positive'].max()-info['Positive'].min())
normalised_Negative=(info['Negative']-info['Negative'].min())/(info['Negative'].max()-info['Negative'].min())
normalised_Uncertainty=(info['Uncertainty']-info['Uncertainty'].min())/(info['Uncertainty'].max()-info['Uncertainty'].min())
normalised_Litigious=(info['Litigious']-info['Litigious'].min())/(info['Litigious'].max()-info['Litigious'].min())
normalised_Constraining=(info['Constraining']-info['Constraining'].min())/(info['Constraining'].max()-info['Constraining'].min())
normalised_Superfluous=(info['Superfluous']-info['Superfluous'].min())/(info['Superfluous'].max()-info['Superfluous'].min())
normalised_Interesting=(info['Interesting']-info['Interesting'].min())/(info['Interesting'].max()-info['Interesting'].min())
normalised_Modal=(info['Modal']-info['Modal'].min())/(info['Modal'].max()-info['Modal'].min())
info = info.drop(columns='Total Words')
dates=info.index
fig = Figure(figsize=(5, 4), dpi=100)
a = fig.add_subplot(111)
a.plot(dates,normalised_prices,label='Price')
a.plot(dates,normalised_Positive,label='Positive')
a.plot(dates,normalised_Negative,label='Negative')
a.plot(dates,normalised_Uncertainty,label='Uncertainty')
a.plot(dates,normalised_Litigious,label='Litigious')
a.plot(dates,normalised_Constraining,label='Constraining')
a.plot(dates,normalised_Superfluous,label='Superfluous')
a.plot(dates,normalised_Interesting,label='Interesting')
a.plot(dates,normalised_Modal,label='Modal')
fig.legend()
canvas = FigureCanvasTkAgg(fig, master=root)
canvas.draw()
canvas.get_tk_widget().grid(row=2,columnspan=4,sticky=N+S+W+E)
def plot_spectrum(real, fake):
x = np.linspace(1, 31, 31, endpoint=True)
fig = Figure()
canvas = FigureCanvasAgg(fig)
ax = fig.gca()
plot_real, = ax.plot(x, real)
plot_fake, = ax.plot(x, fake)
fig.legend((plot_real,plot_fake), ('real', 'fake'))
canvas.draw()
I = np.fromstring(canvas.tostring_rgb(), dtype='uint8', sep='')
I = I.reshape(canvas.get_width_height()[::-1]+(3,))
I = np.transpose(I, [2,0,1])
return np.float32(I)
def create_window_graph(xas,yas,labname):
window = tk.Toplevel()
#t = np.arange(5, 10, .01) #plotter x axes
#t1 = np.arange(10, 15, .01) #plotter x axes
fig = Figure(figsize=(8, 4), dpi=80)
ax = fig.add_subplot(111)
ax.plot(xas,yas, 'r--', label = labname)#plotter y og x axes NB DE MÅ VÆRE LIKE LANGE OM DU VIL HA EN NY LINJE COPY PAST DENNE
ax.set_xlim(xmin =1 , xmax = 10)
fig.legend()
canvas = FigureCanvasTkAgg(fig, master=window)
canvas.draw()
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
toolbar = NavigationToolbar2Tk(canvas, window)
toolbar.update()
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
def on_key_press(event):
print("you pressed {}".format(event.key))
key_press_handler(event, canvas, toolbar)
canvas.mpl_connect("key_press_event", on_key_press)
def _quit():
#window.quit()
window.destroy()
lable32 = tk.Label(master = window, text = "Time")
lable32.pack()
sap = tk.Label(master = window, text = "")
sap.pack()
button = tk.Button(master=window, text="Quit", command=_quit, bg='red', fg='white', font=('helvetica', 10, 'bold'))
button.pack()
class PlotCanvas(FigureCanvas):
def __init__(self, parent=None, width=8.8, height=10.5, dpi=100, title=' '):
self.fig = Figure(figsize=(width, height), dpi=dpi)
FigureCanvas.__init__(self, self.fig)
self.setStyleSheet("background-color:rgb(240,240,240);")
self.fig.set_facecolor("none")
self.axes = self.fig.add_subplot(111)
self.setParent(parent)
self.title = title
self.set_up_plot()
FigureCanvas.setSizePolicy(self, QSizePolicy.Expanding, QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
def set_up_plot(self):
self.axes.cla()
self.axes.grid(True, which='both', axis='both')
self.axes.set_xscale('linear')
self.axes.set_yscale('linear')
self.axes.set_title(self.title)
def plot(self, x, y, do_cla=True, **kwargs):
if do_cla:
self.axes.cla() # Стереть всё предыдущее
self.axes.grid(True, which='both', axis='both')
self.axes.plot(x, y, **kwargs)
if 'label' in kwargs:
self.fig.legend()
self.fig.canvas.draw_idle()
def add_point(self, x, y, **kwargs):
self.axes.plot(x, y, **kwargs)
self.fig.canvas.draw_idle()
def clear(self):
self.axes.cla()
#self.axes.clear()
def set_xlim(self, left, right):
self.axes.set_xlim(left, right)
def setFrameShape(self, styled_panel):
pass # Этот метод вызывается в автоматически сгенерированном коде от Qt Designer, но нам он не нужен
def setFrameShadow(self, raised):
pass # Этот метод вызывается в автоматически сгенерированном коде от Qt Designer, но нам он не нужен
def setTitle(self, title):
self.axes.set_title(title, fontsize=19)
def plot_data(self, x, y1, y2, title, legend_y1, legend_y2):
for widget in self.draw_frame.winfo_children():
widget.destroy()
fig = Figure(figsize=(5, 3.8), dpi=100)
fig.suptitle(title)
fig.add_subplot(111).plot(x, y1)
fig.legend(legend_y1)
if len(y2) > 0:
fig.add_subplot(111).plot(x, y2)
fig.legend((legend_y1, legend_y2))
canvas = FigureCanvasTkAgg(fig,
master=self.draw_frame) # A tk.DrawingArea.
canvas.draw()
canvas.get_tk_widget().pack()
def plot(self, curveList, starList):
colors = plt.rcParams["axes.prop_cycle"]()
fig = Figure(figsize=(10,10))
n = len(curveList)
starList = [str(x) for x in starList]
for i in range(n):
c = next(colors)["color"]
plotfig = fig.add_subplot((n//2)+1, 2, i + 1)
plotfig.plot(curveList[i],label=starList[i],color=c)
fig.legend()
canvas = FigureCanvasTkAgg(fig, master=self.master)
canvas.get_tk_widget().pack()
canvas.draw()
return None
def horizontal_legend( fig: Figure, handles: Optional[Iterable[Artist]] = None, labels: Optional[Iterable[str]] = None, *, ncol: int = 1, **kwargs, ) -> Legend: """ Place a legend on the figure, with the items arranged to read right to left rather than top to bottom. :param fig: The figure to plot the legend on. :param handles: :param labels: :param ncol: The number of columns in the legend. :param kwargs: Addition keyword arguments passed to :meth:`matplotlib.figure.Figure.legend`. """ if handles is None and labels is None: handles, labels = fig.axes[0].get_legend_handles_labels() # Rearrange legend items to read right to left rather than top to bottom. if handles: handles = list(filter(None, transpose(handles, ncol))) if labels: labels = list(filter(None, transpose(labels, ncol))) return fig.legend(handles, labels, ncol=ncol, **kwargs)
def generate_figure(samples):
ohms_styles = (
('r', 'r:'),
('x', 'y:'),
('z', 'g:'),
)
x = []
yswr = []
handles = []
for sample in samples:
x.append(float(sample['frequency'])/10**6)
yswr.append(sample['swr'])
fake_file = StringIO()
figure = Figure(figsize=(9, 6, ), facecolor='white')
canvas = FigureCanvasAgg(figure)
axis = figure.add_subplot(111)
axis.set_ylabel('SWR')
axis.set_xlabel('Frequency (MHz)')
axis.set_axis_bgcolor((1, 1, 1,))
axis_ohms = axis.twinx()
axis_ohms.set_ylabel('Ohms')
handles.append(
axis.plot(x, yswr, 'b', label='SWR')[0]
)
for prop, style in ohms_styles:
sample = [float(v.get(prop)) for v in samples]
handles.append(
axis_ohms.plot(x, sample, style, label=prop)[0]
)
figure.legend(
handles=handles,
labels=[
'SWR'
] + [prop for prop, style in ohms_styles]
)
canvas.print_png(fake_file)
data = fake_file.getvalue()
return data
def CreateCurrentVoltagePlot(t, c, v, title, filename, xlim=(0,60)):
figure = Figure(figsize=(8,4))
figure.suptitle(title)
axis1 = figure.add_subplot(111)
axis1.grid(True)
lines = []
lines.extend(axis1.plot(t, c, 'b'))
axis1.set_xlabel('Time')
axis1.set_ylabel('Current [A]')
axis1.set_xlim(xlim)
axis1.set_ylim([0, 6])
axis2 = axis1.twinx()
lines.extend(axis2.plot(t, v, 'r'))
axis2.set_ylabel('Voltage [V]')
axis2.set_ylim([11, 15])
figure.legend(lines, ('Current', 'Voltage'), 'upper left')
canvas = FigureCanvasAgg(figure)
canvas.print_figure(filename, dpi=80)
def plot_raw_lightcurve(picid, lc0, psc_dir):
fig = Figure()
FigureCanvas(fig)
fig.set_size_inches(12, 7)
ax = fig.add_subplot(111)
ax.plot(lc0.loc[lc0.color == 'g'].target.values,
marker='o', label='Target') # .plot(marker='o')
ax.plot(lc0.loc[lc0.color == 'g'].reference.values,
marker='o', label='Reference') # .plot(marker='o')
fig.suptitle(f'Raw Flux - {picid}')
fig.tight_layout()
fig.legend()
plot_fn = os.path.join(psc_dir, 'plots', f'raw-flux-{picid}.png')
fig.savefig(plot_fn, transparent=False)
class Gui:
def __init__( self ):
self.root = tk.Tk()
self.root.wm_title( "Log grapher" )
matplotlib.rc('font', size=8 )
self.fig = Figure( figsize=(11,5), dpi=100 )
self.fig.set_tight_layout( True )
self.axis = self.fig.add_subplot( 111 )
self.axis.set_title( 'Graph' )
self.axis.set_xlabel( 'X axis label' )
self.axis.set_ylabel( 'Y label' )
self.canvas = FigureCanvasTkAgg( self.fig, master=self.root )
self.canvas.show()
self.canvas.get_tk_widget().pack( side=TOP, fill=BOTH, expand=1 )
def setLabels( self, labelList ):
"""setLabels before doing anything else - configures axes etc"""
self.labels = labelList
for i in range( 0, len( labelList ) ):
self.axis.plot( [] )
self.fig.legend( self.axis.lines, self.labels, 'lower center', ncol=len(self.labels),
borderpad=0.3, handletextpad=0.2, columnspacing=0.3 )
def append( self, xVal, yValList ):
"""
yValList must be the same length as labelList, None values will be ignored.
Call update() afterwards.
"""
#print( "gui append " + str( xVal ) + ", " )
#pprint( yValList )
for idx, yVal in enumerate( yValList ):
if yVal is not None:
hl = self.axis.lines[idx]
hl.set_xdata( numpy.append( hl.get_xdata(), xVal ) )
hl.set_ydata( numpy.append( hl.get_ydata(), yVal ) )
def update( self ):
self.axis.relim()
self.axis.autoscale_view()
self.canvas.draw()
class matplot_figure(object):
"""\brief figure to show, which can be closed
"""
def __init__(self,):
"""\brief constuctor
"""
self.win = gtk.Window()
self.win.connect("delete-event", lambda widget, event: False)
self.win.set_default_size(640, 480)
self.win.set_title("Plot")
vbox = gtk.VBox()
self.win.add(vbox)
self.fig = Figure(figsize=(5, 4), dpi=100)
canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
vbox.pack_start(canvas)
toolbar = NavigationToolbar(canvas, self.win)
vbox.pack_start(toolbar, False, False)
def show(self,):
"""\brief show window of the figure
"""
self.win.show_all()
def hide(self,):
"""\brief hide window of the figure
"""
self.win.hide()
def add_subplot(self, *args, **kargs):
"""\brief
\param *args
\param **kargs
"""
return self.fig.add_subplot(*args, **kargs)
def autofmt_xdate(self, *args, **kargs):
"""\brief autoformat date along X
\param *args
\param **kargs
"""
return self.fig.autofmt_xdate(*args, **kargs)
def legend(self, *args, **kargs):
"""\brief plot legend
\param *args
\param **kargs
"""
return self.fig.legend(*args, **kargs)
for p in pl:
p.set_marker('o')
p.set_markersize(5)
ax.set_xlabel(r'run number')
ax.set_xlim(56350,57323)
ax.set_ylabel(r'\texttt{DC} residual mean (\textmu m)')
ax.set_ylim(-150,150)
legend_labels = []
for i in numpy.arange(1,7):
legend_labels += [i]
lgd = fig.legend(pl, legend_labels, title=r'superlayer', loc='right')
lgd.draw_frame(False)
fig.subplots_adjust(right=0.85)
can = FigureCanvas(fig)
can.print_figure('dc_resid_mean.eps')
fig = Figure(figsize=(8,4), dpi=100, facecolor = '#FFFFFF')
ax = fig.add_subplot(111)
pl = []
for i in numpy.arange(7,13):
pl += ax.plot(d[0], d[i])
class TemperaturePanel(wx.Panel):
"""
GUI Window for plotting temperature data.
"""
#--------------------------------------------------------------------------
def __init__(self, *args, **kwargs):
wx.Panel.__init__(self, *args, **kwargs)
global filePath
global ttempA_list
global tempA_list
global ttempB_list
global tempB_list
self.create_title("Temperature Panel")
self.init_plot()
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self.create_control_panel()
self.create_sizer()
pub.subscribe(self.OnTimeTempA, "Time Temp A")
pub.subscribe(self.OnTempA, "Temp A")
pub.subscribe(self.OnTimeTempB, "Time Temp B")
pub.subscribe(self.OnTempB, "Temp B")
# For saving the plots at the end of data acquisition:
pub.subscribe(self.save_plot, "Save_All")
self.animator = animation.FuncAnimation(self.figure, self.draw_plot, interval=500, blit=False)
#end init
#--------------------------------------------------------------------------
def create_title(self, name):
self.titlePanel = wx.Panel(self, -1)
title = wx.StaticText(self.titlePanel, label=name)
font_title = wx.Font(16, wx.DEFAULT, wx.NORMAL, wx.BOLD)
title.SetFont(font_title)
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((0,-1))
hbox.Add(title, 0, wx.LEFT, 5)
self.titlePanel.SetSizer(hbox)
#end def
#--------------------------------------------------------------------------
def create_control_panel(self):
self.xmin_control = BoundControlBox(self, -1, "t min", 0)
self.xmax_control = BoundControlBox(self, -1, "t max", 100)
self.ymin_control = BoundControlBox(self, -1, "T min", 0)
self.ymax_control = BoundControlBox(self, -1, "T max", 70)
self.hbox1 = wx.BoxSizer(wx.HORIZONTAL)
self.hbox1.AddSpacer(10)
self.hbox1.Add(self.xmin_control, border=5, flag=wx.ALL)
self.hbox1.Add(self.xmax_control, border=5, flag=wx.ALL)
self.hbox1.AddSpacer(10)
self.hbox1.Add(self.ymin_control, border=5, flag=wx.ALL)
self.hbox1.Add(self.ymax_control, border=5, flag=wx.ALL)
#end def
#--------------------------------------------------------------------------
def OnTimeTempA(self, msg):
self.ttA = float(msg)
ttempA_list.append(self.ttA)
#end def
#--------------------------------------------------------------------------
def OnTempA(self, msg):
self.tA = float(msg)
tempA_list.append(self.tA)
#end def
#--------------------------------------------------------------------------
def OnTimeTempB(self, msg):
self.ttB = float(msg)
ttempB_list.append(self.ttB)
#end def
#--------------------------------------------------------------------------
def OnTempB(self, msg):
self.tB = float(msg)
tempB_list.append(self.tB)
#end def
#--------------------------------------------------------------------------
def init_plot(self):
self.dpi = 100
self.colorTA = 'r'
self.colorTB = 'b'
self.figure = Figure((6,2), dpi=self.dpi)
self.subplot = self.figure.add_subplot(111)
self.lineTA, = self.subplot.plot(ttempA_list,tempA_list, color=self.colorTA, linewidth=1)
self.lineTB, = self.subplot.plot(ttempB_list,tempB_list, color=self.colorTB, linewidth=1)
self.legend = self.figure.legend( (self.lineTA, self.lineTB), (r"$T_A$",r"$T_B$"), (0.15,0.65),fontsize=8)
#self.subplot.text(0.05, .95, r'$X(f) = \mathcal{F}\{x(t)\}$', \
#verticalalignment='top', transform = self.subplot.transAxes)
#end def
#--------------------------------------------------------------------------
def draw_plot(self,i):
self.subplot.clear()
#self.subplot.set_title("temperature vs. time", fontsize=12)
self.subplot.set_ylabel(r"temperature ($\degree$C)", fontsize = 8)
self.subplot.set_xlabel("time (s)", fontsize = 8)
# Adjustable scale:
if self.xmax_control.is_auto():
xmax = max(ttempA_list+ttempB_list)
else:
xmax = float(self.xmax_control.manual_value())
if self.xmin_control.is_auto():
xmin = 0
else:
xmin = float(self.xmin_control.manual_value())
if self.ymin_control.is_auto():
ymin = 0
else:
ymin = float(self.ymin_control.manual_value())
if self.ymax_control.is_auto():
maxT = max(tempA_list+tempB_list)
ymax = maxT + abs(maxT)*0.3
else:
ymax = float(self.ymax_control.manual_value())
self.subplot.set_xlim([xmin, xmax])
self.subplot.set_ylim([ymin, ymax])
pylab.setp(self.subplot.get_xticklabels(), fontsize=8)
pylab.setp(self.subplot.get_yticklabels(), fontsize=8)
self.lineTA, = self.subplot.plot(ttempA_list,tempA_list, color=self.colorTA, linewidth=1)
self.lineTB, = self.subplot.plot(ttempB_list,tempB_list, color=self.colorTB, linewidth=1)
return (self.lineTA, self.lineTB)
#end def
#--------------------------------------------------------------------------
def save_plot(self, msg):
path = filePath + "/Temperature_Plot.png"
self.canvas.print_figure(path)
#end def
#--------------------------------------------------------------------------
def create_sizer(self):
sizer = wx.GridBagSizer(3,1)
sizer.Add(self.titlePanel, (0, 0),flag=wx.ALIGN_CENTER_HORIZONTAL)
sizer.Add(self.canvas, ( 1,0),flag=wx.ALIGN_CENTER_HORIZONTAL)
sizer.Add(self.hbox1, (2,0),flag=wx.ALIGN_CENTER_HORIZONTAL)
self.SetSizer(sizer)
class MplCanvas(FigureCanvas):
def __init__(self, parent=None, width=8, height=10, dpi=80):
self.parent = parent
self.redraw_yticks = True
self.figure = Figure(figsize=(width, height), dpi=dpi, facecolor='#bbbbbb')
FigureCanvas.__init__(self, self.figure)
self.setParent(parent)
FigureCanvas.setSizePolicy(self,
QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
def run(self, config_file, server):
self.mod = Dragonfly_Module(0, 0)
self.mod.ConnectToMMM(server)
self.msg_types = ['END_TASK_STATE', 'SESSION_CONFIG', 'EM_DECODER_CONFIGURATION']
self.msg_types.sort()
self.mod.Subscribe(MT_EXIT)
self.mod.Subscribe(rc.MT_PING)
for i in self.msg_types:
self.mod.Subscribe(eval('rc.MT_%s' % (i)))
self.mod.SendModuleReady()
print "Connected to Dragonfly at", server
print "mod_id = ", self.mod.GetModuleID()
self.config_file = config_file
self.load_config()
self.init_vars()
self.init_plot()
self.init_legend()
timer = QtCore.QTimer(self)
QtCore.QObject.connect(timer, QtCore.SIGNAL("timeout()"), self.timer_event)
timer.start(10)
def init_vars(self):
self.num_trials = 0
self.reset_counters()
self.msg_cnt = 0
self.console_disp_cnt = 0
def reset_counters(self):
self.trial_sync = 0
self.num_trials_postcalib = 0
self.num_trial_started_postcalib = 0
self.num_trial_givenup_postcalib = 0
self.num_trial_successful_postcalib = 0
self.shadow_num_trial_started_postcalib = 0
self.shadow_num_trial_givenup_postcalib = 0
self.shadow_num_trial_successful_postcalib = 0
self.started_window = []
self.givenup_window = []
self.success_window = []
self.shadow_started_window = []
self.shadow_givenup_window = []
self.shadow_success_window = []
self.percent_start = 0
self.percent_success = 0
self.percent_givenup = 0
self.hist_narrow_SUR = []
self.hist_narrow_GUR = []
self.hist_narrow_STR = []
self.hist_wide_SUR = []
self.hist_wide_GUR = []
self.hist_wide_STR = []
def update_gui_label_data(self):
self.parent.GALL.setText("%d" % self.num_trials_postcalib)
self.parent.GSTR.setText("%d" % self.num_trial_started_postcalib)
self.parent.GGUR.setText("%d" % self.num_trial_givenup_postcalib)
self.parent.GSUR.setText("%d" % self.num_trial_successful_postcalib)
#def reload_config(self):
# self.load_config()
# for ax in self.figure.axes:
# self.figure.delaxes(ax)
# self.figure.clear()
# self.draw()
# self.init_plot(True)
# self.init_legend()
# self.redraw_yticks = True
#def load_config(self):
# self.config = ConfigObj(self.config_file, unrepr=True)
def load_config(self):
self.config = SafeConfigParser()
self.config.read(self.config_file)
self.window_narrow = self.config.getint('general', 'window_narrow')
self.window_wide = self.config.getint('general', 'window_wide')
self.task_state_codes = {}
for k, v in self.config.items('task state codes'):
self.task_state_codes[k] = int(v)
def init_plot(self, clear=False):
self.nDims = 3
self.figure.subplots_adjust(bottom=.05, right=.98, left=.08, top=.98, hspace=0.07)
self.ax = []
self.old_size = []
self.ax_bkg = []
self.lines = []
ax = self.figure.add_subplot(1,1,1)
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * 0.85, box.height])
self.reset_axis(ax)
self.draw()
bbox_width = ax.bbox.width
bbox_height = ax.bbox.height
if clear == True: # force to redraw
bbox_width = 0
bbox_height = 0
self.old_size.append( (bbox_width, bbox_height) )
self.ax_bkg.append(self.copy_from_bbox(ax.bbox))
self.colors = ['k', 'r', 'g']
self.styles = ['-', '-', '--']
for d in range(self.nDims):
for m in range(3):
line, = ax.plot([], [], self.colors[d]+self.styles[m], lw=1.5, aa=True, animated=True)
line.set_ydata([0, 0])
line.set_xdata([0, 1])
self.lines.append(line)
self.draw()
self.ax.append(ax)
def reset_axis(self, ax): #, label):
ax.grid(True)
ax.set_ylim(-1, 101)
ax.set_autoscale_on(False)
ax.get_xaxis().set_ticks([])
for tick in ax.get_yticklabels():
tick.set_fontsize(9)
def init_legend(self):
legnd = []
for d in range(self.nDims):
for m in range(3):
line = matplotlib.lines.Line2D([0,0], [0,0], color=self.colors[d], ls=self.styles[m], lw=1.5)
legnd.append(line)
legend_text = []
legend_text.append('STR')
legend_text.append('STR%d' % self.window_narrow)
legend_text.append('STR%d' % self.window_wide)
legend_text.append('GUR')
legend_text.append('GUR%d' % self.window_narrow)
legend_text.append('GUR%d' % self.window_wide)
legend_text.append('SUR')
legend_text.append('SUR%d' % self.window_narrow)
legend_text.append('SUR%d' % self.window_wide)
self.figure.legend(legnd, legend_text, loc = 'right', bbox_to_anchor=(1, 0.5),
frameon=False, labelspacing=1.5, prop={'size':'11'})
self.draw()
def timer_event(self):
done = False
while not done:
msg = CMessage()
rcv = self.mod.ReadMessage(msg, 0)
if rcv == 1:
msg_type = msg.GetHeader().msg_type
# SESSION_CONFIG => start of session
if msg_type == rc.MT_SESSION_CONFIG:
#self.msg_cnt += 1
self.num_trials = 0
self.reset_counters()
self.update_gui_label_data()
# EM_DECODER_CONFIGURATION => end of an adaptation round
elif msg_type == rc.MT_EM_DECODER_CONFIGURATION:
#self.msg_cnt += 1
self.reset_counters()
self.update_gui_label_data()
# END_TASK_STATE => end of a task
elif msg_type == rc.MT_END_TASK_STATE:
#self.msg_cnt += 1
mdf = rc.MDF_END_TASK_STATE()
copy_from_msg(mdf, msg)
# need to know:
# begin task state code
# final task state code
# intertrial state code
if (mdf.id == 1):
self.trial_sync = 1
self.shadow_started_window.append(0)
if (mdf.id == self.task_state_codes['begin']) & (mdf.outcome == 1):
if self.trial_sync:
#print "*** trial started ***"
#self.rewards_given += 1
self.shadow_num_trial_started_postcalib += 1
self.shadow_success_window.append(0)
self.shadow_givenup_window.append(0)
self.shadow_started_window[-1] = 1
if mdf.reason == "JV_IDLE_TIMEOUT":
if self.trial_sync:
self.shadow_num_trial_givenup_postcalib += 1
self.shadow_givenup_window[-1] = 1
if (mdf.id == self.task_state_codes['final']) & (mdf.outcome == 1):
if self.trial_sync:
#print "*** trial complete and successful"
self.shadow_num_trial_successful_postcalib += 1
self.shadow_success_window[-1] = 1
if (mdf.id == self.task_state_codes['intertrial']):
if self.trial_sync:
# do end-of-trial stuff here
self.num_trials += 1
self.num_trials_postcalib += 1
self.num_trial_started_postcalib = self.shadow_num_trial_started_postcalib
self.num_trial_successful_postcalib = self.shadow_num_trial_successful_postcalib
self.num_trial_givenup_postcalib = self.shadow_num_trial_givenup_postcalib
if len(self.shadow_success_window) > self.window_wide: #self.window_narrow:
self.shadow_success_window.pop(0)
if len(self.shadow_givenup_window) > self.window_wide: #self.window_narrow:
self.shadow_givenup_window.pop(0)
if len(self.shadow_started_window) > self.window_wide: #self.window_narrow:
self.shadow_started_window.pop(0)
self.success_window = copy.deepcopy(self.shadow_success_window)
self.started_window = copy.deepcopy(self.shadow_started_window)
self.givenup_window = copy.deepcopy(self.shadow_givenup_window)
if self.num_trials_postcalib > 0:
self.percent_start = 100 * self.num_trial_started_postcalib / self.num_trials_postcalib
self.percent_givenup = 100 * self.num_trial_givenup_postcalib / self.num_trials_postcalib
self.percent_success = 100 * self.num_trial_successful_postcalib / self.num_trials_postcalib
percent_success_wide_window = np.NAN
if len(self.success_window) >= self.window_wide:
num_success_window = np.sum(self.success_window)
percent_success_wide_window = 100 * num_success_window / len(self.success_window)
percent_givenup_wide_window = np.NAN
if len(self.givenup_window) >= self.window_wide:
num_givenup_window = np.sum(self.givenup_window)
percent_givenup_wide_window = 100 * num_givenup_window / len(self.givenup_window)
percent_started_wide_window = np.NAN
if len(self.started_window) >= self.window_wide:
num_started_window = np.sum(self.started_window)
percent_started_wide_window = 100 * num_started_window / len(self.started_window)
percent_success_narrow_window = np.NAN
if len(self.success_window) >= self.window_narrow:
success_window_narrow = self.success_window[len(self.success_window)-self.window_narrow:]
num_success_window = np.sum(success_window_narrow)
percent_success_narrow_window = 100 * num_success_window / len(success_window_narrow)
percent_givenup_narrow_window = np.NAN
if len(self.givenup_window) >= self.window_narrow:
givenup_window_narrow = self.givenup_window[len(self.givenup_window)-self.window_narrow:]
num_givenup_window = np.sum(givenup_window_narrow)
percent_givenup_narrow_window = 100 * num_givenup_window / len(givenup_window_narrow)
if len(self.started_window) >= self.window_narrow:
started_window_narrow = self.started_window[len(self.started_window)-self.window_narrow:]
num_started_window = np.sum(started_window_narrow)
percent_started_narrow_window = 100 * num_started_window / len(started_window_narrow)
self.hist_narrow_STR.append(percent_started_narrow_window)
self.hist_narrow_SUR.append(percent_success_narrow_window)
self.hist_narrow_GUR.append(percent_givenup_narrow_window)
self.hist_wide_STR.append(percent_started_wide_window)
self.hist_wide_SUR.append(percent_success_wide_window)
self.hist_wide_GUR.append(percent_givenup_wide_window)
self.update_gui_label_data()
elif msg_type == rc.MT_PING:
respond_to_ping(self.mod, msg, 'TrialStatusDisplay')
elif msg_type == MT_EXIT:
self.exit()
done = True
else:
done = True
self.console_disp_cnt += 1
if self.console_disp_cnt == 50:
self.update_plot()
self.console_disp_cnt = 0
def update_plot(self):
#print "All trials : %d" % (self.num_trials_postcalib)
#print ""
#print "GSTR: ", self.percent_start
#print "GGUR: ", self.percent_givenup
#print "GSUR: ", self.percent_success
#print ""
#print "STR win: ", self.started_window
#print "GUP win: ", self.givenup_window
#print "SUC win: ", self.success_window
#print ""
#print "nSTR: ", self.hist_narrow_STR
#print "nGUR: ", self.hist_narrow_GUR
#print "nSUR :", self.hist_narrow_SUR
#print ""
#print "wSTR: ", self.hist_wide_STR
#print "wGUR: ", self.hist_wide_GUR
#print "wSUR :", self.hist_wide_SUR
#print ""
#print "Msg cnt : %d" % (self.msg_cnt)
#print "\n ----------------------- \n"
i = 0
ax = self.ax[i]
current_size = ax.bbox.width, ax.bbox.height
if self.old_size[i] != current_size:
self.old_size[i] = current_size
self.draw()
self.ax_bkg[i] = self.copy_from_bbox(ax.bbox)
self.restore_region(self.ax_bkg[i])
#if len(self.hist_narrow_STR) > 1:
if not self.hist_narrow_STR:
self.lines[0].set_ydata([self.percent_start, self.percent_start])
self.lines[0].set_xdata([0, 1])
ax.draw_artist(self.lines[0])
self.lines[3].set_ydata([self.percent_givenup, self.percent_givenup])
self.lines[3].set_xdata([0, 1])
ax.draw_artist(self.lines[3])
self.lines[6].set_ydata([self.percent_success, self.percent_success])
self.lines[6].set_xdata([0, 1])
ax.draw_artist(self.lines[6])
else:
ax.set_xlim(0, len(self.hist_narrow_STR)-1)
for k in range(0,9):
self.lines[k].set_xdata(range(len(self.hist_narrow_STR)))
self.lines[0].set_ydata([self.percent_start, self.percent_start])
self.lines[0].set_xdata([0, len(self.hist_narrow_STR)])
self.lines[1].set_ydata(self.hist_narrow_STR)
self.lines[2].set_ydata(self.hist_wide_STR)
###
self.lines[3].set_ydata([self.percent_givenup, self.percent_givenup])
self.lines[3].set_xdata([0, len(self.hist_narrow_STR)])
self.lines[4].set_ydata(self.hist_narrow_GUR)
self.lines[5].set_ydata(self.hist_wide_GUR)
###
self.lines[6].set_ydata([self.percent_success, self.percent_success])
self.lines[6].set_xdata([0, len(self.hist_narrow_STR)])
self.lines[7].set_ydata(self.hist_narrow_SUR)
self.lines[8].set_ydata(self.hist_wide_SUR)
for k in range(0,9):
ax.draw_artist(self.lines[k])
self.blit(ax.bbox)
# need to redraw once to update y-ticks
if self.redraw_yticks == True:
self.draw()
self.redraw_yticks = False
def exit(self):
print "exiting"
self.parent.exit_app()
def stop(self):
print 'disconnecting'
self.mod.SendSignal(rc.MT_EXIT_ACK)
self.mod.DisconnectFromMMM()
yValues0 = [6,7.5,8,7.5]
yValues1 = [5.5,6.5,50,6] # one very high value (50)
yValues2 = [6.5,7,8,7]
axis.set_ylim(5, 8) # limit the vertical display
t0, = axis.plot(xValues, yValues0)
t1, = axis.plot(xValues, yValues1)
t2, = axis.plot(xValues, yValues2)
axis.set_ylabel('Vertical Label')
axis.set_xlabel('Horizontal Label')
axis.grid()
fig.legend((t0, t1, t2), ('First line', 'Second line', 'Third line'), 'upper right')
#--------------------------------------------------------------
def _destroyWindow():
root.quit()
root.destroy()
#--------------------------------------------------------------
root = tk.Tk()
root.withdraw()
root.protocol('WM_DELETE_WINDOW', _destroyWindow)
#--------------------------------------------------------------
canvas = FigureCanvasTkAgg(fig, master=root)
canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
#--------------------------------------------------------------
root.update()
root.deiconify()
def plot_linear_relation(x, y, x_err=None, y_err=None, title=None, point_label=None, legend=None, plot_range=None, plot_range_y=None, x_label=None, y_label=None, y_2_label=None, marker_style='-o', log_x=False, log_y=False, size=None, filename=None):
''' Takes point data (x,y) with errors(x,y) and fits a straight line. The deviation to this line is also plotted, showing the offset.
Parameters
----------
x, y, x_err, y_err: iterable
filename: string, PdfPages object or None
PdfPages file object: plot is appended to the pdf
string: new plot file with the given filename is created
None: the plot is printed to screen
'''
fig = Figure()
FigureCanvas(fig)
ax = fig.add_subplot(111)
if x_err is not None:
x_err = [x_err, x_err]
if y_err is not None:
y_err = [y_err, y_err]
ax.set_title(title)
if y_label is not None:
ax.set_ylabel(y_label)
if log_x:
ax.set_xscale('log')
if log_y:
ax.set_yscale('log')
if plot_range:
ax.set_xlim((min(plot_range), max(plot_range)))
if plot_range_y:
ax.set_ylim((min(plot_range_y), max(plot_range_y)))
if legend:
fig.legend(legend, 0)
ax.grid(True)
ax.errorbar(x, y, xerr=x_err, yerr=y_err, fmt='o', color='black') # plot points
# label points if needed
if point_label is not None:
for X, Y, Z in zip(x, y, point_label):
ax.annotate('{}'.format(Z), xy=(X, Y), xytext=(-5, 5), ha='right', textcoords='offset points')
line_fit, _ = np.polyfit(x, y, 1, full=False, cov=True)
fit_fn = np.poly1d(line_fit)
ax.plot(x, fit_fn(x), '-', lw=2, color='gray')
setp(ax.get_xticklabels(), visible=False) # remove ticks at common border of both plots
divider = make_axes_locatable(ax)
ax_bottom_plot = divider.append_axes("bottom", 2.0, pad=0.0, sharex=ax)
ax_bottom_plot.bar(x, y - fit_fn(x), align='center', width=np.amin(np.diff(x)) / 2, color='gray')
# plot(x, y - fit_fn(x))
ax_bottom_plot.grid(True)
if x_label is not None:
ax.set_xlabel(x_label)
if y_2_label is not None:
ax.set_ylabel(y_2_label)
ax.set_ylim((-np.amax(np.abs(y - fit_fn(x)))), (np.amax(np.abs(y - fit_fn(x)))))
ax.plot(ax.set_xlim(), [0, 0], '-', color='black')
setp(ax_bottom_plot.get_yticklabels()[-2:-1], visible=False)
if size is not None:
fig.set_size_inches(size)
if not filename:
fig.show()
elif isinstance(filename, PdfPages):
filename.savefig(fig)
elif filename:
fig.savefig(filename, bbox_inches='tight')
return fig
class Plot_Traces(Tk.Tk):
def __init__(self, root, folder):
Tk.Tk.__init__(self)
self.title("traces - " + folder)
self.root = root
self.folder = folder
self.protocol("WM_DELETE_WINDOW", self.closeGUI)
self.createTracesGUI()
def createTracesGUI(self):
# declare button variables
# control variables for neuron
self.neuronNumber = Tk.StringVar()
self.Vm_neuron = Tk.BooleanVar()
self.g_excit = Tk.BooleanVar()
self.g_inhib = Tk.BooleanVar()
self.G_ref = Tk.BooleanVar()
self.BPAP = Tk.BooleanVar()
self.spikesSelf = Tk.BooleanVar()
self.spikesTC = Tk.BooleanVar()
self.spikesRS = Tk.BooleanVar()
self.spikesFS = Tk.BooleanVar()
self.neuronAvail = True
# control variables for synapses
self.synapseNumber = Tk.StringVar()
self.Vm_syn = Tk.BooleanVar()
self.g = Tk.BooleanVar()
self.calcium = Tk.BooleanVar()
self.Mg = Tk.BooleanVar()
self.I_syn = Tk.BooleanVar()
self.I_NMDA = Tk.BooleanVar()
self.I_VGCC = Tk.BooleanVar()
self.P = Tk.BooleanVar()
self.B = Tk.BooleanVar()
self.D = Tk.BooleanVar()
self.V = Tk.BooleanVar()
# control variables for axes
self.y_min = Tk.StringVar()
self.y_max = Tk.StringVar()
self.x_min = Tk.StringVar()
self.x_max = Tk.StringVar()
self.step_y = 10
# self.step_x = 100
self.offValue = False # False = use provided values
self.legend = False # True = display label info
# create plotframe widget
mainFrame = Tk.Frame(self)
mainFrame.grid(column=0, row=0)
plotFrame = Tk.Frame(mainFrame, borderwidth=5, relief="sunken", width=500, height=500)
plotFrame.grid(column=0, row=0, columnspan=3, rowspan=2, sticky=(N, W, E), padx=(10, 10), pady=(10, 10))
selectionFrame = Tk.Frame(mainFrame, borderwidth=5, relief="sunken", width=500, height=125)
selectionFrame.grid(column=0, row=3, columnspan=7, rowspan=5, sticky=(N, S, E, W), padx=(10, 10), pady=(10, 10))
# create main figure
self.mainFig = Figure()
# create main plot canvas
self.canvas = FigureCanvasTkAgg(self.mainFig, master=plotFrame)
self.canvas.show()
self.canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
# create control for neuron variables
Tk.Label(selectionFrame, text="neuron: ").grid(column=0, row=0, sticky=(W))
self.neuronInput = Tk.Entry(selectionFrame, textvariable=self.neuronNumber, width=11)
self.neuronInput.grid(column=1, row=0, sticky=(W))
self.neuronNumber.set("0")
self.neuronInput.insert(0, "0")
self.neuronInput.bind("<Return>", self.renewCanvas)
self.neuronInput.bind("<Up>", lambda unit: self.nextUnit("neuron", +1))
self.neuronInput.bind("<Down>", lambda unit: self.nextUnit("neuron", -1))
check = Tk.Checkbutton(
selectionFrame,
text="neuron Vm",
command=lambda: self.checked(self.Vm_neuron),
variable=self.Vm_neuron,
onvalue=True,
offvalue=False,
)
check.grid(column=0, row=1, sticky=(W), padx=(0, 10))
self.Vm_neuron.set(False)
check = Tk.Checkbutton(
selectionFrame,
text="g excit",
command=lambda: self.checked(self.g_excit),
variable=self.g_excit,
onvalue=True,
offvalue=False,
)
check.grid(column=0, row=2, sticky=(W))
self.g_excit.set(False)
check = Tk.Checkbutton(
selectionFrame,
text="g inhib",
command=lambda: self.checked(self.g_inhib),
variable=self.g_inhib,
onvalue=True,
offvalue=False,
)
check.grid(column=0, row=3, sticky=(W))
self.g_inhib.set(False)
check = Tk.Checkbutton(
selectionFrame,
text="G ref",
command=lambda: self.checked(self.G_ref),
variable=self.G_ref,
onvalue=True,
offvalue=False,
)
check.grid(column=0, row=4, sticky=(W))
self.G_ref.set(False)
check = Tk.Checkbutton(
selectionFrame,
text="BPAP",
command=lambda: self.checked(self.BPAP),
variable=self.BPAP,
onvalue=True,
offvalue=False,
)
check.grid(column=0, row=5, sticky=(W))
self.BPAP.set(False)
check = Tk.Checkbutton(
selectionFrame,
text="spikes",
command=lambda: self.checked(self.spikesSelf),
variable=self.spikesSelf,
onvalue=True,
offvalue=False,
)
check.grid(column=1, row=1, sticky=(W), padx=(0, 10))
self.spikesSelf.set(False)
check = Tk.Checkbutton(
selectionFrame,
text="spikes TC",
command=lambda: self.checked(self.spikesTC),
variable=self.spikesTC,
onvalue=True,
offvalue=False,
)
check.grid(column=1, row=2, sticky=(W))
self.spikesTC.set(False)
check = Tk.Checkbutton(
selectionFrame,
text="spikes RS",
command=lambda: self.checked(self.spikesRS),
variable=self.spikesRS,
onvalue=True,
offvalue=False,
)
check.grid(column=1, row=3, sticky=(W))
self.spikesRS.set(False)
check = Tk.Checkbutton(
selectionFrame,
text="spikes FS",
command=lambda: self.checked(self.spikesFS),
variable=self.spikesFS,
onvalue=True,
offvalue=False,
)
check.grid(column=1, row=4, sticky=(W))
self.spikesFS.set(False)
s = ttk.Separator(selectionFrame, orient=VERTICAL)
s.grid(column=2, row=0, rowspan=6, sticky="snew", pady=(2, 2), padx=(2, 3))
# create controls for synapse variables
Tk.Label(selectionFrame, text="synapse: ").grid(column=3, row=0, sticky=(W))
self.synapseInput = Tk.Entry(selectionFrame, textvariable=self.synapseNumber, width=14)
self.synapseInput.grid(column=4, row=0, columnspan=2, sticky=(W))
self.synapseNumber.set("0")
self.synapseInput.insert(0, "0")
self.synapseInput.bind("<Return>", self.renewCanvas)
self.synapseInput.bind("<Up>", lambda unit: self.nextUnit("synapse", +1))
self.synapseInput.bind("<Down>", lambda unit: self.nextUnit("synapse", -1))
self.CB_Vm_syn = Tk.Checkbutton(
selectionFrame,
text="syn Vm",
command=lambda: self.checked(self.Vm_syn),
variable=self.Vm_syn,
onvalue=True,
offvalue=False,
)
self.CB_Vm_syn.grid(column=3, row=1, sticky=(W), padx=(0, 10))
self.Vm_syn.set(False)
self.CB_g = Tk.Checkbutton(
selectionFrame,
text="g syn",
command=lambda: self.checked(self.g),
variable=self.g,
onvalue=True,
offvalue=False,
)
self.CB_g.grid(column=3, row=2, sticky=(W))
self.g.set(False)
self.CB_calcium = Tk.Checkbutton(
selectionFrame,
text="calcium",
command=lambda: self.checked(self.calcium),
variable=self.calcium,
onvalue=True,
offvalue=False,
)
self.CB_calcium.grid(column=3, row=3, sticky=(W))
self.calcium.set(False)
self.CB_Mg = Tk.Checkbutton(
selectionFrame,
text="Mg",
command=lambda: self.checked(self.Mg),
variable=self.Mg,
onvalue=True,
offvalue=False,
)
self.CB_Mg.grid(column=3, row=4, sticky=(W))
self.Mg.set(False)
self.CB_I_syn = Tk.Checkbutton(
selectionFrame,
text="I syn",
command=lambda: self.checked(self.I_syn),
variable=self.I_syn,
onvalue=True,
offvalue=False,
)
self.CB_I_syn.grid(column=4, row=1, sticky=(W))
self.I_syn.set(False)
self.CB_I_NMDA = Tk.Checkbutton(
selectionFrame,
text="I NMDA",
command=lambda: self.checked(self.I_NMDA),
variable=self.I_NMDA,
onvalue=True,
offvalue=False,
)
self.CB_I_NMDA.grid(column=4, row=2, sticky=(W), padx=(0, 10))
self.I_NMDA.set(False)
self.CB_I_VGCC = Tk.Checkbutton(
selectionFrame,
text="I VGCC",
command=lambda: self.checked(self.I_VGCC),
variable=self.I_VGCC,
onvalue=True,
offvalue=False,
)
self.CB_I_VGCC.grid(column=4, row=3, sticky=(W))
self.I_VGCC.set(False)
self.CB_P = Tk.Checkbutton(
selectionFrame,
text="P",
command=lambda: self.checked(self.P),
variable=self.P,
onvalue=True,
offvalue=False,
)
self.CB_P.grid(column=5, row=1, sticky=(W), padx=(0, 10))
self.P.set(False)
self.CB_B = Tk.Checkbutton(
selectionFrame,
text="B",
command=lambda: self.checked(self.B),
variable=self.B,
onvalue=True,
offvalue=False,
)
self.CB_B.grid(column=5, row=2, sticky=(W), padx=(0, 10))
self.B.set(False)
self.CB_D = Tk.Checkbutton(
selectionFrame,
text="D",
command=lambda: self.checked(self.D),
variable=self.D,
onvalue=True,
offvalue=False,
)
self.CB_D.grid(column=5, row=3, sticky=(W), padx=(0, 10))
self.D.set(False)
self.CB_V = Tk.Checkbutton(
selectionFrame,
text="V",
command=lambda: self.checked(self.V),
variable=self.V,
onvalue=True,
offvalue=False,
)
self.CB_V.grid(column=5, row=4, sticky=(W), padx=(0, 10))
self.V.set(False)
s = ttk.Separator(selectionFrame, orient=VERTICAL)
s.grid(column=6, row=0, rowspan=6, sticky="snew", pady=(2, 2), padx=(2, 3))
# create controls for time variables
self.offButton = Tk.Button(selectionFrame, command=self.disable, width=3)
self.offButton.grid(column=7, row=0, rowspan=2, sticky=(N, S))
self.y_upButton = Tk.Button(selectionFrame, text="^", command=lambda: self.move("y_up"), width=3)
self.y_upButton.grid(column=8, row=0)
self.y_downButton = Tk.Button(selectionFrame, text="v", command=lambda: self.move("y_down"), width=3)
self.y_downButton.grid(column=8, row=1)
self.ymaxInput = Tk.Entry(selectionFrame, textvariable=self.y_max, width=8)
self.ymaxInput.grid(column=9, row=0, columnspan=2, sticky=(E, W))
self.y_max.set("80")
self.ymaxInput.insert(0, self.y_max.get())
self.ymaxInput.bind("<Return>", self.moveReturn)
self.yminInput = Tk.Entry(selectionFrame, textvariable=self.y_min, width=8)
self.yminInput.grid(column=9, row=1, columnspan=2, sticky=(E, W))
self.y_min.set("-100")
self.yminInput.insert(0, self.y_min.get())
self.yminInput.bind("<Return>", self.moveReturn)
s = ttk.Separator(selectionFrame, orient=HORIZONTAL)
s.grid(column=7, row=2, columnspan=5, sticky="nsew", pady=(2, 2), padx=(2, 2))
self.xminInput = Tk.Entry(selectionFrame, textvariable=self.x_min, width=12)
self.xminInput.grid(column=7, row=3, columnspan=2, sticky=(E, W))
self.x_min.set("0")
self.xminInput.insert(0, self.x_min.get())
self.xminInput.bind("<Return>", self.moveReturn)
self.xmaxInput = Tk.Entry(selectionFrame, textvariable=self.x_max, width=12)
self.xmaxInput.grid(column=9, row=3, columnspan=2, sticky=(E, W))
self.x_max.set("200")
self.xmaxInput.insert(0, self.x_max.get())
self.xmaxInput.bind("<Return>", self.moveReturn)
button = Tk.Button(selectionFrame, text="<", command=lambda: self.move("x_left"), width=6)
button.grid(column=7, row=4, columnspan=2, sticky=(E, W))
button = Tk.Button(selectionFrame, text=">", command=lambda: self.move("x_right"), width=6)
button.grid(column=9, row=4, columnspan=2, sticky=(E, W))
self.legendButton = Tk.Button(selectionFrame, text="info ON", command=self.legendClicked, width=6)
self.legendButton.grid(column=7, row=5, columnspan=2, sticky=(EW))
self.offValue = not self.offValue
self.disable()
# self.renewCanvas(False)
def legendClicked(self):
self.legend = not self.legend
if self.legend:
self.legendButton.config(text="info OFF")
else:
self.legendButton.config(text="info ON")
self.renewCanvas(False)
def checked(self, var):
var.set(not var.get())
self.renewCanvas(False)
def disable(self):
self.offValue = not self.offValue
if self.offValue:
self.offButton.config(text="ON")
self.y_upButton.config(state=DISABLED)
self.y_downButton.config(state=DISABLED)
self.yminInput.config(state=DISABLED)
self.ymaxInput.config(state=DISABLED)
else:
self.offButton.config(text="OFF")
self.y_upButton.config(state=NORMAL)
self.y_downButton.config(state=NORMAL)
self.yminInput.config(state=NORMAL)
self.ymaxInput.config(state=NORMAL)
self.yminInput.delete(0, END)
self.yminInput.insert(0, self.y_min.get())
self.ymaxInput.delete(0, END)
self.ymaxInput.insert(0, self.y_max.get())
self.renewCanvas(False)
def moveReturn(self, event):
self.y_min.set(self.yminInput.get())
self.y_max.set(self.ymaxInput.get())
self.x_min.set(self.xminInput.get())
self.x_max.set(self.xmaxInput.get())
self.renewCanvas(False)
def move(self, moveDir):
self.step_x = int((float(self.x_max.get()) - float(self.x_min.get())) / 4)
if moveDir == "y_up":
self.y_min.set(str(int(self.y_min.get()) + self.step_y))
self.y_max.set(str(int(self.y_max.get()) + self.step_y))
if moveDir == "y_down":
self.y_min.set(str(int(self.y_min.get()) - self.step_y))
self.y_max.set(str(int(self.y_max.get()) - self.step_y))
if moveDir == "x_left":
self.x_min.set(str(int(self.x_min.get()) - self.step_x))
self.x_max.set(str(int(self.x_max.get()) - self.step_x))
if moveDir == "x_right":
self.x_min.set(str(int(self.x_min.get()) + self.step_x))
self.x_max.set(str(int(self.x_max.get()) + self.step_x))
self.yminInput.delete(0, END)
self.yminInput.insert(0, self.y_min.get())
self.ymaxInput.delete(0, END)
self.ymaxInput.insert(0, self.y_max.get())
self.xminInput.delete(0, END)
self.xminInput.insert(0, self.x_min.get())
self.xmaxInput.delete(0, END)
self.xmaxInput.insert(0, self.x_max.get())
self.renewCanvas(False)
def nextUnit(self, unit, d):
if unit == "synapse":
newNumber = int(self.synapseNumber.get()) + d
if newNumber >= 0 and newNumber < self.root.neurons[self.folder]["TC"].size:
self.synapseNumber.set(str(newNumber))
self.synapseInput.delete(0, END)
self.synapseInput.insert(0, self.synapseNumber.get())
else:
self.mainFig.text(
0.5,
0.5,
"synapse out-of-bound",
bbox=dict(facecolor="red", alpha=0.8),
horizontalalignment="center",
verticalalignment="center",
)
self.canvas.show()
if (
unit == "neuron"
): # if the neuron that is looked at now doesn't have synapse info, than jump to next neuron; else jump to next neuron with synapse info
if self.neuronNumber.get() not in self.root.genParam[self.folder]["neuronsToTrack"]:
newNumber = int(self.neuronNumber.get()) + d
if newNumber >= 0 and newNumber < np.size(
self.root.neurons[self.folder]["RS"].g_excit, 0
): # makes sure that index won't go out of bound
self.neuronNumber.set(str(newNumber))
self.neuronInput.delete(0, END)
self.neuronInput.insert(0, self.neuronNumber.get())
else:
self.mainFig.text(
0.5,
0.5,
"neuron out-of-bound",
bbox=dict(facecolor="red", alpha=0.8),
horizontalalignment="center",
verticalalignment="center",
)
self.canvas.show()
else:
index = self.root.genParam[self.folder]["neuronsToTrack"].index(self.neuronNumber.get())
if index + d >= 0 and index + d < np.size(
self.root.genParam[self.folder]["neuronsToTrack"]
): # makes sure that index won't go out of bound
self.neuronNumber.set(str(int(self.root.genParam[self.folder]["neuronsToTrack"][index + d])))
self.neuronInput.delete(0, END)
self.neuronInput.insert(0, self.neuronNumber.get())
else:
self.mainFig.text(
0.5,
0.5,
"neuron out-of-bound",
bbox=dict(facecolor="red", alpha=0.8),
horizontalalignment="center",
verticalalignment="center",
)
self.canvas.show()
self.renewCanvas(False)
def rasterPlotSelf(self, n):
spikesRS = np.argwhere(self.root.neurons[self.folder]["RS"].spikeTimes[n, :])
self.plt.plot(
spikesRS * self.root.genParam[self.folder]["dt"],
(self.root.neurons[self.folder]["TC"].size + 5) * np.ones(len(spikesRS)),
"d",
markerfacecolor="y",
markeredgecolor="k",
markeredgewidth=2,
markersize=6,
)
def rasterPlotTC(self, pop):
colorPlot = np.array(["k" for neuron in range(self.root.neurons[self.folder][pop].size)])
colorPlot[self.root.genParam[self.folder]["allPats"]["pat1"]] = "r"
colorPlot[self.root.genParam[self.folder]["allPats"]["pat2"]] = "b"
colorPlot[self.root.genParam[self.folder]["allPats"]["pat3"]] = "y"
colorPlot[self.root.genParam[self.folder]["allPats"]["pat4"]] = "c"
for neuron in range(self.root.neurons[self.folder][pop].size):
spikes = np.argwhere(self.root.neurons[self.folder][pop].spikeTimes[neuron, :])
self.plt.scatter(
spikes * self.root.genParam[self.folder]["dt"],
neuron * np.ones(len(spikes)),
marker="d",
color=colorPlot[neuron],
)
def rasterPlotRSFS(self, pop):
colorPlot = {"RS": "|r", "FS": "|b"}
compress = 0.5
offSet = self.root.neurons[self.folder]["TC"].size + 10
if pop == "FS":
offSet += self.root.neurons[self.folder]["TC"].size * compress + 5
for neuron in range(self.root.neurons[self.folder][pop].size):
spikes = np.argwhere(self.root.neurons[self.folder][pop].spikeTimes[neuron, :])
self.plt.plot(
spikes * self.root.genParam[self.folder]["dt"],
neuron * np.ones(len(spikes)) * compress + offSet,
colorPlot[pop],
)
def renewCanvas(self, event):
# clear previous figure
self.mainFig.clf()
self.plt = self.mainFig.add_subplot(111)
# get input variables
self.neuronNumber.set(self.neuronInput.get())
self.synapseNumber.set(self.synapseInput.get())
n, s = self.checkAvail(int(self.neuronNumber.get()), int(self.synapseNumber.get()))
# plot variables
p1 = p2 = p3 = p4 = p5 = p6 = p7 = p8 = p9 = p10 = p11 = p12 = p13 = p14 = p15 = []
# neuron variables:
if self.Vm_neuron.get():
p1, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"], self.root.neurons[self.folder]["RS"].Vm[n, :], "k"
)
if self.g_excit.get():
p2, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"], self.root.neurons[self.folder]["RS"].g_excit[n, :], "r"
)
if self.g_inhib.get():
p3, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"], self.root.neurons[self.folder]["RS"].g_inhib[n, :], "b"
)
if self.G_ref.get():
p4, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"], self.root.neurons[self.folder]["RS"].Gref[n, :] * 8, "k"
)
if self.BPAP.get():
p4, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"], self.root.neurons[self.folder]["RS"].BPAP[n, :] * 30, "k"
)
if self.spikesSelf.get():
self.rasterPlotSelf(n)
if self.spikesTC.get():
self.rasterPlotTC("TC")
if self.spikesRS.get():
self.rasterPlotRSFS("RS")
if self.spikesFS.get():
self.rasterPlotRSFS("FS")
# synapse variables
if self.neuronAvail:
if self.Vm_syn.get():
p5, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"], self.root.synapses[self.folder][str(n)].Vm[s, :], "k"
)
if self.g.get():
p6, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"],
self.root.synapses[self.folder][str(n)].g[s, :] * 100,
"k",
)
if self.calcium.get():
p7, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"],
self.root.synapses[self.folder][str(n)].calcium[s, :] * 8,
"k",
)
if self.Mg.get():
p8, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"],
self.root.synapses[self.folder][str(n)].Mg[s, :] * 50,
"k",
)
if self.I_syn.get():
p9, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"],
self.root.synapses[self.folder][str(n)].I[s, :] * 5,
"k",
)
if self.I_NMDA.get():
p10, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"],
self.root.synapses[self.folder][str(n)].I_NMDA[s, :] * 50,
"k",
)
if self.I_VGCC.get():
p11, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"],
self.root.synapses[self.folder][str(n)].I_VGCC[s, :] * 50,
"k",
)
if self.P.get():
p12, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"],
self.root.synapses[self.folder][str(n)].P[s, :] * 1000,
"k",
)
if self.B.get():
p13, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"],
self.root.synapses[self.folder][str(n)].B[s, :] * 10,
"k",
)
if self.D.get():
p14, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"],
self.root.synapses[self.folder][str(n)].D[s, :] * 500,
"k",
)
if self.V.get():
p15, = self.plt.plot(
self.root.genParam[self.folder]["timeArray"],
self.root.synapses[self.folder][str(n)].V[s, :] * 30,
"k",
)
# plot parameters
self.plt.set_xlabel("time (ms)")
self.plt.set_xlim(int(self.x_min.get()), int(self.x_max.get()))
if not self.offValue:
self.plt.set_ylim(int(self.y_min.get()), int(self.y_max.get()))
# make plot legend
legendPlots = np.array([p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15])
legendNames = np.array(
[
"Vm",
"g excit",
"g inhib",
"G ref",
"Vm syn",
"g",
"calcium",
"Mg",
"I syn",
"I NMDA",
"I VGCC",
"P",
"V",
"B",
"D",
]
)
legendMask = np.array(
map(
bool,
[
self.Vm_neuron.get(),
self.g_excit.get(),
self.g_inhib.get(),
self.G_ref.get(),
self.Vm_syn.get(),
self.g.get(),
self.calcium.get(),
self.Mg.get(),
self.I_syn.get(),
self.I_NMDA.get(),
self.I_VGCC.get(),
self.P.get(),
self.V.get(),
self.B.get(),
self.D.get(),
],
)
)
if self.legend:
self.mainFig.legend(legendPlots[legendMask], legendNames[legendMask], mode="expand", ncol=6)
self.canvas.show()
def checkAvail(self, n, s):
# check for out-of-bound neuron
if n >= np.size(self.root.neurons[self.folder]["RS"].g_excit, 0):
n = np.size(self.root.neurons[self.folder]["RS"].g_excit, 0) - 1
self.neuronNumber.set(str(n))
self.neuronInput.delete(0, END)
self.neuronInput.config(foreground="red")
self.neuronInput.insert(0, str(n))
self.mainFig.text(
0.5,
0.5,
"neuron out-of-bound",
bbox=dict(facecolor="red", alpha=0.8),
horizontalalignment="center",
verticalalignment="center",
)
self.canvas.show()
else:
self.neuronInput.config(foreground="black")
# check for out-of-bound neuron
if s >= self.root.neurons[self.folder]["TC"].size:
s = self.root.neurons[self.folder]["TC"].size - 1
self.synapseNumber.set(str(s))
self.synapseInput.delete(0, END)
self.synapseInput.config(foreground="red")
self.synapseInput.insert(0, str(s))
self.mainFig.text(
0.5,
0.5,
"synapse out-of-bound",
bbox=dict(facecolor="red", alpha=0.8),
horizontalalignment="center",
verticalalignment="center",
)
self.canvas.show()
else:
self.synapseInput.config(foreground="black")
# check for neuron with unavailable synapse information
if self.neuronNumber.get() not in self.root.genParam[self.folder]["neuronsToTrack"]:
tt = "synapse information not available; use neurons "
for k in self.root.genParam[self.folder]["neuronsToTrack"]:
tt += k + " "
self.mainFig.text(0.02, 0.95, tt, bbox=dict(facecolor="red", alpha=0.35))
self.canvas.show()
self.neuronAvail = False
self.CB_Vm_syn.config(state=DISABLED)
self.CB_g.config(state=DISABLED)
self.CB_calcium.config(state=DISABLED)
self.CB_Mg.config(state=DISABLED)
self.CB_I_syn.config(state=DISABLED)
self.CB_I_NMDA.config(state=DISABLED)
self.CB_I_VGCC.config(state=DISABLED)
self.CB_P.config(state=DISABLED)
self.CB_B.config(state=DISABLED)
self.CB_D.config(state=DISABLED)
self.CB_V.config(state=DISABLED)
self.synapseInput.config(state=DISABLED)
else:
self.neuronAvail = True
self.CB_Vm_syn.config(state=NORMAL)
self.CB_g.config(state=NORMAL)
self.CB_calcium.config(state=NORMAL)
self.CB_Mg.config(state=NORMAL)
self.CB_I_syn.config(state=NORMAL)
self.CB_I_NMDA.config(state=NORMAL)
self.CB_I_VGCC.config(state=NORMAL)
self.CB_P.config(state=NORMAL)
self.CB_B.config(state=NORMAL)
self.CB_D.config(state=NORMAL)
self.CB_V.config(state=NORMAL)
self.synapseInput.config(state=NORMAL)
return n, s
def closeGUI(self, allGUI=False):
if not allGUI:
self.root.allGUI.remove(self)
self.destroy()
class SimulationGui(QMainWindow):
def __init__(self, net=None, parent=None, fname=None):
QMainWindow.__init__(self)
self.ui = Ui_SimulationWindow()
self.ui.setupUi(self)
if fname:
self.set_title(fname)
# context menu
self.ui.nodeInspector.addAction(self.ui.actionCopyInspectorData)
self.ui.nodeInspector.addAction(self.ui.actionShowLocalizedSubclusters)
# callbacks
self.ui.actionCopyInspectorData.activated\
.connect(self.on_actionCopyInspectorData_triggered)
self.ui.actionShowLocalizedSubclusters.activated\
.connect(self.on_actionShowLocalizedSubclusters_triggered)
self.dpi = 72
# take size of networDisplayWidget
self.fig = Figure((700 / self.dpi, 731 / self.dpi), self.dpi,
facecolor='0.9')
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.ui.networkDisplayWidget)
self.nav = NavigationToolbar(self.canvas, self.ui.networkDisplayWidget,
coordinates=True)
self.nav.setGeometry(QRect(0, 0, 651, 36))
self.nav.setIconSize(QSize(24, 24))
self.axes = self.fig.add_subplot(111)
# matplotlib.org/api/figure_api.html#matplotlib.figure.SubplotParams
self.fig.subplots_adjust(left=0.03, right=0.99, top=0.92)
if net:
self.init_sim(net)
self.connect(self.ui.showNodes, SIGNAL('stateChanged(int)'),
self.refresh_visibility)
self.connect(self.ui.showEdges, SIGNAL('stateChanged(int)'),
self.refresh_visibility)
self.connect(self.ui.showMessages, SIGNAL('stateChanged(int)'),
self.refresh_visibility)
self.connect(self.ui.showLabels, SIGNAL('stateChanged(int)'),
self.refresh_visibility)
self.connect(self.ui.redrawNetworkButton, SIGNAL('clicked(bool)'),
self.redraw)
self.connect(self.ui.treeGroupBox, SIGNAL('toggled(bool)'),
self.refresh_visibility)
self.connect(self.ui.treeKey, SIGNAL('textEdited(QString)'),
self.redraw)
self.connect(self.ui.propagationError, SIGNAL('toggled(bool)'),
self.refresh_visibility)
self.connect(self.ui.locKey, SIGNAL('textEdited(QString)'),
self.redraw)
# callbacks
self.ui.actionOpenNetwork.activated\
.connect(self.on_actionOpenNetwork_triggered)
self.ui.actionSaveNetwork.activated\
.connect(self.on_actionSaveNetwork_triggered)
self.ui.actionRun.activated.connect(self.on_actionRun_triggered)
self.ui.actionStep.activated.connect(self.on_actionStep_triggered)
self.ui.actionReset.activated.connect(self.on_actionReset_triggered)
self.canvas.mpl_connect('pick_event', self.on_pick)
def handleInspectorMenu(self, pos):
menu = QMenu()
menu.addAction('Add')
menu.addAction('Delete')
menu.exec_(QCursor.pos())
def init_sim(self, net):
self.net = net
self.sim = Simulation(net)
self.connect(self.sim, SIGNAL("redraw()"), self.redraw)
self.connect(self.sim, SIGNAL("updateLog(QString)"), self.update_log)
self.redraw()
def update_log(self, text):
""" Add item to list widget """
print "Add: " + text
self.ui.logListWidget.insertItem(0, text)
# self.ui.logListWidget.sortItems()
def redraw(self):
self.refresh_network_inspector()
self.draw_network()
self.reset_zoom()
self.refresh_visibility()
def draw_network(self, net=None, clear=True, subclusters=None,
drawMessages=True):
if not net:
net = self.net
currentAlgorithm = self.net.get_current_algorithm()
if clear:
self.axes.clear()
self.axes.imshow(net.environment.im, vmin=0, cmap='binary_r',
origin='lower')
self.draw_tree(str(self.ui.treeKey.text()), net)
self.draw_edges(net)
self.draw_propagation_errors(str(self.ui.locKey.text()), net)
if subclusters:
node_colors = self.get_node_colors(net, subclusters=subclusters)
else:
node_colors = self.get_node_colors(net, algorithm=currentAlgorithm)
self.node_collection = self.draw_nodes(net, node_colors)
if drawMessages:
self.draw_messages(net)
self.draw_labels(net)
self.drawnNet = net
step_text = ' (step %d)' % self.net.algorithmState['step'] \
if isinstance(currentAlgorithm, NodeAlgorithm) else ''
self.axes.set_title((currentAlgorithm.name
if currentAlgorithm else '') + step_text)
self.refresh_visibility()
# To save multiple figs of the simulation uncomment next two lines:
#self.fig.savefig('network-alg-%d-step-%d.png' %
# (self.net.algorithmState['index'], self.net.algorithmState['step']))
def draw_nodes(self, net=None, node_colors={}, node_radius={}):
if not net:
net = self.net
if type(node_colors) == str:
node_colors = {node: node_colors for node in net.nodes()}
nodeCircles = []
for n in net.nodes():
c = NodeCircle(tuple(net.pos[n]), node_radius.get(n, 8.0),
color=node_colors.get(n, 'r'),
ec='k', lw=1.0, ls='solid', picker=3)
nodeCircles.append(c)
node_collection = PatchCollection(nodeCircles, match_original=True)
node_collection.set_picker(3)
self.axes.add_collection(node_collection)
return node_collection
def get_node_colors(self, net, algorithm=None, subclusters=None,
drawLegend=True):
COLORS = 'rgbcmyw' * 100
node_colors = {}
if algorithm:
color_map = {}
if isinstance(algorithm, NodeAlgorithm):
for ind, status in enumerate(algorithm.STATUS.keys()):
if status == 'IDLE':
color_map.update({status: 'k'})
else:
color_map.update({status: COLORS[ind]})
if drawLegend:
proxy = []
labels = []
for status, color in color_map.items():
proxy.append(Circle((0, 0), radius=8.0,
color=color, ec='k',
lw=1.0, ls='solid'))
labels.append(status)
self.fig.legends = []
self.fig.legend(proxy, labels, loc=8,
prop={'size': '10.0'}, ncol=len(proxy),
title='Statuses for %s:'
% algorithm.name)
for n in net.nodes():
if n.status == '' or not n.status in color_map.keys():
node_colors[n] = 'r'
else:
node_colors[n] = color_map[n.status]
elif subclusters:
for i, sc in enumerate(subclusters):
for n in sc:
if n in node_colors:
node_colors[n] = 'k'
else:
node_colors[n] = COLORS[i]
return node_colors
def draw_edges(self, net=None):
if not net:
net = self.net
self.edge_collection = nx.draw_networkx_edges(net, net.pos, alpha=0.6,
edgelist=None,
ax=self.axes)
def draw_messages(self, net=None):
if not net:
net = self.net
self.messages = []
msgCircles = []
for node in net.nodes():
for msg in node.outbox:
# broadcast
if msg.destination is None:
for neighbor in net.adj[node].keys():
nbr_msg = msg.copy()
nbr_msg.destination = neighbor
c = MessageCircle(nbr_msg, net, 'out', 3.0, lw=0,
picker=3, zorder=3, color='b')
self.messages.append(nbr_msg)
msgCircles.append(c)
else:
c = MessageCircle(msg, net, 'out', 3.0, lw=0, picker=3,
zorder=3, color='b')
self.messages.append(msg)
msgCircles.append(c)
for msg in node.inbox:
c = MessageCircle(msg, net, 'in', 3.0, lw=0, picker=3,
zorder=3, color='g')
self.messages.append(msg)
msgCircles.append(c)
if self.messages:
self.message_collection = PatchCollection(msgCircles,
match_original=True)
self.message_collection.set_picker(3)
self.axes.add_collection(self.message_collection)
def draw_labels(self, net=None):
if not net:
net = self.net
label_pos = {}
for n in net.nodes():
label_pos[n] = net.pos[n].copy() + 10
self.label_collection = nx.draw_networkx_labels(net, label_pos,
labels=net.labels,
ax=self.axes)
def refresh_visibility(self):
try:
self.node_collection.set_visible(self.ui.showNodes.isChecked())
self.edge_collection.set_visible(self.ui.showEdges.isChecked())
for label in self.label_collection.values():
label.set_visible(self.ui.showLabels.isChecked())
self.tree_collection.set_visible(self.ui.treeGroupBox.isChecked())
self.ini_error_collection.set_visible(self.ui.propagationError\
.isChecked())
self.propagation_error_collection.set_visible(self.ui\
.propagationError\
.isChecked())
# sould be last, sometimes there are no messages
self.message_collection.set_visible(self.ui.showMessages\
.isChecked())
except AttributeError:
print 'Refresh visibility warning'
self.canvas.draw()
def draw_tree(self, treeKey, net=None):
"""
Show tree representation of network.
Attributes:
treeKey (str):
key in nodes memory (dictionary) where tree data is stored
storage format can be a list off tree neighbors or a dict:
{'parent': parent_node,
'children': [child_node1, child_node2 ...]}
"""
if not net:
net = self.net
treeNet = net.get_tree_net(treeKey)
if treeNet:
self.tree_collection = draw_networkx_edges(treeNet, treeNet.pos,
treeNet.edges(),
width=1.8, alpha=0.6,
ax=self.axes)
def draw_propagation_errors(self, locKey, net):
SCALE_FACTOR = 0.6
if not net:
net = self.net
if any([not locKey in node.memory for node in net.nodes()]):
self.propagation_error_collection = []
self.ini_error_collection = []
return
rms = {'iniRms': {}, 'stitchRms': {}}
for node in net.nodes():
rms['iniRms'][node] = get_rms(self.net.pos,
(node.memory['iniLocs']), True) * \
SCALE_FACTOR
rms['stitchRms'][node] = get_rms(self.net.pos, node.memory[locKey],
True) * SCALE_FACTOR
self.propagation_error_collection = \
self.draw_nodes(net=net, node_colors='g',
node_radius=rms['stitchRms'])
self.ini_error_collection = self.draw_nodes(net=net, node_colors='b',
node_radius=rms['iniRms'])
def reset_zoom(self):
self.axes.set_xlim((0, self.net.environment.im.shape[1]))
self.axes.set_ylim((0, self.net.environment.im.shape[0]))
def set_title(self, fname):
new = ' - '.join([str(self.windowTitle()).split(' - ')[0], str(fname)])
self.setWindowTitle(new)
def refresh_network_inspector(self):
niModel = DictionaryTreeModel(dic=self.net.get_dic())
self.ui.networkInspector.setModel(niModel)
self.ui.networkInspector.expandToDepth(0)
"""
Callbacks
"""
def on_actionRun_triggered(self):
self.ui.logListWidget.clear()
print 'running ...',
self.sim.stepping = True
self.sim.run_all()
def on_actionStep_triggered(self):
print 'next step ...',
self.sim.run(self.ui.stepSize.value())
def on_actionReset_triggered(self):
print 'reset ...',
self.sim.reset()
self.redraw()
def on_actionCopyInspectorData_triggered(self):
string = 'Node inspector data\n-------------------'
# raise()
for qModelIndex in self.ui.nodeInspector.selectedIndexes():
string += '\n' + qModelIndex.internalPointer().toString(' ')
clipboard = app.clipboard()
clipboard.setText(string)
event = QEvent(QEvent.Clipboard)
app.sendEvent(clipboard, event)
def on_actionShowLocalizedSubclusters_triggered(self):
if len(self.ui.nodeInspector.selectedIndexes()) == 1:
qModelIndex = self.ui.nodeInspector.selectedIndexes()[0]
treeItem = qModelIndex.internalPointer()
assert(isinstance(treeItem.itemDataValue, Positions))
estimated = deepcopy(treeItem.itemDataValue)
estimatedsub = estimated.subclusters[0]
# rotate, translate and optionally scale
# w.r.t. original positions (pos)
align_clusters(Positions.create(self.net.pos), estimated, True)
net = self.net.subnetwork(estimatedsub.keys(), pos=estimatedsub)
self.draw_network(net=net, drawMessages=False)
edge_pos = numpy.asarray([(self.net.pos[node], estimatedsub[node][:2])
for node in net])
error_collection = LineCollection(edge_pos, colors='r')
self.axes.add_collection(error_collection)
rms = get_rms(self.net.pos, estimated, scale=False)
self.update_log('rms = %.3f' % rms)
self.update_log('localized = %.2f%% (%d/%d)' %
(len(estimatedsub) * 1. / len(self.net.pos) * 100,
len(estimatedsub), len(self.net.pos)))
def on_actionSaveNetwork_triggered(self, *args):
default_filetype = 'gz'
start = datetime.now().strftime('%Y%m%d') + default_filetype
filters = ['Network pickle (*.gz)', 'All files (*)']
selectedFilter = 'Network pickle (gz)'
filters = ';;'.join(filters)
fname = QFileDialog.getSaveFileName(self, "Choose a filename",
start, filters, selectedFilter)[0]
if fname:
try:
write_pickle(self.net, fname)
except Exception, e:
QMessageBox.critical(
self, "Error saving file", str(e),
QMessageBox.Ok, QMessageBox.NoButton)
else:
self.set_title(fname)
class dpph_measurement:
'''
'''
def __init__(self, pype, toplevel=False, **runargs):
'''
'''
self.pype = pype
self.runargs = runargs
self.toplevel = toplevel
self.sweep_result = {}
self.powerVar = DoubleVar(value=20) #dBm
self.set_power_BoolVar = BooleanVar(value=True)
self.start_freq_Var = DoubleVar(value=26350) #MHz
self.stop_freq_Var = DoubleVar(value=26600) #MHz
self.start_search_freq_Var = DoubleVar(value=26450) #MHz
self.stop_search_freq_Var = DoubleVar(value=26510) #MHz
self.sweep_time_Var = DoubleVar(value=15) #s
self.num_points_Var = IntVar(value=400) #ms
self.spanVar = DoubleVar(value=100)
self.stepVar = DoubleVar(value=4)
#self.fit_channel_Var = StringVar(value='xdata')
self.result_str_Var = StringVar(value='')
self._BuildGui()
def _BuildGui(self):
'''
Dpph popup window
'''
row = 0
##################################################################
# Lockin Scan
Label(self.toplevel, text='Input Power'
).grid(row=row, column=0, sticky='ew')
Entry(self.toplevel, textvariable=self.powerVar
).grid(row=row, column=1, sticky='ew')
Label(self.toplevel, text='[dBm]', justify='left'
).grid(row=row, column=2, sticky='w')
Checkbutton(self.toplevel, text="Don't Change",
variable=self.set_power_BoolVar).grid(row=row, column=3)
row += 1
Label(self.toplevel, text='Scan Frequency Range'
).grid(row=row, column=0, sticky='ew')
Entry(self.toplevel, textvariable=self.start_freq_Var
).grid(row=row, column=1, sticky='ew')
Entry(self.toplevel, textvariable=self.stop_freq_Var
).grid(row=row, column=2, columnspan=2, sticky='ew')
Label(self.toplevel, text='[MHz]').grid(row=row, column=4, sticky='w')
row += 1
Label(self.toplevel, text='Sweep Time'
).grid(row=row, column=0, sticky='ew')
Entry(self.toplevel, textvariable=self.sweep_time_Var
).grid(row=row, column=1, sticky='ew')
Label(self.toplevel, text='[s]').grid(row=row, column=2, sticky='w')
row += 1
Label(self.toplevel, text='Number of Points'
).grid(row=row, column=0, sticky='ew')
Entry(self.toplevel, textvariable=self.num_points_Var
).grid(row=row, column=1, sticky='ew')
row += 1
Button(self.toplevel, text='take data', command=self._CollectSweep
).grid(row=row, column=0)
row += 1
Label(self.toplevel, text='-'*50).grid(row=row, column=0, columnspan=4, sticky='ew')
row += 1
##################################################################
# Resonance Search
Label(self.toplevel, text='Search Frequency Range'
).grid(row=row, column=0, sticky='ew')
Entry(self.toplevel, textvariable=self.start_search_freq_Var
).grid(row=row, column=1, sticky='ew')
Entry(self.toplevel, textvariable=self.stop_search_freq_Var
).grid(row=row, column=2, columnspan=2, sticky='ew')
Label(self.toplevel, text='[MHz]').grid(row=row, column=4, sticky='w')
row += 1
#ch_options = ['xdata', 'ydata']
#OptionMenu(self.toplevel, self.fit_channel_Var, *ch_options
# ).grid(row=row, column=0, rowspan=2, sticky='ew')
Button(self.toplevel, text='find resonance', command=self._FindResonance
).grid(row=row, column=1, rowspan=2, sticky='ew')
Label(self.toplevel, textvariable=self.result_str_Var
).grid(row=row, column=2, rowspan=2, columnspan=3, sticky='ew')
row += 2
Button(self.toplevel, text='Dump To json', command=self._SaveJson
).grid(row=row, column=0)
Button(self.toplevel, text='Save Image', command=self._SaveFigure
).grid(row=row, column=1)
Button(self.toplevel, text='Log DPPH', command=self._LogDPPH
).grid(row=row, column=2)
self._SetupPlot(row=0, column=5)
def _SetupPlot(self, row, column):
'''
Initialize the plot in the gui
'''
self.figure = Figure()
self.figure.subplots_adjust(left=0.15, bottom=0.2)
self.subfigure = self.figure.add_subplot(1, 1, 1)
self.subfigure.plot([0], [0])
self.subfigure.plot([0], [0])
self.subfigure.set_xlabel('Freq [MHz]')
self.canvas = FigureCanvasTkAgg(self.figure, master=self.toplevel)
self.canvas.show()
self.canvas.get_tk_widget().grid(row=row, column=column, rowspan=10)
def _CollectSweep(self):
'''
'''
tmp_power = self.powerVar.get()
if self.set_power_BoolVar.get():
tmp_power = False
while True:
sweep = _GetSweptVoltages(pype=self.pype,
start_freq=self.start_freq_Var.get(),
stop_freq=self.stop_freq_Var.get(),
sweep_time=self.sweep_time_Var.get(),
power=tmp_power,
num_points=self.num_points_Var.get())
self.sweep_result = sweep.copy()
freqdata = array(sweep['frequency_curve'])
magdata = sweep['amplitude_curve']
if type(magdata[0]) is unicode:
print('Warning: _GetSweptVoltages failed;')
print('magdata:')
print(magdata)
print('Acquiring data again...')
elif type(magdata[0]) is int:
break
if not sweep['frequencies_confirmed']:
showwarning('Warning', 'Communication with lockin amp failed. Frequencies data may be wrong')
magdata = magdata - mean(magdata)
#ydata = sweep['y_curve']
print('freq range is ', min(freqdata), ' to ', max(freqdata))
#xdata = sweep['x_curve']
y_del = max((max(magdata) - min(magdata)) * .05, 1)
self.subfigure.set_xlim(left=freqdata[0], right=freqdata[-1])
self.subfigure.set_ylim(bottom=(min(magdata) - y_del), top=(max(magdata) + y_del))
line = self.subfigure.get_lines()[0]
line.set_xdata(array(freqdata))
line.set_ydata(array(magdata))
line.set_label('lockin output')
#line = self.subfigure.get_lines()[1]
#line.set_xdata(array(freqdata))
#line.set_ydata(array(ydata))
#line.set_label('y output')
self.figure.legends = []
self.figure.legend(*self.subfigure.get_legend_handles_labels())
self.figure.legends[0].draggable(True)
self.canvas.draw()
self.canvas.show()
print('Searching for resonance...')
self._FindResonance()
def _FindResonance(self):
'''
'''
#if self.fit_channel_Var.get() == 'xdata':
# line = self.subfigure.get_lines()[0]
#elif self.fit_channel_Var.get() == 'ydata':
# line = self.subfigure.get_lines()[1]
line = self.subfigure.get_lines()[0]
#else:
# raise ValueError('not a valid dataset selection')
xdata = line.get_xdata()
ydata = line.get_ydata()
fit = _FindFieldFFT(min_freq=self.start_search_freq_Var.get(),
max_freq=self.stop_search_freq_Var.get(),
freq_data=xdata,
volts_data=ydata)
outline = self.subfigure.get_lines()[1]
factor = max(ydata) / max(fit['result'])
scaled_data = [val * factor for val in fit['result']]
scaled_data = scaled_data - mean(scaled_data)
outline.set_xdata(fit['freqs'])
outline.set_ydata(scaled_data)
outline.set_label('filter result')
self.figure.legends = []
self.figure.legend(*self.subfigure.get_legend_handles_labels())
self.figure.legends[0].draggable(True)
self.canvas.draw()
self.canvas.show()
res_freq = max(zip(fit['result'], fit['freqs']))[1]
res_unct = fit['freqs'][1] - fit['freqs'][0]
print('resonance found at:', res_freq, 'MHz')
print('err is:', res_unct)
geff = 2.0036
chargemass = 1.758e11
freq_to_field = 4 * pi * 10 ** 7 / (geff * chargemass)
res_field = freq_to_field * res_freq
res_field_unct = freq_to_field * res_unct
print('for a field of', res_field)
print('field unct of', res_field_unct)
self.result_str_Var.set('{:.4E} +/- {:.1E} MHz \n({:.4E} +/- {:.1E} kG)'.format(
res_freq, res_unct, res_field, res_field_unct))
self.sweep_result.update({'res_freq': res_freq,
'res_freq_unct': res_unct,
'res_field': res_field,
'res_field_unct': res_field_unct})
def _SaveJson(self):
'''
'''
if not self.sweep_result:
print('no result stored')
return
outfile = asksaveasfile(defaultextension='.json')
dump(self.sweep_result, outfile, indent=4)
outfile.close()
def _SaveFigure(self):
'''
'''
file_extensions = [('vectorized', '.eps'), ('adobe', '.pdf'), ('image', '.png'), ('all', '.*')]
outfile = asksaveasfilename(defaultextension='.pdf',
filetypes=file_extensions)
self.figure.savefig(outfile)
def _LogDPPH(self):
if not self.sweep_result:
print('no dpph_result stored')
return
result = {
'uncal': self.sweep_result['res_freq'],
'uncal_err': self.sweep_result['res_freq_unct'],
'uncal_units': 'MHz',
'cal': self.sweep_result['res_field'],
'cal_err': self.sweep_result['res_field_unct'],
'cal_units': 'kG',
}
dpph_result = {'uncal_val': ' '.join([str(result['uncal']), '+/-', str(result['uncal_err']), result['uncal_units']]),
'cal_val': ' '.join([str(result['cal']), '+/-', str(result['cal_err']), result['cal_units']]),
'timestamp': datetime.utcnow()}
self.pype.LogValue(sensor='dpph_field', **dpph_result)
print('dpph_result stored')
class XratersWindow(gtk.Window):
__gtype_name__ = "XratersWindow"
def __init__(self):
"""__init__ - This function is typically not called directly.
Creation a XratersWindow requires redeading the associated ui
file and parsing the ui definition extrenally,
and then calling XratersWindow.finish_initializing().
Use the convenience function NewXratersWindow to create
XratersWindow object.
"""
self._acc_cal = ((128, 128, 128),
(255, 255, 255))
self._acc = [0, 0, 0]
self._connected = False
self._wiiMote = None
self._resetData()
self._dataLock = threading.Lock()
isConnected = property(lambda self: self._connected)
def callback(funct):
"""A decorator used to require connection to the Wii Remote
This decorator is used to implement the precondition that
the Wii Remote must be connected.
"""
def _callback(cls, *args, **kwds):
if cls.isConnected:
funct(cls, *args, **kwds)
return True
else:
return False
return _callback
def _connectCallback(self, connectionMaker):
"""Callback function called upon successful connection to the Wiimote
"""
if connectionMaker.connected:
self._connected = True
self._wiiMote = connectionMaker.wiiMote
self._resetData()
gobject.timeout_add(45, self._drawAcc)
self.widget('actionDisconnect').set_sensitive(True)
self.widget('actionSave').set_sensitive(True)
self.widget('actionReset').set_sensitive(True)
self.widget('actionPause').set_sensitive(True)
self.widget('toolbutton1').set_related_action(self.widget('actionDisconnect'))
self._acc_cal = connectionMaker.acc_cal
self._wiiMote.mesg_callback = self._getAcc
self._updBatteryLevel()
gobject.timeout_add_seconds(60, self._updBatteryLevel)
else:
self.widget('actionWiiConnect').set_sensitive(True)
@callback
def _upd_background(self, event):
"""Keep a copy of the figure background
"""
self.__background = self._accCanvas.copy_from_bbox(self._accAxis.bbox)
def _getAcc(self, messages, theTime=0):
"""Process acceleration messages from the Wiimote
This function is intended to be set as cwiid.mesg_callback
"""
if self._Paused:
return
for msg in messages:
if msg[0] == cwiid.MESG_ACC:
# Normalize data using calibration info
for i, axisAcc in enumerate(msg[1]):
self._acc[i] = float(axisAcc-self._acc_cal[0][i])
self._acc[i] /=(self._acc_cal[1][i]\
-self._acc_cal[0][i])
with self._dataLock:
# Store time and acceleration in the respective arrays
self._time.append(theTime-self._startTime)
[self._accData[i].append(self._acc[i]) for i in threeAxes]
# We only keep about 6 seconds worth of data
if (self._time[-1] - self._time[0] > 6):
with self._dataLock:
self._time.pop(0)
[self._accData[i].pop(0) for i in threeAxes]
@callback
def _drawAcc(self):
"""Update the acceleration graph
"""
# Do nothing while paused or there's no data available
if self._Paused or len(self._time)==0:
return
draw_flag = False
# Update axes limits if the data fall out of range
lims = self._accAxis.get_xlim()
if self._time[-1] > lims[1]:
self._accAxis.set_xlim(lims[0], lims[1]+2)
lims = self._accAxis.get_xlim()
draw_flag = True
if (self._time[-1] - lims[0] > 6):
self._accAxis.set_xlim(lims[0]+2, lims[1])
draw_flag = True
if draw_flag:
gobject.idle_add(self._accCanvas.draw)
# Do the actual update of the background
if self.__background != None:
self._accCanvas.restore_region(self.__background)
# Do the actual update of the lines
with self._dataLock:
[self._lines[i].set_data(self._time, self._accData[i]) for i in threeAxes]
[self._accAxis.draw_artist(self._lines[i]) for i in threeAxes]
self._accCanvas.blit(self._accAxis.bbox)
@callback
def _updBatteryLevel(self):
"""Callback to update the battery indicator in the status bar
"""
self._wiiMote.request_status()
self._setBatteryIndicator(float(self._wiiMote.state['battery']) /
cwiid.BATTERY_MAX)
def _setBatteryIndicator(self, level):
"""Actually update the battery indicator in the status bar
"""
progressBar = self.widget("progressbarBattery")
progressBar.set_fraction(level)
progressBar.set_text("Battery: %.0f%%" % (level * 100))
def _resetData(self):
"""Reset stored data and status flags to their defaults
"""
self._accData = [list(), list(), list()]
self._time = list()
self._startTime = time.time()
self._moveTime = self._startTime
self._Paused = False
def widget(self, name):
"""Helper function to retrieve widget handlers
"""
return self.builder.get_object(name)
def finish_initializing(self, builder):
"""finish_initalizing should be called after parsing the ui definition
and creating a XratersWindow object with it in order to finish
initializing the start of the new XratersWindow instance.
"""
#get a reference to the builder and set up the signals
self.builder = builder
self.builder.connect_signals(self)
#uncomment the following code to read in preferences at start up
dlg = PreferencesXratersDialog.NewPreferencesXratersDialog()
self.preferences = dlg.get_preferences()
#code for other initialization actions should be added here
self._accFigure = Figure(figsize=(8,6), dpi=72)
self._accAxis = self._accFigure.add_subplot(111)
self._accAxis.set_xlabel("time (s)")
self._accAxis.set_ylabel("acceleration (g)")
self._lines = self._accAxis.plot(self._time, self._accData[X],
self._time, self._accData[Y],
self._time, self._accData[Z],
animated=True)
self._accFigure.legend(self._lines, ("X", "Y", "Z"),
'upper center',
ncol=3)
self._accAxis.set_xlim(0, 2)
self._accAxis.set_ylim(-3, 3)
self._accCanvas = FigureCanvas(self._accFigure)
self._accCanvas.mpl_connect("draw_event", self._upd_background)
self.__background = self._accCanvas.copy_from_bbox(self._accAxis.bbox)
self._accCanvas.show()
self._accCanvas.set_size_request(600, 400)
vbMain = self.widget("vboxMain")
vbMain.pack_start(self._accCanvas, True, True)
vbMain.show()
vbMain.reorder_child(self._accCanvas, 2)
self._setBatteryIndicator(0)
def about(self, widget, data=None):
"""about - display the about box for xraters """
about = AboutXratersDialog.NewAboutXratersDialog()
response = about.run()
about.destroy()
def preferences(self, widget, data=None):
"""preferences - display the preferences window for xraters """
prefs = PreferencesXratersDialog.NewPreferencesXratersDialog()
response = prefs.run()
if response == gtk.RESPONSE_OK:
#make any updates based on changed preferences here
self.preferences = prefs.get_preferences()
prefs.destroy()
def quit(self, widget, data=None):
"""quit - signal handler for closing the XratersWindow"""
self.destroy()
def on_destroy(self, widget, data=None):
"""on_destroy - called when the XratersWindow is close. """
#clean up code for saving application state should be added here
if self.isConnected:
self.on_wiiDisconnect(widget, data)
gtk.main_quit()
def on_wiiConnect(self, widget, data=None):
"""Signal handler for the WiiConnect action
"""
self.widget('actionWiiConnect').set_sensitive(False)
connectionMaker = WiiConnectionMaker(self.preferences['wiiAddress'],
self.widget("statusbar"),
self._connectCallback)
self._accAxis.set_xlim(0, 2)
gobject.idle_add(self._accCanvas.draw)
connectionMaker.start()
def on_wiiDisconnect(self, widget, data=None):
"""Signal handler for the WiiDisconnect action
"""
self._wiiMote.close()
self._connected = False
self.widget('actionDisconnect').set_sensitive(False)
self.widget('actionWiiConnect').set_sensitive(True)
self.widget('actionReset').set_sensitive(False)
self.widget('actionPause').set_sensitive(False)
self.widget('toolbutton1').set_related_action(self.widget('actionWiiConnect'))
self.widget('actionSave').set_sensitive(True)
self.widget('statusbar').pop(self.widget("statusbar").get_context_id(''))
self._setBatteryIndicator(0)
def on_Reset(self, widget, data=None):
"""Signal handler for the reset action
"""
self._resetData()
self._accAxis.set_xlim(0, 2)
gobject.idle_add(self._accCanvas.draw)
def on_Pause(self, widge, data=None):
"""Signal handler for the pause action
"""
if not self._Paused:
self.widget('actionPause').set_short_label("Un_pause")
else:
self.widget('actionPause').set_short_label("_Pause")
self._Paused = not (self._Paused)
def save(self, widget, data=None):
"""Signal handler for the save action
"""
fileName = os.sep.join([self.preferences['outputDir'],
"acceleration_" +
time.strftime("%Y-%m-%d_%H-%M-%S") +
".dat"])
try:
with open(fileName, 'wb') as outFile:
writer = csv.writer(outFile, 'excel-tab')
outFile.write(writer.dialect.delimiter.join(("#time",
"Ax",
"Ay",
"Az")))
outFile.write(writer.dialect.lineterminator)
outFile.write(writer.dialect.delimiter.join(("#s",
"g",
"g",
"g")))
outFile.write(writer.dialect.lineterminator)
with self._dataLock:
writer.writerows(zip(self._time, *self._accData))
except IOError as error:
dialog = gtk.MessageDialog(parent = None,
flags = gtk.DIALOG_DESTROY_WITH_PARENT,
type = gtk.MESSAGE_ERROR,
buttons = gtk.BUTTONS_OK,
message_format = str(error))
dialog.set_title(error[1])
dialog.connect('response', lambda dialog, response: dialog.destroy())
dialog.show()
class OldGraph(object):
"""
Class for matplotlib graphs, i.e. for popups, krw graphs
- calculates correct size
- horizontal axis = dates
- vertical axis = user defined
- outputs httpresponse for png
"""
def __init__(self,
start_date, end_date,
width=None, height=None,
today=datetime.datetime.now(),
restrict_to_month=None):
self.restrict_to_month = restrict_to_month
self.start_date = start_date
self.end_date = end_date
self.today = today
self.figure = Figure()
if width is None or not width:
width = 380.0
if height is None or not height:
height = 250.0
self.width = float(width)
self.height = float(height)
self.figure.set_size_inches((_inches_from_pixels(self.width),
_inches_from_pixels(self.height)))
self.figure.set_dpi(SCREEN_DPI)
# Figure color
self.figure.set_facecolor('white')
# Axes and legend location: full width is "1".
self.legend_width = 0.08
# ^^^ No legend by default, but we *do* allow a little space to the
# right of the graph to prevent the rightmost label from being cut off
# (at least, in a reasonable percentage of the cases).
self.left_label_width = LEFT_LABEL_WIDTH / self.width
self.bottom_axis_location = BOTTOM_LINE_HEIGHT / self.height
self.x_label_height = 0.08
self.legend_on_bottom_height = 0.0
self.axes = self.figure.add_subplot(111)
self.axes.grid(True)
# Fixup_axes in init, so axes can be customised (for example set_ylim).
self.fixup_axes()
#deze kan je zelf zetten
self.ax2 = None
def add_today(self):
# Show line for today.
self.axes.axvline(self.today, color='orange', lw=1, ls='--')
def set_ylim_margin(self, top=0.1, bottom=0.0):
"""Adjust y-margin of axes.
The standard margin is sometimes zero. This method sets the margin
based on already present data in the visible part of the plot, so
call it after plotting and before http_png().
Note that it is assumed here that the y-axis is not reversed.
From matplotlib 1.0 on there is a set_ymargin method
like this already."""
lines = self.axes.lines
arrays = [numpy.array(l.get_data()) for l in lines]
# axhline and axvline give trouble - remove short lines from list
big_arrays = [a for a in arrays if a.size > 4]
if len(big_arrays) > 0:
data = numpy.concatenate(big_arrays, axis=1)
if len(data[0]) > 0:
# Datatimes from database may have timezone information.
# In that case, start_date and end_date cannot be naive.
# Assume all datetimes do have the same timezone, so we
# can do the comparison.
start_date_tz =\
self.start_date.replace(tzinfo=data[0][0].tzinfo)
end_date_tz =\
self.end_date.replace(tzinfo=data[0][0].tzinfo)
index_in_daterange = ((data[0] < end_date_tz) &
(data[0] > start_date_tz))
if index_in_daterange.any():
data_low = numpy.min(data[1, index_in_daterange])
data_high = numpy.max(data[1, index_in_daterange])
data_span = data_high - data_low
view_low = data_low - data_span * bottom
view_high = data_high + data_span * top
self.axes.set_ylim(view_low, view_high)
return None
def suptitle(self, title):
self.figure.suptitle(title,
x=self.left_label_width,
horizontalalignment='left')
def set_xlabel(self, xlabel):
self.axes.set_xlabel(xlabel)
self.x_label_height = BOTTOM_LINE_HEIGHT / self.height
def fixup_axes(self, second=False):
"""Fix up the axes by limiting the amount of items."""
axes_to_change = self.axes
if second:
if self.ax2 is None:
return
else:
axes_to_change = self.ax2
# available_width = self.width - LEFT_LABEL_WIDTH - LEGEND_WIDTH
# approximate_characters = int(available_width / (FONT_SIZE / 2))
# max_number_of_ticks = approximate_characters // 20
# if max_number_of_ticks < 2:
# max_number_of_ticks = 2
if not self.restrict_to_month:
major_locator = LessTicksAutoDateLocator()
axes_to_change.xaxis.set_major_locator(major_locator)
major_formatter = MultilineAutoDateFormatter(
major_locator, axes_to_change)
axes_to_change.xaxis.set_major_formatter(major_formatter)
available_height = (self.height -
BOTTOM_LINE_HEIGHT -
self.x_label_height -
self.legend_on_bottom_height)
approximate_lines = int(available_height / (FONT_SIZE * 1.5))
max_number_of_ticks = approximate_lines
if max_number_of_ticks < 2:
max_number_of_ticks = 2
locator = MaxNLocator(nbins=max_number_of_ticks - 1)
if not second:
axes_to_change.yaxis.set_major_locator(locator)
axes_to_change.yaxis.set_major_formatter(
ScalarFormatter(useOffset=False))
def legend_space(self):
"""reserve space for legend (on the right side). even when
there is no legend displayed"""
self.legend_width = LEGEND_WIDTH / self.width
def legend(self, handles=None, labels=None, ncol=1):
"""
Displays legend. Default is right side, but if the width is
too small, it will display under the graph.
handles is list of matplotlib objects (e.g. matplotlib.lines.Line2D)
labels is list of strings
"""
# experimental update: do not reserve space for legend by
# default, just place over graph. use legend_space to manually
# add space
if handles is None and labels is None:
handles, labels = self.axes.get_legend_handles_labels()
if handles and labels:
# Determine 'small' or 'large'
if self.width < 500:
legend_loc = 4 # lower right
# approximation of legend height
self.legend_on_bottom_height = min(
(len(labels) / ncol + 2) * BOTTOM_LINE_HEIGHT /
self.height,
0.5)
else:
legend_loc = 1 # Upper right'
return self.figure.legend(
handles,
labels,
bbox_to_anchor=(1 - self.legend_width,
0, # self.bottom_axis_location
self.legend_width,
# 1 = Upper right of above bbox. Use 0 for
# 'best'
1),
loc=legend_loc,
ncol=ncol,
fancybox=True,
shadow=True,)
#legend.set_size('medium')
# TODO: get rid of the border around the legend.
def init_second_axes(self):
""" init second axes """
self.ax2 = self.axes.twinx()
self.fixup_axes(second=True)
def http_png(self):
"""Output plot to png. Also calculates size of plot and put 'now'
line."""
axes_left = self.left_label_width
axes_bottom = (self.bottom_axis_location + self.x_label_height +
self.legend_on_bottom_height)
axes_width = 1 - self.legend_width - self.left_label_width
axes_height = (1 - 2 * self.bottom_axis_location -
self.x_label_height - self.legend_on_bottom_height)
self.axes.set_position((axes_left, axes_bottom,
axes_width, axes_height))
if self.ax2 is not None:
self.ax2.set_position((axes_left, axes_bottom,
axes_width, axes_height))
# Set date range
# Somehow, the range cannot be set in __init__
if not self.restrict_to_month:
self.axes.set_xlim(date2num((self.start_date, self.end_date)))
try:
self.set_ylim_margin(top=0.1, bottom=0.0)
except:
pass
canvas = FigureCanvas(self.figure)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
class PlotPanel(wx.Panel):
def __init__(self, parent, data, title, page):
wx.Panel.__init__(self, parent, -1)
self.parent = page
self.data = data
self.title = title
self.fig = Figure((3.0, 3.0), dpi=100)
self.canvas = FigureCanvasWxAgg(self, -1, self.fig)
# TODO (minor): exact value according to mouse position
"""
http://matplotlib.sourceforge.net/users/event_handling.html
def onmove(event):
if event.inaxes:
logging.debug('x=%d, y=%d, xdata=%f, ydata=%f' % (event.x, event.y,
event.xdata, event.ydata))
self.canvas.mpl_connect('motion_notify_event', onmove)
"""
self.toolbar = NavigationToolbar2Wx(self.canvas)
self.toolbar.Realize()
self.init_controls()
self.init_plot()
self.lcol = wx.BoxSizer(wx.VERTICAL)
self.lcol.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
self.lcol.Add(self.toolbar, 0, wx.GROW)
self.rcol = wx.BoxSizer(wx.VERTICAL)
self.rcol.Add(self.controls, 0, wx.EXPAND)
self.sizer = wx.BoxSizer(wx.HORIZONTAL)
self.sizer.Add(self.lcol, 1, wx.EXPAND)
self.sizer.Add(self.rcol, 0)
self.SetSizer(self.sizer)
self.Fit()
def init_plot(self):
self.axes = self.fig.add_subplot(111)
self.axes.set_title(self.title, size=12)
self.axes.set_xlabel("Time [GMT]", labelpad=20)
self.axes.set_ylabel("Signal strength [dB]", labelpad=20)
clist = settings.plot_color_cycle.split(" ")
self.axes.set_color_cycle(clist)
self.axes.grid(True, color=settings.plot_grid_color)
self.axes.set_axis_bgcolor(settings.plot_bg_color)
def format_date(x, pos=None):
dt = dates.num2date(x)
main = dt.strftime("%H:%M:%S.")
zeros_missing = 6 - len(str(dt.microsecond))
flo = float(".%s%d" % (zeros_missing * "0", dt.microsecond))
return main + ("%.03f" % round(flo, 3))[2:]
self.axes.xaxis.set_major_locator(ticker.LinearLocator())
self.axes.xaxis.set_major_formatter(ticker.FuncFormatter(format_date))
self.axes.yaxis.set_major_locator(ticker.AutoLocator())
# unused
# self.axes.format_xdata = dates.DateFormatter('%H:%M:%S')
self.fig.autofmt_xdate()
self.plot(self.first_dtype)
xmin = self.data["_times"][0]
xmax = self.data["_times"][-1]
self.axes.set_xbound(lower=xmin, upper=xmax)
self.axes.set_autoscale_on(False)
self.autoscale = False
self.rescale()
self.toolbar.update()
def init_controls(self):
self.controls = wx.Panel(self)
csizer = wx.BoxSizer(wx.VERTICAL)
dtypes = self.data.keys()
dtypes.sort()
fst = True
add = paply(csizer.Add, border=5, flag=wx.ALL)
add_cb = paply(csizer.Add, border=5, flag=wx.LEFT | wx.RIGHT)
btn = wx.Button(self.controls, -1, label="Close file")
add(btn)
self.Bind(wx.EVT_BUTTON, self.parent.on_cancel, btn)
label = wx.StaticText(self.controls, label="Bands:")
add(label)
for dtype in dtypes:
if dtype[0] != "_":
cbox = wx.CheckBox(self.controls, label=dtype)
if fst:
fst = False
self.first_dtype = dtype
cbox.SetValue(True)
add_cb(cbox)
self.Bind(wx.EVT_CHECKBOX, paply(self.on_band, dtype), cbox)
btn = wx.Button(self.controls, -1, label="Re-scale")
add(btn)
self.Bind(wx.EVT_BUTTON, self.rescale, btn)
auto = wx.CheckBox(self.controls, label="Autoscale")
add_cb(auto)
self.Bind(wx.EVT_CHECKBOX, self.on_autoscale, auto)
live_label = wx.StaticText(self.controls, label="Live mode:")
choices = ["Update", "Follow", "Scale x"]
live_mode = wx.Choice(self.controls, -1, choices=choices)
self.controls.live_mode = live_mode
add(live_label)
add(live_mode)
self.controls.SetSizer(csizer)
def rescale(self, event=None):
ymin = 99999
ymax = -ymin
for dtype in self.data.keys():
if hasattr(self, dtype):
ymin = min(ymin, self.data["_bounds"][dtype][0])
ymax = max(ymax, self.data["_bounds"][dtype][1])
# 1% spacing
corr = (ymax - ymin) / 100
self.axes.set_ybound(lower=ymin - corr, upper=ymax + corr)
self.redraw()
def on_autoscale(self, event=None):
if event is not None:
obj = event.GetEventObject()
self.autoscale = obj.IsChecked()
def on_band(self, which, event=None):
if event is not None:
obj = event.GetEventObject()
if obj.IsChecked():
self.plot(which)
if self.autoscale:
self.rescale()
else:
line = getattr(self, which)
for index, _line in enumerate(self.axes.lines):
if _line == line:
break
self.axes.lines.pop(index)
delattr(self, which)
if self.autoscale:
self.rescale()
self.redraw()
def plot(self, which):
x = self.data["_times"]
y = self.data[which]
t = self.data["_time_bounds"][which]
if t != x[0]:
logging.warning("Data type %s appeared later" % which)
start = x.index(self.data["_time_bounds"][which])
x = x[start:]
if len(y) != len(x):
x = x[: len(y)]
line = self.axes.plot(x, y, scaley=False)[0]
# marker='|', markerfacecolor='red')[0]
setattr(self, which, line)
self.redraw()
def redraw(self):
# update legend
handles = []
dtypes = []
for dtype in self.data.keys():
if hasattr(self, dtype):
handles.append(getattr(self, dtype))
dtypes.append(dtype)
self.fig.legends = []
if len(handles) != 0:
self.fig.legend(handles, dtypes, "right")
# update tick style
allticks = self.axes.xaxis.get_ticklines() + self.axes.yaxis.get_ticklines()
for line in allticks:
line.set_color("gray")
# redraw
self.canvas.draw()
def GetToolBar(self):
return self.toolbar
def onEraseBackground(self, evt):
# this is supposed to prevent redraw flicker on some X servers...
pass
def load_and_plot_diurnal(address, password, daysback):
address=address+'@gmail.com'
#print address, password
#Customizing Variables
### HOW FAR BACK? ###
daysback = int(daysback)
notsince = 0
since = (date.today() - timedelta(daysback)).strftime("%d-%b-%Y")
before = (date.today() - timedelta(notsince)).strftime("%d-%b-%Y")
SEARCH = '(SENTSINCE {si} SENTBEFORE {bf})'.format(si=since, bf=before)
BODY = '(BODY.PEEK[TEXT])'
ALL_HEADERS = '(BODY.PEEK[HEADER.FIELDS (DATE TO CC FROM SUBJECT)])'
DATE = '(BODY.PEEK[HEADER.FIELDS (DATE)])'
tyler = GmailAccount(username=address,password=password)
out = tyler.login()
#LOAD GMAIL EMAILS
received = tyler.load_parse_query(SEARCH, ALL_HEADERS, 'inbox')
#print 'loaded received...'
sent = tyler.load_parse_query(SEARCH, ALL_HEADERS, '[Gmail]/Sent Mail')
#print 'loaded received and sent mail!'
xr, yr = diurnalCompute(received)
xs, ys = diurnalCompute(sent)
fig=Figure(figsize=(14,8))
ax=fig.add_subplot(111)
p1, = ax.plot_date(xr, yr, '.', alpha=0.5, color='b', markersize=marker_size(len(xr)))
p2, = ax.plot_date(xs, ys, '.', alpha=0.7, color='r', markersize=marker_size(len(xr)))
fig.autofmt_xdate()
fig.legend((p1, p2,), ('Received','Sent'), 'upper center', numpoints=1, markerscale=4, fancybox=True)
ax.set_xlabel("Specific Date")
ax.set_ylabel("Time Of Day")
fig.tight_layout(pad=2)
#legend(('Received','Sent'), numpoints=1)
#ax.title("Received data for %s las %s days"%(address, str(daysback)))
#ax.xaxis.set_major_formatter(DateFormatter('%Y-%m-%d'))
'''
fig = figure()
plot_date(xr, yr, '.', alpha=0.7, color='b', markersize=marker_size(len(xr)))
#plot_date(xs, ys, '.', alpha=0.7, color='r', markersize=marker_size(len(xs)))
legend(('Received','Sent'), numpoints=1)
out = plt.setp(plt.xticks()[1], rotation=30)
'''
canvas=FigureCanvas(fig)
response=django.http.HttpResponse(content_type='image/png')
canvas.print_png(response)
return response
'''
class GraphFrame(wx.Frame):
""" The main frame of the application
"""
title = 'Demo: dynamic matplotlib graph'
def __init__(self, port, baud, chan):
wx.Frame.__init__(self, None, -1, self.title)
self.chan = chan
self.datagen = DataGen.SerialData(port=port, baud=baud)
self.data = []
for i in range(0, self.chan):
self.data.append([0.0])
self.formatter = VSP_format.Formatter(self.chan*4, ">" + "I"*self.chan)
self.paused = False
self.create_menu()
self.create_status_bar()
self.create_main_panel()
self.redraw_timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.on_redraw_timer, self.redraw_timer)
self.redraw_timer.Start(REFRESH_INTERVAL_MS)
self.Bind(wx.EVT_CLOSE, self.on_exit)
if self.datagen.get_port_info() != None:
self.flash_status_message("%s : %s " % self.datagen.get_port_info())
else:
self.flash_status_message("Failed to connect")
def create_menu(self):
self.menubar = wx.MenuBar()
menu_file = wx.Menu()
m_expt = menu_file.Append(-1, "&Save plot\tCtrl-S", "Save plot to file")
self.Bind(wx.EVT_MENU, self.on_save_plot, m_expt)
menu_file.AppendSeparator()
m_exit = menu_file.Append(-1, "E&xit\tCtrl-X", "Exit")
self.Bind(wx.EVT_MENU, self.on_exit, m_exit)
self.menubar.Append(menu_file, "&File")
self.SetMenuBar(self.menubar)
def create_main_panel(self):
self.panel = wx.Panel(self)
self.init_plot()
self.canvas = FigCanvas(self.panel, -1, self.fig)
self.xmin_control = BoundControlBox(self.panel, -1, "X min", 0)
self.xmax_control = BoundControlBox(self.panel, -1, "X max", 50)
self.ymin_control = BoundControlBox(self.panel, -1, "Y min", 0)
self.ymax_control = BoundControlBox(self.panel, -1, "Y max", 4)
self.pause_button = wx.Button(self.panel, -1, "Pause")
self.Bind(wx.EVT_BUTTON, self.on_pause_button, self.pause_button)
self.Bind(wx.EVT_UPDATE_UI, self.on_update_pause_button, self.pause_button)
self.cb_grid = wx.CheckBox(self.panel, -1,
"Show Grid",
style=wx.ALIGN_RIGHT)
self.Bind(wx.EVT_CHECKBOX, self.on_cb_grid, self.cb_grid)
self.cb_grid.SetValue(True)
self.cb_xlab = wx.CheckBox(self.panel, -1,
"Show X labels",
style=wx.ALIGN_RIGHT)
self.Bind(wx.EVT_CHECKBOX, self.on_cb_xlab, self.cb_xlab)
self.cb_xlab.SetValue(True)
self.hbox1 = wx.BoxSizer(wx.HORIZONTAL)
self.hbox1.Add(self.pause_button, border=5, flag=wx.ALL | wx.ALIGN_CENTER_VERTICAL)
self.hbox1.AddSpacer(20)
self.hbox1.Add(self.cb_grid, border=5, flag=wx.ALL | wx.ALIGN_CENTER_VERTICAL)
self.hbox1.AddSpacer(10)
self.hbox1.Add(self.cb_xlab, border=5, flag=wx.ALL | wx.ALIGN_CENTER_VERTICAL)
self.hbox2 = wx.BoxSizer(wx.HORIZONTAL)
self.hbox2.Add(self.xmin_control, border=5, flag=wx.ALL)
self.hbox2.Add(self.xmax_control, border=5, flag=wx.ALL)
self.hbox2.AddSpacer(24)
self.hbox2.Add(self.ymin_control, border=5, flag=wx.ALL)
self.hbox2.Add(self.ymax_control, border=5, flag=wx.ALL)
self.vbox = wx.BoxSizer(wx.VERTICAL)
self.vbox.Add(self.canvas, 1, flag=wx.LEFT | wx.TOP | wx.EXPAND)
self.vbox.Add(self.hbox1, 0, flag=wx.ALIGN_LEFT | wx.TOP)
self.vbox.Add(self.hbox2, 0, flag=wx.ALIGN_LEFT | wx.TOP)
self.panel.SetSizer(self.vbox)
self.vbox.Fit(self)
def create_status_bar(self):
self.statusbar = self.CreateStatusBar()
def init_plot(self):
self.dpi = 100
self.fig = Figure((3.0, 3.0), dpi=self.dpi)
self.axes = self.fig.add_subplot(111)
self.axes.set_axis_bgcolor('black')
self.axes.set_title('Put title here', size=12)
self.axes.set_xlabel('Time (s)', fontsize=10)
self.axes.set_ylabel('CDC value', fontsize=10)
pylab.setp(self.axes.get_xticklabels(), fontsize=8)
pylab.setp(self.axes.get_yticklabels(), fontsize=8)
# plot the data as a line series, and save the reference
# to the plotted line series
#
self.plot_data = []
for i in range(0, self.chan):
self.plot_data.append(self.axes.plot(
self.data,
linewidth=1,
color=numpy.random.rand(3,1),
)[0])
self.fig.legend(self.plot_data, ["Differential"]*6, prop={'size':10})
def set_background_color(self, color):
self.axes.set_axis_bgcolor(color)
def draw_plot(self):
""" Redraws the plot
"""
# when xmin is on auto, it "follows" xmax to produce a
# sliding window effect. therefore, xmin is assigned after
# xmax.
#
if self.xmax_control.is_auto():
xmax = len(self.data[0]) if len(self.data[0]) > 50 else 50
else:
xmax = int(self.xmax_control.manual_value())
if self.xmin_control.is_auto():
xmin = xmax - 50
else:
xmin = int(self.xmin_control.manual_value())
# for ymin and ymax, find the minimal and maximal values
# in the data set and add a mininal margin.
#
# note that it's easy to change this scheme to the
# minimal/maximal value in the current display, and not
# the whole data set.
#
if self.ymin_control.is_auto():
ymin = round(min(self.data[0]), 0) - 1
else:
ymin = int(self.ymin_control.manual_value())
if self.ymax_control.is_auto():
ymax = round(max(self.data[0]), 0) + 1
else:
ymax = int(self.ymax_control.manual_value())
self.axes.set_xbound(lower=xmin, upper=xmax)
self.axes.set_ybound(lower=ymin, upper=ymax)
# anecdote: axes.grid assumes b=True if any other flag is
# given even if b is set to False.
# so just passing the flag into the first statement won't
# work.
#
if self.cb_grid.IsChecked():
self.axes.grid(True, color='gray')
else:
self.axes.grid(False)
# Using setp here is convenient, because get_xticklabels
# returns a list over which one needs to explicitly
# iterate, and setp already handles this.
#
pylab.setp(self.axes.get_xticklabels(),
visible=self.cb_xlab.IsChecked())
for i in range(0, len(self.plot_data)):
self.plot_data[i].set_xdata(np.arange(len(self.data[i])))
self.plot_data[i].set_ydata(np.array(self.data[i]))
self.canvas.draw()
def on_pause_button(self, event):
self.paused = not self.paused
def on_update_pause_button(self, event):
label = "Resume" if self.paused else "Pause"
self.pause_button.SetLabel(label)
def on_cb_grid(self, event):
self.draw_plot()
def on_cb_xlab(self, event):
self.draw_plot()
def on_save_plot(self, event):
file_choices = "PNG (*.png)|*.png"
dlg = wx.FileDialog(
self,
message="Save plot as...",
defaultDir=os.getcwd(),
defaultFile="plot.png",
wildcard=file_choices,
style=wx.SAVE)
if dlg.ShowModal() == wx.ID_OK:
path = dlg.GetPath()
self.canvas.print_figure(path, dpi=self.dpi)
self.flash_status_message("Saved to %s" % path)
def get_data(self):
new_data = self.datagen.next()
data = self.formatter.parse(new_data)
if data == None and len(self.formatter.raw_data) != 0:
data = self.formatter.parse(None, True)
return data
def on_redraw_timer(self, event):
# if paused do not add data, but still redraw the plot
# (to respond to scale modifications, grid change, etc.)
#
if not self.paused:
try:
data = self.get_data()
if data == None and len(self.formatter.raw_data) != 0:
data = self.formatter.parse(None, True)
if data != None:
for i in range(0, self.chan):
print data
self.data[i].append(data[i])
except Queue.Empty:
print "Queue empty"
self.draw_plot()
def on_exit(self, event):
self.datagen.quit()
self.Destroy()
def flash_status_message(self, msg, flash_len_ms=1500):
self.statusbar.SetStatusText(msg)
self.timeroff = wx.Timer(self)
self.Bind(
wx.EVT_TIMER,
self.on_flash_status_off,
self.timeroff)
self.timeroff.Start(flash_len_ms, oneShot=True)
def on_flash_status_off(self, event):
self.statusbar.SetStatusText('')
def create_graph():
"""Create graph of code quality evolution
"""
t0 = time()
cwd = getcwd()
project_name = cwd.split('/')[-1]
# We copy project to tmp (for security)
tmp_directory = '%s/ipkg_quality.git' % mkdtemp()
call(['git', 'clone', cwd, tmp_directory])
chdir(tmp_directory)
# First step: we create a list of statistics
statistics = {}
commit_ids = git.get_revisions()
commit_ids.reverse()
print 'Script will analyse %s commits.' % len(commit_ids)
for commit_id in commit_ids:
# We move to a given commit
call(['git', 'reset', '--hard', commit_id])
# Print script evolution
stdout.write('.')
stdout.flush()
# We list files
filenames = git.get_filenames()
filenames = [ x for x in filenames if x.endswith('.py') ]
# We get code quality for this files
stats, files_db = analyse(filenames, ignore_errors=True)
metadata = git.get_metadata()
date_time = metadata['committer'][1]
commit_date = date(date_time.year, date_time.month, date_time.day)
if commit_date not in statistics:
statistics[commit_date] = stats
else:
# Same day => Avg
for key in statistics[commit_date]:
avg = (statistics[commit_date][key] + stats[key])/2
statistics[commit_date][key] = avg
print
# Get dates
values = []
dates = statistics.keys()
dates.sort()
for a_date in dates:
values.append(statistics[a_date])
# Base graph informations
base_title = '[%s %s]' % (project_name, git.get_branch_name())
# We generate graphs
chdir(cwd)
for problem_dict in ['code_length', 'aesthetics_problems',
'exception_problems', 'import_problems']:
current_problems = eval(problem_dict)
graph_title = '%s %s' % (base_title, current_problems['title'])
lines = []
labels = []
fig = Figure()
graph = fig.add_subplot(111)
for key in current_problems['keys']:
if current_problems['pourcent']:
problem_values = [((x[key]*100.0)/x['lines']) for x in values]
else:
problem_values = [x[key] for x in values]
lines.append(graph.plot_date(dates, problem_values, '-'))
labels.append(current_problems['keys'][key])
graph.set_title(graph_title)
graph.xaxis.set_major_formatter(DateFormatter("%b '%y'"))
if current_problems['pourcent']:
graph.set_ylabel('Pourcent')
graph.yaxis.set_major_formatter(FormatStrFormatter("%5.02f %%"))
else:
graph.set_ylabel('Quantity')
graph.set_xlabel('')
graph.autoscale_view()
graph.grid(True)
fig.autofmt_xdate()
fig.set_figheight(fig.get_figheight()+5)
legend = fig.legend(lines, labels, loc=8, axespad=0.0)
legend.get_frame().set_linewidth(0)
canvas = FigureCanvasAgg(fig)
destination = 'graph_%s.png' % problem_dict
canvas.print_figure(destination, dpi=80)
print '%s -> %s ' % (graph_title, destination)
t1 = time()
print 'Generation time: %d minutes.' % ((t1 - t0)/60)
class mplchart(chart):
colours = dict(zip('red green blue yellow magenta black'.split(),
'r g b y m k'.split()))
def __init__(self, spurset, fef, parent):
chart.__init__(self, spurset, fef, parent)
# make the figure blend in with the native application look
bgcol = parent.palette().window().color().toRgb()
bgcol = [bgcol.redF(), bgcol.greenF(), bgcol.blueF()]
self.fig = Figure()
self.fig.set_facecolor(bgcol)
# a FigureCanvas can be added as a QWidget, so we use that
self.plot = FigureCanvas(self.fig)
self.plot.setParent(parent)
self.ax = self.fig.add_subplot(111)
# TODO skip this, just do a redraw() after initialization?
self.ax.set_xlim(self.spurset.RFmin, self.spurset.RFmax)
self.ax.set_ylim(-0.5*self.spurset.dspan, 0.5*self.spurset.dspan)
self.ax.grid(True)
self.fig.tight_layout()
# a second figure to hold the legend
self.legendFig = Figure()
self.legendFig.set_facecolor(bgcol)
self.legendCanvas = FigureCanvas(self.legendFig)
self.legendFig.legend(*self.ax.get_legend_handles_labels(),
loc='upper left')
# connect up the picker watching
self.picked_obj = None
self._pick = self.plot.mpl_connect('pick_event', self.onpick)
self._drag = self.plot.mpl_connect('motion_notify_event', self.ondrag)
self._drop = self.plot.mpl_connect('button_release_event', self.ondrop)
def legend(self):
return self.legendCanvas
def mkline(self, xdata, ydata, style, title):
return mpl.lines.Line2D(xdata, ydata, label=title,
color=self.colours[style[0]], ls=style[1])
def add_line(self, line):
self.ax.add_line(line)
def del_line(self, line):
self.ax.lines.remove(line)
def draw_spurs(self, obj):
chart.draw_spurs(self, obj)
def redraw(self):
self.ax.set_ylim(-0.5*self.spurset.dspan, 0.5*self.spurset.dspan)
self.ax.set_xlim(self.spurset.RFmin, self.spurset.RFmax)
# WHO WANTS TO BET THIS IS UNSUPPORTED?
# but damn, it works :/
self.legendFig.legends = []
self.legendFig.legend(*self.ax.get_legend_handles_labels(),
loc='upper left')
self.legendCanvas.draw()
self.plot.draw()
def draw_fef(self, obj):
chart.draw_fef(self, obj)
self.feflines[0].set_picker(10)
self.feflines[1].set_picker(10)
def onpick(self, event):
if event.mouseevent.button != 1:
# only picking on left-click atm
return
obj, x, y = event.artist, event.mouseevent.xdata, event.mouseevent.ydata
self.picked_obj = obj
self.pick(obj, x, y)
self.drag(obj, x, y)
def ondrag(self, event):
self.drag(self.picked_obj, event.xdata, event.ydata)
def ondrop(self, event):
if event.button != 1:
# only picking on left-click atm
return
self.drop(self.picked_obj, event.xdata, event.ydata)
self.picked_obj = None
class MplCanvas(FigureCanvas):
subscriptions = [rc.MT_PING, MT_EXIT,
rc.MT_TASK_STATE_CONFIG,
rc.MT_ROBOT_CONTROL_SPACE_ACTUAL_STATE,
rc.MT_GROBOT_SEGMENT_PERCEPTS,
rc.MT_GROBOT_RAW_FEEDBACK,
rc.MT_END_TASK_STATE]
def __init__(self, parent=None, width=8, height=10, dpi=80):
self.parent = parent
self.paused = False
self.LiveData = None
self.fdbk_actual_pos = None
self.fdbk_actual_cori = None
self.tsc_mdf = None
self.ets_mdf = None
self.fdbk_percepts = [0] * 16
self.fdbk_torques = [0] * 16
self.redraw_yticks = True
self.figure = Figure(figsize=(width, height), dpi=dpi, facecolor='#bbbbbb')
FigureCanvas.__init__(self, self.figure)
self.setParent(parent)
FigureCanvas.setSizePolicy(self,
QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
def init_judge_display(self):
N = self.config['config']['number_of_data_points']
self.LiveData = {'ActualPos': {},
'ThreshUpper': {},
'ThreshLower': {},
'JudgingMethod': {},
'JudgingPolarity': {},
'max_scale': {},
'min_scale': {} }
allDims = 1 + 1 + 10 + 15 + 28 # trans + ori + finger + force + torque
for d in range(allDims):
self.LiveData['ActualPos'][d] = np.zeros(N)
self.LiveData['ThreshUpper'][d] = nan_array(N)
self.LiveData['ThreshLower'][d] = nan_array(N)
self.LiveData['JudgingMethod'][d] = nan_array(N)
self.LiveData['JudgingPolarity'][d] = nan_array(N)
self.LiveData['max_scale'][d] = np.finfo(float).eps
self.LiveData['min_scale'][d] = -np.finfo(float).eps #
self.LiveData['TaskStateNo'] = np.zeros(N)
self.LiveData['TaskStateVerdict'] = np.ones(N)
def run(self, config_file, server):
self.mod = RTMA_Module(0, 0)
self.mod.ConnectToMMM(server)
for sub in self.subscriptions:
self.mod.Subscribe(sub)
self.mod.SendModuleReady()
print "Connected to RTMA at", server
self.config_file = config_file
self.load_config()
self.init_judge_display()
self.init_plot()
self.init_legend()
timer = QtCore.QTimer(self)
QtCore.QObject.connect(timer, QtCore.SIGNAL("timeout()"), self.timer_event)
timer.start(10)
def update_scales(self, d):
min_data = np.nanmin(self.LiveData['ActualPos'][d])
if min_data < self.LiveData['min_scale'][d]:
self.LiveData['min_scale'][d] = min_data;
max_data = np.nanmax(self.LiveData['ActualPos'][d])
if max_data > self.LiveData['max_scale'][d]:
self.LiveData['max_scale'][d] = max_data;
def update_judging_data(self):
# this loop is so we can update finger pos data even if we haven't
# received any TASK_STATE_CONFIG msg
for i in range(self.nDims):
d = self.dims[i] - 1
if d > 1: # fingers
finger_idx = d-2
actual_pos = self.fdbk_actual_pos[8+finger_idx];
self.LiveData['ActualPos'][d] = self.add_to_windowed_array(self.LiveData['ActualPos'][d], actual_pos)
self.update_scales(d)
if self.tsc_mdf is None:
return
trans_thresh = self.tsc_mdf.trans_threshold
ori_threshold = self.tsc_mdf.ori_threshold
finger_thresh = np.array(self.tsc_mdf.finger_threshold, dtype=float)
finger_dofs_to_judge = np.where(~np.isnan(finger_thresh)==True)[0]
for i in range(self.nDims):
d = self.dims[i] - 1
threshU = np.NAN
threshL = np.NAN
method = np.NAN
polarity = np.NAN
if d == 0: # trans
tgt_pos = np.array(self.tsc_mdf.target[0:3])
act_pos = np.array(self.fdbk_actual_pos[0:3])
tgt_disp = tgt_pos - act_pos;
tgt_dist = np.sqrt(np.sum(np.power(tgt_disp,2)))
self.LiveData['ActualPos'][d] = self.add_to_windowed_array(self.LiveData['ActualPos'][d], tgt_dist)
self.update_scales(d)
threshU = trans_thresh
threshL = -trans_thresh
method = 1 # dist
polarity = 2 # less than (inverted)
elif d == 1: # ori
tgt_cori = np.array(self.tsc_mdf.coriMatrix).reshape((3,3)).T
act_cori = np.array(self.fdbk_actual_cori).reshape((3,3)).T
cori_diff_matrix = tgt_cori * act_cori.T
[diff_rotaxis, diff_angle] = rotmat2rotvec( cori_diff_matrix)
self.LiveData['ActualPos'][d] = self.add_to_windowed_array(self.LiveData['ActualPos'][d], diff_angle)
self.update_scales(d)
print diff_angle
print ori_threshold
print "-----"
threshU = ori_threshold
threshL = -ori_threshold
method = 1 # dist
polarity = 2 # less than (inverted)
else: # fingers
finger_idx = d-2
if np.where(finger_dofs_to_judge == finger_idx)[0].size > 0:
thresh = self.tsc_mdf.finger_threshold[finger_idx]
method = self.tsc_mdf.finger_threshold_judging_method[finger_idx]
polarity = self.tsc_mdf.finger_threshold_judging_polarity[finger_idx]
# invert polarities (because we plot "keep out" zones)
if (polarity > 0) and (self.tsc_mdf.timed_out_conseq == 0):
polarity = ~polarity & 3;
# finger_threshold_judging_method: 1=distance (default), 2=absolute
if method == 1: # dist
target = self.tsc_mdf.target[8+finger_idx]
threshU = target + thresh
threshL = target - thresh
else: # abs
threshU = thresh
# insert new data to plotting arrays
self.LiveData['ThreshUpper'][d] = self.add_to_windowed_array(self.LiveData['ThreshUpper'][d], threshU)
self.LiveData['ThreshLower'][d] = self.add_to_windowed_array(self.LiveData['ThreshLower'][d], threshL)
self.LiveData['JudgingMethod'][d] = self.add_to_windowed_array(self.LiveData['JudgingMethod'][d], method)
self.LiveData['JudgingPolarity'][d] = self.add_to_windowed_array(self.LiveData['JudgingPolarity'][d], polarity)
self.LiveData['TaskStateNo'] = self.add_to_windowed_array(self.LiveData['TaskStateNo'], self.tsc_mdf.id)
if self.ets_mdf is not None:
self.LiveData['TaskStateVerdict'][-2] = self.ets_mdf.outcome
self.LiveData['TaskStateVerdict'][-1] = self.ets_mdf.outcome
self.LiveData['TaskStateVerdict'] = self.add_to_windowed_array(self.LiveData['TaskStateVerdict'], self.ets_mdf.outcome)
self.ets_mdf = None
else:
self.LiveData['TaskStateVerdict'] = self.add_to_windowed_array(self.LiveData['TaskStateVerdict'], 1)
def add_to_windowed_array(self, arr, data):
arr = np.append(arr, data)
arr = np.delete(arr, 0)
return arr
def load_config(self):
self.config = ConfigObj(self.config_file, unrepr=True)
def reload_config(self):
self.load_config()
for ax in self.figure.axes:
self.figure.delaxes(ax)
self.figure.clear()
self.draw()
self.init_plot(True)
self.init_legend()
self.redraw_yticks = True
def init_plot(self, clear=False):
self.figure.subplots_adjust(bottom=.05, right=.98, left=.08, top=.98, hspace=0.07)
trans_dim = 0
if 'plot_translation' in self.config['config']:
trans_dim = self.config['config']['plot_translation']
ori_dim = 0
if 'plot_orientation' in self.config['config']:
ori_dim = self.config['config']['plot_orientation']
finger_dims = []
if 'active_finger_dims' in self.config['config']:
finger_dims = self.config['config']['active_finger_dims']
force_dims = []
if 'active_force_dims' in self.config['config']:
force_dims = self.config['config']['active_force_dims']
torque_dims = []
if 'active_torque_dims' in self.config['config']:
torque_dims = self.config['config']['active_torque_dims']
axis_labels = []
self.dims = []
if trans_dim == 1:
self.dims.append(1)
axis_labels.extend(['XYZ tgt dist'])
if ori_dim == 1:
self.dims.append(2)
axis_labels.extend(['ORI tgt dist'])
if finger_dims:
for f in finger_dims:
if (f>0) and (f<=10):
self.dims.extend([f+2])
axis_labels.extend(['finger #%d' % f])
else:
print "Warning: invalid finger dim specified: %f, skipping.." % f
if force_dims:
force_labels = ['ifx', 'ify', 'ifz', 'mfx', 'mfy', 'mfz', 'rfx', \
'rfy', 'rfz', 'lfx', 'lfy', 'lfz', 'tfx', 'tfy', 'tfz']
for f in force_dims:
if (f>0) and (f<=15):
self.dims.extend([f+12])
axis_labels.extend(['force #%d (%s)' % (f, force_labels[f-1])])
else:
print "Warning: invalid force dim specified: %d, skipping.." % f
if torque_dims:
for f in torque_dims:
if (f>0) and (f<=28):
self.dims.extend([f+27])
axis_labels.extend(['trq #%d' % f])
else:
print "Warning: invalid torque dim specified: %d, skipping.." % f
self.nDims = trans_dim + ori_dim + len(finger_dims) + len(force_dims) + len(torque_dims)
self.xN = self.config['config']['number_of_data_points']
self.bg = self.config['marked_task_states'].keys()
self.max_scale = self.config['config']['max_scale']
if len(self.max_scale) < self.nDims:
self.max_scale.extend([np.finfo(float).eps] * (self.nDims - len(self.max_scale)))
self.min_scale = self.config['config']['min_scale']
if len(self.min_scale) < self.nDims:
self.min_scale.extend([-np.finfo(float).eps] * (self.nDims - len(self.min_scale)))
self.ax = []
self.old_size = []
self.ax_bkg = []
self.finger_pos = []
self.zones = {}
self.zone_idx = []
for d in range(self.nDims):
ax = self.figure.add_subplot(self.nDims,1,d+1)
self.reset_axis(ax, axis_labels[d])
self.draw()
bbox_width = ax.bbox.width
bbox_height = ax.bbox.height
if clear == True:
# force to redraw
bbox_width = 0
bbox_height = 0
self.old_size.append( (bbox_width, bbox_height) )
self.ax_bkg.append(self.copy_from_bbox(ax.bbox))
line, = ax.plot([], [], 'k-', lw=1.0, aa=None, animated=True)
line.set_xdata(range(self.xN))
line.set_ydata([0.0]*self.xN)
self.finger_pos.append(line)
self.draw()
self.zones[d] = []
self.zone_idx.append(0)
for z in range(60):
patch = ax.add_patch(Polygon([[0, 1e-12],[1e-12, 0],[1e-12, 1e-12],[0, 1e-12]], fc='none', ec='none', fill=True, closed=True, aa=None, animated=True))
self.zones[d].append(patch)
self.draw()
self.ax.append(ax)
def reset_axis(self, ax, label):
ax.grid(True)
ax.set_xlim(0, self.xN-1)
ax.set_autoscale_on(False)
ax.set_ylabel(label, fontsize='small')
ax.get_xaxis().set_ticks([])
ax.yaxis.set_major_formatter(FormatStrFormatter('%.02f'))
for tick in ax.get_yticklabels():
tick.set_fontsize(9)
def init_legend(self):
legnd = []
line = matplotlib.lines.Line2D([0,0], [0,0], color='k')
legnd.append(line)
for d in range(len(self.bg)):
b_color = self.config['marked_task_states'][self.bg[d]]['color']
patch = Polygon([[0,0],[0, 0],[0, 0],[0, 0]], fc=b_color, ec='none', fill=True, closed=True, alpha=0.65)
legnd.append(patch)
self.figure.legend(legnd, ['Position']+self.bg, loc='lower center', frameon=False, ncol=20, prop={'size':'11'}, columnspacing=.5)
self.draw()
def plot_bg_mask(self, ax, idx, x, mask, ylim, fc, ec, hatch, alpha):
# Find starts and ends of contiguous regions of true values in mask because
# we want just one patch object per contiguous region
_mask = np.asarray(np.insert(mask, 0, 0), dtype=int)
begin_indices = np.where( np.diff( _mask) == 1)[0]
_mask = np.asarray(np.append(mask, 0), dtype=int)
end_indices = np.where( np.diff( _mask) == -1)[0]
# Get DeltaX
dx = np.mean( np.diff(x))
# Get YLim if it was not given
if len(ylim) == 0:
ylim = ax.get_ylim()
z = self.zones[idx]
a = self.zone_idx[idx]
for i in range(len( begin_indices)):
b = begin_indices[i]
e = end_indices[i]
xb = x[b] - dx/2;
xe = x[e] + dx/2;
patch = z[a]
patch.set_xy([[xb, ylim[0]],[xe, ylim[0]],[xe, ylim[1]],[xb, ylim[1]]])
patch.set_edgecolor(ec)
patch.set_facecolor(fc)
patch.set_hatch(hatch)
patch.set_alpha(alpha)
ax.draw_artist(patch)
a = a + 1
self.zone_idx[idx] = a
def timer_event(self):
done = False
while not done:
msg = CMessage()
rcv = self.mod.ReadMessage(msg, 0)
if rcv == 1:
msg_type = msg.GetHeader().msg_type
if msg_type == rc.MT_TASK_STATE_CONFIG:
self.tsc_mdf = rc.MDF_TASK_STATE_CONFIG()
copy_from_msg(self.tsc_mdf, msg)
elif msg_type == rc.MT_ROBOT_CONTROL_SPACE_ACTUAL_STATE:
mdf = rc.MDF_ROBOT_CONTROL_SPACE_ACTUAL_STATE()
copy_from_msg(mdf, msg)
self.fdbk_actual_cori = mdf.CoriMatrix
self.fdbk_actual_pos = []
self.fdbk_actual_pos.extend(mdf.pos)
self.fdbk_actual_pos.extend(self.fdbk_percepts)
self.fdbk_actual_pos.extend(self.fdbk_torques)
self.update_judging_data()
elif msg_type == rc.MT_GROBOT_SEGMENT_PERCEPTS:
mdf = rc.MDF_GROBOT_SEGMENT_PERCEPTS()
copy_from_msg(mdf, msg)
self.fdbk_percepts = []
self.fdbk_percepts.extend(mdf.ind_force[:])
self.fdbk_percepts.extend(mdf.mid_force[:])
self.fdbk_percepts.extend(mdf.rng_force[:])
self.fdbk_percepts.extend(mdf.lit_force[:])
self.fdbk_percepts.extend(mdf.thb_force[:])
elif msg_type == rc.MT_GROBOT_RAW_FEEDBACK:
mdf = rc.MDF_GROBOT_RAW_FEEDBACK()
copy_from_msg(mdf, msg)
self.fdbk_torques = mdf.j_trq
elif msg_type == rc.MT_END_TASK_STATE:
self.ets_mdf = rc.MDF_END_TASK_STATE()
copy_from_msg(self.ets_mdf, msg)
elif msg_type == rc.MT_PING:
respond_to_ping(self.mod, msg, 'SimpleJudgeDisplay')
elif msg_type == MT_EXIT:
self.exit()
done = True
else:
done = True
self.update_plot()
def update_plot(self):
if self.paused == False:
LiveData = self.LiveData
else:
LiveData = self.PausedData
for i in range(self.nDims):
ax = self.ax[i]
d = self.dims[i] - 1
current_size = ax.bbox.width, ax.bbox.height
if self.old_size[i] != current_size:
self.old_size[i] = current_size
self.draw()
self.ax_bkg[i] = self.copy_from_bbox(ax.bbox)
self.restore_region(self.ax_bkg[i])
self.zone_idx[i] = 0
min_scale = LiveData['min_scale'][d];
if 'min_scale' in self.config['config']:
min_scale = self.min_scale[i]
max_scale = LiveData['max_scale'][d];
if 'max_scale' in self.config['config']:
max_scale = self.max_scale[i]
ax.set_ylim(min_scale, max_scale)
yLimG = ax.get_ylim()
for b in range(len(self.bg)):
b_id = self.config['marked_task_states'][self.bg[b]]['id']
b_color = self.config['marked_task_states'][self.bg[b]]['color']
mask = np.where(LiveData['TaskStateNo']==b_id, 1, 0)
if np.sum(mask) > 0:
self.plot_bg_mask(ax, i, range(self.xN), mask, [], b_color, 'none', None, 0.65)
else:
# always draw patch for all colors so that they will always show up in the legend
z = self.zones[i]
patch = z[self.zone_idx[i]]
patch.set_xy([[0, 0],[0, 0],[0, 0],[0, 0]])
ax.draw_artist(patch)
self.zone_idx[i] = self.zone_idx[i] + 1
# finger_threshold_judging_method: 1=distance, 2=absolute
# finger threshold_judging_polarity: 1 = <, 2 = >
methods = ~np.isnan(LiveData['JudgingMethod'][d])
if np.sum(methods) > 0:
methods = np.unique(LiveData['JudgingMethod'][d][methods])
for m in range(len(methods)):
method = methods[m]
met_mask = np.where(LiveData['JudgingMethod'][d] == method, True, False)
polaritys = np.unique(LiveData['JudgingPolarity'][d][met_mask])
for p in range(len(polaritys)):
polarity = polaritys[p]
pol_mask = np.where(LiveData['JudgingPolarity'][d] == polarity, True, False)
mask = met_mask & pol_mask
yLimUs = np.unique(LiveData['ThreshUpper'][d][mask])
for b in range(len(yLimUs)):
yLimU = yLimUs[b]
submask = np.where(LiveData['ThreshUpper'][d] == yLimU, True, False) & mask
if method == 1: # dist
yLimLs = np.unique(LiveData['ThreshLower'][d][submask])
for k in range(len(yLimLs)):
yLimL = yLimLs[k]
submask2 = np.where(LiveData['ThreshLower'][d] == yLimL, True, False) & submask
if polarity == 1: # <
self.plot_bg_mask(ax, i, range(self.xN), submask2, [yLimL, yLimU], 'none', 'black', '//', 1)
else:
self.plot_bg_mask(ax, i, range(self.xN), submask2, [yLimG[0], yLimL], 'none', 'black', '//', 1)
self.plot_bg_mask(ax, i, range(self.xN), submask2, [yLimU, yLimG[1]], 'none', 'black', '//', 1)
else: # abs
if polarity == 1: # <
self.plot_bg_mask(ax, i, range(self.xN), submask, [yLimG[0], yLimU], 'none', 'black', '//', 1)
else:
self.plot_bg_mask(ax, i, range(self.xN), submask, [yLimU, yLimG[1]], 'none', 'black', '//', 1)
fail_mask = np.where(LiveData['TaskStateVerdict']==0, True, False)
self.plot_bg_mask(ax, i, range(self.xN), fail_mask, [], 'red', 'none', None, 0.65)
self.finger_pos[i].set_ydata(LiveData['ActualPos'][d])
ax.draw_artist(self.finger_pos[i])
self.blit(ax.bbox)
if self.zone_idx[i] > 60:
print "ERROR: too many zones! Increase number of preallocated patches"
# need to redraw once to update y-ticks
if self.redraw_yticks == True:
self.draw()
self.redraw_yticks = False
def pause(self, pause_state):
self.paused = pause_state
self.PausedData = copy.deepcopy(self.LiveData)
def exit(self):
print "exiting"
self.parent.exit_app()
def stop(self):
print 'disconnecting'
self.mod.SendSignal(rc.MT_EXIT_ACK)
self.mod.DisconnectFromMMM()
def show_fit_at_position(mcmc_set, fit_value, position, fit_name):
"""Create the result page showing the fit quality at the given position.
Parameters
----------
mcmc_set : MCMCSet object
The set of MCMC chains
fit_value : float
The quality of fit at the given position.
position : numpy.array
Array of (log10-transformed) parameter values at the given position.
fit_name : string
A shorthand name for the fit position, e.g., "max_likelihood". Should
conform to rules of Python variable naming (no spaces, doesn't
start with a number, etc.).
Returns
-------
A result object containing the fit value and the link to the accompanying
HTML plot page, if any.
"""
# If the MCMC object does not have a fit_plotting_function defined
# (for example, if it is a base MCMC object), then don't create a
# plot for visualization.
if not hasattr(mcmc_set.chains[0], 'fit_plotting_function'):
return Result(fit_value, None)
# Prepare html for page showing plots at position
html_str = "<html><head><title>Simulation of %s " \
"with %s parameter values</title></head>\n" \
% (mcmc_set.name, fit_name)
html_str += "<body><p>Simulation of %s with %s " \
"parameter values</p>\n" % (mcmc_set.name, fit_name)
# Show the plot vs. the data at the position
fig = mcmc_set.chains[0].fit_plotting_function(position=position)
img_filename = '%s_%s_plot.png' % (mcmc_set.name, fit_name)
fig.savefig(img_filename)
html_str += '<p><img src="%s" /></p>' % img_filename
# Show the plot of all observables at the position
chain0 = mcmc_set.chains[0]
tspan = chain0.options.tspan
observables = chain0.options.model.observables
x = chain0.simulate(position=position, observables=True)
fig = Figure()
ax = fig.gca()
lines = []
for o in observables:
line = ax.plot(tspan, x[o.name])
lines += line
ax.set_title("Observables at %s" % fit_name)
fig.legend(lines, [o.name for o in observables], 'lower right')
canvas = FigureCanvasAgg(fig)
fig.set_canvas(canvas)
img_filename = '%s_%s_species.png' % (mcmc_set.name, fit_name)
fig.savefig(img_filename)
html_str += '<p><img src="%s" /></p>' % img_filename
# Print the parameter values for the position as a dict that can be
# used to override the initial values
html_str += '<pre>%s_params = {\n' % fit_name
for i, p in enumerate(chain0.options.estimate_params):
html_str += "\t'%s': %.17g,\n" % \
(p.name, 10 ** position[i])
html_str += '}</pre>'
html_str += '</body></html>'
# Create the html file
html_filename = '%s_%s_plot.html' % (mcmc_set.name, fit_name)
with open(html_filename, 'w') as f:
f.write(html_str)
return Result(fit_value, html_filename)
def getLegendGraphic(request, dataset):
"""
Parse parameters from request that looks like this:
http://webserver.smast.umassd.edu:8000/wms/NecofsWave?
ELEVATION=1
&LAYERS=hs
&TRANSPARENT=TRUE
&STYLES=facets_average_jet_0_0.5_node_False
&SERVICE=WMS
&VERSION=1.1.1
&REQUEST=GetLegendGraphic
&FORMAT=image%2Fpng
&TIME=2012-06-20T18%3A00%3A00
&SRS=EPSG%3A3857
&LAYER=hs
"""
styles = request.GET["styles"].split("_")
try:
climits = (float(styles[3]), float(styles[4]))
except:
climits = (None, None)
variables = request.GET["layer"].split(",")
plot_type = styles[0]
colormap = styles[2].replace('-', '_')
# direct the service to the dataset
# make changes to server_local_config.py
if settings.LOCALDATASET:
url = settings.LOCALDATASETPATH[dataset]
else:
url = Dataset.objects.get(name=dataset).path()
nc = netCDF4.Dataset(url)
"""
Create figure and axes for small legend image
"""
#from matplotlib.figure import Figure
from matplotlib.pylab import get_cmap
fig = Figure(dpi=100., facecolor='none', edgecolor='none')
fig.set_alpha(0)
fig.set_figwidth(1*1.3)
fig.set_figheight(1.5*1.3)
"""
Create the colorbar or legend and add to axis
"""
v = cf.get_by_standard_name(nc, variables[0])
try:
units = v.units
except:
units = ''
# vertical level label
if v.ndim > 3:
units = units + '\nvertical level: %s' % _get_vertical_level(nc, v)
if climits[0] is None or climits[1] is None: # TODO: NOT SUPPORTED RESPONSE
#going to have to get the data here to figure out bounds
#need elevation, bbox, time, magnitudebool
CNorm = None
ax = fig.add_axes([0, 0, 1, 1])
ax.grid(False)
ax.text(.5, .5, 'Error: No Legend\navailable for\nautoscaled\ncolor styles!', ha='center', va='center', transform=ax.transAxes, fontsize=8)
elif plot_type not in ["contours", "filledcontours"]:
#use limits described by the style
ax = fig.add_axes([.01, .05, .2, .8]) # xticks=[], yticks=[])
CNorm = matplotlib.colors.Normalize(vmin=climits[0],
vmax=climits[1],
clip=False,
)
cb = matplotlib.colorbar.ColorbarBase(ax,
cmap=get_cmap(colormap),
norm=CNorm,
orientation='vertical',
)
cb.set_label(units, size=8)
else: # plot type somekind of contour
if plot_type == "contours":
#this should perhaps be a legend...
#ax = fig.add_axes([0,0,1,1])
fig_proxy = Figure(frameon=False, facecolor='none', edgecolor='none')
ax_proxy = fig_proxy.add_axes([0, 0, 1, 1])
CNorm = matplotlib.colors.Normalize(vmin=climits[0], vmax=climits[1], clip=True)
#levs = numpy.arange(0, 12)*(climits[1]-climits[0])/10
levs = numpy.linspace(climits[0], climits[1], 11)
x, y = numpy.meshgrid(numpy.arange(10), numpy.arange(10))
cs = ax_proxy.contourf(x, y, x, levels=levs, norm=CNorm, cmap=get_cmap(colormap))
proxy = [plt.Rectangle((0, 0), 0, 0, fc=pc.get_facecolor()[0]) for pc in cs.collections]
fig.legend(proxy, levs,
#bbox_to_anchor = (0, 0, 1, 1),
#bbox_transform = fig.transFigure,
loc = 6,
title = units,
prop = { 'size' : 8 },
frameon = False,
)
elif plot_type == "filledcontours":
#this should perhaps be a legend...
#ax = fig.add_axes([0,0,1,1])
fig_proxy = Figure(frameon=False, facecolor='none', edgecolor='none')
ax_proxy = fig_proxy.add_axes([0, 0, 1, 1])
CNorm = matplotlib.colors.Normalize(vmin=climits[0], vmax=climits[1], clip=False,)
#levs = numpy.arange(1, 12)*(climits[1]-(climits[0]))/10
levs = numpy.linspace(climits[0], climits[1], 10)
levs = numpy.hstack(([-99999], levs, [99999]))
x, y = numpy.meshgrid(numpy.arange(10), numpy.arange(10))
cs = ax_proxy.contourf(x, y, x, levels=levs, norm=CNorm, cmap=get_cmap(colormap))
proxy = [plt.Rectangle((0, 0), 0, 0, fc=pc.get_facecolor()[0]) for pc in cs.collections]
levels = []
for i, value in enumerate(levs):
#if i == 0:
# levels[i] = "<" + str(value)
if i == len(levs)-2 or i == len(levs)-1:
levels.append("> " + str(value))
elif i == 0:
levels.append("< " + str(levs[i+1]))
else:
#levels.append(str(value) + "-" + str(levs[i+1]))
text = '%.2f-%.2f' % (value, levs[i+1])
levels.append(text)
fig.legend(proxy, levels,
#bbox_to_anchor = (0, 0, 1, 1),
#bbox_transform = fig.transFigure,
loc = 6,
title = units,
prop = { 'size' : 6 },
frameon = False,
)
canvas = FigureCanvasAgg(fig)
response = HttpResponse(content_type='image/png')
canvas.print_png(response)
nc.close()
return response
class channel_plot:
'''
'''
def __init__(self, interface, toplevel=False, start_t=False, stop_t=False):
'''
'''
self.abort = False
if not start_t:
start_t = datetime.utcnow() - timedelta(hours=2)
if not stop_t:
stop_t = datetime.utcnow()
self.update_pending = False
self.pype = interface
self.plot_dicts = {}
if isinstance(start_t, datetime):
self.start_t = StringVar(value=start_t.strftime(time_format))
elif isinstance(start_t, str):
self.start_t = StringVar(value=start_t)
else:
raise TypeError('start_t must be string or datetime')
if isinstance(stop_t, datetime):
self.stop_t = StringVar(value=stop_t.strftime(time_format))
elif isinstance(stop_t, str):
self.stop_t = StringVar(value=stop_t)
else:
raise TypeError('stop_t must be string or datetime')
self.time_interval = [self.start_t.get(), self.stop_t.get()]
self.ymin = DoubleVar()
self.ymax = DoubleVar()
if toplevel:
self.toplevel = toplevel
else:
self.toplevel = Tk.Tk()
self.status_var = StringVar(value='initializing')
self._SetupCanvas()
self._BuildGui()
if not toplevel:
Tk.mainloop()
def _BuildGui(self):
'''
'''
self.removei = IntVar(value=0)
self.relative_start_time = BooleanVar(value=False)
self.relative_stop_time = BooleanVar(value=False)
self.continuous_updates = BooleanVar(value=False)
self.ManualLimits = BooleanVar(value=False)
self.LogYScale = BooleanVar(value=False)
self.ShowGrid = BooleanVar(value=False)
self.ConnectedPts = BooleanVar(value=True)
Button(self.toplevel, text="Add Line", command=self._AddSubplot
).grid(row=0, column=1)
self._AddSubplot()
Button(self.toplevel, text="Gas Line Temps", command=self._PlotGasLines
).grid(row=0, column=2)
Button(self.toplevel, text="Amps+Cell Temps", command=self._PlotCell
).grid(row=0, column=3)
Label(self.toplevel, text='Start Time').grid(row=4, column=1)
start_entry = Entry(self.toplevel, textvariable=self.start_t)
start_entry.bind('<Return>', self.Update)
start_entry.bind('<KP_Enter>', self.Update, '+')
start_entry.grid(row=4, column=2, columnspan=2)
Checkbutton(self.toplevel, text='Hours ago',
variable=self.relative_start_time).grid(row=4, column=4,
sticky='W')
Label(self.toplevel, text='Stop Time').grid(row=5, column=1)
stop_entry = Entry(self.toplevel, textvariable=self.stop_t)
stop_entry.bind('<Return>', self.Update)
stop_entry.bind('<KP_Enter>', self.Update, '+')
stop_entry.grid(row=5, column=2, columnspan=2)
Checkbutton(self.toplevel, text='Now',
variable=self.relative_stop_time).grid(row=5, column=4,
sticky='W')
Label(self.toplevel, text='Y limits (min-max)').grid(row=7, column=1)
ymin = Entry(self.toplevel, textvariable=self.ymin)
ymin.grid(row=7, column=2)
ymin.bind('<Return>', self.Update)
ymin.bind('<KP_Enter>', self.Update, '+')
ymax = Entry(self.toplevel, textvariable=self.ymax)
ymax.grid(row=7, column=3)
ymax.bind('<Return>', self.Update)
ymax.bind('<KP_Enter>', self.Update, '+')
Checkbutton(self.toplevel, text='Manual Y-limits', variable=self.ManualLimits
).grid(row=8, column=1)
Checkbutton(self.toplevel, text='Log Y-scale', variable=self.LogYScale
).grid(row=8, column=2)
Checkbutton(self.toplevel, text='Show Grid', variable=self.ShowGrid
).grid(row=9, column=1)
Checkbutton(self.toplevel, text='Connected Points', variable=self.ConnectedPts
).grid(row=9, column=2)
Button(self.toplevel, text="Update All", command=self.Update
).grid(row=10, column=1)
Button(self.toplevel, text="Save Plot", command=self.SaveFigure
).grid(row=10, column=2)
Button(self.toplevel, text="Save Json", command=self.SaveJson
).grid(row=10, column=3)
Checkbutton(self.toplevel, text='Continuous (Button above to start)',
variable=self.continuous_updates
).grid(row=11, column=1, columnspan=2)
self.status_var.set('done')
Label(self.toplevel, textvariable=self.status_var).grid(row=20,
column=1,
columnspan=2)
def _SetupCanvas(self):
'''
'''
self.figure = Figure()
self.figure.subplots_adjust(left=0.15, bottom=0.2)
self.subfigure = self.figure.add_subplot(1,1,1)
self.notebook = Notebook(self.toplevel)
self.notebook.grid(row=1, column=1, rowspan=3, columnspan=3, sticky='nsew')
self.canvas = FigureCanvasTkAgg(self.figure, master=self.toplevel)
self.canvas.show()
self.canvas.get_tk_widget().grid(row=0, column=0, rowspan=10)
def _AddSubplot(self):
'''
'''
plotnum = len(self.notebook.tabs())
self.plot_dicts[plotnum] = {}
frame = Frame(self.notebook)
frame.pack(side='top', fill='both', expand='y')
self.plot_dicts[plotnum]['xname'] = StringVar(value='None')
self.plot_dicts['xunit'] = False
self.plot_dicts[plotnum]['yname'] = StringVar(value='None')
self.plot_dicts['yunit'] = False
Label(frame, text='X Channel').grid(row=0, column=0)
Label(frame, text='Y Channel').grid(row=1, column=0)
OptionMenu(frame, self.plot_dicts[plotnum]['xname'],
"None", "time", "dpph_field", *self.pype.EligibleLoggers()
).grid(row=0, column=1, sticky='ew')
OptionMenu(frame, self.plot_dicts[plotnum]['yname'],
"None", "dpph_field", *self.pype.EligibleLoggers()
).grid(row=1, column=1, sticky='ew')
self.notebook.add(frame, text='line:'+str(plotnum))
def _SetStartStop(self, event=None):
'''
'''
try:
if self.relative_stop_time.get():
stop_time = datetime.utcnow()
else:
stop_time = datetime.strptime(self.stop_t.get(), time_format)
if self.relative_start_time.get():
hours = float(self.start_t.get())
start = datetime.utcnow() - timedelta(hours=hours)
else:
start = datetime.strptime(self.start_t.get(), time_format)
assert (start < stop_time)
self.time_interval[0] = start.strftime(time_format)
self.time_interval[1] = stop_time.strftime(time_format)
except ValueError:
showwarning('Warning', 'invalid time format, must match yyyy-mm-ddThh:mm:ssZ')
raise TimeFormatError("invalid start or stop time format")
except AssertionError:
showwarning('Warning', 'time order error, stop time must be after start time')
raise TimeOrderError("stop time must be after start time")
def Update(self, event=None, tab='All', unpend=False):
'''
Call whatever sequence is needed to update local data and redraw
the plot
'''
if self.abort:
self.abort = False
return
if unpend:
self.update_pending = False
self.status_var.set('updating!')
if tab == 'All':
tab = range(len(self.notebook.tabs()))
elif isinstance(tab, int):
tab = [tab]
else:
raise ValueError('tab should be "All" or an int')
try:
self._SetStartStop(event=None)
except:
print('SetStartStop problems')
self.abort = True
self.subfigure.clear()
for tabi in tab:
if tabi > len(self.subfigure.get_lines()):
print('wtf')
elif tabi == len(self.subfigure.get_lines()):
self._UpdateData(tab=tabi)
self._MakePlot(tab=tabi)
else:
self._UpdateExisting(tab=tabi)
self.figure.legends = []
self.figure.legend(*self.subfigure.get_legend_handles_labels())
self.figure.legends[0].draggable(True)
self.canvas.draw()
self.status_var.set('updated at: ' +
datetime.utcnow().strftime(time_format))
if (self.continuous_updates.get() and self.relative_stop_time.get() and
not self.update_pending):
self.update_pending = True
self.toplevel.after(10000, lambda: self.Update(unpend=True))
def _UpdateData(self, tab=0):
'''
'''
try:
yname = self.plot_dicts[tab]['yname'].get()
ychdat = self.pype.GetTimeSeries(yname, self.time_interval[0],
self.time_interval[1])
if self.plot_dicts[tab]['xname'].get() == 'time':
xchdat = (ychdat[0], ychdat[0], 'time' * len(ychdat[0]))
else:
xname = self.plot_dicts[tab]['xname'].get()
xchdat = self.pype.GetTimeSeries(xname, self.time_interval[0],
self.time_interval[1])
if tab > 0 and ychdat[0]:
assert xchdat[2][0] == self.plot_dicts['xunit'], 'x units'
assert ychdat[2][0] == self.plot_dicts['yunit'], 'y units'
self.xdata = []
self.ydata = []
if ychdat[0]:
for tx, x in zip(xchdat[0], xchdat[1]):
xtmp = False
ytmp = False
dt = timedelta(seconds=60)
for ty, y in zip(ychdat[0], ychdat[1]):
if abs(ty - tx) < dt:
dt = abs(ty - tx)
xtmp = x
ytmp = y
if xtmp and ytmp:
self.xdata.append(xtmp)
self.ydata.append(ytmp)
[self.xdata, self.ydata] = zip(*sorted(zip(self.xdata,
self.ydata)))
self.plot_dicts['xunit'] = xchdat[2][0]
self.plot_dicts['yunit'] = ychdat[2][0]
except AssertionError as e:
print('*'*60, '\n the', e[0], 'do not match the 0th line', '*'*60)
def _UpdateExisting(self, tab=0):
'''
'''
try:
yname = self.plot_dicts[tab]['yname'].get()
ychdat = self.pype.GetTimeSeries(yname, self.time_interval[0],
self.time_interval[1])
if self.plot_dicts[tab]['xname'].get() == 'time':
xchdat = (ychdat[0], ychdat[0], 'time' * len(ychdat[0]))
else:
xname = self.plot_dicts[tab]['xname'].get()
xchdat = self.pype.GetTimeSeries(xname, self.time_interval[0],
self.time_interval[1])
if tab > 0 and ychdat[0]:
assert xchdat[2][0] == self.plot_dicts['xunit'], 'x units'
assert ychdat[2][0] == self.plot_dicts['yunit'], 'y units'
self.xdata = []
self.ydata = []
if ychdat[0]:
for tx, x in zip(xchdat[0], xchdat[1]):
xtmp = False
ytmp = False
dt = timedelta(seconds=60)
for ty, y in zip(ychdat[0], ychdat[1]):
if abs(ty - tx) < dt:
dt = abs(ty - tx)
xtmp = x
ytmp = y
if xtmp and ytmp:
self.xdata.append(xtmp)
self.ydata.append(ytmp)
[self.xdata, self.ydata] = zip(*sorted(zip(self.xdata,
self.ydata)))
self.plot_dicts['xunit'] = xchdat[2][0]
self.plot_dicts['yunit'] = ychdat[2][0]
this_line = self.subfigure.get_lines()[tab]
this_line.set_xdata(array(self.xdata))
this_line.set_ydata(array(self.ydata))
except AssertionError as e:
print('*'*60, '\n the', e[0], 'do not match the 0th line', '*'*60)
def _MakePlot(self, tab=0):
'''
'''
if self.ConnectedPts.get():
plotformat='o-'
else:
plotformat='o'
if self.plot_dicts[tab]['xname'].get() == 'time':
self.subfigure.plot_date(self.xdata, self.ydata, plotformat,
label=self.plot_dicts[tab]['yname'].get())
self.subfigure.set_xticklabels(self.subfigure.get_xticklabels(),
rotation=-45)
self.subfigure.xaxis.set_major_formatter(dates.DateFormatter(
"%m/%d %H:%M"))
self.subfigure.yaxis.set_major_formatter(ticker.ScalarFormatter(
useOffset=False))
else:
self.subfigure.plot(self.xdata, self.ydata, plotformat,
label=self.plot_dicts[tab]['yname'].get())
self.subfigure.set_title(self.plot_dicts[tab]['yname'].get() +
' vs ' +
self.plot_dicts[tab]['xname'].get() +
'\n from ' + self.time_interval[0] +
' to ' + self.time_interval[1])
xname = self.plot_dicts[tab]['xname'].get().replace('_', ' ')
xunit = '[' + str(self.plot_dicts['xunit']) + ']'
self.subfigure.set_xlabel(xname + ' ' + xunit)
yname = self.plot_dicts[tab]['yname'].get().replace('_', ' ')
yunit = '[' + str(self.plot_dicts['yunit']) + ']'
self.subfigure.set_ylabel(yname + ' ' + yunit)
tickformat = ticker.ScalarFormatter(useOffset=False)
if self.ManualLimits.get():
self.subfigure.set_ylim(bottom=self.ymin.get(), top=self.ymax.get())
if self.LogYScale.get():
self.subfigure.set_yscale('log')
if self.ShowGrid.get():
self.subfigure.grid(b=True, which='major')
self.subfigure.grid(b=True, which='minor')
def _PlotGasLines(self):
'''
'''
gas_lines = ['left_gas_line_lower_t',
'left_gas_line_upper_t',
'right_gas_line_lower_t',
'right_gas_line_upper_t']
self._PlotSet(gas_lines)
def _PlotCell(self):
'''
'''
sensors = ['kh2_temp', 'kh3_temp', 'waveguide_cell_body_temp',
'coldhead_temp']
self._PlotSet(sensors)
def _PlotSet(self, channels):
'''
Plots a set of channels on common axes
'''
for plotn, channel in enumerate(channels):
if (len(self.plot_dicts)-2) <= plotn:
self._AddSubplot()
self.plot_dicts[plotn]['xname'].set('time')
self.plot_dicts[plotn]['yname'].set(channel)
self.start_t.set('3')
self.relative_start_time.set(True)
self.relative_stop_time.set(True)
self.continuous_updates.set(True)
self.Update()
def SaveFigure(self):
'''
'''
file_extensions = [('vectorized', '.eps'), ('adobe', '.pdf'),
('image', '.png'), ('all', '.*')]
outfile = asksaveasfilename(defaultextension='.pdf',
filetypes=file_extensions)
self.figure.savefig(outfile)
def SaveJson(self):
'''
'''
outfile = asksaveasfile(defaultextension='.json')
outdict = {'xunit':self.plot_dicts['xunit'],
'yunit':self.plot_dicts['yunit']
}
for tab in range(len(self.plot_dicts)-2):
outdict[tab] = {}
outdict[tab]['xname']=self.plot_dicts[tab]['xname'].get()
outdict[tab]['yname']=self.plot_dicts[tab]['yname'].get()
this_line = self.subfigure.get_lines()[tab]
if outdict['xunit'] == 't':
outdict[tab]['xdata'] = [str(t) for t in this_line.get_xdata()]
else:
outdict[tab]['xdata'] = list(this_line.get_xdata())
outdict[tab]['ydata'] = list(this_line.get_ydata())
dump(outdict, outfile, indent=4)
outfile.close()
class DaysimeterData:
"""Takes in Daysimeter data and creates plots for that data"""
def __init__(self):
"""Initializes the DaysimeterData instance for plotting
Initializes a figure, creates a placeholder subplot, then adds the
figure to a canvas
"""
self.fig = Figure(figsize=(600, 400), dpi=72, facecolor=(1, 1, 1),
edgecolor = (0, 0, 0))
self.fig.add_subplot(111)
self.values_set = False
self.ax_dict = {}
self.plot_tup = []
self.timestamps = None
self.data = None
self.attrs = None
self.canvas = FigureCanvas(self.fig)
self.fontP = FontProperties()
self.fontP.set_size('medium')
def show_plots(self, button_names):
"""Show the created plots
button_group - Group of buttons with buttons names matching the names
of the data values (e.g. Lux, CS, etc.)
"""
# Only tries to show plots once the data and timestamps have been set
if self.values_set:
# Iterates through the buttons and gets their names
# If its name is matches an axis name, show the axis, otherwise
# hide it
for name in self.ax_dict:
if name in button_names:
self.ax_dict[name].set_visible(True)
else:
self.ax_dict[name].set_visible(False)
def get_plot(self):
"""Return the canvas for drawing"""
return self.canvas
def set_values(self, timestamps, data, filetype):
"""Set the daysimeter values from a file
times - data structure of datetimes containing the timestamps of the
daysimeter data
data - dict of the the different kinds of data taken in from the
daysimeter
filetype - a string that is either 'cdf' or 'txt'
Sets the timestamps, the data from the daysimeter (lux, CS, etc.) then
smooths them out.
"""
self.timestamps = timestamps
self.data = data
if filetype == 'cdf':
self.attrs = data['attrs']
del data['attrs']
self.values_set = True
def make_plots(self):
"""Create the plots from the data."""
colors = ('aqua', 'black', 'fuchsia', 'gray', 'lime', 'maroon',
'navy', 'olive', 'orange', 'purple', 'silver', 'teal',
'white', 'yellow')
linear_y = {'CS', 'activity'}
main_ax = None
names = self.get_data_names()
self.plots = []
self.ordered_names = []
lower_names = []
if 'red' in names:
self.ordered_names.append('red')
if 'green' in names:
self.ordered_names.append('green')
if 'blue' in names:
self.ordered_names.append('blue')
if 'illuminance' in names:
self.ordered_names.append('illuminance')
if 'CLA' in names:
self.ordered_names.append('CLA')
if 'CS' in names:
self.ordered_names.append('CS')
if 'activity' in names:
self.ordered_names.append('activity')
names.sort()
for name in self.ordered_names:
lower_names.append(string.lower(name))
for name in names:
if name == 'logicalArray':
continue
if string.lower(name) not in lower_names:
self.ordered_names.append(name)
main_ax = self.fig.add_subplot(111)
main_ax.plot(self.timestamps,
ones(len(self.timestamps)), visible=False)
main_ax.set_yticklabels([])
# Iterates through the sets of values (lux, CS, CLA, etc.) and creates
# axes for them and stores the axes in a dictionary mapped with their
# name e.g. ax_dict['Lux'] returns the lux axis
for name, color in zip(self.ordered_names, colors):
if string.lower(name) in ['red', 'green', 'blue']:
color = name
# Makes the rest of the values 'children' of the the main, using
# the x axis of 'main, while creating thei own y axes
self.ax_dict[name] = main_ax.twinx()
if name in linear_y:
self.ax_dict[name].set_yscale('linear')
else:
self.ax_dict[name].set_yscale('log')
self.plots.extend(self.ax_dict[name].plot(self.timestamps,
self.data[name], color=color, alpha=0.8,
label=name))
# Finds the min of the data, then sets that as the the lower y
# bound of the plot to better align the graphs vertically
minimum = min(self.data[name])
self.ax_dict[name].set_ybound(lower=minimum)
self.ax_dict[name].tick_params(axis='y', colors=color)
self.fig.legend(self.plots, self.ordered_names, loc='lower left', ncol=3, prop = self.fontP)
self.fig.subplots_adjust(bottom=0.2)
self.canvas = FigureCanvas(self.fig)
def smooth(self):
"""Applies a lowpass filter to smooth out the data"""
names = self.get_data_names()
for name in names:
if name != 'Activity':
self.data[name] = lpf.lowpassFilter(self.data[name], 90)
def get_data_names(self):
"""Returns a list of the data names"""
if not self.attrs:
return list(self.data.dtype.names)
else:
return self.data.keys()
def get_metadata(self):
"""Returns a dictionary of the cdf's attributes"""
if self.attrs:
return self.attrs
else:
return {}
class DrawPlot(QtGui.QMainWindow):
def __init__(self, sirna_size, query_sequence, sifi_data, off_target_pos_list, region_plot_lst, temp_location,
scoret_lst, main_targets, f_in, mode, table_data, parent = None):
"""Class for drawing the plots inside a window."""
super(DrawPlot, self).__init__(parent)
# Some plotting settings
sns.set(style="white", palette="muted", color_codes=True)
self.sirna_size = sirna_size # Size of siRNA chosen by user.
self.query_sequence = query_sequence # Query sequence.
self.query_length = len(self.query_sequence) # Size of the query sequence.
self.sifi_data = sifi_data # siFi dara in json format file
self.off_target_pos_list = off_target_pos_list # Off target position list for design plot
self.region_plot_lst = region_plot_lst # Plot for suggested RNAi design region
self.score_lst = scoret_lst
self.temp_location = temp_location
self.main_targets = main_targets
self.f_in = f_in
self.mode = mode
self.home_location = str(QtGui.QDesktopServices.storageLocation(QtGui.QDesktopServices.HomeLocation))
self.table_data = table_data
if self.mode == 0:
self.setWindowTitle('RNAi design plot')
else:
self.setWindowTitle('Off-target plot')
# Image tempfile
self.temp_img_file = tempfile.mkstemp()
self.printer = QtGui.QPrinter()
# Single query mode, get all data
query = list(general_helpers.iterparse(self.sifi_data))[0]
# Get number of hits per query
hit_counter = Counter(player['hit_name'] for player in query)
hit_overview = hit_counter.most_common()
dpi = 80
if self.mode == 0:
figsize = (13, 4)
else:
if len(hit_overview) == 1:
figsize = (13,5)
elif len(hit_overview) == 2:
figsize = (13,6)
elif len(hit_overview) == 3:
figsize = (13,8)
elif len(hit_overview) == 4:
figsize = (13,10)
elif len(hit_overview) > 5:
figsize = (13,20)
dpi = 65
self.figure = Figure(figsize =figsize, dpi = dpi, facecolor = '#FFFFFF')
self.canvas = FigureCanvas(self.figure)
# use addToolbar to add toolbars to the main window directly!
#print 'ok'
self.toolbar = NavigationToolbar(self.canvas, self)
self.addToolBar(self.toolbar)
self.main_widget = QtGui.QWidget(self)
self.setCentralWidget(self.main_widget)
layout = QtGui.QVBoxLayout()
layout.addWidget(self.canvas)
self.createActions()
self.createMenus()
self.main_widget.setLayout(layout)
def plot_design(self):
""" Plotting the design plot."""
# Create main figure
ax1 = self.figure.add_subplot(111)
def format_coord(x, y):
return 'Sequence position = %d , Nr. of siRNAs = %d '%(x, y)
ax1.format_coord = format_coord
off_target_dict, main_target_dict, efficient_dict, main_hits_histo = general_helpers.get_target_data(self.f_in, self.sirna_size)
# If there are no hits, we show only the efficient sirnas for designing a construct
if self.main_targets == []:
off_target_dict = {}
main_target_dict = {}
main_hits_histo = []
# Off-target position list
off_targets_pos = set()
for i in off_target_dict.values():
off_targets_pos = off_targets_pos | i
# Main-target position list
main_targets_plot = set()
for i in main_target_dict.values():
main_targets_plot = main_targets_plot | i
# Efficient position list
eff_sirna_plot = []
for i in efficient_dict.values():
eff_sirna_plot.extend(i)
eff_sirna_plot.sort()
# Draw efficiency plot
eff_sirna_histo = np.bincount(eff_sirna_plot, minlength=self.query_length)
ax1.plot(eff_sirna_histo, 'r-', label='Efficient siRNA hits')
# Draw main target histogram
main_histo = np.bincount(main_hits_histo, minlength=self.query_length)
ax1.plot(main_histo, 'b-', label='Main target siRNA hits')
# Draw main targets as green rectangles inside plot figure
for region in main_targets_plot:
someX, someY = region, 0.
currentAxis = self.figure.gca()
tri1 = Rectangle((someX, someY), 1, self.sirna_size + 3, color='g', alpha=0.2)#, label='green')
currentAxis.add_patch(tri1)
tri1.set_clip_on(False)
# Draw off-targets as red rectangles inside plot figure
for off_target in off_targets_pos:
someX, someY = off_target, 0.
currentAxis = self.figure.gca()
tri2 = Rectangle((someX, someY), 1, self.sirna_size + 3, color='r', alpha=0.2)#, label='red')
currentAxis.add_patch(tri2)
tri2.set_clip_on(False)
if max(eff_sirna_histo) > self.sirna_size:
max_y = max(eff_sirna_histo) + 3
else:
max_y = self.sirna_size + 3
ax1.set_ylim([0, max_y])
x_text = 'mRNA sequence position\n\n'
ax1.set_xlabel(x_text, fontsize=12)
ax1.set_ylabel('Nr of siRNAs', color='b', fontsize=12)
ax1.set_xlim([0, self.query_length])
ax1.set_title("RNAi design plot\n\n", fontsize=14)
self.figure.tight_layout()
p1 = Rectangle((0, 0), 1, 1, fc="g", alpha=0.2)
p2 = Rectangle((0, 0), 1, 1, fc="r", alpha=0.2)
p3 = mlines.Line2D([], [], color='r')
p4 = mlines.Line2D([], [], color='b')
ax1.legend([p1,p2, p3, p4], ["Main target", "Off target", 'Efficient siRNAs', 'All siRNAs'],
bbox_to_anchor=(0., 1.02, 1., .102), loc=4, ncol=4, mode="", borderaxespad=0.5, frameon=True)
self.figure.savefig(self.temp_img_file[1] + '.png')
self.canvas.draw()
return self.temp_img_file[1] + '.png', off_target_dict, main_target_dict
def plot_offtarget(self):
"""Plotting the off-target plot."""
max_sirna_count = self.sirna_size
# Single query mode, get all data
query = list(general_helpers.iterparse(self.sifi_data))[0]
# Get number of hits per query
hit_counter = Counter(player['hit_name'] for player in query)
efficicent_counter = Counter(player['hit_name'] for player in query if player['is_efficient'])
hit_overview = hit_counter.most_common()
table_data = []
for x in hit_counter.most_common():
for y in efficicent_counter.most_common():
if x[0] == y[0]:
table_data.append([x[0], x[1], y[1]])
if x[0] not in list(efficicent_counter):
table_data.append([x[0], x[1], 0])
if len(hit_overview) > 5:
data = table_data[:5]
data.append([str(len(table_data)-5) + ' More targets', '...', '...'])
else:
data = table_data
nrows = len(hit_overview[:5]) + 1
ncols = 1
### Create main figure
axes = self.figure.add_subplot(nrows, 1, 1)
# First plot is table
axes.axis('off')
collabel = ("Targets", "Total siRNA hits", "Efficient siRNA hits")
the_table = axes.table(cellText=data, colLabels=collabel, loc='center', cellLoc='left')
cellDict = the_table.get_celld()
for row, col in cellDict:
cellDict[(row, col)].set_width(0.08)
the_table.set_fontsize(12)
the_table.scale(2.1, 2.1)
p3 = mlines.Line2D([], [], color='r')
p4 = mlines.Line2D([], [], color='b')
# Extract all siRNA position, separate for all and efficient siRNAs
# Show only up to five targets in plot, otherwise it become to much
counter = 2
for hit, nr_hits in hit_overview[:5]:
all_sirna_plot = []
eff_sirna_plot = []
for data in query:
if hit == data['hit_name']:
all_sirna_plot.extend(range(int(data['sirna_position']) + 1, int(data['sirna_position']) + self.sirna_size + 1))
if data['is_efficient']:
eff_sirna_plot.extend(range(int(data['sirna_position']) + 1, int(data['sirna_position']) + self.sirna_size + 1))
axes = self.figure.add_subplot(nrows, 1, counter)
# Create a new plot for each hit
axes.set_title(str(hit), loc='left')#, color='k', fontsize=14, fontweight='bold')
# Create a histogram of siRNA positions
all_sirna_histo = np.bincount(all_sirna_plot, minlength=self.query_length)
eff_sirna_histo = np.bincount(eff_sirna_plot, minlength=self.query_length)
# Plot both histograms into one plot
axes.plot(all_sirna_histo, color="b", label='Total siRNA hits')
axes.plot(eff_sirna_histo, color="r", label='Strand selected siRNAs')
# Adjust axis
if np.amax(all_sirna_histo) > max_sirna_count:
max_sirna_count = np.amax(all_sirna_histo)
axes.set_ylim([0, max_sirna_count + 3])
axes.set_xlim([0, self.query_length + 5])
# Next plot
counter += 1
# Some figure settings
bottom_offset = (nrows-1)
if bottom_offset > 5:
bottom_offset = 5
axes.set_xlabel('\nRNAi trigger sequence position', fontsize=12)
axes.set_ylabel('siRNA counts per position', fontsize=12)
def format_coord(x, y):
return 'Sequence position = %d , Nr. of siRNAs = %d '%(x, y)
axes.format_coord = format_coord
self.figure.subplots_adjust(left=0.05, bottom=0.15/bottom_offset, right=0.98, top=0.99, wspace=None, hspace=0.35)
self.figure.legend([p4, p3], ['All siRNAs', 'Efficient siRNAs'], loc = "lower right", ncol=2, frameon=True,)
self.figure.tight_layout()
self.figure.savefig(self.temp_img_file[1] + '.png')
self.canvas.draw()
return self.temp_img_file[1] + '.png', table_data
def print_(self):
fileName = self.temp_img_file[1] + '.png'
if fileName:
image = QtGui.QImage(fileName)
self.imageLabel = QtGui.QLabel()
self.imageLabel.setBackgroundRole(QtGui.QPalette.Base)
self.imageLabel.setSizePolicy(QtGui.QSizePolicy.Ignored,
QtGui.QSizePolicy.Ignored)
self.imageLabel.setScaledContents(True)
self.imageLabel.setPixmap(QtGui.QPixmap.fromImage(image))
self.scaleFactor = 1.0
dialog = QtGui.QPrintDialog(self.printer, self)
if dialog.exec_():
painter = QtGui.QPainter(self.printer)
rect = painter.viewport()
size = self.imageLabel.pixmap().size()
size.scale(rect.size(), QtCore.Qt.KeepAspectRatio)
painter.setViewport(rect.x(), rect.y(), size.width(), size.height())
painter.setWindow(self.imageLabel.pixmap().rect())
painter.drawPixmap(0, 0, self.imageLabel.pixmap())
def export_image(self):
"""Export the images as png."""
filename = QtGui.QFileDialog.getSaveFileName(self, 'Save File', self.home_location, '*.png')
if filename:
if not str(filename).endswith('.png'):
filename += filename + '.png'
shutil.copy(self.temp_img_file[1] + '.png', filename)
if os.path.exists(filename):
message = 'Image successfully saved!'
else:
message = 'Could not save image!'
self.show_info_message(message)
def export_table(self):
filename = QtGui.QFileDialog.getSaveFileName(self, 'Export table', self.home_location, '*.csv')
if filename:
if not str(filename).endswith('.csv'):
filename += filename + '.csv'
try:
f_in = open(filename, 'w')
f_in.write("Targets" + ';' + "Total siRNA hits" + ';' + "Efficient siRNA hits" + '\n')
for data in self.table_data:
f_in.write(str(data[0]) + ';' + str(data[1]) + ';' + str(data[2]) + '\n')
f_in.close()
if os.path.exists(filename):
message = 'Table successfully saved!'
else:
message = 'Could not save table!'
except IOError:
message = 'Permission denied! Please close the file.'
self.show_info_message(message)
def show_info_message(self, message):
"""Pop up an info message."""
QtGui.QMessageBox.information(self,
u"Information",
message)
def createActions(self):
self.printAct = QtGui.QAction("&Print...", self, enabled=True, triggered=self.print_)
self.exitAct = QtGui.QAction("E&xit", self, triggered=self.close)
self.imgAct = QtGui.QAction("Image file", self, triggered=self.export_image)
self.tableAct = QtGui.QAction("Table (CSV)", self, triggered=self.export_table)
def createMenus(self):
self.fileMenu = QtGui.QMenu("&File", self)
self.fileMenu.addAction(self.printAct)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.exitAct)
# Export menu
self.exportMenu = QtGui.QMenu("&Save as", self)
self.exportMenu.addAction(self.imgAct)
self.exportMenu.addAction(self.tableAct)
self.menuBar().addMenu(self.fileMenu)
self.menuBar().addMenu(self.exportMenu)
class VoltagePanel(wx.Panel):
"""
GUI Window for plotting voltage data.
"""
#--------------------------------------------------------------------------
def __init__(self, *args, **kwargs):
wx.Panel.__init__(self, *args, **kwargs)
global filePath
global tV_list
global V_list
self.create_title("Voltage Panel")
self.init_plot()
self.canvas = FigureCanvasWxAgg(self, -1, self.figure)
self.create_control_panel()
self.create_sizer()
pub.subscribe(self.OnVoltage, "Voltage")
pub.subscribe(self.OnVTime, "Time Voltage")
# For saving the plots at the end of data acquisition:
pub.subscribe(self.save_plot, "Save_All")
self.animator = animation.FuncAnimation(self.figure, self.draw_plot, interval=500, blit=False)
#end init
#--------------------------------------------------------------------------
def create_title(self, name):
self.titlePanel = wx.Panel(self, -1)
title = wx.StaticText(self.titlePanel, label=name)
font_title = wx.Font(16, wx.DEFAULT, wx.NORMAL, wx.BOLD)
title.SetFont(font_title)
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add((0,-1))
hbox.Add(title, 0, wx.LEFT, 5)
self.titlePanel.SetSizer(hbox)
#end def
#--------------------------------------------------------------------------
def create_control_panel(self):
self.xmin_control = BoundControlBox(self, -1, "t min", 0)
self.xmax_control = BoundControlBox(self, -1, "t max", 100)
self.ymin_control = BoundControlBox(self, -1, "V min", -500)
self.ymax_control = BoundControlBox(self, -1, "V max", 500)
self.hbox1 = wx.BoxSizer(wx.HORIZONTAL)
self.hbox1.AddSpacer(10)
self.hbox1.Add(self.xmin_control, border=5, flag=wx.ALL)
self.hbox1.Add(self.xmax_control, border=5, flag=wx.ALL)
self.hbox1.AddSpacer(10)
self.hbox1.Add(self.ymin_control, border=5, flag=wx.ALL)
self.hbox1.Add(self.ymax_control, border=5, flag=wx.ALL)
#end def
#--------------------------------------------------------------------------
def OnVoltage(self, msg):
self.V = float(msg)
V_list.append(self.V)
#end def
#--------------------------------------------------------------------------
def OnVTime(self, msg):
self.tV = float(msg)
tV_list.append(self.tV)
#end def
#--------------------------------------------------------------------------
def init_plot(self):
self.dpi = 100
self.colorV = 'g'
self.figure = Figure((6,2), dpi=self.dpi)
self.subplot = self.figure.add_subplot(111)
self.lineV, = self.subplot.plot(tV_list,V_list, color=self.colorV, linewidth=1)
self.legend = self.figure.legend( (self.lineV,), (r"$V$",), (0.15,0.75),fontsize=8)
#self.subplot.text(0.05, .95, r'$X(f) = \mathcal{F}\{x(t)\}$', \
#verticalalignment='top', transform = self.subplot.transAxes)
#end def
#--------------------------------------------------------------------------
def draw_plot(self,i):
self.subplot.clear()
#self.subplot.set_title("voltage vs. time", fontsize=12)
self.subplot.set_ylabel(r"voltage ($\mu$V)", fontsize = 8)
self.subplot.set_xlabel("time (s)", fontsize = 8)
# Adjustable scale:
if self.xmax_control.is_auto():
xmax = max(tV_list)
else:
xmax = float(self.xmax_control.manual_value())
if self.xmin_control.is_auto():
xmin = 0
else:
xmin = float(self.xmin_control.manual_value())
if self.ymin_control.is_auto():
minV = min(V_list)
ymin = minV - abs(minV)*0.3
else:
ymin = float(self.ymin_control.manual_value())
if self.ymax_control.is_auto():
maxV = max(V_list)
ymax = maxV + abs(maxV)*0.3
else:
ymax = float(self.ymax_control.manual_value())
self.subplot.set_xlim([xmin, xmax])
self.subplot.set_ylim([ymin, ymax])
pylab.setp(self.subplot.get_xticklabels(), fontsize=8)
pylab.setp(self.subplot.get_yticklabels(), fontsize=8)
self.lineV, = self.subplot.plot(tV_list,V_list, color=self.colorV, linewidth=1)
return (self.lineV)
#return (self.subplot.plot( thighV_list, highV_list, color=self.colorH, linewidth=1),
#self.subplot.plot( tlowV_list, lowV_list, color=self.colorL, linewidth=1))
#end def
#--------------------------------------------------------------------------
def save_plot(self, msg):
path = filePath + "/Voltage_Plot.png"
self.canvas.print_figure(path)
#end def
#--------------------------------------------------------------------------
def create_sizer(self):
sizer = wx.GridBagSizer(3,1)
sizer.Add(self.titlePanel, (0, 0), flag=wx.ALIGN_CENTER_HORIZONTAL)
sizer.Add(self.canvas, ( 1,0), flag=wx.ALIGN_CENTER_HORIZONTAL)
sizer.Add(self.hbox1, (2,0), flag=wx.ALIGN_CENTER_HORIZONTAL)
self.SetSizer(sizer)
