class MonitorWindow(PanedWindow):
def __init__(self, master, skeleton):
PanedWindow.__init__(self, master=master, height=400)
self.skeleton = skeleton
self.figure = Figure(figsize=(5,4), dpi=100)
self.subplots = {}
nrows = len(self.skeleton.units)
ncols = 3
plot_counter = 1
for u in self.skeleton.units.keys():
subplots = [None, None, None]
history = self.skeleton.units[u].history()
t = range(0, len(history[0]))
for a in range(0, 3):
subplot = self.figure.add_subplot(nrows, ncols, plot_counter, xlim=[0,200], ylim=[-90,90])
s = history[a]
subplot.plot(t,s)
plot_counter += 1
subplots[a] = subplot
self.subplots[u] = subplots
self.canvas = FigureCanvasTkAgg(self.figure, master=self)
self.canvas.show()
self.canvas.get_tk_widget().pack(side="top", fill="both", expand=1)
self.canvas.mpl_connect("key_press_event", self.pressed_key)
self.pack(fill="both", expand="yes")
def redraw_graph(self):
plot_counter = 1
for k, axes in self.subplots.iteritems():
history = self.skeleton.units[k].history()
t = range(0, len(history[0]))
for a, subplot in enumerate(axes):
s = history[a]
subplot.plot(t,s)
plot_counter += 1
subplot.clear()
subplot.plot(t,s)
subplot.set_xlim([0, 200])
subplot.set_ylim([-90, 90])
self.canvas.draw()
def pressed_key(self, event):
if event.key == "r":
self.redraw_graph()
else:
print("Key pressed: %s" % event.key)
class Graph(tk.Frame,object):
def __init__(self,master=None,onClick=None,xSize=40,ySize=30):
self.onClick=(lambda x,y,z:None) if onClick is None else onClick
tk.Frame.__init__(self,master)
self.f = Figure(figsize=(4,4), dpi=100) # return a matplotlib.figure.Figure instance, Höhe und Breite in Inches
self.a = self.f.add_subplot(111) # Add a subplot with static key "111" and return instance to it
self.a.grid(True) # Set the axes grids on
self.a.set_xlim((0,ySize))
self.a.set_ylim((0,xSize))
self.canvas = FigureCanvasTkAgg(self.f, master=self) # The Canvas widget provides structured graphics facilities for Tkinter.
self.canvas.mpl_connect('button_press_event', self.rawOnClick)
self.canvas.show() # Aus matplotlib: display all figures and block until the figures have been closed
self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
def addline(self,x,y):
self.curline=matplotlib.lines.Line2D([y],[x])
self.a.add_line(self.curline)
def append(self,x,y):
y0,x0=self.curline.get_data()
x0.append(x)
y0.append(y)
self.curline.set_data(y0,x0)
self.canvas.draw()
def rawOnClick(self,evt):
print evt.key
both=True if evt.key=='shift' else False
self.onClick(evt.ydata, evt.xdata, both)
class LiveGraphTk(Backend):
""" LiveGraph backend for Tkinter.
"""
def show(self, delay):
if self.master is None:
self.root = Tk.Toplevel()
self.master = self.root
else:
self.root = Tk.Toplevel(self.master)
self.canvas = FigureCanvasTkAgg(self.figure, master=self.root)
#self.canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
self.toolbar = NavigationToolbar2TkAgg(self.canvas, self.root)
self.toolbar.update()
self.canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=True)
self.canvas.mpl_connect('key_press_event', self.on_key_event)
self.root.protocol("WM_DELETE_WINDOW", self.close)
super().show(delay)
def run(self, delay):
"""Calls the update method periodically with the delay in milliseconds.
Decrease the delay to make the plotting smoother and increase it to
reduce the preformance. For live plotting the delay must fit the rate
of the incoming data.
Keyword arguments:
delay -- the delay in millisconds after each call (default 50)
"""
super().run()
self.root.after(delay, self.run, delay)
@property
def visible(self):
if self.root.state() in ['normal', 'zoomed']:
return True
else:
return False
@visible.setter
def visible(self, boolean):
if boolean:
self.root.deiconify()
else:
self.root.withdraw()
self.visible = False
def close(self):
super().close()
self.master.destroy()
def __init__(self, root, controller):
f = Figure()
ax = f.add_subplot(111)
ax.set_xticks([])
ax.set_yticks([])
ax.set_xlim((x_min, x_max))
ax.set_ylim((y_min, y_max))
canvas = FigureCanvasTkAgg(f, master=root)
canvas.show()
canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
canvas.mpl_connect('button_press_event', self.onclick)
toolbar = NavigationToolbar2TkAgg(canvas, root)
toolbar.update()
self.controllbar = ControllBar(root, controller)
self.menubar = MenuBar(root, controller)
self.f = f
self.ax = ax
self.canvas = canvas
self.controller = controller
self.contours = []
self.tube = []
self.c_labels = None
self.plot_kernels()
self.class_colors = ('b', 'r', 'g', 'y')
class PlotWindow(Frame):
"""
"""
def __init__(self, parent, figure, plotType=None):
"""
Constructor
@param parent:
@param figure:
@param plotType:
@return
"""
Frame.__init__(self, parent)
# a tk.DrawingAre
self.plotType = plotType
self.canvas = FigureCanvasTkAgg(figure, master=self)
self.canvas.show()
self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
self.toolbar = NavigationToolbar2TkAgg(self.canvas, self)
self.toolbar.update()
self.canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=1)
self.canvas.mpl_connect('key_press_event', self.on_key_event)
def getPlotType(self):
"""
@return
"""
return self.plotType
def updateFigure(self, figure):
"""
@param figure:
@return
"""
self.canvas._tkcanvas.pack_forget()
self.canvas = FigureCanvasTkAgg(figure, master=self)
self.canvas.show()
self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
self.toolbar = NavigationToolbar2TkAgg(self.canvas, self)
self.toolbar.update()
self.canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=1)
self.canvas.mpl_connect('key_press_event', self.on_key_event)
def on_key_event(self, event):
"""
@param event:
@return
"""
print('you pressed %s' % event.key)
key_press_handler(event, self.canvas, self.toolbar)
def __init__(self, root, f):
Tk.Frame.__init__(self, root)
# a tk.DrawingArea
canvas = FigureCanvasTkAgg(f, root)
canvas.show()
canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
toolbar = NavigationToolbar2TkAgg(canvas, root)
toolbar.update()
canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
def on_key_event(event):
print('you pressed %s' % event.key)
key_press_handler(event, canvas, toolbar)
canvas.mpl_connect('key_press_event', on_key_event)
def _quit():
root.quit() # stops mainloop
root.destroy() # this is necessary on Windows to prevent
# Fatal Python Error: PyEval_RestoreThread: NULL tstate
button = Tk.Button(root, text='Quit', command=_quit)
button.pack(side=Tk.BOTTOM)
def __init__(self, master, controller):
def onClick(event):
global pause
pause ^= True
global ser, instrument
Frame.__init__(self, master)
self.graphframe = Frame(self)
self.graphframe.pack(side = TOP, fill=BOTH, expand=True)
self.filenameframe = Frame(self)
self.filenameframe.pack(side = BOTTOM, fill=BOTH, pady = 10)
self.browseframe = Frame(self)
self.browseframe.pack(side = BOTTOM, fill=BOTH, pady = 10)
self.title = ttk.Label(self.graphframe, text = "Pressure Reading from Pads", font = ("", "14", "bold"))
self.title.pack(pady = 10, padx = 10)
# figure window
canvas = FigureCanvasTkAgg(f, self.graphframe)
canvas.show()
canvas.get_tk_widget().pack(side=BOTTOM, fill=BOTH, expand=True)
canvas.mpl_connect('button_press_event', onClick)
toolbar = NavigationToolbar2TkAgg(canvas, self.graphframe)
toolbar.update()
canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=True)
self.filepath = StringVar()
self.filename = StringVar()
self.filename.set(str(strftime("%d-%m-%Y_%H%M", gmtime())) + '.mid')
browse_label = ttk.Label(self.browseframe, text = "Save MIDI file in:")
browse_label.pack(side = LEFT, fill=Y, padx = 5)
self.browse_filepath = ttk.Entry(self.browseframe, textvariable = self.filepath)
self.browse_filepath.pack(side = LEFT, fill=X, expand=True, padx = 5)
browse_button = ttk.Button(self.browseframe, text = "Browse", command = self.askopenfile)
browse_button.pack(side = LEFT, fill=BOTH, padx = 5)
filename_label = ttk.Label(self.filenameframe, text = "MIDI filename:")
filename_label.pack(side = LEFT, fill=Y, padx = 5)
self.saveFileName = ttk.Entry(self.filenameframe, textvariable = self.filename)
self.saveFileName.pack(side = LEFT, fill=X, expand=True, padx = 5)
browse_button = ttk.Button(self.filenameframe, text = "Save", command = self.savefile)
browse_button.pack(side = LEFT, fill=BOTH, padx = 5)
def __init__(self, master):
super(ImageFrame, self).__init__(master)
figure = Figure((5,4), dpi=100)
self.figure = figure
canvas = FigureCanvasTkAgg(figure, master=master)
canvas.mpl_connect('button_press_event', self._on_click)
canvas.mpl_connect('key_press_event',self._on_keypress)
canvas.show()
self.__canvas = canvas
toolbar = NavigationToolbar2TkAgg(canvas, master)
toolbar.update()
canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=YES)
toolbar.pack()
self.axes = figure.add_subplot(111)
self.peakFinder = PeakFinder(self.axes, canvas)
def __init__(self, master):
super().__init__(master)
figure = Figure((5,4), dpi=100)
self.figure = figure
canvas = FigureCanvasTkAgg(figure, master=master)
canvas.mpl_connect('button_press_event', self._on_click)
canvas.mpl_connect('key_press_event',self._on_keypress)
canvas.draw()
self.__canvas = canvas
toolbar = NavigationToolbar2TkAgg(canvas, master)
toolbar.update()
canvas.get_tk_widget().pack(side='top', fill='both', expand='yes')
toolbar.pack()
self.axes = figure.add_subplot(111)
self.__rectselector = RectSelector(self.axes, canvas)
def draw():
def on_key_event(event):
print('you pressed %s' % event.key)
key_press_handler(event, canvas, toolbar)
fig = Figure(figsize=(5, 4), dpi=100)
ax = fig.add_subplot(111)
x = arange(0.0, 3.0, 0.01)
y=eval(entry.get()+"(x)")
ax.set_title(entry.get())
ax.plot(x, y)
ax.set_xlabel('x')
ax.set_ylabel('y')
canvas = FigureCanvasTkAgg(fig, master=root)
canvas.show()
canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
toolbar = NavigationToolbar2TkAgg(canvas, root)
toolbar.update()
canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
canvas.mpl_connect('key_press_event', on_key_event)
def __init__(self):
self.root = tk.Tk()
self.root.wm_title("AEViewer")
self.make_menu()
frame = tk.Frame(self.root)
frame.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
self.fig = Figure(figsize=(8,6), dpi=100)
canvas = FigureCanvasTkAgg(self.fig, frame)
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
self.toolbar = NavigationToolbar2TkAgg(canvas, frame)
canvas.mpl_connect('key_press_event', self.on_key_press)
canvas.mpl_connect('scroll_event', self.on_scroll)
self.progressbar = ttk.Progressbar(self.root, orient='horizontal', mode='determinate', )
self.progressbar.pack(side=tk.BOTTOM, fill=tk.X)
self.data = None
self.root.update() # needed on windows for events to work
def __init__(self, abs_path_to_csv, var_names):
self.check_vars(var_names)
self._root = Tk.Tk()
self._root.wm_title("pyDataGate")
self._figure = Figure(figsize=(5,4), dpi=100)
self._dataset = DataSet(abs_path)
root = self._root
f = self._figure
canvas = FigureCanvasTkAgg(f, master=root)
canvas.show()
canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
canvas.mpl_connect('button_press_event', self.on_click_event)
arrays = []
for a_var in var_names:
arrays.append(self._dataset.get_array_from_dicts(a_var))
if len(var_names) == 2:
ax = f.add_subplot(111)
ax.scatter(arrays[0], arrays[1])
if len(var_names) == 3:
ax = f.add_subplot(111)
ax.scatter(arrays[0], arrays[1], c=arrays[2])
button = Tk.Button(master=root, text='Quit', command=self.quit)
button.pack(side=Tk.BOTTOM)
def __init__(self, root, controller):
f = Figure()
nticks = 10
ax = f.add_subplot(111, aspect='1')
ax.set_xticks([x*(x_max-x_min)/nticks+x_min for x in range(nticks+1)])
ax.set_yticks([y*(y_max-y_min)/nticks+y_min for y in range(1,nticks+1)])
ax.set_xlim((x_min, x_max))
ax.set_ylim((y_min, y_max))
canvas = FigureCanvasTkAgg(f, master=root)
canvas.show()
canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
canvas.mpl_connect('button_press_event', self.onclick)
toolbar = NavigationToolbar2TkAgg(canvas, root)
toolbar.update()
self.controllbar = ControllBar(root, controller)
self.f = f
self.ax = ax
self.canvas = canvas
self.controller = controller
self.contours = []
self.c_labels = None
self.plot_kernels()
def fig_plot(frame, tarr, parr, nshot, y_ticks=[], col='#c00000', ylbl=''):
fig = Figure(figsize=(8.2, 8.2), dpi=100)
can = FigureCanvasTkAgg(fig, master=frame)
can._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
fig.subplots_adjust(left=0.1, bottom=0.1, right=0.95, top=0.92, hspace=0)
fig.text(.5, .95, '#%d' %nshot, ha='center')
nsrc = parr.shape[1]
for jx in range(nsrc):
ax = fig.add_subplot(8, 1, jx+1)
ax.plot(tarr, parr[:, jx], color=col)
ax.set_ylabel('%s%d' %(ylbl, jx+1), fontsize=fsize)
ax.set_yticks(y_ticks)
ax.ticklabel_format(axis='y', style='sci', scilimits=(-4,-4))
ax.yaxis.major.formatter._useMathText = True
if jx < nsrc-1:
ax.tick_params(axis='x', which='both', bottom='on', top='on', labelbottom='off')
ax.set_xlabel('Time [s]', fontsize=fsize)
can.mpl_connect('button_press_event', fconf.on_click)
toolbar = NavigationToolbar2TkAgg(can, frame)
toolbar.update()
def __init__(self,root,listener=None):
self.root=root
fig,ax=plt.subplots(figsize=(6,6))
self.ax=ax
self.ax.set_xlim([0,255])
self.ax.set_ylim([0,255])
browser=ToneCurve(fig,self.ax,listener)
plot_frame=Frame(self.root)
self.root.add(plot_frame)
canvas=FigureCanvasTkAgg(fig,master=plot_frame)
canvas.mpl_connect('pick_event',browser.onpick)
canvas.mpl_connect('motion_notify_event',browser.on_motion)
#both bind is very important for release event but I do not know why
canvas._tkcanvas.bind('button_release_event',browser.on_release)
canvas.mpl_connect('button_release_event', browser.on_release)
toolbar = NavigationToolbar2TkAgg(canvas, plot_frame)
toolbar.update()
self.canvas=canvas
self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
class MainPlot():
def __init__(self, parent, filenames, trials, timing, destroy_fun,
mainplot_axes_fun, queuein, offset_frames, loaded_variables):
self.mainplot_axes_fun = mainplot_axes_fun
self.queuein = queuein
self.fig = Figure(figsize=(12, 4))
self.destroy_fun = destroy_fun
gs = gridspec.GridSpec(1, 1)
gs.update(left=0.001, right=0.999, bottom=0.07, top=0.999)
self.ax = self.fig.add_subplot(gs[0, 0])
self.cont_y_pos = -1
self.fig2 = Figure(figsize=(2, 4))
self.axname = self.fig2.add_subplot(gs[0, 0])
# self.axname = self.fig.add_subplot(gs[0, 1])
self.axname.set_ylim(bottom=0, top=10.5)
self.axname.set_xlim(left=0, right=1)
self.axname.axis('off')
self.ax.set_ylim(bottom=-1, top=0)
self.ax.set_yticklabels([])
self.ax.set_yticks([])
# a tk.DrawingArea
self.canvas = FigureCanvasTkAgg(self.fig, master=parent)
self.canvas.get_tk_widget().config(highlightthickness=0)
self.canvas.show()
self.canvas.get_tk_widget().grid(row=1, column=0, sticky='NSEW')
self.canvas.mpl_connect('button_press_event', self.onclick)
canvas2 = FigureCanvasTkAgg(self.fig2, master=parent)
canvas2.get_tk_widget().config(highlightthickness=0)
canvas2.show()
canvas2.get_tk_widget().grid(row=1, column=1, sticky='NSEW')
canvas2.mpl_connect('button_press_event', self.onclick)
camtime = self.get_camTime(timing)
camrate = self.get_camRate(timing)
self.offset = (offset_frames / camrate) - camtime
# print(self.offset)
# self.colors = ["#4542f4", "#41f465", "#f44141", "#f441e5"]
self.label_colors = ["#E9CAF4", "#CAEDF4"]
self.numstreams = 0
self.loaded_variables = loaded_variables
data = self.load_matfile(trials)
# self.xmin = float('Inf')
# self.xmax = -float('Inf')
self.xmin = data[0, 0]
self.xmax = data[-1, 1]
# self.update_axes(0,1)
self.boxes_and_labels = []
self.loaddata(filenames)
def get_camTime(self, timingfile):
return scipy.io.loadmat(timingfile)['trialInfo']['camTime'][0][0][0][0]
def get_camRate(self, timingfile):
return scipy.io.loadmat(timingfile)['trialInfo']['camRate'][0][0][0][0]
def cstream2cevent(self, cstream):
cevent = np.array([[-1, -1, -1]], dtype=np.float64)
numrows, numcols = np.shape(cstream)
if numcols > 2:
return cstream
in_event = False
prev_category = 0
build_event = np.array([[-1, -1, -1]], dtype=np.float64)
for c in range(0, numrows):
cur_category = cstream[c, 1]
if cur_category != prev_category:
if build_event[0, 0] > 0:
build_event[0, 1] = cstream[c, 0]
build_event[0, 2] = prev_category
cevent = np.append(cevent, build_event, axis=0)
build_event = np.array([[-1, -1, -1]])
elif cur_category > 0:
build_event[0, 0] = cstream[c, 0]
prev_category = cur_category
return cevent[1:, :]
def draw_rects(self, data, bottom):
ind = data[:, 0].argsort(axis=0)
data = data[ind, :]
ax = self.ax
values = data[:, 2].astype(int)
prev_off = -1
prev_prev_off = -1
prev_was_half = None
lencolors = len(colors)
for i in range(0, np.size(data[:, 0])):
curr = data[i, :]
dur = data[i, 1] - data[i, 0]
if dur > 0:
thisbottom = bottom
# if rect overlaps, then draw at half height so that both show up
if (data[i, 0] < prev_off):
height = 5
if prev_was_half == "bottom":
prev_was_half = "top"
thisbottom = bottom + 5
else:
prev_was_half = "bottom"
else:
prev_was_half = None
height = 10
if prev_off < data[i, 1]:
prev_prev_off = prev_off
prev_off = data[i, 1]
if (values[i] - 1) > lencolors:
idx = (values[i] - 1) % lencolors
else:
idx = values[i] - 1
ax.add_patch(
pat.Rectangle((data[i, 0], thisbottom),
dur,
height,
color=colors[idx]))
def load_matfile(self, filename):
if ".csv" in filename:
data = self.csv2np(filename)
elif ".mat" in filename:
data = scipy.io.loadmat(filename)['sdata'][0][0][1]
else:
data = []
return data
def loaddata(self, filenames):
for f in filenames:
self.add_variable(f)
self.ax.figure.canvas.draw()
self.axname.figure.canvas.draw()
def onclick(self, event):
if event.inaxes == self.ax:
# print('button=%d, x=%d, y=%d, xdata=%f, ydata=%f' %
# (event.button, event.x, event.y, event.xdata, event.ydata))
command = "seekto " + str(event.xdata + self.offset)
self.queuein.put(command)
if event.inaxes == self.axname:
for b in self.boxes_and_labels:
box, label = b
contains, attrd = box.contains(event)
if contains:
self.destroy_fun(label)
def event2cevent(self, data):
numrows, numcols = np.shape(data)
one_array = np.ones((numrows, 1), dtype=np.float64)
arracat = np.concatenate((data, one_array), axis=1)
return arracat
def draw_cont(self, data, top):
maxval = np.max(data[:, 1])
vals_norm = np.divide(data[:, 1], maxval)
vals_scaled = np.multiply(vals_norm, 10)
# if self.cont_y_pos >= -1:
# top = self.cont_y_pos
# else:
# self.cont_y_pos = top
vals_scaled = vals_scaled + top
self.ax.plot(data[:, 0], vals_scaled)
def csv2np(self, filename):
fid = open(filename, "r")
lines = fid.readlines()
fid.close()
outarray = np.zeros(shape=(1, 3), dtype=np.float64)
for line in lines:
line = line.split("\n")[0]
npline = np.fromstring(line, dtype=np.float64, sep=',')
outarray = np.concatenate((outarray, [npline]), axis=0)
return outarray[1:, :]
def add_variable(self, filename):
# print(filename)
self.numstreams += 1
ax = self.ax
axname = self.axname
# axc = self.axc
bot, top = ax.get_ylim()
data = None
if len(self.loaded_variables) > 0:
for f in self.loaded_variables:
if filename == f[0]:
data = f[1]
break
if data is None:
data = self.load_matfile(filename)
self.loaded_variables.append((filename, data))
# else:
# print("%s already loaded" % filename)
if len(data) > 0:
if "/event" in filename:
data = self.event2cevent(data)
if "/cont_" in filename:
self.draw_cont(data, top)
else:
data = self.cstream2cevent(data)
rects = self.draw_rects(data, top)
if bot < 0:
ax.set_ylim(bottom=0, top=10.5)
axname.set_ylim(bottom=0, top=10.5)
top = 10.5
else:
ax.set_ylim(top=top + 10.5)
axname.set_ylim(top=top + 10.5)
top = top + 10.5
box = axname.add_patch(
pat.Rectangle((0, top - 10.5),
1,
10,
color=self.label_colors[self.numstreams % 2]))
filenamesplit = filename.split('/')
text = axname.text(0, top - 6.5, filenamesplit[-1])
self.boxes_and_labels.append((box, filename))
def update_axes(self, xlim1, xlim2):
width = self.xmax - self.xmin
newleft = xlim1 * width + self.xmin
newright = xlim2 * width + self.xmin
self.ax.set_xlim(left=newleft, right=newright)
self.mainplot_axes_fun(newleft, newright)
self.ax.figure.canvas.draw()
def get_axes(self):
return self.ax.get_xlim()
def __init__(self, master):
Toplevel.__init__(self)
self.sizex = 570
self.sizey = 700
# position window next to main window
self.geometry('{0}x{1}+{2}+{3}'.format(self.sizex, self.sizey, master.sizex+20, 0))
self.master = master
# self.title("Filterer [{}]".format(master.filename))
self.minsize(self.sizex, self.sizey)
# self.resizable(0,0)
f = self.matplt()
canvas = FigureCanvasTkAgg(f, master=self)
canvas.show()
canvas.get_tk_widget().grid(row=0, columnspan=3, sticky="nsew")#(side=TOP, fill=BOTH, expand=1)
canvas.mpl_connect('motion_notify_event', self.mouse_plotclick)
group = LabelFrame(self, text='lambda/theta filtering')
group.grid(row=1, column=0, sticky='nsew')
w = Label(group, text='lambda')
w.pack()
self.lam_check = IntVar()
w = Checkbutton(group, text='active', variable=self.lam_check)
w.pack()
self.scale_lam = Scale(group, from_=0, to=200, orient=HORIZONTAL, length=150)
self.scale_lam.set(0)
self.scale_lam.pack()
w = Label(group, text='theta')
w.pack()
self.theta_check = IntVar()
w = Checkbutton(group, text='active', variable=self.theta_check)
w.pack()
self.scale_theta = Scale(group, from_=0, to=180, resolution=1, orient=HORIZONTAL, length=150)
self.scale_theta.set(0)
self.scale_theta.pack()
group = LabelFrame(self, text='normal map')
group.grid(row=1, column=1, sticky='nsew')
self.normalmap_var = StringVar()
self.normalmap_var.set("none")
w = OptionMenu(group, self.normalmap_var, "none", "lfs", "theta", "radius", "lambda")
w.pack()
w.bind("<ButtonRelease-1>", self.draw_normal_map)
group = LabelFrame(self, text='thetacon noise')
group.grid(row=1, column=2, sticky='nsew')
self.thetacon_check = IntVar()
w = Checkbutton(group, text='active', variable=self.thetacon_check)
w.pack()
self.scale_thetacon_absmin = Scale(group, from_=0, to=180, resolution=1, orient=VERTICAL, length=120)
self.scale_thetacon_absmin.set(26)
self.scale_thetacon_absmin.pack(side=LEFT)
self.scale_thetacon_min = Scale(group, from_=0, to=180, resolution=1, orient=VERTICAL, length=120)
self.scale_thetacon_min.set(37)
self.scale_thetacon_min.pack(side=LEFT)
self.scale_thetacon_delta = Scale(group, from_=0, to=180, resolution=1, orient=VERTICAL, length=120)
self.scale_thetacon_delta.set(45)
self.scale_thetacon_delta.pack(side=LEFT)
group = LabelFrame(self, text='lfs decimation')
group.grid(row=3, column=0, sticky='nsew')
w = Button(group, text='Show', command=self.draw_decimate_lfs )
w.pack()
self.scale_epsilon = Scale(group, from_=0, to=1, resolution=.02, orient=HORIZONTAL, length=150)
self.scale_epsilon.set(0.4)
self.scale_epsilon.pack()
group = LabelFrame(self, text='ballco decimation')
group.grid(row=3, column=1, sticky='nsew')
w = Button(group, text='Show', command=self.draw_decimate_ballco )
w.pack()
self.scale_ballco_xi = Scale(group, from_=0, to=1, resolution=.01, orient=HORIZONTAL, length=150)
self.scale_ballco_xi.set(0.1)
self.scale_ballco_xi.pack()
self.ballco_k = Spinbox(group, from_=1, to=15)
self.ballco_k.pack()
group = LabelFrame(self, text='radiuscon noise')
group.grid(row=3, column=2, sticky='nsew')
self.radiuscon_check = IntVar()
w = Checkbutton(group, text='active', variable=self.radiuscon_check)
w.pack()
self.scale_radiuscon_alpha = Scale(group, from_=0, to=1, resolution=.01, orient=HORIZONTAL, length=150)
self.scale_radiuscon_alpha.set(0.7)
self.scale_radiuscon_alpha.pack()
self.radiuscon_k = Spinbox(group, from_=1, to=15)
self.radiuscon_k.pack()
self.rowconfigure(0, weight=1)
self.rowconfigure(1, weight=0)
self.rowconfigure(2, weight=0)
self.columnconfigure(0, weight=1, minsize=self.sizex/3)
self.columnconfigure(1, weight=1, minsize=self.sizex/3)
self.columnconfigure(2, weight=1, minsize=self.sizex/3)
self.bind('q', master.exit)
self.bind('s', master.spawn_shrinkhistapp)
self.bind("<ButtonRelease-1>", self.highlight_points)#self.click_draw)
class Layout(object):
def __init__(self, root, title, size=5):
fig = Figure(figsize=(7, 7), dpi=100)
self.weights = None
self.has_been_trained = False
self.ax = fig.add_subplot(111)
self.ax.set_title(title)
# Makes the plot fixed (prevents from resizing)
self.ax.set(xlim=(-size, size), ylim=(-size, size))
# Adds guide lines
self.ax.axhline(y=0, color="black")
self.ax.axvline(x=0, color="black")
# Draw arrow points
self.ax.scatter(0, size - .1, marker='^', color='black')
self.ax.scatter(size - .1, 0, marker='>', color='black')
self.ax.scatter(0, -size + .1, marker='v', color='black')
self.ax.scatter(-size + .1, 0, marker='<', color='black')
# Connect the plot with the GUI interface
self.canvas = FigureCanvasTkAgg(fig, master=root)
self.canvas.draw()
self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
self.canvas.mpl_connect("button_press_event", self.on_click)
toolbar = NavigationToolbar2Tk(self.canvas, root)
toolbar.update()
self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
# Left click -> Class with 0s
# Right click -> Class with 1s
def on_click(self, event):
ix, iy = event.xdata, event.ydata
if (self.has_been_trained):
point = {'coord': None, 'class': None, 'color': 'red'}
point['coord'] = [-1, round(ix, 2), round(iy, 2)]
point['class'] = 0
if (np.dot(self.weights, np.array(point['coord'])) >= 0):
point['class'] = 1
point['color'] = 'green'
self.ax.scatter(point['coord'][1],
point['coord'][2],
color=point['color'])
self.ax.annotate('Class {}'.format(point['class']),
(point['coord'][1] + .5, point['coord'][2]))
self.canvas.draw() # Refreshes the canvas
else:
if (ix != None):
point = {'coord': None, 'expected': None}
color = 'orange'
point['expected'] = 0
if (event.button == 3):
point['expected'] = 1
color = 'purple'
# The round operation on the coords is to prevent a slow convergence of the algorithm,
# the plot detects a very precise coord of almost 10 decimal places and it is harder for
# the algorithm to process those values
point['coord'] = [-1, round(ix, 2), round(iy, 2)]
self.ax.scatter(point['coord'][1],
point['coord'][2],
color=color)
self.canvas.draw() # Refreshes the canvas
# Open the file, then read it to append new points in active session
with open('bulk_data.json', 'r+') as file:
data = json.load(file)
data.append(point)
file.seek(0)
json.dump(data, file)
class gui(tk.Frame):
##### Standard Data ####################################################
open_times = [list(t / 2 for t in range(h[0], h[1])) for h in open_hours]
day_abbr = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")
day_index = 0
##### Button Functions #################################################
def check_escape(self, event):
if event.keysym == "Escape":
self.master.quit()
self.master.destroy()
def set_day(self, diff):
self.day_index = (self.day_index + diff) % 7
self.label_day.configure(text=self.day_abbr[self.day_index])
self.plot_figure()
def recalculate(self):
if sum(self.weeks_selected) == 0:
mbox.showwarning("No Weeks Selected",
"Please select at least 1 week")
return
self.week_switches = [i for i in self.weeks_selected]
self.rewrite_weeks()
self.waitscreen_start()
self.update()
self.calculate_data()
self.plot_figure()
self.waitscreen_stop()
self.update()
def save_weeks(self):
savefile = data("saved_weeks.csv")
str_data = [str(c) for c in self.weeks_selected]
save_data = ",".join(str_data)
with open(savefile, "w") as f:
f.write(save_data)
def load_weeks(self):
loadfile = data("saved_weeks.csv")
if not os.path.isfile(loadfile):
default_file = data("term_weeks.csv")
if os.path.isfile(default_file):
with open(default_file, "r") as f:
weeks_str = f.read().split(",")
else:
mbox.showwarning("ERROR", "No 'term_dates.csv' file exists")
return
else:
with open(loadfile, "r") as f:
weeks_str = f.read().split(",")
weeks_int = [int(i) for i in weeks_str]
self.weeks_selected = weeks_int
self.rewrite_weeks()
def reset(self):
loadfile = data("term_weeks.csv")
if not os.path.isfile(loadfile):
print(loadfile)
mbox.showwarning("ERROR", "No 'term_dates.csv' file exists")
return
else:
with open(loadfile, "r") as f:
weeks_str = f.read().split(",")
weeks_int = [int(i) for i in weeks_str]
self.weeks_selected = weeks_int
self.rewrite_weeks()
def restart_and_update(self):
result = mbox.askyesno("Update",
"Restart program and update database?")
if not result:
return
args = sys.argv
if not (any(x in ("--update", "-u") for x in args)):
args.append("-u")
try:
p = psutil.Process(os.getpid())
for handler in p.open_files() + p.connections():
os.close(handler.fd)
except Exception as e:
pass
#logging.error(e)
python = sys.executable
os.execl(python, python, *args)
def update_database(self):
self.waitscreen_start()
self.gc.update_from_aws()
self.get_week_starts()
self.rewrite_weeks()
self.update()
self.calculate_data()
self.plot_figure()
self.waitscreen_stop()
self.update()
# End waitscreen
def hover(self, event):
if event.inaxes == self.ax:
self.show_value(event)
def mouse_leave_plot(self, event):
self.show_value(None)
def week_select(self, widget, single):
index = widget.curselection()[0]
if single:
for i in range(len(self.weeks_selected)):
self.weeks_selected[i] = 0
self.weeks_selected[index] = 1
else:
index = widget.curselection()[0]
if self.weeks_selected[index] == 0:
self.weeks_selected[index] = 1
else:
self.weeks_selected[index] = 0
self.rewrite_weeks()
##### Follow-up Functions ##############################################
def rewrite_weeks(self):
lb = self.lb_weeks
lb.delete(0, "end")
for i in range(len(self.week_starts)):
text = self.week_starts[i]
if self.week_switches[i] == 0:
lb.insert("end", strikethrough(text))
else:
lb.insert("end", text)
if self.weeks_selected[i] == 0:
lb.itemconfig("end", foreground="#999999")
def show_value(self, event):
if event == None:
self.label_values.configure(text="")
self.label_mousepos.configure(text="")
return
# Find the appropriate x_value:
x, y = event.xdata, event.ydata
time_pos = round(x * 2) / 2.
# Get index of time position
try:
time_index = self.open_times[self.day_index].index(time_pos)
# value = round(self.data[self.day_index][time_index],1)
value = round(self.errors[self.day_index][time_index], 1)
except ValueError:
value = 0
hours = str(int(time_pos))
hours = hours if (len(hours) == 2) else "0" + hours
minutes = "30" if (time_pos % 1 == 0.5) else "00"
self.label_values.configure(text="{} {}:{} = {}%".format(\
day_names[self.day_index], hours, minutes, value))
# Show relative mouse position, for evaluating lines and such
self.label_mousepos.configure(text="t={}; y={}%".format(\
round(x,1), round(y,1)))
##### Drawing / Positioning ############################################
def position(self):
# Base Frames
self.f1 = tk.Frame(self)
self.f2 = tk.Frame(self, bg="#ffffff")
self.f3 = tk.Frame(self)
self.f4 = tk.Frame(self)
self.f1.rowconfigure(1, weight=1)
self.f4.columnconfigure(1, minsize=50)
self.f2.rowconfigure(0, weight=1)
self.f1.grid(row=0, column=0, sticky=tk.N + tk.W + tk.S + tk.E)
self.f2.grid(row=0, column=1)
self.f3.grid(row=1, column=0)
self.f4.grid(row=1, column=1)
# Frame 1
self.label_select_weeks = tk.Label(master=self.f1,
text="Selected Weeks:")
self.label_select_weeks.grid(row=0, sticky=tk.W)
self.lb_weeks = tk.Listbox(master=self.f1, selectmode="SINGLE")
self.lb_weeks.grid(row=1, sticky=tk.N + tk.W + tk.S + tk.E)
self.lb_weeks_mc = listboxControl(self.lb_weeks, self)
self.rewrite_weeks()
self.f5 = tk.Frame(master=self.f1)
self.f5.grid(row=2)
self.button_save = tk.Button(master=self.f5, text="Save", \
command=self.save_weeks)
self.button_save.pack(side=tk.LEFT)
self.button_load = tk.Button(master=self.f5, text="Load", \
command=self.load_weeks)
self.button_load.pack(side=tk.LEFT)
self.button_load = tk.Button(master=self.f5, text="Reset", \
command=self.reset)
self.button_load.pack(side=tk.RIGHT)
# Frame 2
self.fig = Figure(figsize=(5, 4), dpi=100)
self.ax = self.fig.add_subplot(111)
self.canvas = FigureCanvasTkAgg(self.fig, master=self.f2)
self.canvas.draw()
self.canvas.get_tk_widget().grid(row=0,
sticky=tk.N + tk.W + tk.S + tk.E)
self.plot_figure()
self.canvas.mpl_connect("motion_notify_event", self.hover)
self.canvas.mpl_connect("axes_leave_event", self.mouse_leave_plot)
self.label_values = tk.Label(master=self.f2, text="", bg="#ffffff")
self.label_values.grid(row=1, sticky=tk.W)
self.label_mousepos = tk.Label(master=self.f2,
text="",
fg="#777777",
bg="#ffffff")
self.label_mousepos.grid(row=2, sticky=tk.W)
# Frame 3
self.button_recalc = tk.Button(master=self.f3, text="Recalculate", \
command=self.recalculate)
self.button_recalc.pack(side=tk.LEFT)
self.button_update = tk.Button(master=self.f3, text="UPDATE", \
command=self.update_database)
self.button_update.pack(side=tk.LEFT)
# Frame 4
self.button_back = tk.Button(master=self.f4, text="<", \
command=lambda : self.set_day(-1))
self.button_back.grid(row=0, column=0)
self.label_day = tk.Label(master=self.f4, text="day_goes_here")
self.label_day.grid(row=0, column=1)
self.button_forward = tk.Button(master=self.f4, text=">", \
command=lambda : self.set_day(1))
self.button_forward.grid(row=0, column=2)
# Set positions
self.grid()
def waitscreen_start(self):
self.waiting = True
canvas = self.canvas.get_tk_widget()
width, height = canvas.winfo_width(), canvas.winfo_height()
self.waitscreen = tk.Canvas(width=width, height=height, master=self.f2)
self.waitscreen.create_rectangle(5, 5, width - 5, height - 5)
self.waitscreen.create_text(width/2,height/2, \
text="Recalculating...")
canvas.grid_forget()
self.waitscreen.grid(row=0, sticky=tk.N + tk.W + tk.S + tk.E)
def waitscreen_stop(self):
self.waiting = False
canvas = self.canvas.get_tk_widget()
self.waitscreen.grid_forget()
canvas.grid(row=0, sticky=tk.N + tk.W + tk.S + tk.E)
##### Plotting #########################################################
def plot_figure(self):
self.figure_type = 4
if self.figure_type == 1:
self.plot_figure1()
elif self.figure_type == 2:
self.plot_figure2()
elif self.figure_type == 3:
self.plot_figure3()
elif self.figure_type == 4:
self.plot_figure4()
def plot_figure1(self):
# Original Plot
i = self.day_index
self.ax.cla()
self.barplot = self.ax.bar(self.open_times[i], self.data[i], width=0.4)
self.ax.set_title("{} - Mean={}%".format(day_names[i], \
round(mean(self.data[i]),1)))
self.ax.set_xlim([6, 23.5])
max_value = 5 * (round(max(map(max, self.data)) / 5) + 1)
total_mean = mean(map(mean, self.data))
self.ax.set_ylim([0, max_value])
self.ax.xaxis.set_ticks(list(range(6, 24)))
self.ax.axhline(y=mean(self.data[i]))
self.ax.axhline(y=total_mean, alpha=0.2, color="#ff0000")
self.canvas.draw()
def plot_figure2(self):
# Original Plot plus standard error bars
i = self.day_index
self.ax.cla()
self.barplot = self.ax.bar(self.open_times[i],self.data[i], \
yerr=self.errors[i],width=0.4)
self.ax.set_title("{} - Mean={}%".format(day_names[i], \
round(mean(self.data[i]),1)))
self.ax.set_xlim([6, 23.5])
max_value = 5 * (round(max(map(max, self.data)) / 5) + 1)
total_mean = mean(map(mean, self.data))
self.ax.set_ylim([0, max_value])
self.ax.xaxis.set_ticks(list(range(6, 24)))
self.ax.axhline(y=mean(self.data[i]))
self.ax.axhline(y=total_mean, alpha=0.2, color="#ff0000")
self.canvas.draw()
def plot_figure3(self):
# Envelope Line Plot
i = self.day_index
self.ax.cla()
self.lineplot = self.ax.plot(self.open_times[i],
self.data[i],
color="gray")
self.ax.set_title("{} - Mean={}%".format(day_names[i], \
round(mean(self.data[i]),1)))
self.ax.set_xlim([6, 23.5])
bottom_line = [
self.data[i][x] - self.errors[i][x]
for x in range(len(self.open_times[i]))
]
top_line = [
self.data[i][x] + self.errors[i][x]
for x in range(len(self.open_times[i]))
]
self.ax.fill_between(self.open_times[i],bottom_line,\
top_line, color="gray",alpha=0.2)
max_value = 5 * (round(max(map(max, self.data)) / 5) + 1)
total_mean = mean(map(mean, self.data))
self.ax.set_ylim([0, max_value])
self.ax.xaxis.set_ticks(list(range(6, 24)))
self.ax.axhline(y=mean(self.data[i]))
self.ax.axhline(y=total_mean, alpha=0.2, color="#ff0000")
self.canvas.draw()
def plot_figure4(self):
# Original plot with custom error bars
i = self.day_index
self.ax.cla()
self.barplot = self.ax.bar(self.open_times[i], self.data[i], width=0.4)
elevation = [
self.data[i][x] - self.errors[i][x] / 2
for x in range(len(self.data[i]))
]
self.errplot = self.ax.bar(self.open_times[i],self.errors[i],\
bottom=elevation,width=0.4,alpha=0.3,color="red")
self.ax.set_title("{} - Mean={}%".format(day_names[i], \
round(mean(self.data[i]),1)))
self.ax.set_xlim([6, 23.5])
max_value = 5 * (round(max(map(max, self.data)) / 5) + 1)
total_mean = mean(map(mean, self.data))
self.ax.set_ylim([0, 100])
self.ax.xaxis.set_ticks(list(range(6, 24)))
self.ax.axhline(y=mean(self.data[i]))
self.ax.axhline(y=total_mean, alpha=0.2, color="green")
self.canvas.draw()
##### Calculation Functions ############################################
def get_week_starts(self):
dates = self.gc.get_uniques("date, day", "date")
for d in dates:
if d[1] == "Monday":
start_date = date(d[0]).value
break
for d in reversed(dates):
if d[1] == "Sunday":
end_date = date(d[0]).value
break
qprint("Data ranges from {} to {}".format(start_date, end_date))
temp_date = start_date
week_starts = []
while True:
week_starts.append(str(date(temp_date)))
temp_date += datetime.timedelta(days=7)
if temp_date > end_date:
break
self.week_starts = week_starts
for fpath in ("saved_weeks.csv", "term_weeks.csv"):
loadfile = data(fpath)
if os.path.isfile(loadfile):
with open(loadfile, "r") as f:
weeks_str = f.read().split(",")
break
try:
self.week_switches = [int(i) for i in weeks_str]
if len(self.week_switches) < len(week_starts):
self.week_switches += [0] * (len(week_starts) -
len(self.week_switches))
except Error as e:
qprint("ERROR: Neither saved_weeks.csv or term_weeks.csv found!")
self.week_switches = [1 for _ in week_starts]
self.weeks_selected = [i for i in self.week_switches]
def calculate_data(self):
data = []
errors = []
for d in range(7):
day_values = []
day_errors = []
for t in self.open_times[d]:
time_values = []
for i in range(len(self.week_starts)):
if self.week_switches[i] == 0:
continue
w_start = date(self.week_starts[i]).value
w_end = w_start + datetime.timedelta(days=6)
com1 = "SELECT value FROM gymchecker WHERE date BETWEEN {} AND {} ".format(\
int(date(w_start)), int(date(w_end)))
com2 = "AND time={} AND day='{}'".format(t, day_names[d])
results = self.gc.x(com1 + com2)
if len(results) > 0:
time_values.append(results[0][0])
# else:
# print("ERROR: {}; {}{}".format(results,com1,com2))
total = mean(time_values)
sd = stdev(time_values)
day_values.append(total)
day_errors.append(sd)
data.append(day_values)
errors.append(day_errors)
self.data = data
self.errors = errors
##### init function ####################################################
def __init__(self, master, gc):
self.gc = gc
tk.Frame.__init__(self, master)
master.bind("<KeyPress>", self.check_escape)
self.get_week_starts()
self.calculate_data()
self.position()
self.set_day(0)
class wishbone_gui(tk.Tk):
def __init__(self, parent):
tk.Tk.__init__(self, parent)
self.parent = parent
self.initialize()
def initialize(self):
self.grid()
self.vals = None
self.currentPlot = None
#set up menu bar
self.menubar = tk.Menu(self)
self.fileMenu = tk.Menu(self.menubar, tearoff=0)
self.menubar.add_cascade(label="File", menu=self.fileMenu)
self.fileMenu.add_command(label="Load data", command=self.loadData)
self.fileMenu.add_command(label="Save data",
state='disabled',
command=self.saveData)
self.fileMenu.add_command(label="Exit Wishbone", command=self.quitWB)
self.analysisMenu = tk.Menu(self.menubar, tearoff=0)
self.menubar.add_cascade(label="Analysis", menu=self.analysisMenu)
self.analysisMenu.add_command(label="Principal component analysis",
state='disabled',
command=self.runPCA)
self.analysisMenu.add_command(label="tSNE",
state='disabled',
command=self.runTSNE)
self.analysisMenu.add_command(label="Diffusion map",
state='disabled',
command=self.runDM)
self.analysisMenu.add_command(label="GSEA",
state='disabled',
command=self.runGSEA)
self.analysisMenu.add_command(label="Wishbone",
state='disabled',
command=self.runWishbone)
self.visMenu = tk.Menu(self.menubar, tearoff=0)
self.menubar.add_cascade(label="Visualization", menu=self.visMenu)
self.visMenu.add_command(label="Principal component analysis",
state='disabled',
command=self.plotPCA)
self.visMenu.add_command(label="tSNE",
state='disabled',
command=self.plotTSNE)
self.visMenu.add_command(label="Diffusion map",
state='disabled',
command=self.plotDM)
self.visMenu.add_command(label="GSEA Results",
state='disabled',
command=self.showGSEAResults)
self.wishboneMenu = tk.Menu(self)
self.visMenu.add_cascade(label="Wishbone", menu=self.wishboneMenu)
self.wishboneMenu.add_command(label="On tSNE",
state='disabled',
command=self.plotWBOnTsne)
self.wishboneMenu.add_command(label="Marker trajectory",
state='disabled',
command=self.plotWBMarkerTrajectory)
self.wishboneMenu.add_command(label="Heat map",
state='disabled',
command=self.plotWBHeatMap)
self.visMenu.add_command(label="Gene expression",
state='disabled',
command=self.plotGeneExpOntSNE)
self.visMenu.add_command(label="Set gate",
state='disabled',
command=self.setGate)
self.config(menu=self.menubar)
#intro screen
tk.Label(self,
text=u"Wishbone",
font=('Helvetica', 48),
fg="black",
bg="white",
padx=100,
pady=50).grid(row=0)
tk.Label(
self,
text=
u"To get started, select a data file by clicking File > Load Data",
fg="black",
bg="white",
padx=100,
pady=25).grid(row=1)
#update
self.protocol('WM_DELETE_WINDOW', self.quitWB)
self.grid_columnconfigure(0, weight=1)
self.resizable(True, True)
self.update()
self.geometry(self.geometry())
self.focus_force()
def loadData(self):
self.dataFileName = filedialog.askopenfilename(
title='Load data file', initialdir='~/.wishbone/data')
if (self.dataFileName != ""):
#pop up data options menu
self.fileInfo = tk.Toplevel()
self.fileInfo.title("Data options")
tk.Label(self.fileInfo, text=u"File name: ").grid(column=0, row=0)
tk.Label(self.fileInfo,
text=self.dataFileName.split('/')[-1]).grid(column=1,
row=0)
tk.Label(self.fileInfo, text=u"Name:", fg="black",
bg="white").grid(column=0, row=1)
self.fileNameEntryVar = tk.StringVar()
tk.Entry(self.fileInfo,
textvariable=self.fileNameEntryVar).grid(column=1, row=1)
if self.dataFileName.split('.')[len(self.dataFileName.split('.')) -
1] == 'fcs':
tk.Label(self.fileInfo,
text=u"Cofactor:",
fg="black",
bg="white").grid(column=0, row=2)
self.cofactorVar = tk.IntVar()
self.cofactorVar.set(5)
tk.Entry(self.fileInfo,
textvariable=self.cofactorVar).grid(column=1, row=2)
elif self.dataFileName.split('.')[len(self.dataFileName.split('.'))
- 1] == 'csv':
self.normalizeVar = tk.BooleanVar()
tk.Checkbutton(self.fileInfo,
text=u"Normalize",
variable=self.normalizeVar).grid(column=0,
row=2,
columnspan=2)
tk.Label(
self.fileInfo,
text=
u"The normalize parameter is used for correcting for library size among cells."
).grid(column=0, row=3, columnspan=2)
tk.Button(self.fileInfo,
text="Cancel",
command=self.fileInfo.destroy).grid(column=0, row=4)
tk.Button(self.fileInfo, text="Load",
command=self.processData).grid(column=1, row=4)
self.wait_window(self.fileInfo)
def processData(self):
#clear intro screen
for item in self.grid_slaves():
item.grid_forget()
#display file name
tk.Label(self,
text=u"File name: " + self.fileNameEntryVar.get(),
fg="black",
bg="white").grid(column=0, row=0)
#set up canvas for plots
self.fig, self.ax = wishbone.wb.get_fig()
self.canvas = FigureCanvasTkAgg(self.fig, self)
self.canvas.show()
self.canvas.get_tk_widget().grid(column=1,
row=1,
rowspan=10,
columnspan=4,
sticky='NSEW')
tk.Label(self, text=u"Visualizations:", fg='black',
bg='white').grid(column=0, row=1)
#load data based on input type
if self.dataFileName.split('.')[len(self.dataFileName.split('.')) -
1] == 'fcs': # mass cytometry data
self.scdata = wishbone.wb.SCData.from_fcs(
os.path.expanduser(self.dataFileName),
cofactor=self.cofactorVar.get())
self.wb = None
elif self.dataFileName.split('.')[len(self.dataFileName.split('.')) -
1] == 'csv': # sc-seq data
self.scdata = wishbone.wb.SCData.from_csv(
os.path.expanduser(self.dataFileName),
data_type='sc-seq',
normalize=self.normalizeVar.get())
self.wb = None
else:
self.wb = wishbone.wb.Wishbone.load(self.dataFileName)
self.scdata = self.wb.scdata
#set up buttons based on data type
if self.scdata.data_type == 'sc-seq':
self.PCAButton = tk.Button(self,
text=u"PCA",
state='disabled',
command=self.plotPCA)
self.PCAButton.grid(column=0, row=2)
self.tSNEButton = tk.Button(self,
text=u"tSNE",
state='disabled',
command=self.plotTSNE)
self.tSNEButton.grid(column=0, row=3)
self.DMButton = tk.Button(self,
text=u"Diffusion map",
state='disabled',
command=self.plotDM)
self.DMButton.grid(column=0, row=4)
self.GSEAButton = tk.Button(self,
text=u"GSEA Results",
state='disabled',
command=self.showGSEAResults)
self.GSEAButton.grid(column=0, row=5)
self.WBButton = tk.Button(self,
text=u"Wishbone",
state='disabled',
command=self.plotWBOnTsne)
self.WBButton.grid(column=0, row=6)
self.geneExpButton = tk.Button(self,
text=u"Gene expression",
state='disabled',
command=self.plotGeneExpOntSNE)
self.geneExpButton.grid(column=0, row=7)
self.setGateButton = tk.Button(self,
text=u"Set gate",
state='disabled',
command=self.setGate)
self.setGateButton.grid(column=0, row=8)
self.saveButton = tk.Button(self,
text=u"Save plot",
state='disabled',
command=self.savePlot)
self.saveButton.grid(column=4, row=0)
self.diff_component = tk.StringVar()
self.diff_component.set('Component 1')
self.component_menu = tk.OptionMenu(self, self.diff_component,
'Component 1', 'Component 2',
'Component 3', 'Component 4',
'Component 5', 'Component 6',
'Component 7', 'Component 8',
'Component 9')
self.component_menu.config(state='disabled')
self.component_menu.grid(row=0, column=2)
self.updateButton = tk.Button(self,
text=u"Update component",
command=self.updateComponent,
state='disabled')
self.updateButton.grid(column=3, row=0)
#enable buttons based on current state of scdata object
if self.scdata.pca:
self.analysisMenu.entryconfig(1, state='normal')
self.visMenu.entryconfig(0, state='normal')
self.PCAButton.config(state='normal')
if isinstance(self.scdata.tsne, pd.DataFrame):
self.analysisMenu.entryconfig(2, state='normal')
self.visMenu.entryconfig(1, state='normal')
self.visMenu.entryconfig(5, state='normal')
self.tSNEButton.config(state='normal')
self.geneExpButton.config(state='normal')
if isinstance(self.scdata.diffusion_eigenvectors, pd.DataFrame):
self.analysisMenu.entryconfig(3, state='normal')
self.analysisMenu.entryconfig(4, state='normal')
self.visMenu.entryconfig(2, state='normal')
self.DMButton.config(state='normal')
else:
self.tSNEButton = tk.Button(self,
text=u"tSNE",
state='disabled',
command=self.plotTSNE)
self.tSNEButton.grid(column=0, row=2)
self.DMButton = tk.Button(self,
text=u"Diffusion map",
state='disabled',
command=self.plotDM)
self.DMButton.grid(column=0, row=3)
self.WBButton = tk.Button(self,
text=u"Wishbone",
state='disabled',
command=self.plotWBOnTsne)
self.WBButton.grid(column=0, row=4)
self.geneExpButton = tk.Button(self,
text=u"Gene expression",
state='disabled',
command=self.plotGeneExpOntSNE)
self.geneExpButton.grid(column=0, row=5)
self.setGateButton = tk.Button(self,
text=u"Set gate",
state='disabled',
command=self.setGate)
self.setGateButton.grid(column=0, row=6)
self.saveButton = tk.Button(self,
text=u"Save plot",
state='disabled',
command=self.savePlot)
self.saveButton.grid(column=4, row=0)
self.analysisMenu.delete(0)
self.analysisMenu.delete(2)
self.visMenu.delete(0)
self.visMenu.delete(2)
self.analysisMenu.entryconfig(1, state='normal')
#enable buttons based on current state of scdata object
if isinstance(self.scdata.tsne, pd.DataFrame):
self.visMenu.entryconfig(0, state='normal')
self.visMenu.entryconfig(3, state='normal')
self.tSNEButton.config(state='normal')
self.geneExpButton.config(state='normal')
if isinstance(self.scdata.diffusion_eigenvectors, pd.DataFrame):
self.analysisMenu.entryconfig(2, state='normal')
self.visMenu.entryconfig(1, state='normal')
self.DMButton.config(state='normal')
#enable buttons
self.analysisMenu.entryconfig(0, state='normal')
self.fileMenu.entryconfig(1, state='normal')
if self.wb:
if isinstance(self.wb.trajectory, pd.Series):
self.wishboneMenu.entryconfig(0, state='normal')
self.wishboneMenu.entryconfig(1, state='normal')
self.wishboneMenu.entryconfig(2, state='normal')
self.WBButton.config(state='normal')
#get genes
self.genes = self.scdata.data.columns.values
self.gates = {}
self.geometry('800x550')
#destroy pop up menu
self.fileInfo.destroy()
def saveData(self):
pickleFileName = filedialog.asksaveasfilename(
title='Save Wishbone Data',
defaultextension='.p',
initialfile=self.fileNameEntryVar.get())
if pickleFileName != None:
if self.wb != None:
self.wb.save(pickleFileName)
else:
self.scdata.save_as_wishbone(pickleFileName)
def runPCA(self):
self.scdata.run_pca()
#enable buttons
self.analysisMenu.entryconfig(1, state='normal')
self.visMenu.entryconfig(0, state='normal')
self.PCAButton.config(state='normal')
def runTSNE(self):
#pop up for # components
self.tsneOptions = tk.Toplevel()
self.tsneOptions.title("tSNE options")
if self.scdata.data_type == 'sc-seq':
tk.Label(self.tsneOptions,
text=u"Number of components:",
fg="black",
bg="white").grid(column=0, row=0)
self.nCompVar = tk.IntVar()
self.nCompVar.set(15)
tk.Entry(self.tsneOptions,
textvariable=self.nCompVar).grid(column=1, row=0)
tk.Label(self.tsneOptions, text=u"Perplexity:", fg="black",
bg="white").grid(column=0, row=1)
self.perplexityVar = tk.IntVar()
self.perplexityVar.set(30)
tk.Entry(self.tsneOptions,
textvariable=self.perplexityVar).grid(column=1, row=1)
tk.Button(self.tsneOptions, text="Run",
command=self._runTSNE).grid(column=1, row=2)
tk.Button(self.tsneOptions,
text="Cancel",
command=self.tsneOptions.destroy).grid(column=0, row=2)
self.wait_window(self.tsneOptions)
def _runTSNE(self):
if self.scdata.data_type == 'sc-seq':
self.scdata.run_tsne(n_components=self.nCompVar.get(),
perplexity=self.perplexityVar.get())
else:
self.scdata.run_tsne(n_components=None,
perplexity=self.perplexityVar.get())
self.gates = {}
#enable buttons
if self.scdata.data_type == 'sc-seq':
self.analysisMenu.entryconfig(2, state='normal')
self.visMenu.entryconfig(1, state='normal')
self.visMenu.entryconfig(5, state='normal')
else:
self.visMenu.entryconfig(0, state='normal')
self.visMenu.entryconfig(3, state='normal')
self.tSNEButton.config(state='normal')
self.geneExpButton.config(state='normal')
self.tsneOptions.destroy()
def runDM(self):
self.scdata.run_diffusion_map()
#enable buttons
if self.scdata.data_type == 'sc-seq':
self.analysisMenu.entryconfig(3, state='normal')
self.analysisMenu.entryconfig(4, state='normal')
self.visMenu.entryconfig(2, state='normal')
else:
self.analysisMenu.entryconfig(2, state='normal')
self.visMenu.entryconfig(1, state='normal')
self.DMButton.config(state='normal')
def runGSEA(self):
self.GSEAFileName = filedialog.askopenfilename(
title='Select gmt File', initialdir='~/.wishbone/tools')
if self.GSEAFileName != "":
self.scdata.run_diffusion_map_correlations()
self.scdata.data.columns = self.scdata.data.columns.str.upper()
self.outputPrefix = filedialog.asksaveasfilename(
title='Input file prefix for saving output',
initialdir='~/.wishbone/gsea')
if 'mouse' in self.GSEAFileName:
gmt_file_type = 'mouse'
else:
gmt_file_type = 'human'
self.reports = self.scdata.run_gsea(
output_stem=os.path.expanduser(self.outputPrefix),
gmt_file=(gmt_file_type, self.GSEAFileName.split('/')[-1]))
#enable buttons
self.visMenu.entryconfig(3, state='normal')
self.GSEAButton.config(state='normal')
def runWishbone(self):
#popup menu for wishbone options
self.wbOptions = tk.Toplevel()
self.wbOptions.title("Wishbone Options")
#s
tk.Label(self.wbOptions, text=u"Start cell:", fg="black",
bg="white").grid(column=0, row=0)
self.start = tk.StringVar()
tk.Entry(self.wbOptions, textvariable=self.start).grid(column=1, row=0)
if (len(self.gates) > 0):
self.cell_gate = tk.StringVar()
self.cell_gate.set('Use cell gate')
self.gate_menu = tk.OptionMenu(self.wbOptions, self.cell_gate,
*list(self.gates.keys()))
self.gate_menu.grid(row=0, column=2)
#k
tk.Label(self.wbOptions, text=u"k:", fg="black",
bg="white").grid(column=0, row=1)
self.k = tk.IntVar()
tk.Entry(self.wbOptions, textvariable=self.k).grid(column=1, row=1)
self.k.set(15)
#components list
tk.Label(self.wbOptions,
text=u"Components list:",
fg='black',
bg='white').grid(column=0, row=2)
self.compList = tk.StringVar()
tk.Entry(self.wbOptions, textvariable=self.compList).grid(column=1,
row=2)
self.compList.set("1, 2, 3")
#num waypoints
tk.Label(self.wbOptions,
text=u"Number of waypoints:",
fg='black',
bg='white').grid(column=0, row=3)
self.numWaypoints = tk.IntVar()
tk.Entry(self.wbOptions, textvariable=self.numWaypoints).grid(column=1,
row=3)
self.numWaypoints.set(250)
#branch
self.branch = tk.BooleanVar()
self.branch.set(True)
tk.Checkbutton(self.wbOptions, text=u"Branch",
variable=self.branch).grid(column=0,
row=4,
columnspan=2)
tk.Button(self.wbOptions, text="Run",
command=self._runWishbone).grid(column=1, row=5)
tk.Button(self.wbOptions,
text="Cancel",
command=self.wbOptions.destroy).grid(column=0, row=5)
self.wait_window(self.wbOptions)
def _runWishbone(self):
self.wb = wishbone.wb.Wishbone(self.scdata)
if self.cell_gate.get() == 'Use cell gate':
self.wb.run_wishbone(start_cell=self.start.get(),
k=self.k.get(),
components_list=[
int(comp)
for comp in self.compList.get().split(',')
],
num_waypoints=self.numWaypoints.get(),
branch=self.branch.get())
else:
#randomly select start cell in gate
print('Using cell gate:')
print(self.cell_gate.get())
start_cell = random.sample(list(self.gates[self.cell_gate.get()]),
1)[0]
print(start_cell)
self.wb.run_wishbone(start_cell=start_cell,
k=self.k.get(),
components_list=[
int(comp)
for comp in self.compList.get().split(',')
],
num_waypoints=self.numWaypoints.get(),
branch=self.branch.get())
#enable buttons
self.wishboneMenu.entryconfig(0, state='normal')
self.wishboneMenu.entryconfig(1, state='normal')
self.wishboneMenu.entryconfig(2, state='normal')
self.WBButton.config(state='normal')
self.wbOptions.destroy()
def plotPCA(self):
self.saveButton.config(state='normal')
self.setGateButton.config(state='disabled')
if self.scdata.data_type == 'sc-seq':
self.component_menu.config(state='disabled')
self.updateButton.config(state='disabled')
self.visMenu.entryconfig(6, state='disabled')
else:
self.visMenu.entryconfig(4, state='disabled')
#pop up for # components
self.PCAOptions = tk.Toplevel()
self.PCAOptions.title("PCA Plot Options")
tk.Label(self.PCAOptions,
text=u"Max variance explained (ylim):",
fg="black",
bg="white").grid(column=0, row=0)
self.yLimVar = tk.DoubleVar()
self.yLimVar.set(round(self.scdata.pca['eigenvalues'][0][0], 2))
tk.Entry(self.PCAOptions, textvariable=self.yLimVar).grid(column=1,
row=0)
tk.Label(self.PCAOptions,
text=u"Number of components:",
fg='black',
bg='white').grid(column=0, row=1)
self.compVar = tk.IntVar()
self.compVar.set(15)
tk.Entry(self.PCAOptions, textvariable=self.compVar).grid(column=1,
row=1)
tk.Button(self.PCAOptions, text="Plot",
command=self._plotPCA).grid(column=1, row=2)
tk.Button(self.PCAOptions,
text="Cancel",
command=self.PCAOptions.destroy).grid(column=0, row=2)
self.wait_window(self.PCAOptions)
def _plotPCA(self):
self.resetCanvas()
self.fig, self.ax = self.scdata.plot_pca_variance_explained(
ylim=(0, self.yLimVar.get()), n_components=self.compVar.get())
self.canvas = FigureCanvasTkAgg(self.fig, self)
self.canvas.show()
self.canvas.get_tk_widget().grid(column=1,
row=1,
rowspan=10,
columnspan=4,
sticky='NW')
self.currentPlot = 'pca'
#enable buttons
self.saveButton.config(state='normal')
self.PCAOptions.destroy()
def plotTSNE(self):
self.saveButton.config(state='normal')
self.setGateButton.config(state='normal')
if self.scdata.data_type == 'sc-seq':
self.component_menu.config(state='disabled')
self.updateButton.config(state='disabled')
self.visMenu.entryconfig(6, state='normal')
else:
self.visMenu.entryconfig(4, state='normal')
self.resetCanvas()
self.fig, self.ax = self.scdata.plot_tsne()
self.canvas = FigureCanvasTkAgg(self.fig, self)
self.canvas.show()
self.canvas.get_tk_widget().grid(column=1,
row=1,
rowspan=10,
columnspan=4,
sticky='NW')
self.currentPlot = 'tsne'
def plotDM(self):
self.saveButton.config(state='normal')
self.setGateButton.config(state='disabled')
if self.scdata.data_type == 'sc-seq':
self.component_menu.config(state='disabled')
self.updateButton.config(state='disabled')
self.visMenu.entryconfig(6, state='disabled')
else:
self.visMenu.entryconfig(4, state='disabled')
self.geometry('950x550')
self.resetCanvas()
self.fig, self.ax = self.scdata.plot_diffusion_components()
self.canvas = FigureCanvasTkAgg(self.fig, self)
self.canvas.show()
self.canvas.get_tk_widget().grid(column=1,
row=1,
rowspan=10,
columnspan=4,
sticky='W')
self.currentPlot = 'dm_components'
def showGSEAResults(self):
self.saveButton.config(state='disabled')
self.component_menu.config(state='normal')
self.updateButton.config(state='normal')
self.setGateButton.config(state='disabled')
self.visMenu.entryconfig(6, state='disabled')
self.resetCanvas()
self.canvas = tk.Canvas(self, width=600, height=300)
self.canvas.grid(column=1, row=1, rowspan=17, columnspan=4)
self.outputText(1)
self.currentPlot = 'GSEA_result_' + self.diff_component.get()
def updateComponent(self):
self.resetCanvas()
self.canvas = tk.Canvas(self, width=600, height=300)
self.canvas.grid(column=1,
row=1,
rowspan=17,
columnspan=4,
sticky='NSEW')
self.outputText(int(self.diff_component.get().split(' ')[-1]))
self.currentPlot = 'GSEA_result_' + self.diff_component.get()
def outputText(self, diff_component):
pos_text = str(self.reports[diff_component]['pos']).split('\n')
pos_text = pos_text[1:len(pos_text) - 1]
pos_text = '\n'.join(pos_text)
neg_text = str(self.reports[diff_component]['neg']).split('\n')
neg_text = neg_text[1:len(neg_text) - 1]
neg_text = '\n'.join(neg_text)
self.canvas.create_text(5,
5,
anchor='nw',
text='Positive correlations:\n\n',
font=('Helvetica', 16, 'bold'))
self.canvas.create_text(5, 50, anchor='nw', text=pos_text)
self.canvas.create_text(5,
150,
anchor='nw',
text='Negative correlations:\n\n',
font=('Helvetica', 16, 'bold'))
self.canvas.create_text(5, 200, anchor='nw', text=neg_text)
def plotWBOnTsne(self):
self.saveButton.config(state='normal')
self.setGateButton.config(state='disabled')
if self.scdata.data_type == 'sc-seq':
self.component_menu.config(state='disabled')
self.updateButton.config(state='disabled')
self.visMenu.entryconfig(6, state='disabled')
else:
self.visMenu.entryconfig(4, state='disabled')
self.resetCanvas()
self.fig, self.ax = self.wb.plot_wishbone_on_tsne()
self.canvas = FigureCanvasTkAgg(self.fig, self)
self.canvas.show()
self.canvas.get_tk_widget().grid(column=1,
row=1,
rowspan=10,
columnspan=4)
self.currentPlot = 'wishbone_on_tsne'
def plotWBMarkerTrajectory(self):
self.getGeneSelection()
if len(self.selectedGenes) < 1:
print('Error: must select at least one gene')
else:
self.saveButton.config(state='normal')
self.setGateButton.config(state='disabled')
if self.scdata.data_type == 'sc-seq':
self.component_menu.config(state='disabled')
self.updateButton.config(state='disabled')
self.visMenu.entryconfig(6, state='disabled')
else:
self.visMenu.entryconfig(4, state='disabled')
self.resetCanvas()
self.vals, self.fig, self.ax = self.wb.plot_marker_trajectory(
self.selectedGenes)
self.fig.set_size_inches(10, 4, forward=True)
self.fig.tight_layout()
self.fig.subplots_adjust(right=0.8)
self.canvas = FigureCanvasTkAgg(self.fig, self)
self.canvas.show()
self.canvas.get_tk_widget().grid(column=1,
row=1,
rowspan=10,
columnspan=5,
sticky='W')
self.currentPlot = 'wishbone_marker_trajectory'
self.geometry('1050x550')
#enable buttons
self.wishboneMenu.entryconfig(2, state='normal')
def plotWBHeatMap(self):
self.getGeneSelection()
if len(self.selectedGenes) < 1:
print('Error: must select at least one gene')
else:
self.saveButton.config(state='normal')
self.setGateButton.config(state='disabled')
if self.scdata.data_type == 'sc-seq':
self.component_menu.config(state='disabled')
self.updateButton.config(state='disabled')
self.visMenu.entryconfig(6, state='disabled')
else:
self.visMenu.entryconfig(4, state='disabled')
self.resetCanvas()
self.vals, self.fig, self.ax = self.wb.plot_marker_trajectory(
self.selectedGenes)
self.fig, self.ax = self.wb.plot_marker_heatmap(self.vals)
self.fig.set_size_inches(10, 4, forward=True)
self.fig.tight_layout()
self.canvas = FigureCanvasTkAgg(self.fig, self)
self.canvas.show()
self.canvas.get_tk_widget().grid(column=1,
row=1,
rowspan=10,
columnspan=5,
sticky='W')
self.currentPlot = 'wishbone_marker_heatmap'
def plotGeneExpOntSNE(self):
self.getGeneSelection()
if len(self.selectedGenes) < 1:
print('Error: must select at least one gene')
else:
self.saveButton.config(state='normal')
self.setGateButton.config(state='disabled')
if self.scdata.data_type == 'sc-seq':
self.component_menu.config(state='disabled')
self.updateButton.config(state='disabled')
self.visMenu.entryconfig(6, state='disabled')
else:
self.visMenu.entryconfig(4, state='disabled')
self.resetCanvas()
self.fig, self.ax = self.scdata.plot_gene_expression(
self.selectedGenes)
self.canvas = FigureCanvasTkAgg(self.fig, self)
self.canvas.show()
self.canvas.get_tk_widget().grid(column=1,
row=1,
rowspan=10,
columnspan=4,
sticky='W')
self.currentPlot = 'gene_expression_tsne'
self.geometry('950x550')
def getGeneSelection(self):
#popup menu to get selected genes
self.geneSelection = tk.Toplevel()
self.geneSelection.title("Select Genes")
tk.Label(self.geneSelection, text=u"Genes:", fg="black",
bg="white").grid(row=0)
self.geneInput = wishbone.autocomplete_entry.AutocompleteEntry(
self.genes.tolist(), self.geneSelection, listboxLength=6)
self.geneInput.grid(row=1)
self.geneInput.bind('<Return>', self.AddToSelected)
self.geneSelectBox = tk.Listbox(self.geneSelection,
selectmode=tk.EXTENDED)
self.geneSelectBox.grid(row=2, rowspan=10)
self.geneSelectBox.bind('<BackSpace>', self.DeleteSelected)
self.selectedGenes = []
tk.Button(self.geneSelection,
text="Use selected genes",
command=self.geneSelection.destroy).grid(row=12)
tk.Button(self.geneSelection,
text="Cancel",
command=self.cancelGeneSelection).grid(row=13)
self.wait_window(self.geneSelection)
def cancelGeneSelection(self):
self.selectedGenes = []
self.geneSelection.destroy()
def AddToSelected(self, event):
self.selectedGenes.append(self.geneInput.get())
self.geneSelectBox.insert(
tk.END, self.selectedGenes[len(self.selectedGenes) - 1])
def DeleteSelected(self, event):
selected = self.geneSelectBox.curselection()
pos = 0
for i in selected:
idx = int(i) - pos
self.geneSelectBox.delete(idx, idx)
self.selectedGenes = self.selectedGenes[:idx] + self.selectedGenes[
idx + 1:]
pos = pos + 1
def savePlot(self):
self.plotFileName = filedialog.asksaveasfilename(
title='Save Plot',
defaultextension='.png',
initialfile=self.fileNameEntryVar.get() + "_" + self.currentPlot)
if self.plotFileName != None:
self.fig.savefig(self.plotFileName)
def setGate(self):
#pop up for gate name
self.gateOptions = tk.Toplevel()
self.gateOptions.title("Create gate for start cells")
tk.Label(self.gateOptions, text=u"Gate name:", fg="black",
bg="white").grid(column=0, row=0)
self.gateName = tk.StringVar()
self.gateName.set('Gate ' + str(len(self.gates) + 1))
tk.Entry(self.gateOptions, textvariable=self.gateName).grid(column=1,
row=0)
tk.Button(self.gateOptions, text="Select gate",
command=self._setGate).grid(column=1, row=1)
tk.Button(self.gateOptions,
text="Cancel",
command=self.gateOptions.destroy).grid(column=0, row=1)
self.wait_window(self.gateOptions)
def _setGate(self):
self.gateOptions.destroy()
self.buttonPress = self.canvas.mpl_connect('button_press_event',
self._startGate)
self.buttonRelease = self.canvas.mpl_connect('button_release_event',
self._endGate)
self.canvas.get_tk_widget().config(cursor='plus')
def _startGate(self, event):
self.start_x = event.xdata
self.start_y = event.ydata
def _endGate(self, event):
#draw gate rectangle
start_x = self.start_x if self.start_x < event.xdata else event.xdata
start_y = self.start_y if self.start_y < event.ydata else event.ydata
width = np.absolute(event.xdata - self.start_x)
height = np.absolute(event.ydata - self.start_y)
rect = Rectangle((start_x, start_y),
width,
height,
fill=False,
ec='black',
alpha=1,
lw=2)
self.ax.add_patch(rect)
self.canvas.draw()
#disable mouse events
self.canvas.mpl_disconnect(self.buttonPress)
self.canvas.mpl_disconnect(self.buttonRelease)
self.canvas.get_tk_widget().config(cursor='arrow')
#save cell gate
gate = Path([[start_x, start_y], [start_x + width, start_y],
[start_x + width, start_y + height],
[start_x, start_y + height], [start_x, start_y]])
gated_cells = self.scdata.tsne.index[gate.contains_points(
self.scdata.tsne)]
self.gates[self.gateName.get()] = gated_cells
#replot tSNE w gate colored
self.fig.clf()
plt.scatter(self.scdata.tsne['x'],
self.scdata.tsne['y'],
s=10,
edgecolors='none',
color='lightgrey')
plt.scatter(self.scdata.tsne.ix[gated_cells, 'x'],
self.scdata.tsne.ix[gated_cells, 'y'],
s=10,
edgecolors='none')
self.canvas.draw()
self.setGateButton.config(state='disabled')
self.visMenu.entryconfig(6, state='disabled')
def resetCanvas(self):
self.fig.clf()
if type(self.canvas) is FigureCanvasTkAgg:
for item in self.canvas.get_tk_widget().find_all():
self.canvas.get_tk_widget().delete(item)
else:
for item in self.canvas.find_all():
self.canvas.delete(item)
def quitWB(self):
self.quit()
self.destroy()
class Viewer(tk.Frame):
def __init__(self, parent, collection=None, with_toolbar=True):
tk.Frame.__init__(self, parent)
# toolbar
if with_toolbar:
self.create_toolbar()
# canvas
#canvas_frame = tk.Frame(self)
#canvas_frame.pack(side=tk.LEFT,fill=tk.BOTH,expand=1)
#title_frame = tk.Frame(canvas_frame)
#title_frame.pack(side=tk.TOP,anchor=tk.NW)
#tk.Label(title_frame,text=" Plot Title: ").pack(side=tk.LEFT)
#self._title = tk.Entry(title_frame,width=30)
#self._title.pack(side=tk.LEFT)
#tk.Button(title_frame, text='Set', command=lambda: self.updateTitle()
# ).pack(side=tk.LEFT)
self.fig = plt.Figure(figsize=(8, 6))
self.ax = self.fig.add_subplot(111)
self.canvas = FigureCanvasTkAgg(self.fig, master=self)
self.setupMouseNavigation()
self.navbar = ToolBar(self.canvas, self,
self.ax) # for matplotlib features
self.setupNavBarExtras(self.navbar)
self.canvas.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH, expand=1)
# spectra list
self.create_listbox()
# toggle options
self.mean = False
self.median = False
self.max = False
self.min = False
self.std = False
self.spectrum_mode = False
self.show_flagged = True
# data
self.collection = collection
self.head = 0
self.flag_filepath = os.path.abspath('./flagged_spectra.txt')
if collection:
self.update_artists(new_lim=True)
self.update_list()
# pack
self.pack(fill=tk.BOTH, expand=1)
self.color = '#000000'
def returnToSelectMode(self):
if self.ax.get_navigate_mode() == 'PAN':
#Turn panning off
self.navbar.pan()
elif self.ax.get_navigate_mode() == 'ZOOM':
#Turn zooming off
self.navbar.zoom()
def setupNavBarExtras(self, navbar):
working_dir = os.path.dirname(os.path.abspath(__file__))
self.select_icon = tk.PhotoImage(
file=os.path.join(working_dir, "select.png"))
self.select_button = tk.Button(navbar,
width="24",
height="24",
image=self.select_icon,
command=self.returnToSelectMode).pack(
side=tk.LEFT, anchor=tk.W)
self.dirLbl = tk.Label(navbar, text="Viewing: None")
self.dirLbl.pack(side=tk.LEFT, anchor=tk.W)
def plotConfig(self):
config = PlotConfigDialog(self,
title=self.ax.get_title(),
xlabel=self.ax.get_xlabel(),
ylabel=self.ax.get_ylabel(),
xlim=self.ax.get_xlim(),
ylim=self.ax.get_ylim())
if (config.applied):
print(config.title)
print(config.xlim)
self.ax.set_title(config.title)
self.ax.set_xlabel(config.xlabel)
self.ax.set_ylabel(config.ylabel)
self.ax.set_xlim(*config.xlim)
self.ax.set_ylim(*config.ylim)
self.canvas.draw()
def rectangleStartEvent(self, event):
self._rect = None
self._rect_start = event
def rectangleMoveEvent(self, event):
try:
dx = event.xdata - self._rect_start.xdata
dy = event.ydata - self._rect_start.ydata
except TypeError:
#we're out of canvas bounds
return
if self._rect is not None:
self._rect.remove()
self._rect = Rectangle(
(self._rect_start.xdata, self._rect_start.ydata),
dx,
dy,
color='k',
ls='--',
lw=1,
fill=False)
self.ax.add_patch(self._rect)
self.ax.draw_artist(self._rect)
def rectangleEndEvent(self, event):
if self._rect is not None:
self._rect.remove()
else:
#make a small, fake rectangle
class FakeEvent(object):
def __init__(self, x, y):
self.xdata, self.ydata = x, y
dy = (self.ax.get_ylim()[1] - self.ax.get_ylim()[0]) / 100.
self._rect_start = FakeEvent(event.xdata - 10, event.ydata + dy)
event = FakeEvent(event.xdata + 10, event.ydata - dy)
if not self.collection is None:
x0 = min(self._rect_start.xdata, event.xdata)
x1 = max(self._rect_start.xdata, event.xdata)
y0 = min(self._rect_start.ydata, event.ydata)
y1 = max(self._rect_start.ydata, event.ydata)
try:
#if our data is sorted, we can easily isolate it
x_data = self.collection.data.loc[x0:x1]
except:
#Pandas builtin throws an error, use another pandas builtin
data = self.collection.data
in_xrange = (data.index >= x0) & (data.index <= x1)
x_data = data.iloc[in_xrange]
ylim = sorted([self._rect_start.ydata, event.ydata])
is_in_box = ((x_data > y0) & (x_data < y1)).any()
highlighted = is_in_box.index[is_in_box].tolist()
key_list = list(self.collection._spectra.keys())
self.update_selected(highlighted)
flags = self.collection.flags
for highlight in highlighted:
#O(n^2) woof
if (not (highlight in flags)) or self.show_flagged:
pos = key_list.index(highlight)
self.listbox.selection_set(pos)
def setupMouseNavigation(self):
self.clicked = False
self.select_mode = 'rectangle'
self._bg_cache = None
START_EVENTS = {'rectangle': self.rectangleStartEvent}
MOVE_EVENTS = {'rectangle': self.rectangleMoveEvent}
END_EVENTS = {'rectangle': self.rectangleEndEvent}
def onMouseDown(event):
if self.ax.get_navigate_mode() is None:
self._bg_cache = self.canvas.copy_from_bbox(self.ax.bbox)
self.clicked = True
START_EVENTS[self.select_mode](event)
def onMouseUp(event):
if self.ax.get_navigate_mode() is None:
self.canvas.restore_region(self._bg_cache)
self.canvas.blit(self.ax.bbox)
self.clicked = False
END_EVENTS[self.select_mode](event)
def onMouseMove(event):
if self.ax.get_navigate_mode() is None:
if (self.clicked):
self.canvas.restore_region(self._bg_cache)
MOVE_EVENTS[self.select_mode](event)
self.canvas.blit(self.ax.bbox)
self.canvas.mpl_connect('button_press_event', onMouseDown)
self.canvas.mpl_connect('button_release_event', onMouseUp)
self.canvas.mpl_connect('motion_notify_event', onMouseMove)
@property
def head(self):
return self._head
@head.setter
def head(self, value):
if not hasattr(self, '_head'):
self._head = 0
else:
self._head = value % len(self.collection)
def set_head(self, value):
if isinstance(value, Iterable):
if len(value) > 0:
value = value[0]
else:
value = 0
self.head = value
if self.spectrum_mode:
self.update()
self.update_selected()
@property
def collection(self):
return self._collection
@collection.setter
def collection(self, value):
if isinstance(value, Spectrum):
# create new collection
self._collection = Collection(name=Spectrum.name, spectra=[value])
if isinstance(value, Collection):
self._collection = value
else:
self._collection = None
def move_selected_to_top(self):
selected = self.listbox.curselection()
keys = [self.collection.spectra[s].name for s in selected]
for s in selected[::-1]:
self.listbox.delete(s)
self.listbox.insert(0, *keys)
self.listbox.selection_set(0, len(keys))
def unselect_all(self):
self.listbox.selection_clear(0, tk.END)
self.update_selected()
def select_all(self):
self.listbox.selection_set(0, tk.END)
self.update_selected()
def invert_selection(self):
for i in range(self.listbox.size()):
if self.listbox.selection_includes(i):
self.listbox.selection_clear(i)
else:
self.listbox.selection_set(i)
self.update_selected()
def change_color(self):
cpicker = ColorPickerDialog(self)
#rgb,color = askcolor(self.color)
if cpicker.applied:
self.color = cpicker.color
self.color_pick.config(bg=self.color)
#update our list of chosen colors
selected = self.listbox.curselection()
selected_keys = [self.collection.spectra[s].name for s in selected]
for key in selected_keys:
self.colors[key] = self.color
self.update()
def select_by_name(self):
pattern = self.name_filter.get()
for i in range(self.listbox.size()):
if pattern in self.listbox.get(i):
self.listbox.selection_set(i)
else:
self.listbox.selection_clear(i)
self.update_selected()
def create_listbox(self):
self._sbframe = tk.Frame(self)
list_label = tk.Frame(self._sbframe)
list_label.pack(side=tk.TOP, anchor=tk.N, fill=tk.X)
tk.Label(list_label, text="Name:").pack(side=tk.LEFT, anchor=tk.W)
self.name_filter = tk.Entry(list_label, width=14)
self.name_filter.pack(side=tk.LEFT, anchor=tk.W)
tk.Button(list_label,
text="Select",
command=lambda: self.select_by_name()).pack(side=tk.LEFT,
anchor=tk.W)
self.sblabel = tk.Label(list_label, text="Showing: 0")
self.sblabel.pack(side=tk.RIGHT)
self.scrollbar = tk.Scrollbar(self._sbframe)
self.listbox = tk.Listbox(self._sbframe,
yscrollcommand=self.scrollbar.set,
selectmode=tk.EXTENDED,
width=30)
self.scrollbar.config(command=self.listbox.yview)
self.list_tools = tk.Frame(self._sbframe)
tk.Button(self.list_tools,
text="To Top",
command=lambda: self.move_selected_to_top()).pack(
side=tk.TOP, anchor=tk.NW, fill=tk.X)
tk.Button(self.list_tools,
text="Select All",
command=lambda: self.select_all()).pack(side=tk.TOP,
anchor=tk.NW,
fill=tk.X)
tk.Button(self.list_tools,
text="Clear",
command=lambda: self.unselect_all()).pack(side=tk.TOP,
anchor=tk.NW,
fill=tk.X)
tk.Button(self.list_tools,
text="Invert",
command=lambda: self.invert_selection()).pack(side=tk.TOP,
anchor=tk.NW,
fill=tk.X)
self.color_field = tk.Frame(self.list_tools)
tk.Label(self.color_field, text="Color:").pack(side=tk.LEFT)
self.color_pick = tk.Button(self.color_field,
text="",
command=lambda: self.change_color(),
bg='#000000')
self.color_pick.pack(side=tk.RIGHT,
anchor=tk.NW,
fill=tk.X,
expand=True)
self.color_field.pack(side=tk.TOP, anchor=tk.NW, fill=tk.X)
self.list_tools.pack(side=tk.RIGHT, anchor=tk.NW)
self.scrollbar.pack(side=tk.RIGHT, anchor=tk.E, fill=tk.Y)
self.listbox.pack(side=tk.RIGHT, anchor=tk.E, fill=tk.Y)
self.listbox.bind('<<ListboxSelect>>',
lambda x: self.set_head(self.listbox.curselection()))
self._sbframe.pack(side=tk.RIGHT, anchor=tk.E, fill=tk.Y)
def create_toolbar(self):
self.toolbar = tk.Frame(self)
tk.Button(self.toolbar, text='Read',
command=lambda: self.read_dir()).pack(side=tk.LEFT,
fill=tk.X,
expand=1)
tk.Button(self.toolbar,
text='Mode',
command=lambda: self.toggle_mode()).pack(side=tk.LEFT,
fill=tk.X,
expand=1)
tk.Button(self.toolbar,
text="Plot Config",
command=lambda: self.plotConfig()).pack(side=tk.LEFT,
fill=tk.X,
expand=1)
tk.Button(self.toolbar,
text='Show/Hide Flagged',
command=lambda: self.toggle_show_flagged()).pack(
side=tk.LEFT, fill=tk.X, expand=1)
tk.Button(self.toolbar,
text='Flag/Unflag',
command=lambda: self.toggle_flag()).pack(side=tk.LEFT,
fill=tk.X,
expand=1)
tk.Button(self.toolbar,
text='Unflag all',
command=lambda: self.unflag_all()).pack(side=tk.LEFT,
fill=tk.X,
expand=1)
#tk.Button(self.toolbar, text='Save Flag', command=lambda:
# self.save_flag()).pack(side=tk.LEFT,fill=tk.X,expand=1)
tk.Button(self.toolbar,
text='Save Flags',
command=lambda: self.save_flag_as()).pack(side=tk.LEFT,
fill=tk.X,
expand=1)
tk.Button(self.toolbar, text='Stitch',
command=lambda: self.stitch()).pack(side=tk.LEFT,
fill=tk.X,
expand=1)
tk.Button(self.toolbar,
text='Jump_Correct',
command=lambda: self.jump_correct()).pack(side=tk.LEFT,
fill=tk.X,
expand=1)
tk.Button(self.toolbar,
text='mean',
command=lambda: self.toggle_mean()).pack(side=tk.LEFT,
fill=tk.X,
expand=1)
tk.Button(self.toolbar,
text='median',
command=lambda: self.toggle_median()).pack(side=tk.LEFT,
fill=tk.X,
expand=1)
tk.Button(self.toolbar, text='max',
command=lambda: self.toggle_max()).pack(side=tk.LEFT,
fill=tk.X,
expand=1)
tk.Button(self.toolbar, text='min',
command=lambda: self.toggle_min()).pack(side=tk.LEFT,
fill=tk.X,
expand=1)
tk.Button(self.toolbar, text='std',
command=lambda: self.toggle_std()).pack(side=tk.LEFT,
fill=tk.X,
expand=1)
self.toolbar.pack(side=tk.TOP, fill=tk.X)
def updateTitle(self):
print("Hello world!")
self.ax.set_title(self._title.get())
self.canvas.draw()
def set_collection(self, collection):
new_lim = True if self.collection is None else False
self.collection = collection
self.update_artists(new_lim=new_lim)
self.update()
self.update_list()
def read_dir(self):
try:
directory = os.path.split(
filedialog.askopenfilename(filetypes=(
("Supported types", "*.asd *.sed *.sig *.pico"),
("All files", "*"),
)))[0]
except:
return
if not directory:
return
c = Collection(name="collection", directory=directory)
self.set_collection(c)
self.dirLbl.config(text="Viewing: " + directory)
def reset_stats(self):
if self.mean_line:
self.mean_line.remove()
self.mean_line = None
self.mean = False
if self.median_line:
self.median_line.remove()
self.median_line = None
self.median = False
if self.max_line:
self.max_line.remove()
self.max_line = None
self.max = False
if self.min_line:
self.min_line.remove()
self.min_line = None
self.min = False
if self.std_line:
self.std_line.remove()
self.std_line = None
self.std = False
def toggle_mode(self):
if self.spectrum_mode:
self.spectrum_mode = False
else:
self.spectrum_mode = True
self.update()
def toggle_show_flagged(self):
if self.show_flagged:
self.show_flagged = False
else:
self.show_flagged = True
self.update()
def unflag_all(self):
#new flags -> new statistics
self.reset_stats()
for spectrum in list(self.collection.flags):
self.collection.unflag(spectrum)
self.update()
self.update_list()
def toggle_flag(self):
#new flags -> new statistics
self.reset_stats()
selected = self.listbox.curselection()
keys = [self.listbox.get(s) for s in selected]
for i, key in enumerate(keys):
print(i, key)
spectrum = key
if spectrum in self.collection.flags:
self.collection.unflag(spectrum)
self.listbox.itemconfigure(selected[i], foreground='black')
else:
self.collection.flag(spectrum)
self.listbox.itemconfigure(selected[i], foreground='red')
# update figure
self.update()
def save_flag(self):
''' save flag to self.flag_filepath'''
with open(self.flag_filepath, 'w') as f:
for spectrum in self.collection.flags:
print(spectrum, file=f)
def save_flag_as(self):
''' modify self.flag_filepath and call save_flag()'''
flag_filepath = filedialog.asksaveasfilename()
if os.path.splitext(flag_filepath)[1] == '':
flag_filepath = flag_filepath + '.txt'
self.flag_filepath = flag_filepath
self.save_flag()
def update_list(self):
self.listbox.delete(0, tk.END)
for i, spectrum in enumerate(self.collection.spectra):
self.listbox.insert(tk.END, spectrum.name)
if spectrum.name in self.collection.flags:
self.listbox.itemconfigure(i, foreground='red')
self.update_selected()
def ask_for_draw(self):
#debounce canvas updates
now = datetime.now()
print(now - self.last_draw)
if ((now - self.last_draw).total_seconds() > 0.5):
self.canvas.draw()
self.last_draw = now
def update_artists(self, new_lim=False):
if self.collection is None:
return
#update values being plotted -> redo statistics
self.mean_line = None
self.median_line = None
self.max_line = None
self.min_line = None
self.std_line = None
# save limits
if new_lim == False:
xlim = self.ax.get_xlim()
ylim = self.ax.get_ylim()
# plot
self.ax.clear()
# show statistics
if self.spectrum_mode:
idx = self.listbox.curselection()
if len(idx) == 0:
idx = [self.head]
spectra = [self.collection.spectra[i] for i in idx]
flags = [s.name in self.collection.flags for s in spectra]
print("flags = ", flags)
flag_style = ' '
if self.show_flagged:
flag_style = 'r'
artists = Collection(name='selection', spectra=spectra).plot(
ax=self.ax,
style=list(np.where(flags, flag_style, self.color)),
picker=1)
self.ax.set_title('selection')
# c = str(np.where(spectrum.name in self.collection.flags, 'r', 'k'))
# spectrum.plot(ax=self.ax, label=spectrum.name, c=c)
else:
# red curves for flagged spectra
flag_style = ' '
if self.show_flagged:
flag_style = 'r'
flags = [
s.name in self.collection.flags
for s in self.collection.spectra
]
print("flags = ", flags)
self.collection.plot(ax=self.ax,
style=list(np.where(flags, flag_style, 'k')),
picker=1)
#self.ax.set_title(self.collection.name)
keys = [s.name for s in self.collection.spectra]
artists = self.ax.lines
self.artist_dict = {key: artist for key, artist in zip(keys, artists)}
self.colors = {key: 'black' for key in keys}
self.ax.legend().remove()
self.navbar.setHome(self.ax.get_xlim(), self.ax.get_ylim())
self.canvas.draw()
self.sblabel.config(text="Showing: {}".format(len(artists)))
def update_selected(self, to_add=None):
""" Update, only on flaged"""
if self.collection is None:
return
if to_add:
for key in to_add:
self.artist_dict[key].set_linestyle('--')
else:
keys = [s.name for s in self.collection.spectra]
selected = self.listbox.curselection()
selected_keys = [self.collection.spectra[s].name for s in selected]
for key in keys:
if key in selected_keys:
self.artist_dict[key].set_linestyle('--')
else:
self.artist_dict[key].set_linestyle('-')
self.canvas.draw()
def update(self):
""" Update the plot """
if self.collection is None:
return
# show statistics
if self.spectrum_mode:
self.ax.clear()
idx = self.listbox.curselection()
if len(idx) == 0:
idx = [self.head]
spectra = [self.collection.spectra[i] for i in idx]
flags = [s.name in self.collection.flags for s in spectra]
print("flags = ", flags)
flag_style = ' '
if self.show_flagged:
flag_style = 'r'
Collection(name='selection', spectra=spectra).plot(
ax=self.ax,
style=list(np.where(flags, flag_style, 'k')),
picker=1)
self.ax.set_title('selection')
# c = str(np.where(spectrum.name in self.collection.flags, 'r', 'k'))
# spectrum.plot(ax=self.ax, label=spectrum.name, c=c)
else:
# red curves for flagged spectra
keys = [s.name for s in self.collection.spectra]
for key in keys:
if key in self.collection.flags:
if self.show_flagged:
self.artist_dict[key].set_visible(True)
self.artist_dict[key].set_color('red')
else:
self.artist_dict[key].set_visible(False)
else:
self.artist_dict[key].set_color(self.colors[key])
self.artist_dict[key].set_visible(True)
if self.show_flagged:
self.sblabel.config(
text="Showing: {}".format(len(self.artist_dict)))
else:
self.sblabel.config(text="Showing: {}".format(
len(self.artist_dict) - len(self.collection.flags)))
'''
self.collection.plot(ax=self.ax,
style=list(np.where(flags, flag_style, 'k')),
picker=1)
self.ax.set_title(self.collection.name)
'''
if self.spectrum_mode:
#self.ax.legend()
pass
else:
#self.ax.legend().remove()
pass
self.ax.set_ylabel(self.collection.measure_type)
#toggle appearance of statistics
if self.mean_line != None: self.mean_line.set_visible(self.mean)
if self.median_line != None: self.median_line.set_visible(self.median)
if self.max_line != None: self.max_line.set_visible(self.max)
if self.min_line != None: self.min_line.set_visible(self.min)
if self.std_line != None: self.std_line.set_visible(self.std)
self.canvas.draw()
def next_spectrum(self):
if not self.spectrum_mode:
return
self.head = (self.head + 1) % len(self.collection)
self.update()
def stitch(self):
'''
Known Bugs
----------
Can't stitch one spectrum and plot the collection
'''
self.collection.stitch()
self.update_artists()
def jump_correct(self):
'''
Known Bugs
----------
Only performs jump correction on 1000 and 1800 wvls and 1 reference
'''
self.collection.jump_correct([1000, 1800], 1)
self.update_artists()
def toggle_mean(self):
if self.mean:
self.mean = False
else:
self.mean = True
if not self.mean_line:
self.collection.mean().plot(ax=self.ax,
c='b',
label=self.collection.name +
'_mean',
lw=3)
self.mean_line = self.ax.lines[-1]
self.update()
def toggle_median(self):
if self.median:
self.median = False
else:
self.median = True
if not self.median_line:
self.collection.median().plot(ax=self.ax,
c='g',
label=self.collection.name +
'_median',
lw=3)
self.median_line = self.ax.lines[-1]
self.update()
def toggle_max(self):
if self.max:
self.max = False
else:
self.max = True
if not self.max_line:
self.collection.max().plot(ax=self.ax,
c='y',
label=self.collection.name + '_max',
lw=3)
self.max_line = self.ax.lines[-1]
self.update()
def toggle_min(self):
if self.min:
self.min = False
else:
self.min = True
if not self.min_line:
self.collection.min().plot(ax=self.ax,
c='m',
label=self.collection.name + '_min',
lw=3)
self.min_line = self.ax.lines[-1]
self.update()
def toggle_std(self):
if self.std:
self.std = False
else:
self.std = True
if not self.std_line:
self.collection.std().plot(ax=self.ax,
c='c',
label=self.collection.name + '_std',
lw=3)
self.std_line = self.ax.lines[-1]
self.update()
# plt.title('Databricks Visualization')
t = arange(0.0, 3.0, 0.01)
s = sin(2*pi*t)
# ax.plot(t, s)
canvas = FigureCanvasTkAgg(fig, master=root)
canvas.show()
canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
canvas.set_window_title('AMON')
canvas.mpl_connect('button_press_event', onClick)
canvas.show()
# using evaluate built-in function-- taken in an expression and evaluates it!
def evaluate(event):
data = e.get()
print data
e = Entry(root)
e.bind("<Return>", evaluate)
e.pack()
while True:
im = ax.imshow(np.random.random([128,128]), origin = 'upper', cmap=plt.cm.RdYlGn, interpolation = 'nearest', vmax = 0, vmin = -400000)
s = sin(2 * pi * t)
a.plot(t, s)
# canvas
canvas = FigureCanvasTkAgg(f, master=root)
canvas.show()
canvas.get_tk_widget().pack(side=Tk.BOTTOM, fill=Tk.BOTH, expand=True)
toolbar = NavigationToolbar2TkAgg(canvas, root)
toolbar.update()
canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=True)
def on_key_event(event):
print('presiona %s' % event.key)
key_press_handler(event, canvas, toolbar)
canvas.mpl_connect('key_press_event', on_key_event)
def _quit():
root.quit()
root.destroy()
button = Tk.Button(master=root, text='Salir', command=_quit)
button.pack(side=Tk.BOTTOM)
root.mainloop()
def quickPlayer(soundfile,
data,
stamps,
names,
h=128,
onlyValues=False,
regions=None):
"""
USAGE:
press spacebar to start/stop playing.
Navigate by clicking on plot, and with 'zoom' and 'pan' features of the toolbar.
Zoom: Click and drag. Right click to zoom out.
Plot and player will automatically follow if zoomed. But if zoomed too much, it may cause stuttering.
Panning while audio is being played will cause stuttering.
ARGS:
onlyValues: If provided time stamps does not have IDs or names (so just lines to be drawn), this should be True. Manually annotated files will have IDs and names for the stamps .
soundfile: sound file to be played
data: data that shown on the player plot
stamps: lines will be drawed on these points on the data
h: hopsize
size(data) * h = size(sound) If you pass audio samples as data, h (hop size) should be 1.
"""
wf = wave.open(soundfile, 'rb')
parent = Tk()
chunk_size = 2048
sem = asyncio.Semaphore()
play_mode = tk.BooleanVar(parent, False)
fig = plt.figure(figsize=(18, 7), dpi=100)
mainplot = fig.add_subplot(111)
canvas = FigureCanvasTkAgg(fig, parent)
canvaswidget = canvas.get_tk_widget()
canvaswidget.grid(row=2, column=0, columnspan=5, sticky=W)
toolbarFrame = Frame(master=parent)
toolbarFrame.grid(row=3, column=0, columnspan=7)
toolbar = NavigationToolbar2Tk(canvas, toolbarFrame)
toolbar.update()
canvas._tkcanvas.grid(row=2, column=0, columnspan=7, sticky=W)
global background
background = canvas.copy_from_bbox(mainplot.bbox)
cursor = mainplot.axvline(color="k", animated=True)
cursor.set_xdata(0)
for d in data:
if d.ndim == 2:
ymax = d.shape[1]
ymin = 0
mainplot.pcolormesh(np.arange(d.shape[0]), np.arange(d.shape[1]),
np.transpose(d))
if d.ndim == 1:
ymax = np.max(data[0])
ymin = np.min(data[0])
mainplot.plot(d)
global x0, x1
x0, x1 = mainplot.get_xlim()
p = pyaudio.PyAudio()
def callbackstream(in_data, frame_count, time_info, status):
sem.acquire()
data = wf.readframes(frame_count)
parent.event_generate("<<playbackmove>>", when="now")
sem.release()
return (data, pyaudio.paContinue)
_callbackstream = callbackstream
def initStream():
global stream
stream = p.open(format=8,
channels=1,
rate=44100,
output=True,
stream_callback=_callbackstream,
start=True,
frames_per_buffer=chunk_size)
def playsound(event=None):
if sem.locked():
return
if play_mode.get() == True:
# this is broken
global stream
stream.close()
play_mode.set(False)
else:
try:
initStream()
play_mode.set(True)
except:
print("play failed")
def playbackMove(event=None): # move cursor by audio chunk size
global x0, x1
global background
incr = (chunk_size) // h
nextpos = cursor.get_xdata() + incr
cursor.set_xdata(nextpos)
updateCursor()
if (x1 - nextpos) < 0:
mainplot.set_xlim(x1, x1 + x1 - x0)
canvas.draw()
toolbar.push_current()
background = canvas.copy_from_bbox(mainplot.bbox)
x0, x1 = mainplot.get_xlim()
def new_release_zoom(*args, **kwargs):
global x0, x1
release_zoom_orig(*args, **kwargs)
s = 'toolbar_event'
event = Event(s, canvas)
canvas.callbacks.process(s, Event('toolbar_event', canvas))
x0, x1 = mainplot.get_xlim()
def new_release_pan(*args, **kwargs):
global x0, x1
release_pan_orig(*args, **kwargs)
s = 'toolbar_event'
event = Event(s, canvas)
canvas.callbacks.process(s, Event('toolbar_event', canvas))
x0, x1 = mainplot.get_xlim()
def new_update_view(*args, **kwargs):
global x0, x1
_update_view_orig(*args, **kwargs)
s = 'toolbar_event'
event = Event(s, canvas)
canvas.callbacks.process(s, Event('toolbar_event', canvas))
x0, x1 = mainplot.get_xlim()
def handle_toolbar(event):
global x0, x1
canvas.draw()
global background
background = canvas.copy_from_bbox(mainplot.bbox)
def onclick(event):
if (toolbar._active == 'ZOOM' or toolbar._active == 'PAN'):
pass
else:
cursor.set_xdata(event.xdata)
wf.setpos(int(event.xdata * h))
updateCursor()
def updateCursor():
canvas.restore_region(background)
mainplot.draw_artist(cursor)
canvas.blit(mainplot.bbox)
parent.bind("<space>", playsound)
parent.bind("<<playbackmove>>", playbackMove)
release_zoom_orig = toolbar.release_zoom
toolbar.release_zoom = new_release_zoom
release_pan_orig = toolbar.release_pan
toolbar.release_pan = new_release_pan
_update_view_orig = toolbar._update_view
toolbar._update_view = new_update_view
canvas.mpl_connect('toolbar_event', handle_toolbar)
cid1 = canvas.mpl_connect("button_press_event", onclick)
canvas.draw()
colors = [
'c', 'm', 'y', 'r', '#FFBD33', '#924A03', '#D00000', '#D000D0',
'#6800D0', '#095549', 'b', 'r', 'r'
]
if onlyValues:
for i in range(len(stamps)):
mainplot.draw_artist(
mainplot.vlines(x=np.array(stamps[i]) / h,
color=colors[i],
ymin=ymin,
ymax=ymax,
label=names[i]))
mainplot.legend(loc="upper left")
else:
for i in range(len(stamps)):
for j in stamps[i]:
mainplot.draw_artist(
mainplot.axvline(x=j[1] / h,
ymin=ymin,
ymax=ymax,
color=colors[i]))
mainplot.text(j[1] / h + 2, (0.8 * ymax) + (i * 0.04),
names[i] + str(j[0]),
bbox=dict(fill=False,
edgecolor=colors[i],
linewidth=1))
if regions != None:
for r in regions:
mainplot.fill_betweenx([ymin, ymax],
r[0],
r[1],
facecolor='blue',
alpha=0.5)
canvas.draw()
background = canvas.copy_from_bbox(mainplot.bbox)
parent.mainloop()
for func in [stream.close, wf.close, p.terminate, parent.destroy]:
try:
func()
except:
pass
return
class MapPage(tk.Frame):
'''
A page that will show the map of currently plotted earthquakes from the 'current_data.json' file
'''
def __init__(self, parent, controller):
super().__init__(parent)
self.controller = controller
self.local_url = None
self.mappage_balloon = Pmw.Balloon(self)
self.bind("<<RefreshPlot>>", self.refresh_plot)
self.menubar = Pmw.MenuBar(self, hull_relief="raised", hull_borderwidth=1, balloon=self.mappage_balloon)
self.menubar.pack(side="top", fill="x")
self.menubar.addmenu("pages", "Switch Pages", "", "right")
self.menubar.addmenu("file", "File And Data Options")
self.menubar.addmenuitem("file", "command", "Quit The Program",
command=self.controller.on_close_window, label="Quit")
self.menubar.addmenuitem("pages", "command", "Switch To Settings Page",
command=lambda: self.controller.show_frame("SettingsPage"), label="Settings Page")
self.map_frame = tk.Frame(self)
self.map_frame.pack(side="bottom", fill="both", expand=True)
#Line2D objects are used here to be placed in the legend of the graph for more detail on the map
legend_elements = [Line2D([0], [0], marker="o", color="green", label="Small (below 3)"),
Line2D([0], [0], marker="o", color="yellow", label="Medium (below 6)"),
Line2D([0], [0], marker="o", color="red", label="Large (above 6)")]
self.map_figure = plt.figure(num=None, figsize=(12, 4))
self.map_axes = self.map_figure.add_subplot(111)
self.map_axes_legend = self.map_axes.legend(handles=legend_elements, loc="upper right") #placing the legend
self.map_axes.set_title("Earthquake Events - Mercator Projection")
self.map_figure.tight_layout() #makes sure that when placing the map onto the GUI, it is responsive
self.figure_basemap = Basemap(projection="merc", llcrnrlat=-80, urcrnrlat=80,
llcrnrlon=-180, urcrnrlon=180, resolution="c") #defines that the map is using mercator projection
self.figure_basemap.drawcoastlines()
self.figure_basemap.fillcontinents(color="tan", lake_color="lightblue")
self.figure_basemap.drawstates(color="darkred")
self.figure_basemap.drawparallels(np.arange(-90.,91.,30.), labels=(True, True, False, False), dashes=(2,2))
self.figure_basemap.drawmeridians(np.arange(-180.,181.,60.), labels=(False, False, False, True), dashes=(2,2))
self.figure_basemap.drawmapboundary(fill_color="lightblue")
self.figure_basemap.drawcountries()
self.figure_canvas = FigureCanvasTkAgg(self.map_figure, self.map_frame) #creates the figure and draws the map onto it
self.figure_canvas.draw()
self.figure_canvas.get_tk_widget().pack(side="bottom", fill="both", expand=True)
self.canvas_pick_event = self.figure_canvas.mpl_connect("pick_event", self.display_point_info)
self.figure_toolbar = NavigationToolbar2Tk(self.figure_canvas, self.map_frame) #Toolbar with additional options is added to the figure
self.figure_toolbar.update()
self.figure_canvas._tkcanvas.pack(side="top", fill="both", expand=True)
def refresh_plot(self, event):
'''
Method for checking whether there is any different data to plot and if so
reads it from the json file, done by checking the local_url against controller's current_url
'''
if self.local_url == self.controller.current_url:
return "Same Request"
self.local_url = self.controller.current_url
with open("current_data.json", "r") as json_file:
data = json.load(json_file)
self.plot_points(data)
messagebox.showinfo(title="Data Plotted", message="{} points plotted".format(data["metadata"]["count"]))
def plot_points(self, filedata):
'''
Method for creating MapPoint objects and plotting them on the figure, by first clearing the figure of any
previous plots and then reading 'current_data.json'
'''
self.map_axes.lines.clear()
for quake in filedata["features"]:
lat=quake["geometry"]["coordinates"][1]
if lat > 80: lat=80
elif lat <-80: lat=-80
nx,ny = self.figure_basemap((quake["geometry"]["coordinates"][0],), (lat,))
new_point = MapPoint(nx, ny, quake["properties"]["mag"], quake["properties"]["place"],
quake["properties"]["time"], quake["properties"]["felt"], quake["properties"]["cdi"],
quake["properties"]["mmi"], quake["properties"]["alert"], quake["properties"]["tsunami"],
quake["properties"]["sig"], quake["properties"]["title"], quake["properties"]["status"],
quake["properties"]["dmin"], quake["properties"]["gap"], quake["properties"]["magType"],
quake["properties"]["type"])
self.map_axes.add_line(new_point)
self.figure_canvas.draw()
def display_point_info(self, event):
'''
Method when an individual point is picked, prompts the user to view information about it
'''
line_obj = event.artist
messagebox.showinfo(title="Point Selected", message="Here is more info about the point - {}".format(line_obj.place))
self.figure_canvas.mpl_disconnect(self.canvas_pick_event)
self.controller.call_display_info(line_obj)
self.controller.show_frame("PointInfoPage")
def reconnect_pick_event(self):
'''
Method to reconnect pick event with the figure after a previous disconnect
'''
self.canvas_pick_event = self.figure_canvas.mpl_connect("pick_event", self.display_point_info)
class Gui :
"""
A tkinter GUI to quickly visualize ARPES data, i.e. cuts and maps. Should
be built in a modular fashion such that any data reader can be 'plugged in'.
data : 3D array; the raw data from the selected file. This is
expected to be in the shape (z, x, y) (z may be equal to 1)
pp_data : 3D array; the postprocessed data to be displayed.
cmaps : list of str; a list of available matplotlib colormap names.
xscale, yscale, zscale
: 1D arrays; the x, y and z-axis data.
cursor_xy : tuple; current location of the cursor in the bottom left plot.
dpi : int; resolution at which to save .png`s.
"""
data = STARTUP_DATA
pp_data = STARTUP_DATA.copy()
cmaps = CMAPS
xscale = None
yscale = None
zscale = None
cursor_xy = None
dpi = DPI
main_mesh = None
vmain_mesh = None
cut1 = None
cut2 = None
def __init__(self, master, filename=None) :
""" This init function mostly just calls all 'real' initialization
functions where the actual work is outsourced to. """
# Create the main container/window
frame = tk.Frame(master)
# Define some elements
self._set_up_load_button(master)
self._set_up_pp_selectors(master)
self._set_up_plots(master)
self._set_up_colormap_sliders(master)
self._set_up_z_slider(master)
self._set_up_integration_range_selector(master)
self._set_up_status_label(master)
# Align all elements
self._align()
# Load the given file
if filename :
self.filepath.set(filename)
self.load_data()
# The setup of event handling requires there to be some data already
self._set_up_event_handling()
def _align(self) :
""" Use the grid() layout manager to align the elements of the GUI.
At this stage of development the grid has 12 columns of unequal size.
"""
# The plot takes up the space of PLOT_COLUMNSPAN widgets
PLOT_COLUMNSPAN = 8
PLOT_ROWSPAN = 3
N_PATH_FIELD = PLOT_COLUMNSPAN
# 'Load file' elements
LOADROW = 0
c = 0
self.browse_button.grid(row=LOADROW, column=c, sticky='ew')
c += 1
self.load_button.grid(row=LOADROW, column=c, sticky='ew')
c += 1
self.decrement_button.grid(row=LOADROW, column=c, sticky='ew')
c += 1
self.increment_button.grid(row=LOADROW, column=c, sticky='ew')
c += 1
self.path_field.grid(row=LOADROW, column=c, columnspan=N_PATH_FIELD,
sticky='ew')
# Postprocessing selectors
PPROW = LOADROW + 1
c = 0
for lst in self.radiobuttons :
r = 0
for btn in lst :
btn.grid(row=PPROW+r, column=c, sticky='ew')
r += 1
c += 1
# Plot & colormap sliders & selector
PLOTROW = PPROW + max([len(lst) for lst in self.radiobuttons])
PLOTCOLUMN = 1
self.canvas.get_tk_widget().grid(row=PLOTROW, column=PLOTCOLUMN,
rowspan=PLOT_ROWSPAN, columnspan=PLOT_COLUMNSPAN)
right_of_plot = PLOT_COLUMNSPAN + PLOTCOLUMN
self.cm_min_slider.grid(row=PLOTROW, column=right_of_plot + 1)
self.cm_max_slider.grid(row=PLOTROW, column=right_of_plot + 2)
self.cmap_dropdown.grid(row=PLOTROW + 1, column=right_of_plot + 1)
self.invert_cmap_checkbutton.grid(row=PLOTROW + 1, column=right_of_plot + 2)
# Save png button
self.save_button.grid(row=PLOTROW + 2, column=right_of_plot + 1)
# z slider, integration range selector
self.z_slider.grid(row=PLOTROW, column=0)
self.integration_range_entry.grid(row=PLOTROW+1, column=0)
# Put the status label at the very bottom left
STATUSROW = PLOTROW + PLOT_ROWSPAN + 1
self.status_label.grid(row=STATUSROW, column=0, columnspan=10,
sticky='ew')
def _set_up_load_button(self, master) :
""" Add a button which opens a filebrowser to choose the file to load
and a textbox (Entry widget) where the filepath can be changed.
"""
# Define the Browse button
self.browse_button = tk.Button(master, text='Browse',
command=self.browse)
# and the Load button
self.load_button = tk.Button(master, text='Load',
command=self.load_data)
# and the entry field which holds the path to the current file
self.filepath = tk.StringVar()
self.path_field = tk.Entry(master, textvariable=self.filepath)
# Also add inc and decrement buttons
self.increment_button = tk.Button(master, text='>',
command=lambda : self.increment(1))
self.decrement_button = tk.Button(master, text='<',
command=lambda : self.increment(-1))
# Add a 'save' button for creating png s
self.save_button = tk.Button(master, text='Save png',
command=self.save_plot)
def _set_up_pp_selectors(self, master) :
""" Create radiobuttons for the selction of postprocessing methods.
The order of the pp methods in all lists is:
0) Make map
1) BG subtraction
2) Normalization
3) derivative
"""
# Create control variables to hold the selections and store them in a
# list for programmatic access later on
self.map = tk.StringVar()
self.subtractor = tk.StringVar()
self.normalizer = tk.StringVar()
self.derivative = tk.StringVar()
self.selection = [self.map,
self.subtractor,
self.normalizer,
self.derivative]
# Create sets of radiobuttons and set all to default value 'Off'
self.radiobuttons = []
for i, D in enumerate(PP_DICTS) :
variable = self.selection[i]
variable.set('Off')
self.radiobuttons.append([])
for key in D :
rb = tk.Radiobutton(master, text=key, variable=variable,
value=key, command=self.process_data,
indicatoron=0)
self.radiobuttons[i].append(rb)
def _set_up_plots(self, master) :
""" Take care of all the matplotlib stuff for the plot. """
fig = Figure(figsize=FIGSIZE)
fig.patch.set_alpha(0)
ax_cut1 = fig.add_subplot(221)
ax_cut2 = fig.add_subplot(224)
ax_map = fig.add_subplot(223)#, sharex=ax_cut1, sharey=ax_cut2)
ax_energy = fig.add_subplot(222)
# Virtual figure and ax for creation of png's
self.vfig = Figure(figsize=VFIGSIZE)
vax = self.vfig.add_subplot(111)
self.vcanvas = FigureCanvasTkAgg(self.vfig, master=master)
# Remove padding between min and max of data and plot border
ax_cut2.set_ymargin(0)
# Move ticks to the other side
ax_energy.xaxis.tick_top()
ax_energy.yaxis.tick_right()
ax_cut1.xaxis.tick_top()
ax_cut2.yaxis.tick_right()
# Get a handle on all axes through the dictionary self.axes
self.axes = {'cut1': ax_cut1,
'cut2': ax_cut2,
'map': ax_map,
'energy': ax_energy,
'vax': vax}
# Set bg color
for ax in self.axes.values() :
ax.set_facecolor(BGCOLOR)
# Remove spacing between plots
fig.subplots_adjust(wspace=PLOT_SPACING, hspace=PLOT_SPACING)
self.canvas = FigureCanvasTkAgg(fig, master=master)
self.canvas.show()
def _set_up_colormap_sliders(self, master) :
""" Add the colormap adjust sliders, set their starting position and add
its binding such that it only triggers upon release. Also, couple
them to the variables vmin/max_index.
Then, also create a dropdown with all available cmaps and a checkbox
to invert the cmap.
"""
self.vmin_index = tk.IntVar()
self.vmax_index = tk.IntVar()
cm_slider_kwargs = { 'showvalue' : 0,
'to' : CM_SLIDER_RESOLUTION,
'length':SLIDER_LENGTH }
self.cm_min_slider = tk.Scale(master, variable=self.vmin_index,
label='Min', **cm_slider_kwargs)
self.cm_min_slider.set(CM_SLIDER_RESOLUTION)
self.cm_max_slider = tk.Scale(master, variable=self.vmax_index,
label='Max', **cm_slider_kwargs)
self.cm_max_slider.set(0)
# StringVar to keep track of the cmap and whether it's inverted
self.cmap = tk.StringVar()
self.invert_cmap = tk.StringVar()
# Default to the first cmap
self.cmap.set(self.cmaps[0])
self.invert_cmap.set('')
# Register callbacks for colormap-range change
for var in [self.vmin_index, self.vmax_index, self.cmap,
self.invert_cmap] :
var.trace('w', self.redraw_mesh)
# Create the dropdown menu, populated with all strings in self.cmaps
self.cmap_dropdown = tk.OptionMenu(master, self.cmap, *self.cmaps)
# And a button to invert
self.invert_cmap_checkbutton = tk.Checkbutton(master, text='Invert',
variable=self.invert_cmap,
onvalue='_r',
offvalue='')
def _set_up_z_slider(self, master) :
""" Create a Slider which allows to select the z value of the data.
This value is stored in the DoubleVar self.z """
self.z = tk.IntVar()
self.z.set(0)
self.zmax = tk.IntVar()
self.zmax.set(1)
self.z_slider = tk.Scale(master, variable=self.z, label='z',
to=self.zmax.get(), showvalue=1,
length=SLIDER_LENGTH)
self.z_slider.bind('<ButtonRelease-1>', self.process_data)
def _set_up_integration_range_selector(self, master) :
""" Create widgets that will allow setting the integration range when
creating a map. """
self.integrate = tk.IntVar()
self.integration_range_entry = tk.Entry(master, width=3,
textvariable=self.integrate)
def _set_up_status_label(self, master) :
""" Create a label which can hold informative text about the current
state of the GUI or success/failure of certain operations. This text
is held in the StringVar self.status.
"""
self.status = tk.StringVar()
# Initialize the variable with the default status
self.update_status()
self.status_label = tk.Label(textvariable=self.status, justify=tk.LEFT,
anchor='w')
def redraw_mesh(self, *args, **kwargs) :
""" Efficiently redraw the pcolormesh without having to redraw the
axes, ticks, labels, etc. """
# Get the new colormap parameters and apply them to the pcolormesh
cmap = self.get_cmap()
vmin, vmax = self.vminmax(self.pp_data)
mesh = self.main_mesh
mesh.set_clim(vmin=vmin, vmax=vmax)
mesh.set_cmap(cmap)
# Redraw the mesh
ax = self.axes['map']
ax.draw_artist(mesh)
# Cursors need to be redrawn - the blitting happens there
self.redraw_cursors()
# Also redraw the cuts if they are pcolormeshes
if self.map.get() != 'Off' :
self.redraw_cuts()
def redraw_cuts(self, *args, **kwargs) :
""" Efficiently redraw the cuts (meshes or lines, depending on state
of `self.map`) without having to redraw the axes, ticks, labels, etc.
"""
axes = [self.axes['cut1'], self.axes['cut2']]
data = [self.cut1, self.cut2]
artists = [self.cut1_plot, self.cut2_plot]
cmap = self.get_cmap()
for i,ax in enumerate(axes) :
artist = artists[i]
if self.map.get() != 'Off' :
vmin, vmax = self.vminmax(data[i])
artist.set_clim(vmin=vmin, vmax=vmax)
artist.set_cmap(cmap)
ax.draw_artist(artist)
self.canvas.blit(ax.bbox)
def redraw_cursors(self, *args, **kwargs) :
""" Efficiently redraw the cursors in the bottom left plot without
having to redraw the axes, ticks, labels, etc. """
ax = self.axes['map']
#self.canvas.restore_region(self.bg_mesh)
ax.draw_artist(self.xcursor)
ax.draw_artist(self.ycursor)
self.canvas.blit(ax.bbox)
def update_z_slider(self, state) :
""" Change the relief of the z slider to indicate that it is
inactive/active. Also update the z slider range"""
if state == 'active' :
config = dict(sliderrelief='raised', showvalue=1)
else :
config = dict(sliderrelief='flat', showvalue=0)
self.zmax.set( len(self.data) - 1)
config.update(dict(to=self.zmax.get()))
self.z_slider.config(**config)
def get_filename(self) :
""" Return the filename (without path) of the currently selected
file. """
return self.filepath.get().split('/')[-1]
def increment(self, plusminus) :
# Get the path and the name of the current file
filepath = self.filepath.get()
split = filepath.split('/')
# If just a filename is given, assume the current directory
if filepath[0] is not '/' :
path = './'
else :
#path = '/' + '/'.join(split[:-1]) + '/'
path = '/'.join(split[:-1]) + '/'
old_filename = split[-1]
# Get a list of the files in the current directory
dir_content = sorted( os.listdir(path) )
dir_size = len(dir_content)
# Get the index of the current file in the directory
index = dir_content.index(old_filename)
# Raise/lower the index until a not-obiously skippable entry is found
while True :
index += plusminus
# Cycle through the list
index %= dir_size
new_filename = dir_content[index]
suffix = new_filename.split('.')[-1]
if suffix not in SKIPPABLE :
self.filepath.set(path+new_filename)
break
def update_status(self, status=DEFAULT_STATUS) :
""" Update the status StringVar with the current time and the given
status argument.
"""
now = datetime.now().strftime('%H:%M:%S')
new_status = '[{}] {}'.format(now, status)
self.status.set(new_status)
def browse(self) :
""" Open a filebrowser dialog and put the selected file into
self.path_field.
"""
# If the file entry field already contains a path to a file use it
# as the default file for the browser
old_filepath = self.filepath.get()
if old_filepath :
default_file = old_filepath
initialdir = None
else :
default_file = None
initialdir = '/'
# Open a browser dialog
new_filepath = askopenfilename(initialfile=default_file,
initialdir=initialdir)
# Update the path only if a selection was made
if new_filepath != "" :
self.filepath.set(new_filepath)
def load_data(self) :
""" Load data from the file currently selected by self.filepath. And
reset and prepare several things such that the GUI is able to handle
the new data properly.
"""
# Show the user that something is happening
self.update_status('Loading data...')
# Try to load the data with the given dataloader
try :
ns = dl.load_data(self.filepath.get())
except Exception as e :
print(e)
self.update_status('Failed to load data.')
# Leave the function
return 1
# Extract the fields from the namespace
self.data = ns.data
self.xscale = ns.xscale
self.yscale = ns.yscale
try :
self.zscale = ns.zscale
except KeyError :
# Set zscale to None
self.zscale = None
pass
# Notify user of success
self.update_status('Loaded data: {}.'.format(self.get_filename()))
# Update the max z value/toggle z slider (should better be handled in
# background by tkinter)
if self.data.shape[0] == 1 :
self.update_z_slider('disabled')
else :
self.update_z_slider('active')
# Initiate new cursors
self.cursor_xy = None
# The postprocessing also creates copy of the raw data and replots
self.process_data()
def process_data(self, event=None) :
""" Apply all the selected postprocessing routines in the following
order:
0) Make map
1) bg subtraction
2) normalization
3) derivative
"""
# Retain a copy of the raw data
self.pp_data = self.data.copy()
z = self.z.get()
# Make a map if necessary
if self.map.get() != 'Off' :
integrate = self.integrate.get()
self.pp_data = pp.make_slice(self.pp_data, d=0, i=z, integrate=integrate)
#self.pp_data = pp.make_map(self.pp_data, z, integrate=integrate)
# Need to reshape
shape = self.pp_data.shape
self.pp_data = self.pp_data.reshape(1, shape[0], shape[1])
# Apply all pp, unless they are set to 'Off' (None)
for i, D in enumerate(PP_DICTS) :
pp_operation = D[self.selection[i].get()]
if pp_operation :
self.pp_data = pp_operation(self.pp_data)
#self.pp_data[z,:,:] = pp_operation(self.pp_data[z,:,:])
# Replot
self.plot_data()
def plot_intensity(self) :
""" Plot the binding energy distribution in the top right if we have
a map. """
# Clear the current distribution
ax = self.axes['energy']
ax.clear()
# Write the value of the energy in the upper right plot
z = self.z.get()
if self.zscale is not None :
z_val = self.zscale[z]
else :
z_val = z
ax.text(0.1, 0.05, z_val, color='red', transform=ax.transAxes)
# Nothing else to do if we don't have a map
if self.map.get() == 'Off' :
return
# Get the energies and number of energies
if self.zscale is not None :
energies = self.zscale
else :
energies = np.arange(len(self.data))
N_e = len(energies)
# Get the intensities
intensities = []
for i in range(N_e) :
this_slice = self.data[i,:,:]
intensity = sum( sum(this_slice) )
intensities.append(intensity)
# Plot energy distribution
ax.plot(energies, intensities, **intensity_kwargs)
# Plot a cursor indicating the current value of z
y0 = min(intensities)
y1 = max(intensities)
ylim = [y0, y1]
ax.plot(2*[z_val], ylim, **intensity_cursor_kwargs)
ax.set_ylim(ylim)
def calculate_cuts(self) :
""" """
if self.map.get() != 'Off' :
# Create a copy of the original map (3D) data
data = self.data.copy()
# Slice and dice it
self.cut1 = pp.make_slice(data, d=1, i=self.yind, integrate=1)
self.cut2 = pp.make_slice(data, d=2, i=self.xind, integrate=1)
else :
z = self.z.get()
self.cut1 = self.pp_data[z, self.yind, :]
self.cut2 = self.pp_data[z, :, self.xind]
def plot_cuts(self) :
""" Plot cuts of whatever is in the bottom left ('map') axis along
the current positions of the cursors.
"""
self.calculate_cuts()
# Clear the current cuts
for ax in ['cut1', 'cut2'] :
self.axes[ax].clear()
# Get the right xscale/yscale information
xscale, yscale = self.get_xy_scales()
if self.map.get() != 'Off' :
kwargs = dict(cmap=self.get_cmap())
# Ensure zscale is defined
if self.zscale is None :
zscale = np.arange(self.cut1.shape[0])
else :
zscale = self.zscale
# Plot x cut in upper left
vmin, vmax = self.vminmax(self.cut1)
kwargs.update(dict(vmin=vmin, vmax=vmax))
self.cut1_plot = self.axes['cut1'].pcolormesh(xscale, zscale,
self.cut1, **kwargs)
# Plot y cut in lower right (rotated by 90 degrees)
vmin, vmax = self.vminmax(self.cut2)
kwargs.update(dict(vmin=vmin, vmax=vmax))
self.cut2_plot = self.axes['cut2'].pcolormesh(zscale, yscale,
self.cut2.T, **kwargs)
else :
# Plot the x cut in the upper left
self.cut1_plot = self.axes['cut1'].plot(xscale, self.cut1,
**cut_kwargs)[0]
# Plot the y cut in the lower right
self.cut2_plot = self.axes['cut2'].plot(self.cut2, yscale,
**cut_kwargs)[0]
# Make sure the cut goes over the full range of the plot
#self.axes['cut2'].set_ymargin(0) # For some reason this doesn't work
ymin = min(yscale)
ymax = max(yscale)
self.axes['cut2'].set_ylim([ymin, ymax])
def get_plot_args_and_kwargs(self) :
""" Prepare args and kwargs for plotting, depending on the
circumstances. """
# Add x and y scales to args if available
args = []
if self.xscale is not None and self.yscale is not None :
args.append(self.xscale)
args.append(self.yscale)
# Use z=0 in case of a map (as pp_data is of length 1 along this
# dimension as a result of pp_make_cut())
if self.map.get() != 'Off' :
z = 0
else :
z = self.z.get()
args.append(self.pp_data[z,:,:])
vmin, vmax = self.vminmax(self.pp_data)
kwargs = dict(cmap=self.get_cmap(), vmin=vmin,
vmax=vmax)
return args, kwargs
def plot_data(self, event=None, *args, **kwargs) :
""" Update the colormap range and (re)plot the data. """
# Remove old plots
for ax in self.axes.values() :
ax.clear()
args, kwargs = self.get_plot_args_and_kwargs()
# Do the actual plotting with just defined args and kwargs
ax = self.axes['map']
self.main_mesh = ax.pcolormesh(*args, **kwargs)
self.bg_mesh = self.canvas.copy_from_bbox(ax.bbox)
# Update the cursors (such that they are above the pcolormesh) and cuts
self.plot_cursors()
self.plot_cuts()
self.plot_intensity()
self.canvas.draw()
def get_cmap(self) :
""" Build the name of the colormap by combining the value stored in
`self.cmap` (the basename of the colormap) and `self.invert_cmap`
(either empty string or '_r', which is the suffix for inverted cmaps
in matplotlib) """
# Build the name of the cmap
cmap_name = self.cmap.get() + self.invert_cmap.get()
# Make sure this name exists in the list of cmaps. Otherwise reset to
# default cmap
try :
cmap = get_cmap(cmap_name)
except ValueError :
# Notify user
message = \
'Colormap {} not found. Using default instead.'.format(cmap_name)
self.update_status(message)
# Set default
cmap = get_cmap(self.cmaps[0])
return cmap
def vminmax(self, data) :
""" Helper function that returns appropriate values for vmin and vmax
for a given set of data. """
# Note: vmin_index goes from 100 to 0 and vice versa for vmax_index.
# This is to turn the sliders upside down.
# Crude method to avoid unreasonable colormap settings
if self.vmin_index.get() < self.vmax_index.get() :
self.vmin_index.set(CM_SLIDER_RESOLUTION)
# Split the data value range into equal parts
#drange = np.linspace(self.pp_data.min(), data.max(),
# CM_SLIDER_RESOLUTION + 1)
drange = np.linspace(data.min(), data.max(),
CM_SLIDER_RESOLUTION + 1)
# Get the appropriate vmin and vmax values from the data
vmin = drange[CM_SLIDER_RESOLUTION - self.vmin_index.get()]
vmax = drange[CM_SLIDER_RESOLUTION - self.vmax_index.get()]
return vmin, vmax
def get_xy_minmax(self) :
""" Return the min and max for the x and y axes, depending on whether
xscale and yscale are defined.
"""
xscale, yscale = self.get_xy_scales()
xmin = min(xscale)
xmax = max(xscale)
ymin = min(yscale)
ymax = max(yscale)
return xmin, xmax, ymin, ymax
def get_xy_scales(self) :
""" Depending on whether we have actual data scales (self.xscale and
self.yscale are defined) or not, return arrays which represent data
coordinates.
"""
if self.xscale is None or self.yscale is None :
shape = self.data.shape
yscale = np.arange(0, shape[1], 1)
xscale = np.arange(0, shape[2], 1)
else :
xscale = self.xscale
yscale = self.yscale
return xscale, yscale
def snap_to(self, x, y) :
""" Return the closest data value to the given values of x and y. """
xscale, yscale = self.get_xy_scales()
# Find the index where element x/y would have to be inserted in the
# sorted array.
self.xind = np.searchsorted(xscale, x)
self.yind = np.searchsorted(yscale, y)
# Find out whether the lower or upper 'neighbour' is closest
x_lower = xscale[self.xind-1]
y_lower = yscale[self.yind-1]
# NOTE In principle, these IndexErrors shouldn't occur. Try-except
# only helps when debugging.
try :
x_upper = xscale[self.xind]
except IndexError :
x_upper = max(xscale)
try :
y_upper = yscale[self.yind]
except IndexError :
y_upper = max(yscale)
dx_upper = x_upper - x
dx_lower = x - x_lower
dy_upper = y_upper - y
dy_lower = y - y_lower
# Assign the exact data value and update self.xind/yind if necessary
if dx_upper < dx_lower :
x_snap = x_upper
else :
x_snap = x_lower
self.xind -= 1
if dy_upper < dy_lower :
y_snap = y_upper
else :
y_snap = y_lower
self.yind -= 1
return x_snap, y_snap
def plot_cursors(self) :
""" Plot the cursors in the bottom left axis. """
# Delete current cursors (NOTE: this is dangerous if there are any
# other lines in the plot)
ax = self.axes['map']
ax.lines = []
# Retrieve information about current data range
xmin, xmax, ymin, ymax = self.get_xy_minmax()
xlimits = [xmin, xmax]
ylimits = [ymin, ymax]
# Initiate cursors in the center of graph if necessary
if self.cursor_xy is None :
x = 0.5 * (xmax + xmin)
y = 0.5 * (ymax + ymin)
# Keep a handle on cursor positions
self.cursor_xy = (x, y)
else :
x, y = self.cursor_xy
# Make the cursor snap to actual data points
x, y = self.snap_to(x, y)
# Plot cursors and keep handles on them (need the [0] because plot()
# returns a list of Line objects)
self.xcursor = ax.plot([x, x], ylimits, zorder=3, **cursor_kwargs)[0]
self.ycursor = ax.plot(xlimits, [y, y], zorder=3, **cursor_kwargs)[0]
def _set_up_event_handling(self) :
""" Define what happens when user clicks in the plot (move cursors to
clicked position) or presses an arrow key (move cursors in specified
direction).
"""
def on_click(event):
event_ax = event.inaxes
if event_ax == self.axes['map'] :
self.cursor_xy = (event.xdata, event.ydata)
self.plot_cursors()
# Also update the cuts
self.plot_cuts()
self.canvas.draw()
elif event_ax == self.axes['energy'] and \
self.map.get() != 'Off' :
if self.zscale is not None :
z = np.where(self.zscale > event.xdata)[0][0]
else :
z = int(event.xdata)
self.z.set(z)
# Since z changed we need to apply the whole data processing
# and replot
self.process_data()
def on_press(event):
# Get the name of the pressed key and info on the current cursors
key = event.key
x, y = self.cursor_xy
xmin, xmax, ymin, ymax = self.get_xy_minmax()
# Stop if no arrow key was pressed
if key not in ['up', 'down', 'left', 'right'] : return
# Move the cursor by one unit in data points
xscale, yscale = self.get_xy_scales()
dx = xscale[1] - xscale[0]
dy = yscale[1] - yscale[0]
# In-/decrement cursor positions depending on what button was
# pressed and only if we don't leave the axis
if key == 'up' and y+dy <= ymax :
y += dy
elif key == 'down' and y-dy >= ymin :
y -= dy
elif key == 'right' and x+dx <= xmax :
x += dx
elif key == 'left' and x-dx >= xmin:
x -= dx
# Update the cursor position and redraw it
self.cursor_xy = (x, y)
#self.plot_cursors()
self.redraw_cursors()
# Now the cuts have to be redrawn as well
self.calculate_cuts()
#self.plot_cuts()
self.redraw_cuts()
cid = self.canvas.mpl_connect('button_press_event', on_click)
pid = self.canvas.mpl_connect('key_press_event', on_press)
# Inititate the cursors
self.plot_cursors()
def save_plot(self) :
""" Save a png image of the currently plotted data (only what is in
bottom left) """
# Plot the same thing into a virtual figure such that a png can be
# created
args, kwargs = self.get_plot_args_and_kwargs()
self.vmain_mesh = self.axes['vax'].pcolormesh(*args, **kwargs)
# Open a filebrowser where user can select a place to store the result
filename = asksaveasfilename(filetypes=[('PNG', '*.png')])
if filename :
self.vfig.savefig(filename, transparent=True, dpi=self.dpi)
self.update_status('Saved file {}.'.format(filename))
else :
self.update_status('Saving file aborted.')
class matplotlibSwitchGraphs:
def __init__(self, master):
self.master = master
self.frame = Frame(self.master)
self.fig, self.ax = config_plot()
self.graphIndex = 0
self.canvas = FigureCanvasTkAgg(self.fig, self.master)
self.config_window()
self.draw_graph('janvier')
self.frame.pack(expand=YES, fill=BOTH)
def config_window(self):
self.canvas.mpl_connect("key_press_event", self.on_key_press)
toolbar = NavigationToolbar2Tk(self.canvas, self.master)
toolbar.update()
self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
self.button = Button(self.master, text="Quit", command=self._quit)
self.button.pack(side=BOTTOM)
self.button_back = Button(self.master, text="Graphique précédent", command=self.back_graph)
self.button_back.pack(side=BOTTOM)
self.button_next = Button(self.master, text="Graphique suivant", command=self.next_graph)
self.button_next.pack(side=BOTTOM)
def draw_graph(self, month):
self.ax.clear()
self.ax.plot(df[month])
self.ax.set(title=month)
self.canvas.draw()
def on_key_press(event):
key_press_handler(event, self.canvas, toolbar)
def _quit(self):
self.master.quit()
def next_graph(self):
if self.graphIndex == 0:
self.draw_graph('février')
self.graphIndex = 1
elif self.graphIndex == 1:
self.draw_graph('mars')
self.graphIndex = 2
elif self.graphIndex == 2:
self.draw_graph('avril')
self.graphIndex = 3
elif self.graphIndex == 3:
self.draw_graph('mai')
self.graphIndex = 4
elif self.graphIndex == 4:
self.draw_graph('juin')
self.graphIndex = 5
elif self.graphIndex == 5:
self.draw_graph('juillet')
self.graphIndex = 6
elif self.graphIndex == 6:
self.draw_graph('août')
self.graphIndex = 7
elif self.graphIndex == 7:
self.draw_graph('septembre')
self.graphIndex = 8
elif self.graphIndex == 8:
self.draw_graph('octobre')
self.graphIndex = 9
elif self.graphIndex == 9:
self.draw_graph('novembre')
self.graphIndex = 10
elif self.graphIndex == 10:
self.draw_graph('décembre')
self.graphIndex = 11
elif self.graphIndex == 11:
self.draw_graph('janvier')
self.graphIndex = 0
def back_graph(self):
if self.graphIndex == 0:
self.draw_graph('décembre')
self.graphIndex = 11
elif self.graphIndex == 11:
self.draw_graph('novembre')
self.graphIndex = 10
elif self.graphIndex == 10:
self.draw_graph('octobre')
self.graphIndex = 9
elif self.graphIndex == 9:
self.draw_graph('septembre')
self.graphIndex = 8
elif self.graphIndex == 8:
self.draw_graph('août')
self.graphIndex = 7
elif self.graphIndex == 7:
self.draw_graph('juillet')
self.graphIndex = 6
elif self.graphIndex == 6:
self.draw_graph('juin')
self.graphIndex = 5
elif self.graphIndex == 5:
self.draw_graph('mai')
self.graphIndex = 4
elif self.graphIndex == 4:
self.draw_graph('avril')
self.graphIndex = 3
elif self.graphIndex == 3:
self.draw_graph('mars')
self.graphIndex = 2
elif self.graphIndex == 2:
self.draw_graph('février')
self.graphIndex = 1
elif self.graphIndex == 1:
self.draw_graph('janvier')
self.graphIndex = 0
class ApSynSim_UV_Plotter1(object):
def quit(self):
self.FFTwin.destroy()
def __init__(self, parent):
self.parent = parent
self.FFTwin = Tk.Toplevel(self.parent.tks)
self.FFTwin.title("UV space")
menubar = Tk.Menu(self.FFTwin)
menubar.add_command(label="Quit", command=self.quit)
self.FFTwin.config(menu=menubar)
self.figUV1 = pl.figure(figsize=(8.5, 7))
self.UVPSF = self.figUV1.add_subplot(231, aspect='equal')
pl.setp(self.UVPSF.get_xticklabels(), visible=False)
self.UVCLEANMOD = self.figUV1.add_subplot(232,
sharex=self.UVPSF,
sharey=self.UVPSF,
aspect='equal')
pl.setp(self.UVCLEANMOD.get_xticklabels(), visible=False)
pl.setp(self.UVCLEANMOD.get_yticklabels(), visible=False)
self.UVResid = self.figUV1.add_subplot(234,
sharex=self.UVPSF,
sharey=self.UVPSF,
aspect='equal')
self.UVCLEAN = self.figUV1.add_subplot(235,
sharex=self.UVPSF,
sharey=self.UVPSF,
aspect='equal')
pl.setp(self.UVCLEAN.get_yticklabels(), visible=False)
self.UVSOURCE = self.figUV1.add_subplot(233,
sharex=self.UVPSF,
sharey=self.UVPSF,
aspect='equal')
pl.setp(self.UVSOURCE.get_xticklabels(), visible=False)
pl.setp(self.UVSOURCE.get_yticklabels(), visible=False)
self.UVSOURCECONV = self.figUV1.add_subplot(236,
sharex=self.UVPSF,
sharey=self.UVPSF,
aspect='equal')
pl.setp(self.UVSOURCECONV.get_yticklabels(), visible=False)
self.figUV1.subplots_adjust(left=0.1,
right=0.98,
top=0.90,
bottom=0.15,
wspace=0.02,
hspace=0.15)
self.UVfmt = '%.2e Jy'
self.PSFfmt = '%.2e'
self.PSFText = self.UVPSF.text(0.05,
0.87,
self.PSFfmt % (0.0),
transform=self.UVPSF.transAxes,
bbox=dict(facecolor='white', alpha=0.7))
self.ResidText = self.UVResid.text(0.05,
0.87,
self.UVfmt % (0.0),
transform=self.UVResid.transAxes,
bbox=dict(facecolor='white',
alpha=0.7))
self.CLEANText = self.UVCLEAN.text(0.05,
0.87,
self.UVfmt % (0.0),
transform=self.UVCLEAN.transAxes,
bbox=dict(facecolor='white',
alpha=0.7))
self.CLEANMODText = self.UVCLEANMOD.text(
0.05,
0.87,
self.UVfmt % (0.0),
transform=self.UVCLEANMOD.transAxes,
bbox=dict(facecolor='white', alpha=0.7))
self.UVSOURCEText = self.UVSOURCE.text(
0.05,
0.87,
self.UVfmt % (0.0),
transform=self.UVSOURCE.transAxes,
bbox=dict(facecolor='white', alpha=0.7))
self.UVSOURCECONVText = self.UVSOURCECONV.text(
0.05,
0.87,
self.UVfmt % (0.0),
transform=self.UVSOURCECONV.transAxes,
bbox=dict(facecolor='white', alpha=0.7))
self.frames = {}
self.frames['FigUV'] = Tk.Frame(self.FFTwin)
self.frames['BFr'] = Tk.Frame(self.FFTwin)
self.canvasUV1 = FigureCanvasTkAgg(self.figUV1,
master=self.frames['FigUV'])
self.canvasUV1.show()
self.frames['FigUV'].pack(side=Tk.TOP)
self.frames['BFr'].pack(side=Tk.TOP)
self.buttons = {}
self.buttons['reload'] = Tk.Button(self.frames['BFr'],
text="Reload",
command=self._FFTRead)
self.buttons['reload'].pack()
self.canvasUV1.mpl_connect('pick_event', self._onUVPick)
self.canvasUV1.get_tk_widget().pack(
side=Tk.LEFT) # , fill=Tk.BOTH, expand=1)
toolbar_frame = Tk.Frame(self.FFTwin)
__toolbar = NavigationToolbar2TkAgg(self.canvasUV1, toolbar_frame)
toolbar_frame.pack(side=Tk.LEFT)
self._FFTRead()
def _FFTRead(self):
Toplot = np.abs(
np.fft.fftshift(np.fft.fft2(np.fft.fftshift(self.parent.beam))))
vmax = np.max(Toplot)
__vmin = np.min(Toplot)
self.UVPSFPlot = self.UVPSF.imshow(Toplot,
vmin=0.0,
vmax=vmax,
cmap=self.parent.currcmap,
picker=True,
interpolation='nearest')
pl.setp(self.UVPSFPlot,
extent=(-self.parent.UVmax + self.parent.UVSh,
self.parent.UVmax + self.parent.UVSh,
-self.parent.UVmax - self.parent.UVSh,
self.parent.UVmax - self.parent.UVSh))
self.UVPSF.set_ylabel(self.parent.vlab)
self.UVPSF.set_title('UV - PSF')
try:
Toplot = np.abs(
np.fft.fftshift(
np.fft.fft2(np.fft.fftshift(
self.parent.myCLEAN.residuals))))
except:
Toplot = np.zeros(np.shape(self.parent.beam))
vmax = np.max(np.abs(np.fft.fft2(self.parent.dirtymap)))
self.UVResidPlot = self.UVResid.imshow(Toplot,
vmin=0.0,
vmax=vmax,
cmap=self.parent.currcmap,
picker=True,
interpolation='nearest')
pl.setp(self.UVResidPlot,
extent=(-self.parent.UVmax + self.parent.UVSh,
self.parent.UVmax + self.parent.UVSh,
-self.parent.UVmax - self.parent.UVSh,
self.parent.UVmax - self.parent.UVSh))
self.UVResid.set_xlabel(self.parent.ulab)
self.UVResid.set_ylabel(self.parent.vlab)
self.UVResid.set_title('UV - RESIDUALS (REST.)')
try:
Toplot = np.abs(
np.fft.fftshift(
np.fft.fft2(np.fft.fftshift(
self.parent.myCLEAN.cleanmod))))
except:
Toplot = np.zeros(np.shape(self.parent.beam))
vmax = np.max(Toplot)
self.UVCLEANPlot = self.UVCLEAN.imshow(Toplot,
vmin=0.0,
vmax=vmax,
cmap=self.parent.currcmap,
picker=True,
interpolation='nearest')
pl.setp(self.UVCLEANPlot,
extent=(-self.parent.UVmax + self.parent.UVSh,
self.parent.UVmax + self.parent.UVSh,
-self.parent.UVmax - self.parent.UVSh,
self.parent.UVmax - self.parent.UVSh))
self.UVCLEAN.set_xlabel(self.parent.ulab)
self.UVCLEAN.set_title('UV - CLEAN (REST.)')
try:
Toplot = np.abs(
np.fft.fftshift(
np.fft.fft2(np.fft.fftshift(
self.parent.myCLEAN.cleanmodd))))
except:
Toplot = np.zeros(np.shape(self.parent.beam))
vmax = np.max(Toplot)
self.UVCLEANMODPlot = self.UVCLEANMOD.imshow(Toplot,
vmin=0.0,
vmax=vmax,
cmap=self.parent.currcmap,
picker=True,
interpolation='nearest')
pl.setp(self.UVCLEANMODPlot,
extent=(-self.parent.UVmax + self.parent.UVSh,
self.parent.UVmax + self.parent.UVSh,
-self.parent.UVmax - self.parent.UVSh,
self.parent.UVmax - self.parent.UVSh))
self.UVCLEANMOD.set_title('UV - CLEAN (MODEL)')
try:
Toplot = np.fft.fftshift(
np.abs(self.parent.modelfft *
np.fft.fft2(self.parent.myCLEAN.cleanBeam)))
except:
Toplot = np.zeros(np.shape(self.parent.beam))
vmax = np.max(Toplot)
self.UVSOURCECONVPlot = self.UVSOURCECONV.imshow(
Toplot,
vmin=0.0,
vmax=vmax,
cmap=self.parent.currcmap,
picker=True,
interpolation='nearest')
pl.setp(self.UVSOURCECONVPlot,
extent=(-self.parent.UVmax + self.parent.UVSh,
self.parent.UVmax + self.parent.UVSh,
-self.parent.UVmax - self.parent.UVSh,
self.parent.UVmax - self.parent.UVSh))
self.UVSOURCECONV.set_title('UV - SOURCE (REST.)')
Toplot = np.fft.fftshift(np.abs(self.parent.modelfft))
vmax = np.max(Toplot)
self.UVSOURCEPlot = self.UVSOURCE.imshow(Toplot,
vmin=0.0,
vmax=vmax,
cmap=self.parent.currcmap,
picker=True,
interpolation='nearest')
pl.setp(self.UVSOURCEPlot,
extent=(-self.parent.UVmax + self.parent.UVSh,
self.parent.UVmax + self.parent.UVSh,
-self.parent.UVmax - self.parent.UVSh,
self.parent.UVmax - self.parent.UVSh))
self.UVSOURCE.set_title('UV - SOURCE')
self.canvasUV1.draw()
def _onUVPick(self, event):
Up = event.mouseevent.xdata - self.parent.UVSh
Vp = event.mouseevent.ydata + self.parent.UVSh
yi = int(
np.floor((self.parent.UVmax + Up) / (self.parent.UVmax) *
self.parent.Npix / 2.))
xi = int(
np.floor((self.parent.UVmax - Vp) / (self.parent.UVmax) *
self.parent.Npix / 2.))
if xi > 0 and yi > 0 and xi < self.parent.Npix and yi < self.parent.Npix:
self.PSFText.set_text(self.PSFfmt %
self.UVPSFPlot.get_array()[xi, yi])
self.ResidText.set_text(self.UVfmt %
self.UVResidPlot.get_array()[xi, yi])
self.CLEANText.set_text(self.UVfmt %
self.UVCLEANPlot.get_array()[xi, yi])
self.CLEANMODText.set_text(self.UVfmt %
self.UVCLEANMODPlot.get_array()[xi, yi])
self.UVSOURCEText.set_text(self.UVfmt %
self.UVSOURCEPlot.get_array()[xi, yi])
self.UVSOURCECONVText.set_text(
self.UVfmt % self.UVSOURCECONVPlot.get_array()[xi, yi])
else:
self.PSFText.set_text(self.PSFfmt % 0.0)
self.ResidText.set_text(self.UVfmt % 0.0)
self.CLEANText.set_text(self.UVfmt % 0.0)
self.CLEANMODText.set_text(self.UVfmt % 0.0)
self.UVSOURCEText.set_text(self.UVfmt % 0.0)
self.UVSOURCECONVText.set_text(self.UVfmt % 0.0)
self.canvasUV1.draw()
class App():
def __init__(self):
self.root = Tk()
self.root.wm_title("Animated Graph embedded in TK")
self.root.protocol("WM_DELETE_WINDOW", self.quit_app)
self.root.resizable(width=True, height=True)
self.root.geometry("800x400")
self.colors = ['#B2E4CF', '#E4E4B2']
# the networkx part
self.G = List()
# figure
self.f = plt.figure(figsize=(5, 4))
# a tk.DrawingArea
self.canvas = FigureCanvasTkAgg(self.f, master=self.root)
self.canvas.show()
self.canvas.mpl_connect('button_press_event', self.on_press)
self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
# axes
self.a = self.f.add_subplot(111)
self.pos = (1, 1)
self.draw()
def update(self):
self.root.mainloop()
def quit_app(self):
if messagebox.askokcancel("Quit", "Do you want to quit?"):
self.root.quit()
def draw(self):
self.a.cla()
nx.draw_networkx(self.G.getGraph(),
self.G.getPos(),
ax=self.a,
with_labels=True,
node_color=self.G.getColors(),
node_size=1000)
self.a.plot(self.pos[0], self.pos[1], 'r.')
plt.axis('off')
self.a.set_xlim(0, 1)
self.a.set_ylim(0, 1)
plt.tight_layout()
self.canvas.draw()
def closeEntryWindow(self):
self.entryWindow.destroy()
def openEntryWindow(self, x, y):
self.pos = (x, y)
self.draw()
self.entryWindow = Tk()
self.entryWindow.wm_title("Type in node details")
self.entryWindow.protocol("WM_DELETE_WINDOW", self.closeEntryWindow)
Label(self.entryWindow, text="Genotype").grid(row=0,
column=0,
sticky=W,
pady=1)
self.genentry = Entry(self.entryWindow)
self.genentry.grid(row=0, column=1, sticky=W, pady=1)
self.genentry.bind("<Return>", self.Enter)
Label(self.entryWindow, text="Date").grid(row=1,
column=0,
sticky=W,
pady=1)
self.datentry = Entry(self.entryWindow)
self.datentry.grid(row=1, column=1, sticky=W, pady=1)
self.datentry.bind("<Return>", self.Enter)
def Enter(self, event):
name = self.genentry.get()
date = self.datentry.get()
print(name, date)
self.G.addNode(name, self.pos, self.colors[0], date)
self.draw()
self.entryWindow.destroy()
def on_press(self, event):
if event.xdata is not None and event.ydata is not None:
#print('you pressed', event.button, event.xdata, event.ydata)
if not self.G.isNear((event.xdata, event.ydata),
self.getScale(self.f.gca().get_xlim(),
self.f.gca().get_ylim())):
self.openEntryWindow(event.xdata, event.ydata)
def getScale(self, x, y):
return (x[1] - x[0], y[1] - y[0])
class VBDCMM_gui_simul:
def __init__( self, parent ):
self.myParent = parent
# --- Model parameters ------------------------------
self.K_true = Tk.IntVar(master=parent)
self.K_true.trace('w', self.on_K_change)
self.K_true_max = 4
self.L_true = Tk.IntVar(master=parent)
self.L_true.trace('w', self.on_L_change )
self.L_true_max = 4
self.T_xhh = Tk.IntVar(master=parent)
self.T_xhh.trace('w', self.on_T_xhh_change )
self.T_o = Tk.IntVar(master=parent)
self.T_xhh_default = 4400
self.T_o_default = self.T_xhh_default+1
self.time_xhh = arange(0, self.T_xhh_default, 1)
self.xhh_arr = zeros( self.T_xhh_default ) # internal states index starts from 0. However, for plotting, it starts from 1
self.time_o = arange(0, self.T_o_default, 1)
self.xh_arr = zeros( self.T_o_default ) # internal states index starts from 0. However, for plotting, it starts from 1
self.o_arr = 0.5*ones(self.T_o_default ) + 0.1*randn( self.T_o_default )
# Grids coordinates -----------------------------
grid_label_K_true = (0, 0) # row, column, rowspan, columnspan
grid_entry_K_true = (0, 1)
grid_label_T_xhh = (0, 2)
grid_entry_T_xhh = (0, 3)
grid_label_A = (0, 4)
grid_entry_A = (0, 5)
grid_button_generate_params = (1, 5+self.K_true_max, 2, 2)
grid_button_generate_trace_xhh = (0+self.K_true_max, 4, 1, 2)
grid_canvas_xhh = (0+self.K_true_max, 0, 1, self.L_true_max*4 + 6)
grid_label_L_true = (0+self.K_true_max+1, 0) # row, column, rowspan, columnspan
grid_entry_L_true = (0+self.K_true_max+1, 1)
grid_label_mu_true = (0+self.K_true_max+1, 2)
grid_entry_mu1_true = (0+self.K_true_max+1, 3)
grid_entry_mu2_true = (0+self.K_true_max+2, 3)
grid_entry_mu3_true = (0+self.K_true_max+3, 3)
grid_entry_mu4_true = (0+self.K_true_max+4, 3)
grid_label_sig_true = (0+self.K_true_max+1, 4)
grid_entry_sig1_true = (0+self.K_true_max+1, 5)
grid_entry_sig2_true = (0+self.K_true_max+2, 5)
grid_entry_sig3_true = (0+self.K_true_max+3, 5)
grid_entry_sig4_true = (0+self.K_true_max+4, 5)
grid_label_B1 = (0+self.K_true_max+1, 6)
grid_entry_B1 = (0+self.K_true_max+1, 7)
grid_label_B2 = (0+self.K_true_max+1, 7+self.L_true_max)
grid_entry_B2 = (0+self.K_true_max+1, 7+self.L_true_max+1)
grid_label_B3 = (0+self.K_true_max+1, 7+2*self.L_true_max+1)
grid_entry_B3 = (0+self.K_true_max+1, 7+2*self.L_true_max+2)
grid_label_B4 = (0+self.K_true_max+1, 7+3*self.L_true_max+2)
grid_entry_B4 = (0+self.K_true_max+1, 7+3*self.L_true_max+3)
grid_button_generate_trace_o = (0+self.K_true_max+1+self.L_true_max, 4, 1, 2)
grid_canvas_o = (0+self.K_true_max+1+self.L_true_max, 0, 1, self.L_true_max*4+6)
grid_label_save_filename = (0+1*self.K_true_max+1+self.L_true_max, 17, 1, 2)
grid_entry_save_filename = (0+1*self.K_true_max+1+self.L_true_max, 19, 1, 2)
grid_button_save_traces = (0+1*self.K_true_max+1+self.L_true_max, 22, 1, 2)
grid_button_analysis = (0+1*self.K_true_max+1+self.L_true_max, 24, 1, 2)
# Variables ---------------------------
_s = ''
for i in range(1,self.K_true_max+1):
for j in range(1,self.K_true_max+1):
_s += '\n'+'self.A' + str(i) + str(j) + ' = Tk.DoubleVar(master=parent)'
_s += '\n'+'self.A' + str(i) + str(j) + '.trace("w", self.on_A_change)'
exec(_s)
_s = ''
for k in range(1, self.K_true_max+1):
for i in range(1,self.L_true_max+1):
for j in range(1,self.L_true_max+1):
_s += '\n'+'self.B' +str(k) + str(i) + str(j) + ' = Tk.DoubleVar(master=parent)'
_s += '\n'+'self.B' +str(k) + str(i) + str(j) + '.trace("w", self.on_B_change)'
exec(_s)
_s = ''
for i in range(1,self.L_true_max+1):
_s += '\n'+'self.mu'+str(i)+'_true = Tk.DoubleVar(master=parent)'
_s += '\n'+'self.mu'+str(i)+'_true.trace("w", self.on_mu_change)'
_s += '\n'+'self.sig'+str(i)+'_true = Tk.DoubleVar(master=parent)'
_s += '\n'+'self.sig'+str(i)+'_true.trace("w", self.on_sig_change)'
exec(_s)
# --- Set initial values -----------------------------
self.K_default = 2
self.K_true.set(self.K_default)
self.T_xhh.set(self.T_xhh_default)
self.T_o.set(self.T_o_default)
self.L_default = 2
self.L_true.set(self.L_default)
_s = ''
for i in range(1,self.K_default+1):
for j in range(1,self.K_default+1):
if i != j:
_s += '\n'+'self.A' + str(i) + str(j) + '.set(' + str( 0.001/(self.K_default-1)) + ')'
if i == j:
_s += '\n'+'self.A' + str(i) + str(j) + '.set(' + str( 1 - 0.001) + ')'
exec(_s)
_s = ''
for k in range(1, self.K_default+1):
for i in range(1,self.L_default+1):
for j in range(1,self.L_default+1):
if i != j:
_s += '\n'+'self.B' + str(k) + str(i) + str(j) + '.set(' + str( (1/4**(k-1) * 0.1)/(self.L_default-1)) + ')'
if i == j:
_s += '\n'+'self.B' + str(k) + str(i) + str(j) + '.set(' + str( 1 - 1/4**(k-1) * 0.1) + ')'
exec(_s)
_s = ''
for i in range(1,self.L_default+1):
_s += '\n'+'self.mu'+str(i)+'_true.set(' + str( 0.1 + 0.8/(self.L_default-1)* (i-1) ) + ')'
exec(_s)
_s = ''
for i in range(1,self.L_default+1):
_s += '\n'+'self.sig'+str(i)+'_true.set('+ str( 0.15/self.L_default ) + ')'
exec(_s)
# --- Set trace function ---
#self.K_true.trace('w', on_change_K_true)
# --- Labels ---
self.label_K_true = Tk.Label( master=parent, width=2, text='K:' )
self.label_A = Tk.Label( master=parent, width=2, text='A:' )
self.label_T_xhh = Tk.Label( master=parent, width=2, text='T:' )
self.label_L_true = Tk.Label( master=parent, width=2, text='N:' )
self.label_mu_true = Tk.Label( master=parent, width=2, text='mu:')
self.label_sig_true = Tk.Label( master=parent, width=2, text='sig:')
self.label_B1 = Tk.Label( master=parent, width=2, text='B1:')
self.label_B2 = Tk.Label( master=parent, width=2, text='B2:')
self.label_B3 = Tk.Label( master=parent, width=2, text='B3:')
self.label_B4 = Tk.Label( master=parent, width=2, text='B4:')
# --- Labels grid ---
self.label_K_true.grid( row=grid_label_K_true[0], column=grid_label_K_true[1] )
self.label_A.grid( row=grid_label_A[0], column=grid_label_A[1] )
self.label_T_xhh.grid( row=grid_label_T_xhh[0], column=grid_label_T_xhh[1] )
self.label_L_true.grid( row=grid_label_L_true[0], column=grid_label_L_true[1] )
self.label_mu_true.grid( row=grid_label_mu_true[0], column=grid_label_mu_true[1] )
self.label_sig_true.grid( row=grid_label_sig_true[0], column=grid_label_sig_true[1] )
self.label_B1.grid( row=grid_label_B1[0], column=grid_label_B1[1] )
self.label_B2.grid( row=grid_label_B2[0], column=grid_label_B2[1] )
self.label_B3.grid( row=grid_label_B3[0], column=grid_label_B3[1] )
self.label_B4.grid( row=grid_label_B4[0], column=grid_label_B4[1] )
self.save_filename = Tk.StringVar(master=parent, value='batch1')
self.label_save_filename = Tk.Label( master=parent, width=9, text='Filename:')
self.label_save_filename.grid( row=grid_label_save_filename[0], column=grid_label_save_filename[1],
rowspan=grid_entry_save_filename[2],columnspan=grid_entry_save_filename[3])
self.entry_save_filename = Tk.Entry(master=parent, width=9, textvariable=self.save_filename )
self.entry_save_filename.grid( row=grid_entry_save_filename[0], column=grid_entry_save_filename[1],
rowspan=grid_entry_save_filename[2],columnspan=grid_entry_save_filename[3])
# --- Button ---
self.button_generate_params = Tk.Button(text='Gen. Params', width=8, command=self.on_click_button_generate_params, height=4)
self.button_generate_params.grid( row=grid_button_generate_params[0], column=grid_button_generate_params[1],
rowspan=grid_button_generate_params[2], columnspan=grid_button_generate_params[3],
sticky='EW')
self.button_save_traces = Tk.Button(text='Save. traces', width=10, command=self.on_click_button_save_traces, height=4)
self.button_save_traces.grid( row=grid_button_save_traces[0], column=grid_button_save_traces[1],
rowspan=grid_button_save_traces[2], columnspan=grid_button_save_traces[3],
sticky='EW')
self.button_analysis = Tk.Button(text='Analyze traces', width=8, command=self.on_click_button_analysis, height=4)
self.button_analysis.grid( row=grid_button_analysis[0], column=grid_button_analysis[1],
rowspan=grid_button_analysis[2], columnspan=grid_button_analysis[3],
sticky='EW')
self.button_generate_trace_xhh = Tk.Button(text='Gen. X', width=8, command=self.on_click_button_generate_trace_xhh, relief=Tk.SUNKEN, height=4)
self.button_generate_trace_xhh.grid( row=grid_button_generate_trace_xhh[0], column=grid_button_generate_trace_xhh[1],
rowspan=grid_button_generate_trace_xhh[2], columnspan=grid_button_generate_trace_xhh[3],
sticky='EW')
self.button_generate_trace_o = Tk.Button(text='Gen. O', width=8, command=self.on_click_button_generate_trace_o, relief=Tk.SUNKEN, height=4)
self.button_generate_trace_o.grid( row=grid_button_generate_trace_o[0], column=grid_button_generate_trace_o[1],
rowspan=grid_button_generate_trace_o[2], columnspan=grid_button_generate_trace_o[3],
sticky='EW')
# --- Entries ---
#self.entry_K_true = Tk.Entry( relief=Tk.SOLID, master=parent, textvariable=self.K_true, width=3) # SOLID: style. Clearer boundary
self.entry_K_true = Tk.Spinbox( relief=Tk.RIDGE, master=parent, textvariable=self.K_true, width=3, value=(1,2,3,4) ) # SOLID: style. Clearer boundary
self.K_true.set(self.K_default)
self.entry_T_xhh = Tk.Entry( relief=Tk.SOLID, master=parent, textvariable=self.T_xhh, width=5) # SOLID: style. Clearer boundary
#self.entry_L_true = Tk.Entry( relief=Tk.SOLID, master=parent, textvariable=self.L_true, width=3) # SOLID: style. Clearer boundary
self.entry_L_true = Tk.Spinbox( relief=Tk.RIDGE, master=parent, textvariable=self.L_true, width=3, value=(1,2,3,4) ) # SOLID: style. Clearer boundary
self.L_true.set(self.L_default)
_s = ''
for i in range(1,self.K_true_max+1):
for j in range(1,self.K_true_max+1):
_s += '\n'+'self.entry_A' + str(i) + str(j) + ' = Tk.Entry(relief=Tk.RIDGE, master=parent, textvariable=self.A'+str(i)+str(j)+', width=7)'
if i <= self.K_default and j <= self.K_default:
_s += '\n'+'self.entry_A' + str(i) + str(j) + '.config(relief=Tk.SOLID)'
exec(_s)
_s = ''
for i in range(1,self.L_true_max+1):
_s += '\n'+'self.entry_mu' + str(i) + '_true = Tk.Entry(relief=Tk.RIDGE, master=parent, textvariable=self.mu'+str(i)+'_true, width=5)'
_s += '\n'+'self.entry_sig' + str(i) + '_true = Tk.Entry(relief=Tk.RIDGE, master=parent, textvariable=self.sig'+str(i)+'_true, width=5)'
if i <= self.L_default:
_s += '\n'+'self.entry_mu' + str(i) + '_true.config(relief=Tk.SOLID)'
_s += '\n'+'self.entry_sig' + str(i) + '_true.config(relief=Tk.SOLID)'
exec(_s)
_s = ''
for k in range(1, self.K_true_max+1):
for i in range(1,self.L_true_max+1):
for j in range(1,self.L_true_max+1):
_s += '\n'+'self.entry_B' + str(k) + str(i) + str(j) + ' = Tk.Entry(relief=Tk.RIDGE, master=parent, textvariable=self.B'+str(k)+str(i)+str(j)+', width=5)'
if k <= self.K_default and i <= self.L_default and j <=self.L_default:
_s += '\n'+'self.entry_B' + str(k) + str(i) + str(j) + '.config(relief=Tk.SOLID)'
exec(_s)
# --- Entry grid ---
self.entry_K_true.grid(row=grid_entry_K_true[0], column=grid_entry_K_true[1], pady=0.1)
self.entry_T_xhh.grid(row=grid_entry_T_xhh[0], column=grid_entry_T_xhh[1], pady=0.1)
self.entry_L_true.grid(row=grid_entry_L_true[0], column=grid_entry_L_true[1], pady=0.1)
_s = ''
for i in range(1,self.K_true_max+1):
for j in range(1,self.K_true_max+1):
_row = (i-1) + grid_entry_A[0]
_column = (j-1) + grid_entry_A[1]
_s += '\n'+'self.entry_A' + str(i) + str(j) + '.grid(row='+str(_row)+', column='+str(_column)+', pady=0.1)'
exec(_s)
_s = ''
for i in range(1,self.L_true_max+1):
_row = eval( 'grid_entry_mu' + str(i) + '_true[0]')
_column = eval( 'grid_entry_mu' + str(i) + '_true[1]')
_s += '\n'+'self.entry_mu' + str(i) + '_true.grid(row='+str(_row)+', column='+str(_column)+', pady=0.1)'
exec(_s)
_s = ''
for i in range(1,self.L_true_max+1):
_row = eval( 'grid_entry_sig' + str(i) + '_true[0]')
_column = eval( 'grid_entry_sig' + str(i) + '_true[1]')
_s += '\n'+'self.entry_sig' + str(i) + '_true.grid(row='+str(_row)+', column='+str(_column)+', pady=0.1)'
exec(_s)
_s = ''
for k in range(1, self.K_true_max+1):
for i in range(1,self.L_true_max+1):
for j in range(1,self.L_true_max+1):
# "exec" doesnt work inside of loop.
_row = (i-1) + eval('grid_entry_B'+str(k)+'[0]' )
_column = (j-1) + eval('grid_entry_B'+str(k)+'[1]' )
_s += '\n'+'self.entry_B' + str(k) + str(i) + str(j) + '.grid(row='+str(_row)+', column='+str(_column)+', pady=0.1)'
exec(_s)
# -------- Canvas --------
_figsize_x = 7
_figsize_y = 2
_padx_1 = 0
_pady_1 = 0
_rect = [0.10, 0.3, 0.8, 0.6]
fign_xhh = 1
fign_o = 2
fign_xhh_VBDCMM = 3
self.fig_xhh = figure(num=fign_xhh, figsize=(_figsize_x, _figsize_y), facecolor='w')
self.ax_xhh = self.fig_xhh.add_axes(_rect)
self.ax_xhh.plot(self.time_xhh, self.xhh_arr+1,'k', linewidth=2)
self.ax_xhh.set_ylim([0.5, self.K_default + 0.5] )
self.ax_xhh.set_yticks( arange(1, self.K_default+1, 1) )
self.ax_xhh.grid(True)
self.ax_xhh.hold(False)
self.canvas_xhh = FigureCanvasTkAgg(self.fig_xhh, master=parent)
self.canvas_xhh.show()
self.tk_canvas_xhh = self.canvas_xhh.get_tk_widget()
self.tk_canvas_xhh.grid( row=grid_canvas_xhh[0], column=grid_canvas_xhh[1],
rowspan=grid_canvas_xhh[2], columnspan=grid_canvas_xhh[3],
padx=_padx_1, pady=_pady_1 )
xlabel('Time (dt=1)')
ylabel('X')
cid1 = self.canvas_xhh.mpl_connect('button_press_event', self.on_figure_click)
cid2 = self.canvas_xhh.mpl_connect('close_event', self.on_destroy)
self.fig_o = figure(num=fign_o, figsize=(_figsize_x, _figsize_y), facecolor='w')
self.ax_o = self.fig_o.add_axes(_rect)
self.ax_o.plot(self.time_o, self.o_arr,'b')
self.ax_o.set_ylim([-0.2, 1.2])
self.ax_o.set_yticks([0, 0.5, 1.0])
self.ax_o.grid(True)
self.ax_o.hold(False)
self.canvas_o = FigureCanvasTkAgg(self.fig_o, master=parent)
self.canvas_o.show()
self.tk_canvas_o = self.canvas_o.get_tk_widget()
self.tk_canvas_o.grid( row=grid_canvas_o[0], column=grid_canvas_o[1],
rowspan=grid_canvas_o[2], columnspan=grid_canvas_o[3],
padx=_padx_1, pady=_pady_1 )
xlabel('Time (dt=1)')
ylabel('O')
cid1 = self.canvas_o.mpl_connect('button_press_event', self.on_figure_click)
cid2 = self.canvas_o.mpl_connect('close_event', self.on_destroy)
def on_destroy(self, event):
"""
Without this..., loop after close the figure
"""
print('Destroy!!')
self.myParent.quit()
def on_figure_click(self, event):
print('you pressed', event.button, event.x, event.y, event.xdata, event.ydata)
#print('e1_number: ' + str(self.e1_number.get()) )
def on_click_button_generate_params(self):
print('Generated parameters')
_K = self.K_true.get()
_L = self.L_true.get()
_T = self.T_xhh.get()
_s = ''
for i in range(1,_K+1):
for j in range(1,_K+1):
if i != j:
_s += '\n'+'self.A' + str(i) + str(j) + '.set(' + str( 0.0005/(_K-1)) + ')'
if i == j:
_s += '\n'+'self.A' + str(i) + str(j) + '.set(' + str( 1 - 0.0005) + ')'
exec(_s)
_s = ''
for k in range(1, _K+1):
for i in range(1, _L+1):
for j in range(1, _L+1):
if i != j:
_s += '\n'+'self.B' + str(k) + str(i) + str(j) + '.set(' + str( (1/4**(k-1) * 0.1)/(_L-1)) + ')'
if i == j:
_s += '\n'+'self.B' + str(k) + str(i) + str(j) + '.set(' + str( 1 - 1/4**(k-1) * 0.1) + ')'
exec(_s)
_s = ''
for i in range(1,_L+1):
_s += '\n'+'self.mu'+str(i)+'_true.set(' + str( 0.1 + 0.8/(_L-1)* (i-1) ) + ')'
exec(_s)
_s = ''
for i in range(1,_L+1):
_s += '\n'+'self.sig'+str(i)+'_true.set('+ str( 0.15/_L ) + ')'
exec(_s)
def on_click_button_save_traces(self):
print('Save traces to %s.dat' % self.save_filename.get())
filename_0 = self.save_filename.get()
savetxt(filename_0 + '_X_true_trace.dat', self.xhh_arr, fmt='%d')
savetxt(filename_0 + '_O_filt_true.dat', self.xh_arr, fmt='%.3f' )
savetxt(filename_0 + '_O_true.dat', self.o_arr, fmt='%.3f' )
# save A
_K = self.K_true.get()
_T = self.T_xhh.get()
self.A = zeros( [_K, _K] )
for i in range(1, _K+1):
for j in range(1, _K+1):
self.A[i-1, j-1] = eval( 'self.A' + str(i) + str(j) + '.get()' )
savetxt(filename_0+'_A_true.dat', self.A, fmt='%.9f' )
_L = self.L_true.get()
self.B = zeros( [_K, _L, _L] )
self.mu_arr = zeros( _L )
self.sig_arr = zeros( _L )
# save B
for k in range(1, _K+1):
for i in range(1, _L+1):
for j in range(1, _L+1):
self.B[k-1, i-1, j-1] = eval( 'self.B' + str(k) + str(i) + str(j) + '.get()' )
savetxt(filename_0+'_B'+str(k)+'_true.dat', self.B[k-1,:,:], fmt='%.9f' )
# save mu and sig
self.mu_arr = zeros( _L )
self.sig_arr = zeros( _L )
for i in range(1, _L+1):
self.mu_arr[i-1] = eval('self.mu'+str(i)+'_true.get()')
self.sig_arr[i-1] = eval('self.sig'+str(i)+'_true.get()')
savetxt(filename_0+'_mu_arr_true.dat', self.mu_arr, fmt='%.3f' )
savetxt(filename_0+'_sig_arr_true.dat', self.sig_arr, fmt='%.3f' )
def on_click_button_analysis(self):
print('VB-DCMM analysis')
VBDCMM_gui_analaysis_func(self.o_arr)
def on_click_button_generate_trace_xhh(self):
print('Generate trace_xhh')
# Construct A matrix
_K = self.K_true.get()
_T = self.T_xhh.get()
self.A = zeros( [_K, _K] )
for i in range(1, _K+1):
for j in range(1, _K+1):
self.A[i-1, j-1] = eval( 'self.A' + str(i) + str(j) + '.get()' )
self.xhh_arr = generate_xhh_func( _T, _K, self.A )
self.ax_xhh.plot(self.time_xhh, self.xhh_arr+1, 'k', linewidth=2)
self.ax_xhh.set_ylim([0.5, _K + 0.5] )
self.ax_xhh.set_yticks( arange(1, _K+1, 1) )
self.ax_xhh.grid(True)
self.ax_xhh.set_xlabel('Time (dt=1)')
self.ax_xhh.set_ylabel('X')
self.fig_xhh.canvas.draw()
def on_click_button_generate_trace_o(self):
print('Generate trace_xhh')
# Construct A matrix
_K = self.K_true.get()
_L = self.L_true.get()
_T = self.T_xhh.get()
self.A = zeros( [_K, _K] )
self.B = zeros( [_K, _L, _L] )
self.mu_arr = zeros( _L )
self.sig_arr = zeros( _L )
for k in range(1, _K+1):
for i in range(1, _L+1):
for j in range(1, _L+1):
self.B[k-1, i-1, j-1] = eval( 'self.B' + str(k) + str(i) + str(j) + '.get()' )
for i in range(1, _L+1):
self.mu_arr[i-1] = eval('self.mu'+str(i)+'_true.get()')
self.sig_arr[i-1] = eval('self.sig'+str(i)+'_true.get()')
self.xh_arr, self.o_arr = generate_o_func( self.xhh_arr, _K, _L, self.B, self.mu_arr, self.sig_arr )
self.ax_o.plot(self.time_o, self.o_arr)
self.ax_o.set_ylim([-0.2, 1.2])
self.ax_o.set_yticks([0, 0.5, 1.0])
self.ax_o.grid(True)
self.ax_o.set_xlabel('Time (dt=1)')
self.ax_o.set_ylabel('O')
self.fig_o.canvas.draw()
def on_K_change(self, *args):
try:
_K = self.K_true.get()
_L = self.L_true.get()
#print( 'K: ' + str( _K ) )
_s = ''
for i in range(1, self.K_true_max+1):
for j in range(1, self.K_true_max+1):
# if i >= _K+1 or j >= _K+1:
# _s += '\n'+'self.A' + str(i) + str(j) + '.set(0.0)'
if i <= _K and j <= _K:
_s += '\n'+'self.entry_A' + str(i) + str(j) + '.config(relief=Tk.SOLID)'
else:
_s += '\n'+'self.entry_A' + str(i) + str(j) + '.config(relief=Tk.RIDGE)'
exec(_s)
for k in range(1, self.K_true_max+1):
for i in range(1, self.L_true_max+1):
for j in range(1, self.L_true_max+1):
if k <= _K and i <= _L and j <= _L:
_s += '\n'+'self.entry_B' + str(k) + str(i) + str(j) + '.config(relief=Tk.SOLID)'
else:
_s += '\n'+'self.entry_B' + str(k) + str(i) + str(j) + '.config(relief=Tk.RIDGE)'
exec(_s)
# special order
if _K == 1:
self.A11.set(1.0)
except:
pass
def on_L_change(self, *args):
try:
_K = self.K_true.get()
_L = self.L_true.get()
#print( 'N: ' + str( _L ) )
_s = ''
for k in range(1, self.K_true_max+1):
for i in range(1, self.L_true_max+1):
for j in range(1, self.L_true_max+1):
if k <= _K and i <= _L and j <= _L:
_s += '\n'+'self.entry_B' + str(k) + str(i) + str(j)+'.config(relief=Tk.SOLID)'
else:
_s += '\n'+'self.entry_B' + str(k) + str(i) + str(j) + '.config(relief=Tk.RIDGE)'
exec(_s)
_s = ''
for i in range(1, self.L_true_max+1):
if i <= _L:
_s += '\n'+'self.entry_mu' + str(i) + '_true.config(relief=Tk.SOLID)'
_s += '\n'+'self.entry_sig' + str(i) + '_true.config(relief=Tk.SOLID)'
else:
_s += '\n'+'self.entry_mu' + str(i) + '_true.config(relief=Tk.RIDGE)'
_s += '\n'+'self.entry_sig' + str(i) + '_true.config(relief=Tk.RIDGE)'
exec(_s)
except:
pass
def on_A_change(self, *args):
pass
def on_B_change(self, *args):
pass
def on_mu_change(self, *args):
pass
def on_sig_change(self, *args):
pass
def on_T_xhh_change(self, *args):
try:
_T = self.T_xhh.get()
self.time_xhh = arange(0, _T, 1)
self.time_o = arange(0, _T+1, 1)
#print('T changed to %d.' % _T )
except: # to catch error generated when the entry is empty.
pass
class App(object): #swapped out object, tk.Frame
def __init__(self, master):
self.rt = master
self.rt.protocol("WM_DELETE_WINDOW", self.onClosing)
self.menu = tk.Menu(self.rt)
self.rt.title('NMR GUI - Potter')
self.rt.config(menu=self.menu)
self.filemenu = tk.Menu(self.menu)
self.menu.add_cascade(label='File', menu=self.filemenu)
self.Master = master
self.filemenu.add_command(label='New')
self.filemenu.add_command(label='Open', command=self.openFile)
self.filemenu.add_separator()
self.filemenu.add_command(
label='Exit',
command=lambda: [root.quit(), root.destroy()])
self.helpmenu = tk.Menu(self.menu)
self.menu.add_cascade(label='Help', menu=self.helpmenu)
self.helpmenu.add_command(label='About', command=self.launchHelpWindow)
self.analysismenu = tk.Menu(self.menu)
self.menu.add_cascade(label='Analysis', menu=self.analysismenu)
self.analysismenu.add_command(label='Integrate',
command=self.openIntegrationModule)
self.analysismenu.add_command(label='EditIntegralList',
command=self.showIntegralList)
self.analysismenu.add_command(label='Calibrate',
command=self.calibrate)
self.xShift = 0.0
self.showIntVar1 = tk.IntVar()
self.calOn = 0
self.intVar1 = tk.IntVar()
self.showPeakVar1 = tk.IntVar()
self.calVar1 = tk.IntVar()
self.startCoords = []
self.endCoords = []
self.integrals = []
self.intListVar = []
self.intGraphics1 = []
self.intGraphics2 = []
self.peakList = []
self.peakGraphics1 = []
self.intCheckBoxes = []
self.intDeleteButtons = []
self.rt.mainloop()
def openFile(self):
self.filename = askopenfilename(parent=self.rt)
with open(self.filename, mode='r') as file:
self.data = pd.read_csv(file, names=['x', 'y'])
self.th = 0.0
self.t1Top = tk.Frame(self.rt)
self.t1Bottom = tk.Frame(self.rt)
self.t1Top.pack(side=tk.TOP)
self.t1Bottom.pack(side=tk.BOTTOM)
self.t1Left = tk.Frame(self.t1Top)
self.t1Right = tk.Frame(self.t1Top)
self.t1Left.pack(side=tk.LEFT)
self.t1Right.pack(side=tk.RIGHT)
self.fig = plt.figure()
self.ax = self.fig.add_subplot(111)
self.ax.set_xlim(self.data['x'].max(), self.data['x'].min())
self.ax.plot(self.data['x'], self.data['y'])
self.canvas = FigureCanvasTkAgg(self.fig, master=self.rt)
self.canvas.draw()
#self.canvas.get_tk_widget().pack(in_ = self.t1Right, fill = tk.BOTH, expand = 1)
self.canvas.get_tk_widget().pack(in_=self.t1Right,
fill=tk.BOTH,
expand=True)
self.toolbar = NavigationToolbar2Tk(self.canvas, self.rt)
self.toolbar.update()
#self.canvas.get_tk_widget().pack(in_ = self.t1Right, fill = tk.BOTH, expand = 1)
self.canvas.get_tk_widget().pack(in_=self.t1Right,
fill=tk.BOTH,
expand=True)
self.xShiftScale = tk.Scale(self.rt,
from_=self.data['y'].max(),
to_=self.data['y'].min())
self.xShiftScale.pack(in_=self.t1Left)
self.showIntToggle = tk.Checkbutton(self.rt,
text='Show Integrals',
variable=self.showIntVar1,
command=self.showIntegrals)
self.showIntToggle.pack(in_=self.t1Bottom, side=tk.RIGHT)
self.showPeaksToggle = tk.Checkbutton(self.rt,
text='Show Peaks',
variable=self.showPeakVar1,
command=self.showPeaks)
self.showPeaksToggle.pack(in_=self.t1Bottom, side=tk.RIGHT)
def openIntegrationModule(self):
self.t = tk.Toplevel(self.rt)
self.t.protocol("WM_DELETE_WINDOW", self.onIntClosing)
self.t.wm_title("Integration Module")
self.intFig = plt.figure()
self.intAx = self.intFig.add_subplot(111)
self.intAx.set_xlim(self.data['x'].max(), self.data['x'].min())
self.intAx.plot(self.data['x'], self.data['y'])
self.canvas2 = FigureCanvasTkAgg(self.intFig, master=self.t)
self.canvas2.draw()
self.canvas2.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
self.toolbar2 = NavigationToolbar2Tk(self.canvas2, self.t)
self.toolbar2.update()
self.canvas2.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
self.intToggle = tk.Checkbutton(self.t,
text="Integration Mode",
variable=self.intVar1,
command=self.integrate)
self.intToggle.pack(side=tk.LEFT)
def onclick(self, event):
ix = event.xdata
self.startCoords.append(ix)
def onrelease(self, event):
ix = event.xdata
self.endCoords.append(ix)
pint.drawTraps(self.data,
min([self.startCoords[-1], self.endCoords[-1]]),
max([self.startCoords[-1], self.endCoords[-1]]),
self.intAx)
self.canvas2.draw()
def integrate(self):
if self.intVar1.get() == 1:
self.cid1 = self.canvas2.mpl_connect('button_press_event',
self.onclick)
self.cid2 = self.canvas2.mpl_connect('button_release_event',
self.onrelease)
else:
self.canvas2.mpl_disconnect(self.cid1)
self.canvas2.mpl_disconnect(self.cid2)
def onClosing(self):
if messagebox.askokcancel("Quit", "Do you want to quit?"):
self.rt.quit()
self.rt.destroy()
def onIntClosing(self):
if messagebox.askokcancel("Quit", "Save integrals?"):
tempInts = []
for i in range(len(self.startCoords)):
tempInts.append(min([self.startCoords[i], self.endCoords[i]]))
tempInts.append(max([self.startCoords[i], self.endCoords[i]]))
tempInts.append(
pint.trapInt(self.data, tempInts[0], tempInts[1]))
tempInts.append(1)
self.integrals.append(tempInts.copy())
tempInts.clear()
self.startCoords.clear()
self.endCoords.clear()
self.t.destroy()
def showIntegrals(self):
if self.showIntVar1.get() == 1:
for i in range(len(self.integrals)): #this is the region marker
if (self.integrals[i][3] == 1 and not self.intListVar) or (
self.integrals[i][3] == 1
and self.intListVar[i].get() == 1):
self.intGraphics1.append(
self.ax.annotate('',
xy=(self.integrals[i][0], 0),
xytext=(self.integrals[i][1], 0),
arrowprops=dict(arrowstyle='<->',
facecolor='red'),
annotation_clip=False))
for i in range(len(self.integrals)
): #this is the line connecting the integral value
if (self.integrals[i][3] == 1 and not self.intListVar) or (
self.integrals[i][3] == 1
and self.intListVar[i].get() == 1):
self.intGraphics2.append(
self.ax.annotate(
'{:.2f}'.format(self.integrals[i][2]),
xy=(self.integrals[i][0] + (
(self.integrals[i][1] - self.integrals[i][0]) /
2), 0),
xytext=(self.integrals[i][0] + (
(self.integrals[i][1] - self.integrals[i][0]) /
2), -3),
arrowprops=dict(arrowstyle='-', facecolor='red'),
annotation_clip=False))
self.canvas.draw()
else:
for i in self.intGraphics1:
i.remove()
for i in self.intGraphics2:
i.remove()
self.intGraphics1.clear()
self.intGraphics2.clear()
self.canvas.draw()
def showIntegralList(self):
self.t2 = tk.Toplevel(self.rt)
self.t2.protocol("WM_DELETE_WINDOW", self.onCloseIntegralListWindow)
self.t2.wm_title("Integrals")
self.t2Top = tk.Frame(self.t2)
self.t2Bottom = tk.Frame(self.t2)
self.t2Top.pack(side=tk.TOP)
self.t2Bottom.pack(side=tk.BOTTOM)
self.t2Left = tk.Frame(self.t2Bottom)
self.t2Right = tk.Frame(self.t2Bottom)
self.t2Left.pack(side=tk.LEFT)
self.t2Right.pack(side=tk.RIGHT)
for i in range(len(self.integrals)):
self.intListVar.append(tk.IntVar(value=1))
self.intCheckBoxes.append(
tk.Checkbutton(self.t2Left,
text=str(len(self.integrals) - i) + '\t' +
'{:.2f}'.format(self.integrals[i][0]) + '\t' +
'{:.2f}'.format(self.integrals[i][1]) + '\t' +
'{:.2f}'.format(self.integrals[i][2]),
variable=self.intListVar[i],
width=40))
self.intDeleteButtons.append(
tk.Button(
self.t2Right,
text='Delete: ' + str((len(self.integrals) - i)),
command=lambda c=i: self.deleteInt(self.integrals, c))
) # why not lambda:self.integrals[len(self.integrals)-i-1] ????
self.intCheckBoxes[i].pack(in_=self.t2Left,
side=tk.BOTTOM,
fill=tk.X)
self.intDeleteButtons[i].pack(in_=self.t2Right, side=tk.BOTTOM)
def deleteInt(self, ar, inx):
del self.integrals[int(inx)]
def onCloseIntegralListWindow(self):
self.intCheckBoxes.clear()
self.intDeleteButtons.clear()
self.canvas.draw()
self.t2Left.destroy()
self.t2Right.destroy()
self.t2Bottom.destroy()
self.t2Top.destroy()
self.t2.destroy()
def showPeaks(self): # removed parameter th
self.th = self.xShiftScale.get()
self.peakList = find_peaks(self.data['y'].to_numpy(), self.th)
if self.showPeakVar1.get() == 1:
a = 0
for i in range(len(self.peakList[0])):
if ((self.data.iloc[self.peakList[0][i - 1]][1] <
self.data.iloc[self.peakList[0][i]][1]) and
((self.data.iloc[self.peakList[0][i - 1]][1]) >=
(self.data.iloc[self.peakList[0][i]][1] - 0.1))
or ((self.data.iloc[self.peakList[0][i - 1]][1] >
(self.data.iloc[self.peakList[0][i]][1])) and
((self.data.iloc[self.peakList[0][i - 1]][1]) <=
(self.data.iloc[self.peakList[0][i]][1] + 0.1)))):
a = a + 1
else:
a = a + 0
self.peakGraphics1.append(
self.ax.annotate(
'{:.2f}'.format(
self.data.iloc[self.peakList[0][i]][0]),
xy=(self.data.iloc[self.peakList[0][i]][0],
self.data.iloc[self.peakList[0][i]][1]),
xytext=(self.data.iloc[self.peakList[0][i]][0],
self.data.iloc[self.peakList[0][i]][1] + a)))
self.canvas.draw()
else:
for i in self.peakGraphics1:
i.remove()
self.peakGraphics1.clear()
self.canvas.draw()
def onclick2(self, event):
ix = event.xdata
self.xShift = ix
self.data['x'] = self.data['x'] - self.xShift
self.shiftIntegrals(self.integrals, self.xShift)
self.calOn = 0
self.canvas.mpl_disconnect(self.cid3)
self.rt.config(cursor='')
def shiftIntegrals(self, iL, sh):
msgBox = tk.messagebox.askquestion(
'Shift Integrals',
'Shift integrals along with spectrum?',
icon='warning')
if msgBox == 'yes':
self.integralShift(iL, sh)
self.ax.cla()
self.ax.set_xlim(self.data['x'].max(), self.data['x'].min())
self.ax.plot(self.data['x'], self.data['y'])
self.canvas.draw()
else:
self.ax.cla()
self.ax.set_xlim(self.data['x'].max(), self.data['x'].min())
self.ax.plot(self.data['x'], self.data['y'])
self.canvas.draw()
def integralShift(self, ints, xsh):
for i in range(len(self.integrals)):
self.integrals[i][0] = self.integrals[i][0] - xsh
self.integrals[i][1] = self.integrals[i][1] - xsh
def calibrate(self):
self.rt.config(cursor='cross')
self.calOn = 1
self.cid3 = self.canvas.mpl_connect('button_press_event',
self.onclick2)
def onHelpClosing(self):
self.t3.destroy()
def launchHelpWindow(self):
self.t3 = tk.Toplevel(self.rt)
self.t3.protocol("WM_DELETE_HELPWINDOW", self.onHelpClosing)
self.helpText = tk.Text(self.t3, height=10, width=30, wrap='word')
self.helpText.pack(expand=True, fill=tk.BOTH)
__location__ = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__)))
aboutFile = open(os.path.join(__location__, 'about.rtf'))
self.helpText.insert(tk.END, aboutFile.read())
aboutFile.close()
def display_graph_ext(dimension, b=False):
root = Tk.Tk()
root.wm_title("SMG2S UI")
graphique = True
#On ouvre les fichiers contenant les chemins des deux fichiers selectionnes
#On ouvre le fichier 1
fichier1 = read_file_path(1)
#On ouvre le fichier 2
fichier2 = read_file_path(2)
print(fichier1, " & ", fichier2)
f = Figure(figsize=(8, 6), dpi=100)
a = f.add_subplot(1, 1, 1)
reel1 = loadtxt(r'data/matrix/r1.vec')
imaginaire1 = loadtxt(r'data/matrix/i1.vec')
reel2 = loadtxt(r'data/matrix/r2.vec')
imaginaire2 = loadtxt(r'data/matrix/i2.vec')
if dimension == 2:
if fichier1 != "":
a.scatter(reel1,
imaginaire1,
c='black',
marker='o',
s=200,
label="Original solution")
graphique = True
if fichier2 != "":
a.scatter(reel2,
imaginaire2,
c='red',
marker='+',
s=200,
label="Final solution")
graphique = True
elif dimension == 1:
if fichier1 != "":
a.scatter(reel1,
imaginaire1,
c='black',
marker='o',
s=200,
label="Original solution")
graphique = True
if fichier2 != "":
a.scatter(reel2,
imaginaire2,
c='red',
marker='+',
s=200,
label="Final solution")
graphique = True
else:
Tk.messagebox.showerror(
"Error",
"Impossible to generate the graph, the dimension is incorrect")
graphique = False
if graphique == True:
if b == True:
u = loadtxt(r'data/custom/axe.vec')
a.set_xlim(u[0], u[1])
a.set_ylim(u[2], u[3])
show()
# a tk.DrawingArea
canvas = FigureCanvasTkAgg(f, master=root)
canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
toolbar = NavigationToolbar2TkAgg(canvas, root)
toolbar.update()
canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
def on_key_event(event):
print('you pressed %s' % event.key)
key_press_handler(event, canvas, toolbar)
canvas.mpl_connect('key_press_event', on_key_event)
def _quit():
root.quit() # stops mainloop
root.destroy() # this is necessary on Windows to prevent
# Fatal Python Error: PyEval_RestoreThread: NULL tstate
button = Tk.Button(master=root, text='Quit', command=_quit)
button.pack(side=Tk.BOTTOM)
Tk.mainloop()
class SplitPrintWindow():
def __init__(self,
print_manager,
combo_prints,
hulls_df,
print_numb,
vid_panel,
invert_axes=True):
self.root = tk.Tk()
self.root.wm_title("Split the Selected Print")
self.fig = Figure(figsize=(10, 8), dpi=100)
self.canvas = FigureCanvasTkAgg(self.fig,
master=self.root) # A tk.DrawingArea.
self.canvas.draw()
self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
self.toolbar = NavigationToolbar2TkAgg(self.canvas, self.root)
self.toolbar.update()
self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
self.print_manager = print_manager
self.combo_prints = combo_prints
self.print_numb = print_numb
self.first_frame = self.combo_prints.first_frame[print_numb]
n_frames = (self.combo_prints.last_frame[print_numb] -
self.first_frame) + 1
grid_size = int(np.ceil(np.sqrt(n_frames)))
self.axes = []
self.fig.set_size_inches(16, 9)
button_axes = self.fig.add_axes([.01, .01, .05, .05])
self.button = Button(button_axes, 'Split')
self.button.on_clicked(self.create_new_hulls)
these_hulls = hulls_df[hulls_df.print_numb == print_numb]
self.collections = {}
self.xyes = {}
for i in range(0, n_frames):
ax = self.fig.add_subplot(grid_size, grid_size, i + 1)
self.axes.append(ax)
ax.set_axis_off()
frame = vid_panel.get_frame(self.first_frame + i)
X = self.combo_prints.X[print_numb]
Y = self.combo_prints.Y[print_numb]
ax.imshow(frame)
xes = []
yes = []
for c in (these_hulls.contours[these_hulls.frame ==
self.first_frame + i].values[0]):
#add all to a single list to make one collection
xes = xes + list(c[:, 0, 0])
yes = yes + list(c[:, 0, 1])
self.collections[ax] = ax.scatter(xes, yes)
self.xyes[ax] = self.collections[ax].get_offsets()
#set it to have list of facecolors so that selection works
facecolors = self.collections[ax].get_facecolors()
npts = len(self.xyes[ax])
facecolors = np.tile(facecolors, npts).reshape(npts, -1)
self.collections[ax].set_facecolor(facecolors)
if invert_axes:
ax.set_xlim(X + 50, X - 50)
else:
ax.set_xlim(X - 50, X + 50)
ax.set_ylim(Y - 50, Y + 50)
ax.set_title('Frame ' + str(self.first_frame + i))
self.axes = np.asarray(self.axes)
self.cid = self.canvas.mpl_connect('button_press_event', self.onpress)
self.canvas.draw()
tk.mainloop()
def create_new_hulls(self, event):
new_hull_points = []
old_hull_points = []
frame = []
if (sys.version_info > (3, 0)):
iterab = self.collections.items()
else:
iterab = self.collections.iteritems()
for ax, collection in iterab:
#make np array of bools with whether color matches the selection color for each point
inds = np.asarray([
True if np.array_equal(i, [.4, .4, .9, 1.0]) else False
for i in collection.get_facecolors()
])
#use np bool indexing to get x,y values for selected and unselected
new_hull_points.append(self.xyes[ax][inds])
old_hull_points.append(self.xyes[ax][~inds])
frame.append(self.first_frame + np.where(self.axes == ax)[0])
self.print_manager.split_print(new_hull_points, old_hull_points, frame,
self.print_numb)
self.root.destroy()
def callback(self, verts):
facecolors = self.collections[self.current_axes].get_facecolors()
p = path.Path(verts)
ind = p.contains_points(self.xyes[self.current_axes])
for i in range(len(self.xyes[self.current_axes])):
if ind[i]:
facecolors[i] = [.4, .4, .9, 1.0]
else:
facecolors[i] = [.4, .4, .2, .5]
self.collections[self.current_axes].set_facecolor(facecolors)
self.fig.canvas.draw_idle()
self.fig.canvas.widgetlock.release(self.lasso)
del self.lasso
#TODO: troubleshoot widget locks
def onpress(self, event):
if self.fig.canvas.widgetlock.locked(): return
if event.inaxes is None: return
self.current_axes = event.inaxes
self.lasso = Lasso(event.inaxes, (event.xdata, event.ydata),
self.callback)
# acquire a lock on the widget drawing
self.fig.canvas.widgetlock(self.lasso)
class Graph(tk.Frame):
ax, original_xlim, original_ylim, coll, pick_id = None, None, None, None, None
start_end_bool = -1 # 0 is start, 1 is end, -1 is None
start_index, end_index, move_index, remove_index = 0, None, None, None
max_time, max_speed, max_height, min_height = 0, 0, 0, 0
data = []
connect_ids, move_ids = [], []
current_color_scheme = 'd'
def __init__(self, master):
super().__init__(master)
self.master = master
self.fig = Figure(figsize=(10, 7), dpi=100, tight_layout=True)
self.fig.set_facecolor('#f0f0ed')
self.zoom_pan = GraphInteractions.ZoomPan()
self.master_string = tk.StringVar()
self.canvas = FigureCanvasTkAgg(self.fig, self)
self.canvas.draw()
self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
def redraw(self, input_file_location):
x, y, c = zip(*self.read_data(input_file_location))
self.fig.clear()
self.ax = self.fig.add_subplot(111, frameon=False)
self.coll = self.ax.scatter(x, y, color=c, picker=True)
self.end_index = len(self.data) - 1
self.connect_ids.append(
GraphInteractions.ZoomPan.zoom_factory(self.zoom_pan,
self.ax,
base_scale=1.3))
self.connect_ids.extend(
GraphInteractions.ZoomPan.pan_factory(self.zoom_pan, self.ax))
self.original_xlim = self.ax.get_xlim()
self.original_ylim = self.ax.get_ylim()
self.canvas.draw()
def redraw_color(self, x, y, c):
self.fig.clear()
self.ax = self.fig.add_subplot(111, frameon=False)
self.coll = self.ax.scatter(x, y, color=c, picker=True)
self.ax.set_xlim(self.zoom_pan.cur_xlim)
self.ax.set_ylim(self.zoom_pan.cur_ylim)
self.connect_ids.append(
GraphInteractions.ZoomPan.zoom_factory(self.zoom_pan,
self.ax,
base_scale=1.3))
self.connect_ids.extend(
GraphInteractions.ZoomPan.pan_factory(self.zoom_pan, self.ax))
self.canvas.draw()
def reset_zoom(self):
self.ax.set_xlim(self.original_xlim)
self.ax.set_ylim(self.original_ylim)
self.ax.figure.canvas.draw() # force re-draw
def reset_start(self, master_string):
self.start_index = 0
master_string.set("")
self.redraw_ext()
def reset_end(self, master_string):
self.end_index = len(self.data) - 1
master_string.set("")
self.redraw_ext()
def read_data(self, input_file_location):
x_array = []
y_array = []
color_array = []
self.data.clear()
json_file = open(input_file_location, "r")
file_data = json.load(json_file)
json_file.close()
old_time, old_x, old_y = 0, file_data['recording']['path'][0][
'x'], file_data['recording']['path'][0]['y']
self.max_time, self.max_speed, self.max_height, self.min_height = 0, 0, 0, file_data[
'recording']['path'][0]['z']
speed = 0
for time in file_data['recording']['path']:
x_array.append(time['x'])
y_array.append(time['y'])
time_div = time['t'] - old_time
if time['t'] > self.max_time:
self.max_time = time['t']
if time_div != 0:
speed = distance(time['x'], old_x, time['y'], old_y) / time_div
if speed > self.max_speed:
self.max_speed = speed
if time['z'] > self.max_height:
self.max_height = time['z']
elif time['z'] < self.min_height:
self.min_height = time['z']
self.data.append(
[time['x'], time['y'], time['t'], speed, time['z']])
color_array.append('tab:blue')
old_time = time['t']
old_x, old_y = time['x'], time['y']
return zip(x_array, y_array, color_array)
def redraw_ext(self):
for cid in self.connect_ids:
self.canvas.mpl_disconnect(cid)
self.connect_ids.clear()
x = []
y = []
c = []
for idx, row in enumerate(self.data):
x.append(row[0])
y.append(row[1])
if idx == self.start_index or idx == self.end_index or idx == self.remove_index:
c.append('tab:red')
elif idx < self.start_index or idx > self.end_index or\
(self.start_index == 0 and self.end_index == len(self.data) - 1):
c.append('tab:blue')
elif self.start_index < idx < self.end_index:
c.append('c')
self.redraw_color(x, y, c)
def redraw_simp(self):
for cid in self.connect_ids:
self.canvas.mpl_disconnect(cid)
self.connect_ids.clear()
x = []
y = []
c = []
for idx, row in enumerate(self.data):
x.append(row[0])
y.append(row[1])
if idx == self.move_index:
c.append('tab:red')
else:
c.append('tab:blue')
self.redraw_color(x, y, c)
def change_color(self, event):
if event.mouseevent.button != 1: return
if self.start_end_bool == 0:
self.start_index = event.ind[0]
elif self.start_end_bool == 1:
self.end_index = event.ind[0]
elif self.start_end_bool == 2:
self.remove_index = event.ind[0]
self.redraw_ext()
self.master_string.set(
'x: %.4f, y: %.4f' %
(self.data[event.ind[0]][0], self.data[event.ind[0]][1]))
def show_time(self):
self.current_color_scheme = 't'
for cid in self.connect_ids:
self.canvas.mpl_disconnect(cid)
self.connect_ids.clear()
x = []
y = []
c = []
for idx, row in enumerate(self.data):
x.append(row[0])
y.append(row[1])
gradient = row[2] / self.max_time
c.append((0, 1 - gradient, gradient))
self.redraw_color(x, y, c)
def show_speed(self):
self.current_color_scheme = 's'
for cid in self.connect_ids:
self.canvas.mpl_disconnect(cid)
self.connect_ids.clear()
x = []
y = []
c = []
for idx, row in enumerate(self.data):
x.append(row[0])
y.append(row[1])
gradient = row[3] / self.max_speed
c.append((1 - gradient, gradient, 0))
self.redraw_color(x, y, c)
def show_height(self):
self.current_color_scheme = 'h'
for cid in self.connect_ids:
self.canvas.mpl_disconnect(cid)
self.connect_ids.clear()
x = []
y = []
c = []
for idx, row in enumerate(self.data):
x.append(row[0])
y.append(row[1])
gradient = (row[4] - self.min_height) / (self.max_height -
self.min_height)
c.append((gradient * 0.5 + 0.5, gradient * 0.8, gradient * 0.8))
self.redraw_color(x, y, c)
def reset_color(self):
self.current_color_scheme = 'd'
for cid in self.connect_ids:
self.canvas.mpl_disconnect(cid)
self.connect_ids.clear()
x = []
y = []
c = []
for idx, row in enumerate(self.data):
x.append(row[0])
y.append(row[1])
c.append('tab:blue')
self.redraw_color(x, y, c)
def attach_start_stop(self, master_string_var, start_end):
self.detach_start_stop()
self.start_end_bool = start_end
self.master_string = master_string_var
self.pick_id = self.canvas.mpl_connect('pick_event', self.change_color)
def detach_start_stop(self):
if self.pick_id is None: return
self.start_end_bool = -1
self.canvas.mpl_disconnect(self.pick_id)
for move_id in self.move_ids:
self.canvas.mpl_disconnect(move_id)
def attach_move_node(self):
def on_press(event):
if event.mouseevent.button != 1: return
self.move_index = event.ind[0]
self.master.move_node_location.set(
'x: %.4f, y: %.4f' %
(self.data[self.move_index][0], self.data[self.move_index][1]))
def on_release(event):
self.redraw_simp()
def on_motion(event):
if event.button != 1: return
self.data[self.move_index][0] = event.xdata
self.data[self.move_index][1] = event.ydata
self.master.move_node_location.set(
'x: %.4f, y: %.4f' %
(self.data[self.move_index][0], self.data[self.move_index][1]))
self.redraw_simp()
self.detach_start_stop()
self.pick_id = self.canvas.mpl_connect('pick_event', on_press)
self.move_ids.append(
self.canvas.mpl_connect('key_press_event', self.move_node_button))
self.move_ids.append(
self.canvas.mpl_connect('button_release_event', on_release))
self.move_ids.append(
self.canvas.mpl_connect('motion_notify_event', on_motion))
def attach_remove_node(self, master_string):
self.detach_start_stop()
self.start_end_bool = 2
self.master_string = master_string
self.pick_id = self.canvas.mpl_connect('pick_event', self.change_color)
def next_start(self, master_string, diff):
self.start_index += diff
if self.start_index < 0:
self.start_index = 0
self.redraw_ext()
master_string.set(
'x: %.4f, y: %.4f' %
(self.data[self.start_index][0], self.data[self.start_index][1]))
def next_end(self, master_string, diff):
self.end_index += diff
if self.end_index > len(self.data) - 1:
self.end_index = len(self.data) - 1
self.redraw_ext()
master_string.set(
'x: %.4f, y: %.4f' %
(self.data[self.end_index][0], self.data[self.end_index][1]))
def move_node_button(self, event):
direction = ""
if event.key == "up":
direction = "N"
elif event.key == "right":
direction = "E"
elif event.key == "down":
direction = "S"
elif event.key == "left":
direction = "W"
if direction != "":
self.move_node(direction, float(self.master.move_entry.get()))
def move_node(self, direction, move_distance):
if direction == "N":
self.data[self.move_index][1] += move_distance
elif direction == "E":
self.data[self.move_index][0] += move_distance
elif direction == "S":
self.data[self.move_index][1] -= move_distance
elif direction == "W":
self.data[self.move_index][0] -= move_distance
self.master.move_node_location.set(
'x: %.4f, y: %.4f' %
(self.data[self.move_index][0], self.data[self.move_index][1]))
self.redraw_simp()
def remove_node(self):
del self.data[self.remove_index]
self.end_index = len(self.data) - 1
self.redraw_ext()
self.master_string.set(
'x: %.4f, y: %.4f' %
(self.data[self.remove_index][0], self.data[self.remove_index][1]))
def apply_local_speedup(self, value):
speedup = 1
speed = 0
previous_time = 0
previous_old_time = 0
old_x, old_y = self.data[0][0], self.data[0][1]
for idx, row in enumerate(self.data):
if self.start_index == idx:
speedup = 1 - float(value) / 100
elif self.end_index == idx:
speedup = 1
old_time = row[2]
if old_time < previous_old_time:
previous_old_time = old_time / 2
row[2] = previous_time + (min(old_time - previous_old_time, 2) *
speedup)
time_div = row[2] - previous_time
if row[2] > self.max_time:
self.max_time = row[2]
if time_div != 0:
speed = distance(row[0], old_x, row[1], old_y) / time_div
if speed > self.max_speed:
self.max_speed = speed
row[3] = speed
previous_time = row[2]
previous_old_time = old_time
old_x, old_y = row[0], row[1]
self.update_unknown()
def update_unknown(self):
if self.current_color_scheme == 'h':
self.show_height()
elif self.current_color_scheme == 's':
self.show_speed()
elif self.current_color_scheme == 't':
self.show_time()
else:
self.reset_color()
class Analysis:
""" Main class for GUI visualising transfer functions """
def __init__(self, parent):
"""Creates all widgets"""
self.master = parent
self.move_zero = None
self.index1 = None
self.index2 = None
self.zeros = []
self.poles = []
self.topframe = tkinter.Frame(self.master)
self.topframe.pack(expand=True, fill='both')
self.entries = tkinter.Frame(self.topframe)
self.entries.pack(expand=True, fill='both')
self.figure = tkinter.Frame(self.topframe)
self.figure.pack(expand=True, fill='both')
header = tkinter.Label(self.entries,
text='Define the transfer function:')
header.grid(row=0, column=0, padx=20, pady=7)
self.tfi = TFInput(self.entries)
self.sys = self.tfi.get_tf()
tkinter.Button(self.entries, text='Apply', command=self.apply,
width=9).grid(row=0, column=1, rowspan=3, padx=10, pady=5)
self.f_bode = plt.figure(figsize=(4, 4))
self.f_nyquist = plt.figure(figsize=(4, 4))
self.f_pzmap = plt.figure(figsize=(4, 4))
self.f_step = plt.figure(figsize=(4, 4))
self.canvas_pzmap = FigureCanvasTkAgg(self.f_pzmap,
master=self.figure)
self.canvas_pzmap.draw()
self.canvas_pzmap.get_tk_widget().grid(row=0, column=0,
padx=0, pady=0)
self.canvas_bode = FigureCanvasTkAgg(self.f_bode,
master=self.figure)
self.canvas_bode.draw()
self.canvas_bode.get_tk_widget().grid(row=0, column=1,
padx=0, pady=0)
self.canvas_step = FigureCanvasTkAgg(self.f_step,
master=self.figure)
self.canvas_step.draw()
self.canvas_step.get_tk_widget().grid(row=1, column=0,
padx=0, pady=0)
self.canvas_nyquist = FigureCanvasTkAgg(self.f_nyquist,
master=self.figure)
self.canvas_nyquist.draw()
self.canvas_nyquist.get_tk_widget().grid(row=1, column=1,
padx=0, pady=0)
self.canvas_pzmap.mpl_connect('button_press_event',
self.button_press)
self.canvas_pzmap.mpl_connect('button_release_event',
self.button_release)
self.canvas_pzmap.mpl_connect('motion_notify_event',
self.mouse_move)
self.apply()
def button_press(self, event):
""" Handle button presses, detect if we are going to move
any poles/zeros"""
# find closest pole/zero
if (event.xdata != None and event.ydata != None):
new = event.xdata + 1.0j*event.ydata
tzeros = list(abs(self.zeros-new))
tpoles = list(abs(self.poles-new))
if (size(tzeros) > 0):
minz = min(tzeros)
else:
minz = float('inf')
if (size(tpoles) > 0):
minp = min(tpoles)
else:
minp = float('inf')
if (minz < 2 or minp < 2):
if (minz < minp):
# Moving zero(s)
self.index1 = tzeros.index(minz)
self.index2 = list(self.zeros).index(
conj(self.zeros[self.index1]))
self.move_zero = True
else:
# Moving pole(s)
self.index1 = tpoles.index(minp)
self.index2 = list(self.poles).index(
conj(self.poles[self.index1]))
self.move_zero = False
def button_release(self, event):
""" Handle button release, update pole/zero positions,
if the were moved"""
if (self.move_zero == True):
self.tfi.set_zeros(self.zeros)
elif (self.move_zero == False):
self.tfi.set_poles(self.poles)
else:
return
self.move_zero = None
self.index1 = None
self.index2 = None
tfcn = self.tfi.get_tf()
if (tfcn):
self.zeros = tfcn.zero()
self.poles = tfcn.pole()
self.sys = tfcn
self.redraw()
def mouse_move(self, event):
""" Handle mouse movement, redraw pzmap while drag/dropping """
if (self.move_zero != None and
event.xdata != None and
event.ydata != None):
if (self.index1 == self.index2):
# Real pole/zero
new = event.xdata
if (self.move_zero == True):
self.zeros[self.index1] = new
elif (self.move_zero == False):
self.poles[self.index1] = new
else:
# Complex poles/zeros
new = event.xdata + 1.0j*event.ydata
if (self.move_zero == True):
self.zeros[self.index1] = new
self.zeros[self.index2] = conj(new)
elif (self.move_zero == False):
self.poles[self.index1] = new
self.poles[self.index2] = conj(new)
tfcn = None
if (self.move_zero == True):
self.tfi.set_zeros(self.zeros)
tfcn = self.tfi.get_tf()
elif (self.move_zero == False):
self.tfi.set_poles(self.poles)
tfcn = self.tfi.get_tf()
if (tfcn != None):
self.draw_pz(tfcn)
self.canvas_pzmap.draw()
def apply(self):
"""Evaluates the transfer function and produces different plots for
analysis"""
tfcn = self.tfi.get_tf()
if (tfcn):
self.zeros = tfcn.zero()
self.poles = tfcn.pole()
self.sys = tfcn
self.redraw()
def draw_pz(self, tfcn):
"""Draw pzmap"""
self.f_pzmap.clf()
# Make adaptive window size, with min [-10, 10] in range,
# always atleast 25% extra space outside poles/zeros
tmp = list(self.zeros)+list(self.poles)+[8]
val = 1.25*max(abs(array(tmp)))
plt.figure(self.f_pzmap.number)
control.matlab.pzmap(tfcn)
plt.suptitle('Pole-Zero Diagram')
plt.axis([-val, val, -val, val])
def redraw(self):
""" Redraw all diagrams """
self.draw_pz(self.sys)
self.f_bode.clf()
plt.figure(self.f_bode.number)
control.matlab.bode(self.sys, logspace(-2, 2))
plt.suptitle('Bode Diagram')
self.f_nyquist.clf()
plt.figure(self.f_nyquist.number)
control.matlab.nyquist(self.sys, logspace(-2, 2))
plt.suptitle('Nyquist Diagram')
self.f_step.clf()
plt.figure(self.f_step.number)
try:
# Step seems to get intro trouble
# with purely imaginary poles
tvec, yvec = control.matlab.step(self.sys)
plt.plot(tvec.T, yvec)
except:
print("Error plotting step response")
plt.suptitle('Step Response')
self.canvas_pzmap.draw()
self.canvas_bode.draw()
self.canvas_step.draw()
self.canvas_nyquist.draw()
info_xy.pack()
# The setting of figure
mat_plot = Figure(figsize=(6, 4), dpi=100)
fig = mat_plot.add_subplot(111)
fig.set_xlabel('x')
fig.set_ylabel('y')
# Draw the figure by tk.DrawingArea
canvas_frame = FigureCanvasTkAgg(mat_plot, master=left)
canvas_frame.show()
canvas_frame.get_tk_widget().pack(side='top', fill='both', expand=1)
canvas_frame._tkcanvas.pack(side='top', fill='both', expand=1)
# Help to show the x, y positions
canvas_frame.mpl_connect('motion_notify_event', showXY_handler)
# Help to show the cut lines
canvas_frame.mpl_connect('button_press_event', cut_lines)
# Choose the central position
# Give the central line
var_cen = IntVar() # boolean value: var_cut.get()
check_cen = Checkbutton(right_top, text='Show central line', variable=var_cen)
check_cen.pack()
# Show the opened files
var = StringVar(root)
var.set(choices)
# all submenus to main menu
#plt.xlim((-15000, 20000))
#plt.ylim((-15000, 20000))
canvas.show()
if __name__ == '__main__':
matplotlib.use('TkAgg')
root = tkinter.Tk()
#在Tk的GUI上放置一个画布，并用.grid()来调整布局
fig = Figure(figsize=(7, 5), dpi=100)
canvas = FigureCanvasTkAgg(fig, master=root)
canvas.show()
canvas.get_tk_widget().grid(row=0, columnspan=4)
canvas.mpl_connect('button_release_event', onPress)
canvas.mpl_connect('motion_notify_event', onMotion)
#polygon = plt.Polygon([[150, 150], [350, 400], [200, 600]], facecolor='g', alpha=0.5)
#circ = mpatches.Circle((0, 0), 100, color = 'g', alpha=0.5)
circ = mpatches.RegularPolygon((0, 0), 30, 100, color='g', alpha=0.5)
root.bind("<Motion>", showLocation)
#放置标签、文本框和按钮等部件，并设置文本框的默认值和按钮的事件函数
path = tkinter.StringVar()
tkinter.Label(root, text='目标路径:').grid(row=1, column=0)
tkinter.Entry(root, textvariable=path).grid(row=1, column=1)
tkinter.Button(root, text='Json文件选择', command=selectPath).grid(row=1,
column=2)
tkinter.Button(root, text='画图', command=drawDNA).grid(row=1,
column=3,
t = arange(0.0,3.0,0.01)
s = sin(2*pi*t)
a.plot(t,s)
# a tk.DrawingArea
canvas = FigureCanvasTkAgg(f, master=root)
canvas.show()
canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
toolbar = NavigationToolbar2TkAgg( canvas, root )
toolbar.update()
canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
def on_key_event(event):
print('you pressed %s'%event.key)
key_press_handler(event, canvas, toolbar)
canvas.mpl_connect('key_press_event', on_key_event)
def _quit():
root.quit() # stops mainloop
root.destroy() # this is necessary on Windows to prevent
# Fatal Python Error: PyEval_RestoreThread: NULL tstate
button = Tk.Button(master=root, text='Quit', command=_quit)
button.pack(side=Tk.BOTTOM)
Tk.mainloop()
dx_dt = None
step = float()
error = float()
sigma = float()
# WINDOW INIT
root = tk.Tk()
root.title("Phase portrait")
root.geometry(SCREEN_WIDTH+"x"+SCREEN_HEIGHT)
root.resizable(False, False)
# WIDGETS
figure = plt.figure(figsize=(5, 5), dpi=100)
plot = figure.add_subplot(111)
canvas = FigureCanvasTkAgg(figure)
canvas.mpl_connect('button_press_event', onPlotClick)
move = NavigationToolbar2Tk(canvas, root)
vcmd = (root.register(validate))
sigma_label = tk.Label(text="σ", font=("roboto", 12))
sigma_input = tk.Entry(width=7, validate="all", validatecommand=(vcmd, '%P'))
sigma_input.insert(tk.END, "0")
error_label = tk.Label(text="Error", font="roboto-11")
error_input = tk.Entry(width=7, validate="all", validatecommand=(vcmd, '%P'))
error_input.insert(tk.END, "0")
step_label = tk.Label(text="Step", font="roboto-11")
step_input = tk.Entry(width=7, validate="all", validatecommand=(vcmd, '%P'))
step_input.insert(tk.END, "0")
class SpectrumViewer(object, ttk.Frame):
def __init__(self, master):
ttk.Frame.__init__(self, master)
self.root = master
self._ms_file_name = None
self.reader = None
self.scan = None
self.configure_toolbar()
self.configure_canvas()
self.configure_treeview()
self.configure_display_row()
self.populate()
self.draw_plot()
@property
def ms_file_name(self):
return self._ms_file_name
@ms_file_name.setter
def ms_file_name(self, value):
if value not in (None, '') and os.path.exists(value):
print("Loading %r" % value)
self._ms_file_name = value
self.reader = ms_deisotope.MSFileLoader(self.ms_file_name)
self.populate()
def set_ms_file(self, value, populate=True):
self._ms_file_name = value
self.reader = ms_deisotope.MSFileLoader(self.ms_file_name)
if populate:
self.populate()
def select_ms_file(self):
file_name = tkfiledialog.askopenfilename()
if file_name is not None and file_name != '':
self.ms_file_name = file_name
def do_layout(self):
self.grid(sticky=tk.N + tk.W + tk.E + tk.S)
tk.Grid.rowconfigure(self, 0, weight=1)
tk.Grid.columnconfigure(self, 0, weight=1)
def configure_canvas(self):
self.figure = Figure(dpi=100)
self.canvas = FigureCanvasTkAgg(self.figure, master=self)
self.axis = self.figure.add_subplot(111)
self.canvas.show()
canvas_widget = self.canvas.get_tk_widget()
canvas_widget.grid(row=0, column=0, sticky=tk.N + tk.W + tk.E + tk.S)
self.canvas_cursor = Cursor(self.axis, tk.StringVar(master=self.root))
self.canvas.mpl_connect('motion_notify_event', self.canvas_cursor.mouse_move)
self.span = SpanSelector(
self.axis, self.zoom, 'horizontal', useblit=True,
rectprops=dict(alpha=0.5, facecolor='red'))
self.mz_span = None
self.scan = None
self.annotations = []
self.canvas.show()
def configure_toolbar(self):
self.toolbar = tk.Menu(self)
self.toolbar.add_command(label='Open', command=self.select_ms_file)
self.toolbar.add_command(label='Interact', command=lambda: interactive_console(**{'self': self}))
self.root.config(menu=self.toolbar)
def _zoom_in(self, min_mz, max_mz):
arrays = self.scan.arrays
subset = arrays.between_mz(min_mz, max_mz).intensity
if len(subset) > 0 and subset.max() > 0 and subset.min() < subset.max():
most_intense = np.max(subset)
y_cap = most_intense * 1.2
self.mz_span = (min_mz, max_mz)
self.axis.set_xlim(min_mz, max_mz)
self.axis.set_ylim(0, y_cap)
self.annotate_plot(min_mz, max_mz)
self.figure.canvas.draw()
def zoom(self, xmin, xmax):
# If the bounds are not close, we're zooming in
if not self.scan:
return
arrays = self.scan.arrays
if (xmax - xmin) <= 1:
min_peak = 0
max_peak = len(arrays[0]) - 1
self.mz_span = None
xmin, xmax = arrays.mz[min_peak], arrays.mz[max_peak]
self._zoom_in(xmin, xmax)
def clear_annotations(self):
for anno in self.annotations:
try:
anno.remove()
except ValueError:
break
self.annotations = []
def annotate_plot(self, min_mz=None, max_mz=None):
self.clear_annotations()
if min_mz is None:
min_mz = 0
if max_mz is None:
max_mz = self.scan.arrays.mz[-1]
subset = self.scan.deconvoluted_peak_set.between(min_mz, max_mz, use_mz=True)
if not subset:
return
threshold = 0.0
threshold_list = ([max(i.intensity for i in p.envelope) for p in subset])
if threshold_list:
threshold = np.mean(threshold_list)
threshold_list = ([max(i.intensity for i in p.envelope) for p in subset
if max(i.intensity for i in p.envelope) > threshold])
if threshold_list:
threshold = np.mean(threshold_list)
for peak in subset:
if peak.intensity > threshold:
label = '%0.2f (%d)' % (peak.neutral_mass, peak.charge)
pt = max(peak.envelope, key=lambda x: x.intensity)
y = pt.intensity * 1.05
x = np.average(
[p.mz for p in peak.envelope],
weights=[p.intensity for p in peak.envelope])
self.annotations.append(
self.axis.text(x, y, label, ha='center', clip_on=True, fontsize=10))
def _process_scan(self):
self.scan.pick_peaks(signal_to_noise_threshold=1.5)
if self.scan.ms_level == 1:
averagine_value = self.ms1_averagine_combobox.get()
averagine_value = averagine_label_map[averagine_value]
truncate_after = 0.95
scorer = ms_deisotope.PenalizedMSDeconVFitter(20., 2.)
else:
averagine_value = self.msn_averagine_combobox.get()
averagine_value = averagine_label_map[averagine_value]
truncate_after = 0.8
scorer = ms_deisotope.MSDeconVFitter(10.)
self.scan.deconvolute(
averagine=averagine_value,
scorer=scorer,
truncate_after=truncate_after)
def draw_plot(self, scan=None, children=None):
if children is None:
children = []
if scan is None or scan.arrays.mz.shape[0] == 0:
return
self.axis.clear()
self.scan = scan
self.children_scans = children
if scan.ms_level == 1:
if scan.arrays.mz.shape[0] > 1:
self.scan = scan.average(3)
self.scan = scan.denoise(4)
self._process_scan()
scan = self.scan
if scan.is_profile:
draw_raw(*scan.arrays, ax=self.axis, color='black', lw=0.75)
self.axis.set_xlim(0, max(self.axis.get_xlim()))
draw_peaklist(
[i for p in scan.deconvoluted_peak_set for i in p.envelope],
ax=self.axis, alpha=0.6, lw=0.5, color='orange')
draw_peaklist(
[p.envelope[0] for p in scan.deconvoluted_peak_set if p.envelope[0].intensity > 0],
ax=self.axis, alpha=0.6, lw=1,
color='red')
draw_peaklist(
[EnvelopePair(p.mz, p.intensity / len(self.envelope))
for p in scan.deconvoluted_peak_set if not (p.envelope[0].intensity > 0)],
ax=self.axis, alpha=0.6, lw=0.5,
color='red', linestyle='--')
# draw isolation window and instrument reported precursor
if children:
ylim = scan.arrays.intensity.max()
for child in children:
if child.isolation_window and not child.isolation_window.is_empty():
self.axis.vlines(
[child.isolation_window.lower_bound, child.isolation_window.upper_bound],
0, ylim, linestyle='--', color='skyblue', lw=0.5)
self.axis.vlines(child.precursor_information.mz, 0, ylim,
linestyle='--', color='black', lw=0.5)
if self.scan.precursor_information:
ylim = scan.arrays.intensity.max()
self.axis.vlines(self.scan.precursor_information.mz, 0, ylim, linestyle='-.', color='orange')
if self.mz_span is not None:
self._zoom_in(*self.mz_span)
else:
self.annotate_plot(None, None)
self.canvas.draw()
def on_row_click(self, event):
selection = self.treeview.focus()
item = self.treeview.item(selection)
index = item['text']
if self.reader is not None:
scan = self.reader.get_scan_by_index(index)
if scan.ms_level == 1:
bunch = next(self.reader.start_from_scan(scan.id))
if not isinstance(bunch, ScanBunch):
children = []
else:
children = bunch.products
else:
children = []
self.draw_plot(scan, children)
else:
self.draw_plot(None)
def configure_display_row(self):
self.display_row = ttk.Frame(self)
self.display_row.grid(row=1, column=0, sticky=tk.W + tk.S + tk.E)
self.cursor_label = ttk.Label(self.display_row, text=" " * 20)
self.cursor_label.grid(row=0, padx=(10, 10))
def update_label(*args, **kwargs):
self.cursor_label['text'] = self.canvas_cursor.binding.get()
self.canvas_cursor.binding.trace('w', update_label)
self.ms1_averagine_combobox = ttk.Combobox(self.display_row, values=[
"peptide",
"glycan",
"glycopeptide",
"heparan sulfate",
])
self.ms1_averagine_combobox.set("glycopeptide")
self.ms1_averagine_combobox_label = ttk.Label(self.display_row, text="MS1 Averagine:")
self.ms1_averagine_combobox_label.grid(row=0, column=1, padx=(10, 0))
self.ms1_averagine_combobox.grid(row=0, column=2, padx=(1, 10))
self.msn_averagine_combobox = ttk.Combobox(self.display_row, values=[
"peptide",
"glycan",
"glycopeptide",
"heparan sulfate",
])
self.msn_averagine_combobox.set("peptide")
self.msn_averagine_combobox_label = ttk.Label(self.display_row, text="MSn Averagine:")
self.msn_averagine_combobox_label.grid(row=0, column=3, padx=(10, 0))
self.msn_averagine_combobox.grid(row=0, column=4, padx=(1, 10))
def configure_treeview(self):
self.treeview = ttk.Treeview(self)
self.treeview['columns'] = ["id", "time", 'ms_level', 'precursor_mz', 'precursor_charge', 'activation']
self.treeview.grid(row=2, column=0, sticky=tk.S + tk.W + tk.E + tk.N)
self.treeview_scrollbar = ttk.Scrollbar(self, orient="vertical", command=self.treeview.yview)
self.treeview_scrollbar.grid(row=2, column=0, sticky=tk.S + tk.E + tk.N)
self.treeview.configure(yscrollcommand=self.treeview_scrollbar.set)
self.treeview.heading('id', text="Scan ID")
self.treeview.heading('#0', text='Index')
self.treeview.heading("time", text='Time (min)')
self.treeview.heading("ms_level", text='MS Level')
self.treeview.heading("precursor_mz", text='Precursor M/Z')
self.treeview.heading("precursor_charge", text='Precursor Z')
self.treeview.heading("activation", text='Activation')
self.treeview.column("#0", width=75)
self.treeview.column("ms_level", width=75)
self.treeview.column("time", width=75)
self.treeview.column("precursor_mz", width=100)
self.treeview.column("precursor_charge", width=100)
self.treeview.bind("<<TreeviewSelect>>", self.on_row_click)
def clear_treeview(self):
children = self.treeview.get_children()
if children:
self.treeview.delete(*children)
def _populate_range(self, start, stop):
print("populate range", start, stop)
scans = []
ended = False
for i in range(start, stop):
try:
scan = self.reader[i]
except Exception:
ended = True
break
if scan.index % 5000 == 0:
print(scan)
i = scan.index
values = [scan.id, "%0.4f" % scan.scan_time, scan.ms_level]
if scan.ms_level > 1:
values.extend([scan.precursor_information.mz, scan.precursor_information.charge,
str(scan.activation)])
else:
values.extend(['-', '-', '-'])
scans.append(values)
for values in scans:
self.treeview.insert('', 'end', values=values, text=i)
if not ended:
self.after(100, self._populate_range, stop, stop + 500)
def populate(self, clear=True):
if clear:
self.clear_treeview()
if self.reader is not None:
self.reader.make_iterator(grouped=False)
for scan in self.reader:
if scan.index % 5000 == 0:
print(scan)
i = scan.index
values = [scan.id, "%0.4f" % scan.scan_time, scan.ms_level]
if scan.ms_level > 1:
values.extend([scan.precursor_information.mz, scan.precursor_information.charge,
str(scan.activation)])
else:
values.extend(['-', '-', '-'])
self.treeview.insert('', 'end', values=values, text=i)
self.reader.reset()
class SIAFViewer(object):
instruments = [NIRCAM, NIRSPEC, NIRISS, MIRI, FGS]
instrument_filepaths = None
FILTER_SELECTED, FILTER_ALL = 1, 2
def __init__(self, instrument_filepaths):
self.root = Tk()
self.root.title("SIAF Viewer")
self.instrument_filepaths = instrument_filepaths
def close_app():
self.root.quit()
self.root.destroy()
self.root.protocol("WM_DELETE_WINDOW", close_app)
self._construct()
self.redraw()
def start(self):
self.root.mainloop()
def redraw(self):
mode = self.filter_behavior.get()
show_labels = self.show_labels.get()
self.ax.clear()
# print("show_labels:", show_labels)
if mode == self.FILTER_ALL:
for instrument, siaf in self.siaf_lookup.items():
for item in siaf.apernames:
if siaf[item].AperType == TRANSFORM:
continue
siaf[item].plot(frame='Tel', ax=self.ax, label=show_labels)
elif mode == self.FILTER_SELECTED:
# hacky/slow way to go from selected IDs back to SIAF instances
for item in self.instrument_tree.selection():
# print("item:", item)
for instrument, siaf in self.siaf_lookup.items():
# print('item', item, 'instrument', instrument)
if item in siaf.apernames:
siaf[item].plot(frame='Tel', ax=self.ax, label=show_labels)
self.ax.scatter(siaf[item].V2Ref, siaf[item].V3Ref)
self.ax.set_xlabel('V2 [arcsec]')
self.ax.set_ylabel('V3 [arcsec]')
self._canvas.show()
def apply_filter(self):
pattern = self.filter_value.get()
# print("Pattern: {}".format(pattern))
# pprint(self.instrument_tree.get_children(NIRCAM))
def traverse_items(base=''):
# recurse down the tree structure to find all matches
matches = []
for item in self.instrument_tree.get_children(base):
if pattern in item:
# print("pattern:", pattern, "item:", item)
matches.append(item)
matches.extend(traverse_items(item))
return matches
if pattern not in ('', '*'):
self.filter_behavior.set(self.FILTER_SELECTED)
self.instrument_tree.selection_remove(self.instrument_tree.selection())
matches = traverse_items()
# print('matches:', matches)
self.instrument_tree.selection_set(' '.join(matches))
map(self.instrument_tree.see, matches)
else:
self.clear_filter()
def clear_filter(self):
self.filter_value.set('')
self.filter_behavior.set(self.FILTER_ALL)
self.instrument_tree.selection_remove(self.instrument_tree.selection())
self.redraw()
def _construct_plot(self):
# plot panel
self.plotframe = ttk.Frame(self.main)
self.plotframe.grid(column=1, row=0, sticky=(N, W, E, S))
self.figure = Figure(figsize=(10, 5), dpi=72)
self.ax = self.figure.add_subplot(1, 1, 1)
self.ax.set_aspect('equal')
self.figure.subplots_adjust(left=0.09, right=0.96)
self._canvas = FigureCanvasTkAgg(self.figure, master=self.plotframe)
self._canvas.show()
self._canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
self._toolbar = NavigationToolbar2TkAgg(self._canvas, self.plotframe)
self._toolbar.update()
self._canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=1)
def on_key_event(event):
# print('you pressed %s' % event.key)
key_press_handler(event, self._canvas, self._toolbar)
self._canvas.mpl_connect('key_press_event', on_key_event)
def _construct_filter(self):
# filter / tree panel
self.filterframe = ttk.Frame(self.main)
self.filterframe.grid(column=0, row=0, sticky=(N, W, E, S))
self.filterframe.columnconfigure(1, weight=1)
self.filter_value = StringVar()
filter_label = ttk.Label(self.filterframe, text="Select by pattern:")
filter_label.grid(column=0, row=0, sticky=(N, W))
self.filter_entry = ttk.Entry(self.filterframe, textvariable=self.filter_value)
self.filter_entry.grid(column=1, row=0, sticky=(N, W, E, S))
filter_button = ttk.Button(self.filterframe, text="Filter", command=self.apply_filter)
filter_button.grid(column=2, row=0, sticky=(N, E))
clear_button = ttk.Button(self.filterframe, text="Clear", command=self.clear_filter)
clear_button.grid(column=2, row=1, sticky=(N, E))
filter_behavior_label = ttk.Label(self.filterframe, text="Show:")
filter_behavior_label.grid(column=0, row=1)
self.filter_behavior = IntVar(value=self.FILTER_ALL)
self.filter_behavior.trace("w", lambda evt, x, y: self.redraw())
radiobuttons_frame = ttk.Frame(self.filterframe)
radiobuttons_frame.grid(column=1, row=1)
self.filter_behavior_selected = ttk.Radiobutton(
radiobuttons_frame,
text='Selected',
value=self.FILTER_SELECTED,
variable=self.filter_behavior
)
self.filter_behavior_selected.grid(column=1, row=0)
self.filter_behavior_all = ttk.Radiobutton(
radiobuttons_frame,
text='All',
value=self.FILTER_ALL,
variable=self.filter_behavior
)
self.filter_behavior_all.grid(column=3, row=0)
self.instrument_tree = ttk.Treeview(self.filterframe)
self.instrument_tree.grid(column=0, row=2, sticky=(N, W, E, S), columnspan=3)
self._load_instruments()
self.filterframe.rowconfigure(2, weight=1)
info = ttk.Label(self.filterframe, text='Hold control and click to select multiple.\nHold shift and click to select ranges.')
info.grid(column=0, row=3, columnspan=3)
self.show_labels = BooleanVar(value=False)
self.show_labels_checkbox = ttk.Checkbutton(
self.filterframe,
text='Show labels?',
variable=self.show_labels,
command=self.redraw,
onvalue=True,
offvalue=False
)
self.show_labels_checkbox.grid(column=0, row=4, columnspan=3)
def _construct(self):
self.root.minsize(width=1024, height=500)
# ensure resizing happens:
self.root.columnconfigure(0, weight=1)
self.root.rowconfigure(0, weight=1)
self.main = ttk.Frame(self.root)
self.main.grid(column=0, row=0, sticky=(N, W, E, S))
self._construct_plot()
self._construct_filter()
# massage the gui library a bit
for child in self.main.winfo_children():
child.grid_configure(padx=5, pady=5)
self.main.columnconfigure(0, weight=1)
self.main.columnconfigure(1, weight=1)
self.main.rowconfigure(0, weight=1)
def _load_instrument(self, instrument):
siaf = SIAF(
instr=instrument,
filename=self.instrument_filepaths[instrument]
)
print("Loaded {} from {}".format(instrument, siaf.filename))
return siaf
def _load_instruments(self):
self.siaf_lookup = {}
# Every instrument is a unique snowflake, so load them one by one
self.siaf_lookup[NIRCAM] = self._load_instrument(NIRCAM)
# NIRCam
# - NRCA
# - NRCA1 .. 5
# - NRCB
# - NRCB1 .. 5
self.instrument_tree.insert('', 'end', iid=NIRCAM, text=NIRCAM)
self.instrument_tree.insert(NIRCAM, 'end', iid='NRCA', text='NRCA')
a_segments = ('NRCA1', 'NRCA2', 'NRCA3', 'NRCA4', 'NRCA5')
for segment in a_segments:
self.instrument_tree.insert('NRCA', 'end', iid=segment, text=segment)
self.instrument_tree.insert(NIRCAM, 'end', iid='NRCB', text='NRCB')
b_segments = ('NRCB1', 'NRCB2', 'NRCB3', 'NRCB4', 'NRCB5')
for segment in b_segments:
self.instrument_tree.insert('NRCB', 'end', iid=segment, text=segment)
for aper in sorted(self.siaf_lookup[NIRCAM].apernames):
if 'NRCA' in aper and not 'NRCALL' in aper:
if aper[:5] in a_segments:
self.instrument_tree.insert(aper[:5], 'end', iid=aper, text=aper)
else:
self.instrument_tree.insert('NRCA', 'end', iid=aper, text=aper)
elif 'NRCB' in aper:
if aper[:5] in b_segments:
self.instrument_tree.insert(aper[:5], 'end', iid=aper, text=aper)
else:
self.instrument_tree.insert('NRCB', 'end', iid=aper, text=aper)
else:
self.instrument_tree.insert(NIRCAM, 'end', iid=aper, text=aper)
# MIRI
# - MIRIM
# - MIRIFU
self.siaf_lookup[MIRI] = self._load_instrument(MIRI)
self.instrument_tree.insert('', 'end', iid=MIRI, text=MIRI)
self.instrument_tree.insert(MIRI, 'end', iid='MIRIFU', text='MIRIFU')
self.instrument_tree.insert(MIRI, 'end', iid='MIRIM', text='MIRIM')
for aper in sorted(self.siaf_lookup[MIRI].apernames):
if 'MIRIFU' in aper:
self.instrument_tree.insert('MIRIFU', 'end', iid=aper, text=aper)
elif 'MIRIM' in aper:
self.instrument_tree.insert('MIRIM', 'end', iid=aper, text=aper)
# NIRSpec
# (special: ignore AperType == TRANSFORM)
self.siaf_lookup[NIRSPEC] = self._load_instrument(NIRSPEC)
self.instrument_tree.insert('', 'end', iid=NIRSPEC, text=NIRSPEC)
for aper in sorted(self.siaf_lookup[NIRSPEC].apernames):
if self.siaf_lookup[NIRSPEC][aper].AperType == TRANSFORM:
continue
self.instrument_tree.insert(NIRSPEC, 'end', iid=aper, text=aper)
for instrkey in [NIRISS, FGS]:
self.siaf_lookup[instrkey] = self._load_instrument(instrkey)
self.instrument_tree.insert('', 'end', iid=instrkey, text=instrkey)
for aper in sorted(self.siaf_lookup[instrkey].apernames):
self.instrument_tree.insert(instrkey, 'end', iid=aper, text=aper)
self.instrument_tree.bind('<<TreeviewSelect>>', lambda evt: self.handle_selection())
def handle_selection(self):
if self.filter_behavior.get() == self.FILTER_ALL:
return
else:
self.redraw()
root = tkinter.Tk()
#root.wm_title("Embedding in Tk")
fig = Figure(figsize=(5, 4), dpi=100)
t = np.arange(0, 3, .01)
fig.add_subplot(111).plot(t, 2 * np.sin(2 * np.pi * t))
canvas = FigureCanvasTkAgg(fig, master=root) # A tk.DrawingArea.
canvas.draw()
canvas.get_tk_widget().pack() #side=tkinter.TOP, fill=tkinter.BOTH, expand=1)
#toolbar = NavigationToolbar2Tk(canvas, root)
#toolbar.update()
#canvas.get_tk_widget().pack(side=tkinter.TOP, fill=tkinter.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():
root.quit() # stops mainloop
root.destroy() # this is necessary on Windows to prevent
# Fatal Python Error: PyEval_RestoreThread: NULL tstate
button = tkinter.Button(master=root, text="Quit", command=_quit)
class MainMenu(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.parent.protocol("WM_DELETE_WINDOW", self.myQuit)
self.parent.title("RT structure generator")
BUTTON_WIDTH = 30
TEXT_WIDTH = 10
self.dicomVolume = dict() # { z : np.array } REDUCED to conform to xyz boundaries
self.transformation = None
self.ds = None
self.topContainer = Frame(self, borderwidth=10)
self.midContainer = Frame(self, borderwidth=10)
self.bottomContainer = Frame(self, borderwidth=10)
self.bottomContainer.pack(anchor=S, side=BOTTOM,fill=X, expand=1)
self.topContainer.pack(fill=X, expand=1)
self.midContainer.pack(fill=X, expand=1)
self.useRelativePosContainer = Frame(self.midContainer)
self.useClosedCurveLimiterContainer = Frame(self.midContainer)
self.posEntryContainer = Frame(self.midContainer)
self.deltaEntryContainer = Frame(self.midContainer)
self.angleEntryContainer = Frame(self.midContainer)
self.DBSCANepsContainer = Frame(self.midContainer)
self.DBSCANMinPtsContainer = Frame(self.midContainer)
self.useRelativePosContainer.pack(fill=X)
self.useClosedCurveLimiterContainer.pack(fill=X)
self.posEntryContainer.pack(fill=X)
self.deltaEntryContainer.pack(fill=X)
self.angleEntryContainer.pack(fill=X)
self.useRelativePosVar = IntVar(value=0)
self.useClosedCurveLimiterVar = IntVar(value=1)
self.zPosVar = DoubleVar(value=0)
self.zDeltaVar = DoubleVar(value=0.5)
self.angleVar = DoubleVar(value=0)
self.useRelativePosCheck = Checkbutton(self.useRelativePosContainer,
text="Use relative positions? ", variable=self.useRelativePosVar)
self.useRelativePosCheck.pack(anchor=W)
Label(self.posEntryContainer, text="Slice position (z): ").pack(anchor=W)
Entry(self.posEntryContainer, textvariable=self.zPosVar, width=TEXT_WIDTH).pack(side=LEFT)
Label(self.deltaEntryContainer, text="Slice thickness (z): ").pack(anchor=W)
Entry(self.deltaEntryContainer, textvariable=self.zDeltaVar, width=TEXT_WIDTH).pack(side=LEFT)
Label(self.angleEntryContainer, text="Tilt angle (x-axis, ±180 deg): ").pack(anchor=W)
Entry(self.angleEntryContainer, textvariable=self.angleVar, width=TEXT_WIDTH).pack(side=LEFT)
self.buttonLoadCSV = Button(self.bottomContainer, text="Load CSV mesh (C)",
command=self.commandLoadCSVMesh, width=BUTTON_WIDTH)
self.buttonLoadCSV.pack(anchor=S, side=LEFT)
self.buttonMakePlots = Button(self.bottomContainer, text="Make plots (Enter)",
command=self.commandMakePlots, width=BUTTON_WIDTH)
self.buttonMakePlots.pack(side=LEFT)
self.buttonLoadDICOM = Button(self.bottomContainer, text="Load DICOM series (D)",
command=self.commandLoadDICOM, width=BUTTON_WIDTH)
self.buttonLoadDICOM.pack(side=LEFT)
self.buttonQuit = Button(self.bottomContainer, text="Exit (Esc)",
command=self.myQuit, width=BUTTON_WIDTH)
self.buttonQuit.pack(side=LEFT)
self.parent.bind("c", lambda event=None: self.buttonLoadCSV.invoke())
self.parent.bind("d", lambda event=None: self.buttonLoadDICOM.invoke())
self.parent.bind("<Return>", lambda event=None: self.buttonMakePlots.invoke())
self.parent.bind("<Escape>", lambda event=None: self.buttonQuit.invoke())
df = pd.read_csv("meshCSV/zz010440HUH44_1.2.826.0.1.3680043.2.968.3.8323329.27824.1530802493.162.csv")
#x = df['FractionMeshPointsX'].values
#y = df['FractionMeshPointsY'].values
#z = df['FractionMeshPointsZ'].values
x = df['PlanningMeshPointsX'].values
y = df['PlanningMeshPointsY'].values
z = df['PlanningMeshPointsZ'].values
self.x0 = np.mean(x)
self.y0 = np.mean(y)
self.z0 = np.mean(z)
x = x - self.x0
y = y - self.y0
z = z - self.z0
self.xyz = np.array(list(zip(x,y,z)))
self.pack()
self.commandMakePlotsPlaceHolder()
def myQuit(self):
self.parent.destroy()
plt.close("all")
self.quit()
def commandLoadCSVMesh(self):
newfile = filedialog.askopenfilename(initialdir="meshCSV/")
df = pd.read_csv(newfile)
x = df['FractionMeshPointsX'].values
y = df['FractionMeshPointsY'].values
z = df['FractionMeshPointsZ'].values
self.x0 = np.mean(x)
self.y0 = np.mean(y)
self.z0 = np.mean(z)
x = x - self.x0
y = y - self.y0
z = z - self.z0
self.xyz = np.array(list(zip(x,y,z)))
def commandLoadDICOM(self):
newfile = filedialog.askdirectory(initialdir="DICOM/")
#boundaries = [[50*floor(np.min(self.xyz[:,k])/50), 50*ceil(np.max(self.xyz[:,k])/50)] for k in range(2)]
boundariesMM = [[int(np.min(self.xyz[:,k]))-50, int(np.max(self.xyz[:,k]))+50] for k in range(2)]
self.ds = None
for root, dirs, files in os.walk(newfile):
for file in files:
if not "CT" in file: continue
ds = pydicom.dcmread(f"{root}/{file}")
if not self.ds:
self.ds = ds
img = ds.pixel_array + ds.RescaleIntercept
xy0 = [float(k) for k in ds.ImagePositionPatient] # Upper left corner
dxy = float(ds.PixelSpacing[0])
print("xy0", xy0)
boundaries = [0,0]
for dim in range(2):
boundaries[dim] = [int((boundariesMM[dim][0] - xy0[dim])/dxy), int((boundariesMM[dim][1] - xy0[dim])/dxy)]
print("boundaries", boundaries)
self.dicomVolume[int(ds.SliceLocation)] = img[boundaries[1][0]:boundaries[1][1], boundaries[0][0]:boundaries[0][1]]
"""
zList = np.array(zList)
zList -= self.zPosVar.get()
zListAbs = np.absolute(zList)
zListAbsMin = zListAbs.argmin()
for root, dirs, files in os.walk(newfile):
file = files[zListAbsMin]
if file:
print(f"Choosing file {file} with z = {zList[zListAbsMin]} (want {self.zPosVar.get()})")
self.ds = pydicom.dcmread(f"{root}/{file}")
break
self.img = self.ds.pixel_array + self.ds.RescaleIntercept
"""
self.commandMakePlots()
def commandMakePlotsPlaceHolder(self):
self.fig, self.axs = plt.subplots(1,4, figsize=(20,5))
self.canvas = FigureCanvasTkAgg(self.fig, master=self.topContainer)
self.canvas.draw()
self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
self.canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=1)
def onclick(event):
self.zPosVar.set(event.ydata)
self.commandMakePlots()
def onscroll(event):
self.angleVar.set(self.angleVar.get() + 5 * event.step)
# New default slice position to account of rotation
r = Rotation.from_euler("x", self.angleVar.get(), degrees=True)
xyz = r.apply(self.xyz)
self.zPosVar.set(np.mean(xyz[:,2]))
self.commandMakePlots()
cid = self.canvas.mpl_connect('button_press_event', onclick)
cid2 = self.canvas.mpl_connect('scroll_event', onscroll)
def commandMakePlots(self):
for ax in self.axs:
ax.clear()
self.makePlot(self.axs)
self.canvas.draw()
def makePlot(self, axs):
xyz = self.xyz.copy()
if self.angleVar.get():
r = Rotation.from_euler("x", self.angleVar.get(), degrees=True)
xyz = r.apply(xyz)
x = xyz[:,0]
y = xyz[:,1]
z = xyz[:,2]
zPos = self.zPosVar.get()
zDelta = self.zDeltaVar.get()
zFilter1 = zPos - zDelta/2 < z
zFilter2 = z < zPos + zDelta/2
xFilter = x[zFilter1 & zFilter2]
yFilter = y[zFilter1 & zFilter2]
# SORT by angle
xDC = xFilter - np.mean(xFilter)
yDC = yFilter - np.mean(yFilter)
angles = np.zeros(np.shape(xFilter), dtype=np.float64)
for idx in range(len(xFilter)):
angles[idx] = atan2(yDC[idx], xDC[idx])
angleSortIdx = np.argsort(angles)
anglesSorted = angles[angleSortIdx]
xDCSort = xDC[angleSortIdx]
yDCSort = yDC[angleSortIdx]
xSort = xDCSort + np.mean(xFilter)
ySort = yDCSort + np.mean(yFilter)
step = pi/45
anglesAveraged = np.arange(-pi, pi+step, step)
xAveraged = np.zeros(np.shape(anglesAveraged))
yAveraged = np.zeros(np.shape(anglesAveraged))
idx = 0
for angle in anglesAveraged:
lowerFilter = anglesSorted > angle - step/2
upperFilter = anglesSorted < angle + step/2
if np.sum(xDCSort[lowerFilter & upperFilter]) == 0:
continue
xDCSortFilter = xDCSort[lowerFilter & upperFilter]
yDCSortFilter = yDCSort[lowerFilter & upperFilter]
rAngleMax = np.max(np.sqrt(xDCSortFilter**2 + yDCSortFilter**2))
if isnan(rAngleMax):
continue
xAveraged[idx] = rAngleMax * cos(angle)
yAveraged[idx] = rAngleMax * sin(angle)
idx += 1
xAveraged = xAveraged[:idx] + np.mean(xFilter)
yAveraged = yAveraged[:idx] + np.mean(yFilter)
xlabel = "x - x0 [mm]"
ylabel = "y - y0 [mm]"
zlabel = "z - z0 [mm]"
if not self.useRelativePosVar.get():
x += self.x0
y += self.y0
z += self.z0
xSort += self.x0
ySort += self.y0
xAveraged += self.x0
yAveraged += self.y0
zPos += self.z0
xlabel = "x [mm]"
ylabel = "y [mm]"
zlabel = "z [mm]"
xAveragedExtra = np.append(xAveraged, xAveraged[0])
yAveragedExtra = np.append(yAveraged, yAveraged[0])
axs[0].scatter(x,y,alpha=0.1,marker=".")
axs[0].plot(xAveragedExtra, yAveragedExtra, 'r-')
axs[0].set_xlabel(xlabel)
axs[0].set_ylabel(ylabel)
axs[0].set_title(f"All points XY, rotated {self.angleVar.get()}° about X")
axs[1].scatter(x,z,alpha=0.1,marker=".")
axs[1].plot(axs[1].get_xlim(), [zPos, zPos], 'r-')
axs[1].set_xlabel(xlabel)
axs[1].set_ylabel(zlabel)
axs[1].set_title(f"All points XZ, rotated {self.angleVar.get()}° about X \n(click to set Z)")
axs[2].scatter(xSort, ySort, marker=",", label="All points")
axs[2].plot(xAveragedExtra, yAveragedExtra, "r-", label="Angular average")
axs[2].set_title(f"z = {zPos:.1f} ± {zDelta:.1f} mm with angular average")
axs[2].set_xlabel(xlabel)
axs[2].set_ylabel(ylabel)
if np.sum(self.dicomVolume):
zList = list(self.dicomVolume.keys())
zList2 = [k-self.zPosVar.get() for k in zList]
zListAbs = np.absolute(zList2)
zToUse = zList[zListAbs.argmin()]
img = self.dicomVolume[zToUse]
extent = np.shape(img)[0] * self.ds.PixelSpacing[0]
xiso = self.ds.ImagePositionPatient[0]
yiso = self.ds.ImagePositionPatient[1]
axs[3].imshow(img, cmap="gray")#, extent=(xiso, xiso+extent, extent+yiso, yiso))
axs[3].plot(xAveragedExtra, yAveragedExtra, "r-", label="Angular average")
class tkEMGplot(tk.Frame):
def __init__(self, master=None, channel_num=32, period=100):
tk.Frame.__init__(self,master)
self.fig = None
self.canvas = None
self.toolbar = None
self.channel_num = channel_num
self.period = period
self.databuffer = np.zeros((period,32))
self.createWidgets()
def createWidgets(self):
self.fig = Figure(figsize=(5, 4))
self.canvas = FigureCanvasTkAgg(self.fig, master=self.master) # A tk.DrawingArea.
self.canvas.draw()
# pack_toolbar=False will make it easier to use a layout manager later on.
self.toolbar = NavigationToolbar2Tk(self.canvas, self.master, pack_toolbar=False)
self.toolbar.update()
self.canvas.mpl_connect(
"key_press_event", lambda event: print(f"you pressed {event.key}"))
self.canvas.mpl_connect("key_press_event", key_press_handler)
self.toolbar.pack(side=tk.TOP, fill=tk.X)
self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
# self.toolbar.grid(row = 1, column = 0)
# self.canvas.get_tk_widget().grid(row = 0, column = 0)
self.testbutton = tk.Button(self.master)
self.testbutton["text"] = "Add one data point"
self.testbutton["command"] = self.testaddDatapoint
self.testbutton.pack(side=tk.LEFT, fill=tk.X, expand=False)
self.testplot()
def testaddDatapoint(self):
new_data = ((np.random.rand(self.channel_num)-0.5) * 2) * 2.5
self.addDatapoint(new_data)
def testplot(self):
self.fig.clear()
t = np.arange(0, self.period, 1)
datas = []
## Generate data for testing
for i in range(self.channel_num):
data = 2 * np.sin(2 * np.pi * t)+np.random.uniform(0,1,self.period)
datas.append(data)
# ax.spines['top'].set_visible(False)
# ax.spines['right'].set_visible(False)
# #ax.spines['bottom'].set_visible(False)
# #ax.spines['left'].set_visible(False)
self.graphplot(t, np.array(datas).T)
def graphplot(self, t, datas):
max_d, min_d = max(map(max,datas)), min(map(min,datas))
range_d = round(abs(max_d) + abs(min_d))
ax = self.fig.add_subplot(1,1,1)
for i in range(self.channel_num):
ax.plot(t, datas[:,i]+(range_d*i), label = ["Channel:" + str(i+1)]) ## potential future problem.
self.fig.axes[0].set_yticks(np.arange(0, self.channel_num*range_d, range_d))
labels = [0]*self.channel_num
for i in range(self.channel_num):
labels[i] = "Channel:" + str(i+1)
self.fig.axes[0].set_yticklabels(labels)
self.canvas.draw()
def addDatapoint(self, new_datas):
newlen = 1
if newlen <= 0:
return
self.fig.clear(True)
self.databuffer[0:self.period - newlen,:] = self.databuffer[newlen:,:]
self.databuffer[self.period - newlen:,:] = new_datas
fz = 250
t = np.arange(0, self.period/fz, 1/fz)
self.graphplot(t, self.databuffer)
def video_stop():
timerFrameDisplay.stop()
#~ t.stop()
objShowFrame = ShowFrame()
objShowFrame.captureDevice = cap
objShowFrame.axes = axis1
objShowFrame.hIm = hIm
#Timer for frame
timerFrameDisplay = f2.canvas.new_timer(interval=0)
timerFrameDisplay.add_callback(objShowFrame.showFrame)
#Timer for video
#~ t = RepeatedTimer(0.01, video)
#Start and Stop Buttons
b1 = Button(master, text="Start", bg='white', command=video_start).place(x=50, y=600)
b2 = Button(master, text="Stop", bg='white', command=video_stop).place(x=400, y=600)
#~ master.mainloop()
#~ kShowFrameType = KShowFrameType(0)
#~ KShowFrameType(0)
#~ canvas1.mpl_connect('button_press_event', lambda e: ShowFrame().callback(e,kShowFrameType))
canvas1.mpl_connect('button_press_event', objShowFrame.changeFrame)
#~ kShowFrameType = 0
class Roi(tk.Toplevel):
def closing(self):
if len(self.xx) <= 2:
self.destroy()
self.parent.grab_set()
return
self.parent.widgets['regions'].configure(state='normal')
self.parent.roi_btn_show.configure(state='normal')
self.parent.roi_btn_edit.configure(state='normal')
self.parent.roi_btn_del.configure(state='normal')
if self.parent.adding_roi:
name = None
while not isinstance(name, str):
name = tkinter.simpledialog.askstring('Region name',
'Input name of region',
parent=self)
self.parent.widgets['regions']['values'] = list(
self.parent.widgets['regions']['values']) + [name]
self.parent.widgets['regions'].set(name)
else:
name = self.parent.widgets['regions'].get()
self.parent.regions[name] = {'x': self.xx, 'y': self.yy}
self.parent.widgets['regions'].configure(state='readonly')
self.destroy()
self.parent.grab_set()
def __init__(self, parent, *args, **kwargs):
tk.Toplevel.__init__(self, *args, **kwargs)
self.xx = []
self.yy = []
self.protocol('WM_DELETE_WINDOW', self.closing)
self.wm_title("Region of Interest")
self.grab_set()
self.parent = parent
self.f = matplotlib.figure.Figure(figsize=(12, 9.5))
self.ax = self.f.add_subplot(111)
self.canvas = FigureCanvasTkAgg(self.f, master=self)
self.canvas.draw()
self.canvas.get_tk_widget().pack(side='top', fill='both', expand=1)
try:
video = cv2.VideoCapture(
parent.widgets['video_filename'].get().split(", ")[0])
ret, frame = video.read()
except Exception:
ret = False
if frame is None:
parent.parent.log('Corrupted movie.')
self.destroy()
return
if not ret:
parent.parent.log('Select a movie first.')
self.destroy()
return
try:
start = int(parent.widgets['start_frame'].get())
end = int(parent.widgets['limit_images_to'].get())
except BaseException:
start = 0
end = video.get(cv2.CAP_PROP_FRAME_COUNT) - 1
mid = int((end - start) // 2)
video.set(cv2.CAP_PROP_POS_FRAMES, mid)
ret, frame = video.read()
if frame is None:
parent.parent.log('Corrupted movie.')
self.destroy()
return
self.ax.imshow(frame)
axes = (0, frame.shape[1], frame.shape[0], 0)
self.ax.axis(axes)
poly = [1]
def onclick(event):
x, y = event.xdata, event.ydata
if x is not None:
self.xx.append(x)
self.yy.append(y)
self.ax.plot(self.xx, self.yy, '-xb')
if len(self.xx) >= 3:
if poly[0] != 1:
poly[0].pop(0).remove()
poly[0] = self.ax.plot([self.xx[0], self.xx[-1]],
[self.yy[0], self.yy[-1]], '--b')
self.ax.axis(axes)
self.canvas.draw()
cid = self.canvas.mpl_connect('button_press_event', onclick)
class PlotFrame(Frame):
def __init__(self, master):
Frame.__init__(self, master)
self.figure = Figure(dpi=100)
self.canvas = FigureCanvasTkAgg(self.figure,master=self)
self.canvas.show()
self.widget = self.canvas.get_tk_widget()
self.widget.pack(side=TOP, expand=1, fill=BOTH)
self.__plots = {}
self.reset()
self.bind("<Configure>", self._configure)
self.config(background='red')
self._scaledict = {}
self._panmode = False
self._xzoommode = False
self._panstate = None
self._padding = {}
self._boundaries_changed = {}
self.canvas.mpl_connect('button_press_event', self._button_pressed)
self.canvas.mpl_connect('button_release_event', self._button_released)
self.canvas.mpl_connect('motion_notify_event', self._motion)
self.canvas.mpl_connect('scroll_event', self._scroll)
def _scroll(self, event):
if not event.inaxes:
return
for a in event.inaxes.get_children():
z = 0
if type(a) == YAxis and not self._xzoommode:
self._scaledict[event.inaxes][1] = False
z = 1 if (event.step > 0) else -1
elif type(a) == XAxis and self._xzoommode:
self._scaledict[event.inaxes][0] = False
z = 1 if (event.step > 0) else -1
if z != 0:
a.zoom(z)
self._boundaries_changed[event.inaxes] = True
self._padding[event.inaxes] = [0, 0, 0, 0]
def _button_pressed(self, event):
if event.dblclick or not event.inaxes:
if event.inaxes:
self._panmode = False
self._xzoommode = False
self._panstate = None
self._scaledict[event.inaxes] = [True, True]
self._padding[event.inaxes] = [0, 0, 0, 0]
self._boundaries_changed[event.inaxes] = False
event.inaxes.set_ylim(auto=True)
event.inaxes.set_xlim(auto=True)
self.update()
return
self._panstate = [event.inaxes, event.x, event.y, 0, 0]
if event.button == 1:
self._panmode = True
else:
self._xzoommode = True
def _button_released(self, event):
self._xzoommode = False
self._panmode = False
self._panstate = None
def _motion(self, event):
if not self._panmode:
return
panx = False
pany = False
ps = self._panstate
ps[3] += event.x - ps[1]
ps[4] += event.y - ps[2]
dx = ps[3]
dy = ps[4]
if abs(dx) > 5 and abs(dx) > abs(dy):
panx = True
elif abs(dy) > 5 and abs(dy) > abs(dx):
pany = True
for a in ps[0].get_children():
p = 0
if type(a) == YAxis and pany:
self._scaledict[ps[0]][1] = False
p = 1 if (dy < 0) else -1
elif type(a) == XAxis and panx:
self._scaledict[ps[0]][0] = False
p = 1 if (dx < 0) else -1
if p != 0:
ps[3] = 0
ps[4] = 0
a.pan(p)
self._boundaries_changed[ps[0]] = True
self._padding[event.inaxes] = [0, 0, 0, 0]
ps[1] = event.x
ps[2] = event.y
self._panstate = ps
def update(self):
for p in self.figure.axes:
p.relim()
p.autoscale_view(True, self._scaledict[p][0], self._scaledict[p][1])
xi = p.get_xaxis().get_data_interval()
yi = p.get_yaxis().get_data_interval()
if self._boundaries_changed[p]:
if not self._padding[p][0] and not self._scaledict[p][0]:
self._padding[p][0] = p.get_xlim()[0] - xi[0]
if not self._padding[p][1] and not self._scaledict[p][0]:
self._padding[p][1] = p.get_xlim()[1] - xi[1]
if not self._padding[p][2] and not self._scaledict[p][1]:
self._padding[p][2] = p.get_ylim()[0] - yi[0]
if not self._padding[p][3] and not self._scaledict[p][1]:
self._padding[p][3] = p.get_ylim()[1] - yi[1]
if self._padding[p][0] < 0:
p.set_xlim(left=xi[0] + self._padding[p][0])
if self._padding[p][1] > 0:
p.set_xlim(right=xi[1] + self._padding[p][1])
if self._padding[p][2] < 0:
p.set_ylim(bottom=yi[0] + self._padding[p][2])
if self._padding[p][3] > 0:
p.set_ylim(top=yi[1] + self._padding[p][3])
self.canvas.draw()
def _configure(self, *args):
width = self.winfo_width()
height = self.winfo_height()
w = width / 100.0
h = height / 100.0
self.figure.set_size_inches(w, h)
def add_graph(self, graph, xdata=[], ydata=[]):
if not graph.position in self.__plots:
plt = self.figure.add_subplot(int(graph.position))
plt.set_autoscale_on(True)
self.__plots[graph.position] = plt
plt.grid()
self._scaledict[plt] = [True, True]
self._padding[plt] = [0, 0, 0, 0]
self._boundaries_changed[plt] = False
graph.line, = self.__plots[graph.position].plot(xdata,ydata, graph.cfg)
self.update_legends()
def update_legends(self):
lines = {}
ids = {}
for g in Graph.graphs.values():
if not lines.has_key(g.position) or not ids.has_key(g.position):
lines[g.position] = []
ids[g.position] = []
ids[g.position].append(g.identifier)
lines[g.position].append(g.line)
for p in lines.keys():
if self.__plots.has_key(p):
self.__plots[p].legend(lines[p], ids[p], 'upper left')
def delete_graph(self, graph):
graph.line.remove()
for p in self.__plots.keys():
if len(self.__plots[p].lines) == 0:
self.figure.delaxes(self.__plots[p])
del self.__plots[p]
def update_graph(self, graph):
xd = graph.line.get_xdata()
yd = graph.line.get_ydata()
self.delete_graph(graph)
self.add_graph(graph)
def clear_graph(self, graph):
graph.line.remove()
self.add_graph(graph, [], [])
def reset(self):
for p in self.figure.axes:
self.figure.delaxes(p)
self._scaledict = {}
self.__plots = {}
self._padding = {}
self._boundaries_changed = {}
self.figure.clf()
def add_fig_to_frame(self, fig, containerFrame, dict_frames, title):
#Given a matplotlib figure, and a tk frame, setup the figure within the container frame.
#Additionally, add this frame to a dict with the title as a key.
# This method controls matplotlib events internally.
def onpick_any_pickable_object(event):
"""This is called upon any matplotlib element that has the pickable element being clicked
Method first determines which type object created event[ex: legend, line]
Depending on object, execute click behavior.
Current Behaviors:
-if legend: toggle visibility of all lines corresponding to legend entry.
-if line: output X,Y coordinates, line label, timestring based on X val
-if toggleGoto==True: open a the filtered txt doc of node in notepad++, at timestring of point clicked
"""
event_fig = event.artist.figure
artistLabel = event.artist.get_label()
print('Click Event', artistLabel)
##if legend click
if ('Legend_' in artistLabel):
print('Toggling Visibility')
strAfterLeg = artistLabel[7:]
legline = event.artist
for fig_axes in event_fig.get_axes():
for actualLine in fig_axes.get_lines():
actualLineLabel = actualLine.get_label()
if (actualLineLabel == strAfterLeg):
notCurVis = not actualLine.get_visible()
actualLine.set_visible(notCurVis)
if notCurVis:
legline.set_alpha(1.0)
else:
legline.set_alpha(0.2)
else:
line = event.artist
xdata, ydata = line.get_data()
ind = event.ind
print('Line X,Y:', xdata[ind], ydata[ind])
time_str = self.seconds_to_timestring(
xdata[ind[0]]) #prints 'HH:MM:SS:mmm'
#using time string, search total_time-time_str-line_num list, for line_num.
if (self.boolTog): #open notepad++ @ line_num using cmd line.
#this code works, however needs to be made to take correct node dpl file, and find the line_num
#find wnw instance this line belongs to
ourWNW = None
for wnw in self.wnw_list:
if wnw.node_name in artistLabel:
ourWNW = wnw
offset = self.offsetList[ourWNW.node_num]
time_str = self.seconds_to_timestring(xdata[ind[0]] +
offset)
textfile_path = ourWNW.node_output_dir + os.sep + 'filtered_DSABLACK.txt'
line_num = self.find_line_num_of_time_str_in_filtered_file(
time_str, textfile_path)
notepad_path = ''
if os.path.isdir(r'C:\Program Files\Notepad++'):
notepad_path = r'C:\Program Files\Notepad++'
elif (os.path.isdir(r'C:\Program Files (x86)\Notepad++')):
notepad_path = r'C:\Program Files (x86)\Notepad++'
else:
print('notepad++ is not installed')
return
#textfile_path= r'C:\Users\Kyle\Documents\DSAStyleLog\ColinDSALogs\127Black.txt' #<-- TO BE MADE VARIABLE
#line_num= 12000 #<-- TO BE MADE VARIABLE
cmd_start = r'start cmd /k "cd ' #then notepad_path
cmd_middle = r' & notepad++.exe -n' #then line number, then textfilepath,
full_open_txt_cmd = ('{}{}{}{} {} & exit \"'.format(
cmd_start, notepad_path, cmd_middle, str(line_num),
textfile_path))
print(full_open_txt_cmd)
if (line_num > 0
): #if str_time was not found, line_num would be -1.
os.system(full_open_txt_cmd)
else:
print('time str not found in file')
event_fig.canvas.draw()
return #==========end onpick method
thisFigFrame = tk.Frame(containerFrame)
thisCanvas = FigureCanvasTkAgg(fig, thisFigFrame)
thisCanvas.mpl_connect('pick_event', onpick_any_pickable_object)
thisCanvas.draw()
thisCanvas.get_tk_widget().pack(side=tk.BOTTOM,
fill=tk.BOTH,
expand=True)
toolbar = NavigationToolbar2Tk(thisCanvas, thisFigFrame)
toolbar.update()
thisCanvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
thisFigFrame.grid(row=0, column=0, sticky="nsew")
dict_frames[title] = thisFigFrame
class VisLayersApp():
def __init__(self, master, snap, ppc = 20, dpi = 96, colors='coolwarm'):
self.title = 'FFBPlog_{}'.format(snap.sess_index)
print('[FFBP Viewer] Initializing viewer for {} ...'.format(self.title))
self.master = master
self.master.title(self.title)
self.title_ast = '*** FFBPlog_{} ***'.format(snap.sess_index)
# =========================== Figure preparation ===========================
self.colors = colors
self._ppc = ppc
self._dpi = dpi
self.bfs = self._set_bfs()
self.snap = snap
self.figure = self.create_fig()
self.panelBoard = vl.prep_figure(self.snap, self.figure)
figSize = self.figure.get_size_inches() * self._dpi
# ============================= Parent Windows =============================
# ---------------------- Figure and window parameteres----------------------
self.figWidth, self.figHeight = [int(x) for x in figSize]
self.maxWindWidth = 900
self.maxWindHeight = 700
w = min(self.figWidth, self.maxWindWidth)
h = min(self.figHeight+125, self.maxWindHeight)
self.master.geometry('{}x{}+0+0'.format(w + 20, h))
self.master.update()
# --------------------------------- Canvas ---------------------------------
self.master.rowconfigure(0, weight=1)
self.master.columnconfigure(0, weight=1)
# Frames
self.canvasFrame = ttk.Frame(master, width = w + 20, height = h + 20)
self.canvasFrame.grid(row=0, column=0, columnspan = 2, sticky='nsew')
self.canvasFrame.rowconfigure(0, weight=1)
self.canvasFrame.columnconfigure(0, weight=1)
# Widgets
self.backCanvas = tk.Canvas(self.canvasFrame, scrollregion=(0, 0, w, h))
self.backCanvas.grid(row=0, column=0, columnspan = 2, sticky='nsew')
self.yScroll = tk.Scrollbar(self.canvasFrame,
orient=tk.VERTICAL,
command=self.backCanvas.yview)
self.xScroll = tk.Scrollbar(self.canvasFrame,
orient=tk.HORIZONTAL,
command=self.backCanvas.xview)
self.yScroll.grid(row=0, column=1, columnspan = 1, sticky='ns')
self.xScroll.grid(row=1, column=0, columnspan = 1, sticky='ew')
self.backCanvas.config(xscrollcommand=self.xScroll.set,
yscrollcommand=self.yScroll.set)
self.figureRenderer = FigureCanvasTkAgg(self.figure, self.backCanvas)
self.mplCanvasWidget = self.figureRenderer.get_tk_widget()
self.mplCanvasWidget.grid(sticky = 'nsew')
# self.colprefsButton = ttk.Button(self.master,
# text = 'Color preferences',
# command = self.onColorPrefs)
# self.colprefsButton.grid(row=2, column=1, sticky='ew')
# Integrate mpl and tk
self.backCanvasWind = self.backCanvas.create_window(0, 0, window=self.mplCanvasWidget, anchor = 'nw')
self.backCanvas.config(scrollregion=self.backCanvas.bbox(tk.ALL))
self.figureRenderer.mpl_connect('pick_event', self.onPick)
# ================================ CONTROLS ================================
# Controls
self.controlsFrame = ttk.Frame(master)
# Info
self.infoFrame = ttk.Frame(self.controlsFrame, width = 230, height = 115)
self.epochSubFrame = ttk.Frame(self.infoFrame,
width = 111,
height = 105,
relief = tk.GROOVE)
self.cellSubFrame = ttk.Frame(self.infoFrame,
width=111,
height=105,
relief = tk.GROOVE)
self.tinySub = ttk.Frame(self.cellSubFrame,
width = 40,
height = 40,
relief = tk.SUNKEN)
# Slide and combobox
self.widgetFrame = ttk.Frame(self.controlsFrame,
width = 230,
height = 95)
# Progress bar and hyperparams
self.hyperparamFrame = ttk.Frame(self.controlsFrame,
width = 230,
height = 15)
# -------------------------------- tk Vars ---------------------------------
self.patternVar = tk.StringVar()
# -------------------------------- Widgets ---------------------------------
# Selectors:
self.patternSelector = ttk.Combobox(self.widgetFrame,
textvariable = self.patternVar,
values = list(snap.inp_names.keys()),
)
self.patternSelector.bind('<<ComboboxSelected>>', self.onCombo)
self.patternSelector.current(0)
self.epochSlider = ttk.Scale(self.widgetFrame,
orient = tk.HORIZONTAL,
length = 200,
value =len(snap.epochs) - 1,
from_ = 0,
to =len(snap.epochs) - 1)
self.epochSlider.set(str(len(snap.epochs) - 1)) # Set the slider value after epochValLabel is created
# Buttons:
self.updateButton = ttk.Button(self.widgetFrame,
text='Update',
command=self.onUpdate)
self.zoominButton = ttk.Button(self.widgetFrame,
text = 'Zoom in',
command = lambda: self.changeSize(1))
self.zoomoutButton = ttk.Button(self.widgetFrame,
text='Zoom out',
command=lambda: self.changeSize(-1))
# Labels:
# epoch info
self.epochValLabel = tk.Label(self.epochSubFrame,
text = str(self._get_epoch(int(self.epochSlider.get()))),
fg = 'black',
font = ('Menlo', 30),
justify = tk.CENTER)
self.epochSlider.config(command = self.onSlide)
self.epochLabel = ttk.Label(self.epochSubFrame,
text = 'epoch',
font = ('Menlo', 9),
justify = tk.CENTER)
# draw cell onto tiny canvas
self.tinyFig = plt.figure(self.snap.sess_index+100, figsize=(40 / 96, 40 / 96), facecolor='white')
self.tinyRenderer = FigureCanvasTkAgg(self.tinyFig, self.tinySub)
self.tinyCanvas = self.tinyRenderer.get_tk_widget()
self.tinyRenderer.draw()
self.cellWeight = ttk.Label(self.cellSubFrame,
text = '-',
font = ('Menlo', 9),
justify = tk.CENTER)
self.cellCoords = ttk.Label(self.cellSubFrame,
text = 'r: - | c: -',
font = ('Menlo', 9),
justify = tk.CENTER)
# hyperparam widgets
self.hpFrame = ttk.Frame(self.hyperparamFrame,relief=tk.FLAT)
hp = self.snap.hyperparams[-1]
self.hpLabel = ttk.Label(self.hpFrame,
text = 'lrate: {}\nmrate: {}\nerror function: {}\nbatch size: {}\ntrain mode: {}'.format(
hp[0], hp[1], '{}'.format(hp[2]).split()[1], hp[3], 'p-train' if hp[4] else 's-train'),
font = ('Menlo', 9),
justify = tk.LEFT)
# -------------------------------- Geometry --------------------------------
# Controls
self.controlsFrame.grid(row=1, column=0, columnspan = 2, sticky='nsew')
# Info
self.infoFrame.pack(side = tk.LEFT, fill = tk.BOTH, padx=10)
# Epoch info
self.epochSubFrame.pack(side = tk.LEFT, padx = 2, pady = 10)
self.epochValLabel.place(relx = 0.50, rely = 0.45, anchor = tk.CENTER)
self.epochLabel.place(relx = 0.50, rely = 0.75, anchor = tk.CENTER)
# Cell info
self.cellSubFrame.pack(side = tk.RIGHT, padx = 2, pady = 10)
self.tinySub.place(relx = 0.50, rely = 0.40, anchor = tk.CENTER)
self.tinyCanvas.pack()
self.cellWeight.place(relx = 0.50, rely = 0.70, anchor = tk.CENTER)
self.cellCoords.place(relx = 0.50, rely = 0.84, anchor = tk.CENTER)
# Selectors
self.widgetFrame.pack(side = tk.LEFT, fill = tk.X, pady=10)
self.patternSelector.grid(row=0, column=0, columnspan=2, sticky='nsew')
self.epochSlider.grid(row=1, column=0, columnspan=2, sticky='nsew')
self.zoominButton.grid(row=2, column = 1, columnspan=1, sticky='nsew')
self.zoomoutButton.grid(row=2, column = 0, columnspan=1, sticky='nsew')
self.updateButton.grid(row=3, column = 0, columnspan=2, sticky='nsew')
# Hyperparams and Progress Bar
self.hyperparamFrame.pack(side = tk.LEFT, fill = tk.BOTH, pady=10, padx=10, ipadx = 10)
self.hpFrame.pack(fill=tk.BOTH, expand=True)
self.hpLabel.pack(side = tk.LEFT)
# ================================ COLORS ==================================
mpl_color_maps = (['BrBG', 'bwr', 'coolwarm', 'PiYG',
'PRGn', 'PuOr','RdBu', 'RdGy',
'RdYlBu', 'RdYlGn', 'Spectral',
'seismic', 'jet', 'rainbow', 'terrain'])
self.colorsWindow = tk.Toplevel(self.master, )
self.colorsWindow.title('Color Preferences')
self.colorsWindow.resizable('False','False')
self.colorsWindow.geometry('{}x{}+0+0'.format(350, 150))
self.colorsWindow.withdraw()
self.colorsFrame = ttk.Frame(self.colorsWindow)
self.colorsFrame.place(relx=0.5, rely=0.5, anchor = tk.CENTER, width = 350, height = 150)
self.colorsFrame.columnconfigure(0, weight = 1)
self.colorsFrame.columnconfigure(1, weight = 1)
self.colorsFrame.columnconfigure(2, weight=1)
self.normMode = tk.StringVar()
self.normMode.set('cus')
self.colMap = tk.StringVar()
self.absRadio = ttk.Radiobutton(self.colorsFrame, variable = self.normMode, value = 'abs', text = 'Absolute')
self.relRadio = ttk.Radiobutton(self.colorsFrame, variable = self.normMode, value = 'rel', text = 'Relative')
self.cusRadio = ttk.Radiobutton(self.colorsFrame, variable = self.normMode, value = 'cus', text = 'Custom')
self.colmapLabel = ttk.Label(self.colorsFrame, text='color map', font=('Helvetica', 10))
self.nrangeLabel = ttk.Label(self.colorsFrame, text='nrange', font=('Helvetica', 10))
self.colmapCombo = ttk.Combobox(self.colorsFrame, textvariable = self.colMap, values = mpl_color_maps)
self.colmapCombo.set(self.colors)
self.nrangeEntry = tk.Entry(self.colorsFrame, width = 7)
self.nrangeEntry.insert(0, '1')
self.applyButton = ttk.Button(self.colorsFrame, text = 'Apply', command = self.onApply)
self.helpButton = ttk.Button(self.colorsFrame, text = '?', command = self.onHelp)
self.absRadio.grid(row = 0, column = 0, columnspan = 1, padx = 15, pady = 10, sticky = 'w')
self.relRadio.grid(row = 0, column = 1, columnspan = 1, padx = 15, pady = 10, sticky = 'w')
self.cusRadio.grid(row = 0, column = 2, columnspan = 1, padx = 15, pady = 10, sticky = 'w')
self.colmapLabel.grid(row = 1, column = 0, columnspan = 2, padx = 17, sticky = 'ws')
self.nrangeLabel.grid(row = 1, column = 2, columnspan = 1, padx = 15, sticky = 'ws')
self.colmapCombo.grid(row = 2, column = 0, columnspan = 2, padx = 15, sticky = 'ews')
self.nrangeEntry.grid(row = 2, column = 2, columnspan = 1)
self.applyButton.grid(row = 3, column = 1, columnspan = 2, padx = 15, pady = 20, sticky = 'nesw')
self.helpButton.grid(row = 3, column = 0, columnspan = 1, padx = 15, pady = 20, sticky = 'w')
# ============================ Initial Figure ============================
self._label_groups = vl.annotate(self.snap, self.panelBoard, self._set_bfs())
self._labels_on = True
self._plotLatest()
# ============================== PROTOCOLS ===============================
self.master.protocol('WM_DELETE_WINDOW', self.onMasterX)
self.colorsWindow.protocol('WM_DELETE_WINDOW', self.onColorsX)
self.master.lift()
self.master.minsize(460, 125)
self.master.maxsize(self.master.winfo_width(), self.master.winfo_height())
self._hang(0)
def create_fig(self):
# Create a figure
max_width = max([l.sender[1] for l in self.snap.main.values()])
width_cells = ((max_width + 9) * 2)
width_pixels = width_cells * self._ppc
width_inches = width_pixels / self._dpi
network_size = self.snap.num_units
height_cells = network_size + (6 * self.snap.num_layers)
height_pixels = height_cells * self._ppc
height_inches = height_pixels / self._dpi
fig = plt.figure(self.snap.sess_index, figsize=(width_inches, height_inches), facecolor='w', dpi=self._dpi)
return fig
def onUpdate(self):
epoch_ind = int(self.epochSlider.get())
key = self.patternSelector.get()
if key in self.snap.inp_names.keys():
self.panelBoard.clear()
ind_map = list(self.snap.inp_names.keys())
pattern_ind = ind_map.index(key)
vl.draw_all_layers(self.snap, self.panelBoard, epoch_ind, pattern_ind, colmap=self.colors)
self._label_groups = vl.annotate(self.snap, self.panelBoard, self._set_bfs())
self.figureRenderer.draw()
self._hang(0)
else:
messagebox.showinfo(title='Wrong selection',
message='No such pattern. Please select a pattern from the list')
def changeSize(self, direction):
oldSize_inches = self.figure.get_size_inches()
oldSize_pixels = [s_i * self._dpi for s_i in oldSize_inches]
Size_cells = [s_p / self._ppc for s_p in oldSize_pixels]
self._ppc += 10 * direction
newSize_pixels = [s_c * self._ppc for s_c in Size_cells]
newSize_inches = [s_p / self._dpi for s_p in newSize_pixels]
self.figure.set_size_inches(newSize_inches)
nW, nH = newSize_pixels[0], newSize_pixels[1]
self.canvasFrame.config(width = nW, height = nH)
self.mplCanvasWidget.config(width = nW, height = nH)
self.backCanvas.itemconfigure(self.backCanvasWind, width=nW, height=nH)
self.backCanvas.config(scrollregion=self.backCanvas.bbox(tk.ALL), width=nW, height=nH)
self.checkPPC()
if self._labels_on:
vl.labels_off(self._label_groups)
self._label_groups = vl.annotate(self.snap, self.panelBoard, self._set_bfs())
self.figureRenderer.draw()
self.figure.canvas.draw()
self.figWidth = int(nW)
self.figHeight = int(nH)
# Adjust master window size to figure size, so that regions outside figure are always hidden
if direction < 0 and self.figWidth < self.master.winfo_width():
xx,yy = self.master.winfo_x(), self.master.winfo_y()
self.master.geometry('{}x{}+{}+{}'.format(
min(self.figWidth, self.maxWindWidth) + 20,
min(self.figHeight + 125, self.maxWindHeight),
xx,
yy))
self.master.maxsize(min(self.figWidth, self.maxWindWidth) + 20, min(self.figHeight + 125, self.maxWindHeight))
def checkPPC(self):
upperlim = 60
lowerlim = 10
if self._ppc <= lowerlim:
self.zoomoutButton.state(['disabled'])
elif self._ppc >= upperlim:
self.zoominButton.state(['disabled'])
else:
if self.zoomoutButton.instate(['disabled']): self.zoomoutButton.state(['!disabled'])
if self.zoominButton.instate(['disabled']): self.zoominButton.state(['!disabled'])
def onCombo(self, val):
self._hang(1)
def onPick(self, event):
thiscell = event.artist
value = thiscell.get_cellval()
r, c = thiscell.get_inds()
weight = str(round(value, 4))
rc = 'r: {} | c: {}'.format(r,c)
self.cellCoords.config(text = rc)
self.cellWeight.config(text = weight)
self.tinyFig.set_facecolor(vl.v2c(value, self.colors, 4))
self.tinyRenderer.draw()
def onSlide(self, val):
val = float(val)
self.epochValLabel.config(text = str(self._get_epoch(val)))
self._hang(1)
hp = self.snap.hyperparams[int(val)]
self.hpLabel.config(text = 'lrate: {}\nmrate: {}\nerror function: {}\nbatch size: {}\ntrain mode: {}'.format(
hp[0], hp[1], '{}'.format(hp[2]).split()[1], hp[3], 'p-train' if hp[4] else 's-train'))
# # find inputs that were presented on the given epoch and update the combobox
# pattern_list = []
# for k,v in self.snap.inp_names.items():
# for r in self.snap.inp_vects[int(val)]:
# if np.all(np.array(v)==r):
# pattern_list.append(k)
# self.patternSelector['values'] = pattern_list
# self.patternSelector.current(0)
def onApply(self):
print('Applying changes')
print('Normalization scope: {}'.format(self.normMode.get()))
print('Normalization range: {}'.format(self.nrangeEntry.get()))
print('Color map: {}'.format(self.colmapCombo.get()))
self.colorsWindow.withdraw()
def onHelp(self):
messagebox.showinfo('Need some explanation?',
'Too bad, we are still working on it. '
'Try playing around with the preferences '
'to see what\'s going on :)')
# def onColorPrefs(self):
# if self.colorsWindow.state() == 'withdrawn': self.colorsWindow.state('normal')
# self.colorsWindow.lift()
def onMasterX(self):
self._sleep()
def onColorsX(self):
positive = messagebox.askyesno('O_o', 'Do you want to apply changes')
if positive:
self.onApply()
self.colorsWindow.withdraw()
def catch_up(self, snap):
self.snap = snap
self._plotLatest()
self._hang(0)
self.master.state('normal')
self.master.lift()
def _hang(self, b):
if b:
self.epochValLabel.config(fg='#ABABAB')
self.master.title(self.title_ast)
else:
self.epochValLabel.config(fg='black')
self.master.title(self.title)
def _sleep(self):
self.master.withdraw()
self.colorsWindow.withdraw()
self.master.quit()
def _plotLatest(self):
latest_epoch_ind = len(self.snap.epochs) - 1
vl.draw_all_layers(self.snap,
self.panelBoard,
latest_epoch_ind,
0)
self.epochSlider.config(to = float(latest_epoch_ind))
self.epochSlider.set(latest_epoch_ind)
self.figureRenderer.draw()
def _get_epoch(self, slider_value):
return self.snap.epochs[int(slider_value)]
def _get_pattern(self):
try:
ind = self.snap.inp_names.index(self.patternVar.get())
print('You selected pattern {}'.format(ind))
except ValueError:
print('No such pattern')
def _set_bfs(self, scale = 0.4):
return self._ppc * scale
def destroy(self):
self.master.withdraw()
self.master.quit()
self.master.destroy()
class GUI():
def __init__(self,root,song):
# given parameters
self.root = root
self.song = song
# main window
self.root.title("Song segment player")
self.root.iconbitmap(r'Images/icon.ico')
self.root.configure(background='white')
# menubar
self.menubar = Menu(self.root)
self.filemenu = Menu(self.menubar,tearoff=0)
self.filemenu.add_command(label="Open",
command=lambda:b.openSong(self))
self.menubar.add_cascade(label="File",menu=self.filemenu)
# images for buttons
self.segmentIm = PhotoImage(file=r'Images/SegmentB.png')
self.repSegIm = PhotoImage(file=r'Images/Repeat.png')
self.playIm = PhotoImage(file=r'Images/PlayB.png')
self.pauseIm = PhotoImage(file=r'Images/PauseB.png')
self.stopIm = PhotoImage(file=r'Images/StopB.png')
self.ffIm = PhotoImage(file=r'Images/ffB.png')
self.rwIm = PhotoImage(file=r'Images/rwB.png')
self.fullSpeedIm = PhotoImage(file=r'Images/FullSpeedB.png')
self.halfSpeedIm = PhotoImage(file=r'Images/HalfSpeedB.png')
self.sliderIm = PhotoImage(file=r'Images/SliderB.png')
self.cursorIm = PhotoImage(file=r'Images/Cursor.png')
self.magPlusIm = PhotoImage(file=r'Images/MagPlus.png')
self.magMinusIm = PhotoImage(file=r'Images/MagMinus.png')
# making buttons
self.segmentB = Button(image=self.segmentIm,
command=lambda:b.playSeg(self.song))
self.repSegB = Button(image=self.repSegIm,
command=lambda:b.repeatSeg(self.song,self.repSegB))
self.playB = Button(image=self.playIm,
command=lambda:b.playStream(self.song))
self.pauseB = Button(image=self.pauseIm,
command=lambda:b.pauseStream(self.song))
self.stopB = Button(image=self.stopIm,
command=lambda:b.stopStream(self.song))
self.ffB = Button(image=self.ffIm,
command=lambda:b.ffStream(self.song))
self.rwB = Button(image=self.rwIm,
command=lambda:b.rwStream(self.song))
self.fullSpeedB = Button(image=self.fullSpeedIm)
self.halfSpeedB = Button(image=self.halfSpeedIm)
# making radio buttons
self.CLICKMODE = StringVar(value="slide")
self.sliderB = Radiobutton(
self.root,
image=self.sliderIm,
variable=self.CLICKMODE,
value='slide',
indicatoron=0)
self.cursorB = Radiobutton(
self.root,
image=self.cursorIm,
variable=self.CLICKMODE,
value='curse',
indicatoron=0)
self.magPlusB = Radiobutton(
self.root,
image=self.magPlusIm,
variable=self.CLICKMODE,
value='mag+',
indicatoron=0)
self.magMinusB = Radiobutton(
self.root,
image=self.magMinusIm,
variable=self.CLICKMODE,
value='mag-',
indicatoron=0)
# setting button parameters
self.allButts = [self.segmentB,self.repSegB,self.playB,self.stopB,
self.pauseB,self.ffB,self.rwB,self.fullSpeedB,
self.halfSpeedB,self.sliderB,self.cursorB,
self.magPlusB,self.magMinusB]
[butt.config(bg='white') for butt in self.allButts]
# disable all buttons to start with
[butt.config(state='disabled') for butt in self.allButts]
self.sliderB.config(state='normal')
# placing buttons
rowc = 3
self.segmentB.grid(row=0,column=2)
self.repSegB.grid(row=0,column=3)
self.playB.grid(row=rowc,column=3)
self.pauseB.grid(row=rowc,column=2)
self.stopB.grid(row=rowc,column=1)
self.ffB.grid(row=rowc,column=4)
self.rwB.grid(row=rowc,column=0)
self.fullSpeedB.grid(row=0,column=4,columnspan=3)
self.halfSpeedB.grid(row=0,column=5,columnspan=3)
self.sliderB.grid(row=2,column=0)
self.cursorB.grid(row=2,column=1)
self.magPlusB.grid(row=2,column=2)
self.magMinusB.grid(row=2,column=3)
# display song title
if self.song.songname:
t = self.song.songname[0:-4]
else:
t = ''
self.songTitleL = Label(self.root,text=t,bg='white')
self.songTitleL.grid(row=0,column=0)
# making figure canvas
self.canvas = FigureCanvasTkAgg(self.song.fig,master=self.root)
self.canvas.draw()
self.canvas.get_tk_widget().grid(row=rowc-2,column=0,columnspan=5)
# connecting canvas to monitor events
self.cidpress = self.canvas.mpl_connect(
'button_press_event',
lambda event:e.on_press(event,self.song,self.CLICKMODE))
self.cidrelease = self.canvas.mpl_connect(
'button_release_event',
lambda event:e.on_release(event,self.song))
self.cidmotion = self.canvas.mpl_connect(
'motion_notify_event',
lambda event:e.on_motion(event,self.song))
self.root.bind('<space>', lambda event:b.playPauseStream(self.song))
self.root.bind('<Return>', lambda event:b.playSeg(self.song))
# set cursor updating
self.root.after(10000,lambda: e.updateCursor(self))
# insert menu bar
self.root.config(menu=self.menubar)
# closing behaviour
self.root.protocol("WM_DELETE_WINDOW",self.on_closing)
def on_closing(self):
self.canvas.mpl_disconnect(self.cidpress)
self.canvas.mpl_disconnect(self.cidrelease)
self.canvas.mpl_disconnect(self.cidmotion)
self.root.destroy()
self.song.wf.close()
self.song.stream.close()
self.song.p.terminate()
[os.remove(s) for s in self.song.createdFilepaths]
def updateCursor(self):
if self.song.wf:
pos = self.song.wf.tell()/self.song.RATE
self.song.cursor[0].set_x(pos)
self.canvas.draw()
self.root.after(250,self.updateCursor)
# window
fen = Tk()
fen.title('Hello')
# create the grid
SIZE = 40
grid = np.zeros((SIZE, SIZE))
# grid[4, 4] = 3
U, V = np.gradient(-grid)
fig = plt.figure('hehehe')
im = plt.imshow(grid, cmap='Greys', interpolation='none')
# plt.hold(True)
ve = plt.quiver(-V, U, color='red', scale=2)
# Canvas
fig_can = FigureCanvasTkAgg(fig, master=fen)
fig_can.mpl_connect('button_press_event', onclick)
fig_can.get_tk_widget().grid(row=0, column=0, rowspan=3)
# Label
info_max = Label(fen, text='Max: 0')
info_max.grid(row=0, column=1)
info_min = Label(fen, text='Min: 0 ')
info_min.grid(row=1, column=1)
# Tick
gaussian_interpolation = IntVar()
check_interpolation = Checkbutton(
fen, text='Interpolation', variable=gaussian_interpolation,
command=update_interpolation)
check_interpolation.grid(row=2, column=1)
# Button
def Load_CSV(disable_widgets, enable_widgets):
global array, canvas
for widget in disable_widgets:
widget.config(state="disabled")
for widget in enable_widgets:
widget.config(state="normal")
file_type = (option_menu_title.get())[-4:]
if file_type == '.csv':
CSV_name = option_menu_title.get()
CSV_path = join('Data', CSV_name)
root.title(('PPP: {0}').format(CSV_name))
file = open(CSV_path)
csv_reader = csv.reader(file)
lines = 0 #count lines in the chosen csv
for row in csv_reader:
lines += 1
ref.lines = lines
array = np.zeros((lines, 2))
ref.array_length = lines
#make empty array
file = open(
CSV_path
) #for some reason i need to repeate this bit otherwise it wont work WHO KNOWS
reader = csv.reader(file)
for index, row in enumerate(reader): #populate array
array[index, 0] = float(row[0])
array[index, 1] = float(row[1])
elif file_type == '.txt':
TXT_name = option_menu_title.get()
TXT_path = join('Data', TXT_name)
text_file = open(TXT_path, 'r')
reader = text_file.readlines()
array = np.zeros((len(reader), 2))
for index, line in enumerate(reader):
# print(index)
# print(line[:(line.find('\t'))])
# print(line[(line.find('\t')):])
# print('')
x, y = float(line[:(line.find('\t'))]), float(
line[(line.find('\t')):])
array[index, 0] = float(x)
array[index, 1] = float(y)
ref.lines = len(reader) #fix this to be the number of lines
fig = pl.Figure(figsize=(16, 9))
plot1 = fig.add_subplot(111)
plot1.plot(array[:, 0], array[:, 1])
canvas = FigureCanvasTkAgg(fig, master=root)
canvas.draw()
toolbar = NavigationToolbar2Tk(canvas, root)
toolbar.update()
canvas.get_tk_widget().place(x=0, y=7)
over_view = pl.figure()
pl.xlabel('ADC')
pl.ylabel('Entries')
pl.title('SiPM Output')
pl.plot(array[:, 0], array[:, 1])
pl.xlim(min(array[:, 0]), max(array[:, 0]) / 2)
pl.rcParams['figure.figsize'] = 16, 9
pl.savefig('Saved/fig0.png')
pl.close(over_view)
def callback(event):
x = int(event.xdata)
y = int(event.ydata)
most_recent_coords.set(('Current Coords:\n' + str(x) + ', ' + str(y)))
ref.lastest_coords = (x, y)
canvas.mpl_connect('button_press_event', callback)
y_pts.append(y)
# add horizontal line and point at mouse position
dyn.append(ax.hlines(y_pts, -1850, -100))
dyn.append(ax.scatter(x_pts, y_pts, c = 'black', s = 10))
# when a second point is added, connect horizontal lines with vertical lines and display vertical distance
if len(x_pts) >= 2:
dyn.append(ax.vlines(x = (x_pts[0]+x_pts[1])/2, ymin = y_pts[0], ymax = y_pts[1]))
props = dict(boxstyle='round', facecolor='grey', alpha=0.5)
peak_current = y_pts[1]-y_pts[0]
dyn.append(ax.text(0.05, 0.95, '{:.3f} nA'.format(peak_current),
transform=ax.transAxes, fontsize=14,verticalalignment='top', bbox=props))
canvas.draw()
canvas.mpl_connect('button_press_event', onpick)
#################################################################################
# Manage Keyboard inpput
def on_key_press(event):
#Matplotlib Toolbar keybindings:
key_press_handler(event, canvas, toolbar)
canvas.get_tk_widget().bind("<Left>", previous_file)
canvas.get_tk_widget().bind("<Right>", next_file)
canvas.get_tk_widget().bind("<Delete>", delete)
canvas.mpl_connect("key_press_event", on_key_press)
class DataPanelGUI(object):
##
# @param [in] dataFigSize (w, h) in inches for the data plots figure assuming dpi=72
def __init__(self, master, cd, dataFigSize=(13, 12.5)):
self.mode = 0
self.master = master
self.cd = cd
self.nAdcCh = self.cd.nAdcCh
self.nSdmCh = self.cd.nCh
self.adcSdmCycRatio = self.cd.adcSdmCycRatio
self.master.wm_title("Topmetal-S 1mm version x19 array data")
# appropriate quitting
self.master.wm_protocol("WM_DELETE_WINDOW", self.quit)
self.autoSaveData = False
self.sampleID = 0
######## Control frame #########
self.nVolts = self.cd.nVolts
self.nCh = self.cd.nCh
self.controlFrame = tk.Frame(self.master)
self.controlFrame.pack(side=tk.LEFT)
button1 = tk.Button(master=self.controlFrame,
text='Save data',
command=self.save_data0)
button1.pack(side=tk.TOP, fill=tk.X)
button = tk.Button(master=self.controlFrame,
text='Re-sample',
command=self.re_sample)
button.pack(side=tk.BOTTOM, fill=tk.X)
button2 = tk.Button(master=self.controlFrame,
text='Auto-update',
command=self.auto_update)
button2.pack(side=tk.TOP, fill=tk.X)
# frame for selecting a sensor to operate on
self.sensorsFrame = tk.Frame(self.controlFrame)
self.sensorsFrame.pack(side=tk.TOP)
# sensor location approximated on a grid (row, col)
self.sensorLocOnGrid = {
0: [4, 2],
1: [2, 2],
2: [3, 1],
3: [5, 1],
4: [6, 2],
5: [5, 3],
6: [3, 3],
7: [0, 2],
8: [1, 1],
9: [2, 0],
10: [4, 0],
11: [6, 0],
12: [7, 1],
13: [8, 2],
14: [7, 3],
15: [6, 4],
16: [4, 4],
17: [2, 4],
18: [1, 3]
}
self.sensorSelVar = tk.IntVar()
self.sensorSelRadioButtons = [
tk.Radiobutton(self.sensorsFrame,
text="{:d}".format(i),
variable=self.sensorSelVar,
value=i,
command=self.select_current_sensor)
for i in xrange(self.nCh)
]
for i in xrange(len(self.sensorSelRadioButtons)):
b = self.sensorSelRadioButtons[i]
b.grid(row=self.sensorLocOnGrid[i][0],
column=self.sensorLocOnGrid[i][1])
# frame for controls
self.voltagesFrame = tk.Frame(self.controlFrame)
self.voltagesFrame.pack(side=tk.BOTTOM)
# GUI widgets
self.voltsNameLabels = [
tk.Label(self.voltagesFrame, text=self.cd.voltsNames[i])
for i in xrange(self.nVolts)
]
self.voltsILabels = [
tk.Label(self.voltagesFrame, font="Courier 10", text="0.0")
for i in xrange(self.nVolts)
]
self.voltsOutputLabels = [
tk.Label(self.voltagesFrame, font="Courier 10", text="0.0")
for i in xrange(self.nVolts)
]
self.voltsSetVars = [tk.DoubleVar() for i in xrange(self.nVolts)]
for i in xrange(self.nVolts):
self.voltsSetVars[i].set(self.cd.inputVs[i])
self.voltsSetEntries = [
tk.Spinbox(self.voltagesFrame,
width=8,
justify=tk.RIGHT,
textvariable=self.voltsSetVars[i],
from_=0.0,
to=3.3,
increment=0.001,
format_="%6.4f",
command=self.set_voltage_update)
for i in xrange(self.nVolts)
]
for v in self.voltsSetEntries:
v.bind('<Return>', self.set_voltage_update)
self.voltsSetCodeVars = [tk.IntVar() for i in xrange(self.nVolts)]
for i in xrange(self.nVolts):
self.voltsSetCodeVars[i].set(self.cd.inputVcodes[i])
self.voltsSetCodeEntries = [
tk.Spinbox(self.voltagesFrame,
width=8,
justify=tk.RIGHT,
textvariable=self.voltsSetCodeVars[i],
from_=0,
to=65535,
increment=1,
command=self.set_voltage_dac_code_update)
for i in xrange(self.nVolts)
]
for v in self.voltsSetCodeEntries:
v.bind('<Return>', self.set_voltage_dac_code_update)
# caption
tk.Label(self.voltagesFrame,
text="Name",
width=8,
fg="white",
bg="black").grid(row=0, column=0, sticky=tk.W + tk.E)
tk.Label(self.voltagesFrame,
text="Voltage [V]",
width=10,
fg="white",
bg="black").grid(row=0, column=1, sticky=tk.W + tk.E)
tk.Label(self.voltagesFrame,
text="DAC code",
width=10,
fg="white",
bg="black").grid(row=0, column=2, sticky=tk.W + tk.E)
tk.Label(self.voltagesFrame,
text="Measured [V]",
fg="white",
bg="black").grid(row=0, column=3, sticky=tk.W + tk.E)
# placing widgets
for i in xrange(self.nVolts):
self.voltsNameLabels[i].grid(row=i + 1, column=0)
self.voltsSetEntries[i].grid(row=i + 1, column=1)
self.voltsSetCodeEntries[i].grid(row=i + 1, column=2)
self.voltsOutputLabels[i].grid(row=i + 1, column=3)
self.update_values_display()
######## End of contral Frame ########
# frame for plotting
self.dataPlotsFrame = tk.Frame(self.master)
self.dataPlotsFrame.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
self.dataPlotsFrame.bind("<Configure>", self.on_resize)
self.dataPlotsFigure = Figure(figsize=dataFigSize, dpi=72)
self.dataPlotsFigure.subplots_adjust(left=0.1,
right=0.98,
top=0.98,
bottom=0.05,
hspace=0,
wspace=0)
# x-axis is shared
# dataPlotsSubplotN = self.dataPlotsFigure.add_subplot(self.nCh, 1, self.nCh, xlabel='t [us]', ylabel='[V]')
dataPlotsSubplotN = self.dataPlotsFigure.add_subplot(1,
1,
1,
xlabel='t [us]',
ylabel='[V]')
self.dataPlotsSubplots = []
# self.dataPlotsSubplots = [self.dataPlotsFigure.add_subplot(self.nCh, 1, i+1, sharex=dataPlotsSubplotN)
# for i in xrange(self.nCh-1)]
# for a in self.dataPlotsSubplots:
# artist.setp(a.get_xticklabels(), visible=False)
self.dataPlotsSubplots.append(dataPlotsSubplotN)
self.dataPlotsCanvas = FigureCanvasTkAgg(self.dataPlotsFigure,
master=self.dataPlotsFrame)
self.dataPlotsCanvas.show()
self.dataPlotsCanvas.get_tk_widget().pack(side=tk.TOP,
fill=tk.BOTH,
expand=True)
self.dataPlotsToolbar = NavigationToolbar2TkAgg(
self.dataPlotsCanvas, self.dataPlotsFrame)
self.dataPlotsToolbar.update()
self.dataPlotsCanvas._tkcanvas.pack(side=tk.TOP,
fill=tk.BOTH,
expand=True)
self.dataPlotsCanvas.mpl_connect('key_press_event', self.on_key_event)
#
self.plot_data()
def on_key_event(self, event):
print('You pressed {:s}'.format(event.key))
key_press_handler(event, self.dataPlotsCanvas, self.dataPlotsToolbar)
def on_resize(self, event):
# print(event.width, event.height)
return
def quit(self):
with self.cd.cv:
self.cd.quit = True
self.cd.cv.notify()
self.master.quit() # stops mainloop
self.master.destroy() # this is necessary on Windows to prevent
# Fatal Python Error: PyEval_RestoreThread: NULL tstate
def get_and_plot_data(self):
# reset data fifo
print("in get_and_plot_data")
if online: self.cd.dataSocket.sendall(self.cd.cmd.send_pulse(1 << 2))
time.sleep(0.1)
for i in range(len(self.cd.adcData)):
for j in range(len(self.cd.adcData[i])):
self.cd.adcData0[i][j] = self.cd.adcData[i][j]
if online:
buf = self.cd.cmd.acquire_from_datafifo(self.cd.dataSocket,
self.cd.nWords,
self.cd.sampleBuf)
self.cd.sigproc.demux_fifodata(buf, self.cd.adcData,
self.cd.sdmData)
self.plot_data()
if self.autoSaveData:
self.cd.sigproc.save_data(self.cd.dataFName, self.cd.adcData,
self.cd.sdmData)
def plot_data(self):
print("going to plot sensor", self.cd.currentSensor)
for a in self.dataPlotsSubplots:
a.cla()
self.dataPlotsFigure.texts = []
# for txt in self.dataPlotsFigure.texts:
# txt.set_visible(False)
a = self.dataPlotsSubplots[-1]
# a.set_xlabel(u't [us]')
a.set_xlabel(u't [ms]')
self.cd.adcDt = 0.2 * 0.001
a.set_ylabel('[V]')
nSamples = len(self.cd.adcData[0])
x = [self.cd.adcDt * i for i in xrange(nSamples)]
a.locator_params(axis='y', tight=True, nbins=4)
a.yaxis.set_major_formatter(FormatStrFormatter('%7.4f'))
a.set_xlim([0.0, self.cd.adcDt * nSamples])
a.step(x,
array.array('f', self.cd.adcData0[self.cd.currentSensor]),
where='post',
color='lightcoral')
a.step(x,
array.array('f', self.cd.adcData[self.cd.currentSensor]),
where='post')
dd1 = max(self.cd.adcData[self.cd.currentSensor]) - min(
self.cd.adcData[self.cd.currentSensor])
l1 = self.dataPlotsFigure.text(0.2,
0.92,
'New:{0:.3f}'.format(0.5 * dd1),
ha='center',
va='center',
transform=a.transAxes)
l1.set_color('blue')
dd0 = max(self.cd.adcData0[self.cd.currentSensor]) - min(
self.cd.adcData0[self.cd.currentSensor])
l0 = self.dataPlotsFigure.text(0.2,
0.90,
'Old:{0:.3f}'.format(0.5 * dd0),
ha='center',
va='center',
transform=a.transAxes)
l0.set_color('lightcoral')
l2 = self.dataPlotsFigure.text(0.2,
0.88,
'Old:{0:.3f}'.format(0.5 * (dd1 - dd0)),
ha='center',
va='center',
transform=a.transAxes)
if dd1 - dd0 > 0:
l2.set_color('green')
else:
l2.set_color('black')
# a.set_ylim([0.97,1.03])
self.dataPlotsCanvas.show()
self.dataPlotsToolbar.update()
def re_sample(self):
self.mode = 0
self.get_and_plot_data()
def auto_update(self):
self.mode = 1
while self.mode == 1:
try:
time.sleep(1)
self.get_and_plot_data()
except:
break
def plot_data2(self):
# self.dataPlotsFigure.clf(keep_observers=True)
for a in self.dataPlotsSubplots:
a.cla()
for i in xrange(len(self.dataPlotsSubplots) - 1):
a = self.dataPlotsSubplots[i]
artist.setp(a.get_xticklabels(), visible=False)
a.set_ylabel("#{:d}".format(i), rotation=0)
a = self.dataPlotsSubplots[-1]
a.set_xlabel(u't [us]')
a.set_ylabel('[V]')
nSamples = len(self.cd.adcData[0])
x = [self.cd.adcDt * i for i in xrange(nSamples)]
# print(x if len(x)<10 else x[:10])
for i in xrange(len(self.dataPlotsSubplots)):
a = self.dataPlotsSubplots[i]
a.locator_params(axis='y', tight=True, nbins=4)
a.yaxis.set_major_formatter(FormatStrFormatter('%7.4f'))
a.set_xlim([0.0, self.cd.adcDt * nSamples])
a.step(x, self.cd.adcData[i], where='post')
self.dataPlotsCanvas.show()
self.dataPlotsToolbar.update()
return
def demux_fifodata(self,
fData,
adcData=None,
sdmData=None,
adcVoffset=1.024,
adcLSB=62.5e-6):
wWidth = 512
bytesPerSample = wWidth / 8
if type(fData[0]) == str:
fD = bytearray(fData)
else:
fD = fData
if len(fD) % bytesPerSample != 0:
print("empty fD")
return []
nSamples = len(fD) / bytesPerSample
if adcData == None:
adcData = [[0 for i in xrange(nSamples)]
for j in xrange(self.nAdcCh)]
if sdmData == None:
sdmData = [[0 for i in xrange(nSamples * self.adcSdmCycRatio)]
for j in xrange(self.nSdmCh * 2)]
for i in xrange(nSamples):
for j in xrange(self.nAdcCh):
idx0 = bytesPerSample - 1 - j * 2
v = (fD[i * bytesPerSample + idx0 - 1] << 8
| fD[i * bytesPerSample + idx0])
# convert to signed int
v = (v ^ 0x8000) - 0x8000
# convert to actual volts
adcData[j][i] = v * adcLSB + adcVoffset
b0 = self.nAdcCh * 2
for j in xrange(self.adcSdmCycRatio * self.nSdmCh * 2):
bi = bytesPerSample - 1 - b0 - int(j / 8)
bs = j % 8
ss = int(j / (self.nSdmCh * 2))
ch = j % (self.nSdmCh * 2)
sdmData[ch][i * self.adcSdmCycRatio +
ss] = (fD[i * bytesPerSample + bi] >> bs) & 0x1
#
return adcData
def save_data0(self):
self.cd.sigproc.save_data([
"sample_" + str(self.sampleID) + '_' + x + '.dat'
for x in ['adc', 'sdm']
], self.cd.adcData, self.cd.sdmData)
self.sampleID += 1
def save_data(self, fNames):
with open(fNames[0], 'w') as fp:
fp.write("# 5Msps ADC\n")
nSamples = len(self.cd.adcData[0])
for i in xrange(nSamples):
for j in xrange(len(self.cd.adcData)):
fp.write(" {:9.6f}".format(self.cd.adcData[j][i]))
fp.write("\n")
with open(fNames[1], 'w') as fp:
fp.write("# 25Msps SDM\n")
nSamples = len(self.cd.sdmData[0])
for i in xrange(nSamples):
for j in xrange(len(self.cd.sdmData)):
fp.write(" {:1d}".format(self.cd.sdmData[j][i]))
fp.write("\n")
# def quit(self):
# with self.cd.cv:
# self.cd.quit = True
# self.cd.cv.notify()
# self.master.destroy()
def update_values_display(self):
for i in xrange(self.nVolts):
self.voltsILabels[i].configure(
text="{:7.3f}".format(self.cd.inputIs[i]))
self.voltsOutputLabels[i].configure(
text="{:7.3f}".format(self.cd.voltsOutput[i]))
self.master.after(int(1000 * self.cd.tI), self.update_values_display)
def select_current_sensor(self, *args):
with self.cd.cv:
self.cd.currentSensor = self.sensorSelVar.get()
print("sensor", self.cd.currentSensor)
# self.cd.currentSensor = self.cd.currentSensor
# load Vcodes for the specific sensor
for i in xrange(self.nVolts):
self.voltsSetCodeVars[i].set(
self.cd.sensorVcodes[self.cd.currentSensor][i])
self.set_voltage_dac_code_update()
def set_voltage_update(self, *args):
with self.cd.cv:
for i in xrange(self.nVolts):
self.cd.inputVs[i] = self.voltsSetVars[i].get()
self.cd.inputVcodes[i] = self.cd.tms1mmReg.dac_volt2code(
self.cd.inputVs[i])
self.voltsSetCodeVars[i].set(self.cd.inputVcodes[i])
# update info for the array
self.cd.sensorVcodes[
self.cd.currentSensor][i] = self.cd.inputVcodes[i]
self.cd.vUpdated = True
print(self.cd.inputVs)
print(self.cd.inputVcodes)
return True
def set_voltage_dac_code_update(self, *args):
with self.cd.cv:
for i in xrange(self.nVolts):
self.cd.inputVcodes[i] = self.voltsSetCodeVars[i].get()
self.cd.inputVs[i] = self.cd.tms1mmReg.dac_code2volt(
self.cd.inputVcodes[i])
self.voltsSetVars[i].set(round(self.cd.inputVs[i], 4))
# update info for the array
self.cd.sensorVcodes[
self.cd.currentSensor][i] = self.cd.inputVcodes[i]
self.cd.vUpdated = True
print(self.cd.inputVcodes)
return True
class StripChartWdg(tkinter.Frame):
"""A widget to changing values in real time as a strip chart
Usage Hints:
- For each variable quantity to display:
- Call addLine once to specify the quantity
- Call addPoint for each new data point you wish to display
- For each constant line (e.g. limit) to display call addConstantLine
- To make sure a plot includes one or two y values (e.g. 0 or a range of values) call showY
- To manually scale a Y axis call setYLimits (by default all y axes are autoscaled).
- All supplied times are POSIX timestamps (e.g. as supplied by time.time()).
You may choose the kind of time displayed on the time axis (e.g. UTC or local time) using cnvTimeFunc
and the format of that time using dateFormat.
Known Issues:
matplotlib's defaults present a number of challenges for making a nice strip chart display.
Some issues and manual solutions are discussed in the main file's document string.
Potentially Useful Attributes:
- canvas: the matplotlib FigureCanvas
- figure: the matplotlib Figure
- subplotArr: list of subplots, from top to bottom; each is a matplotlib Subplot object,
which is basically an Axes object but specialized to live in a rectangular grid
- xaxis: the x axis shared by all subplots
"""
def __init__(self,
master,
timeRange = 3600,
numSubplots = 1,
width = 8,
height = 2,
showGrid = True,
dateFormat = "%H:%M:%S",
updateInterval = None,
cnvTimeFunc = None,
):
"""Construct a StripChartWdg with the specified time range
Inputs:
- master: Tk parent widget
- timeRange: range of time displayed (seconds)
- width: width of graph in inches
- height: height of graph in inches
- numSubplots: the number of subplots
- showGrid: if True a grid is shown
- dateFormat: format for major axis labels, using time.strftime format
- updateInterval: now often the time axis is updated (seconds); if None a value is calculated
- cnvTimeFunc: a function that takes a POSIX timestamp (e.g. time.time()) and returns matplotlib days;
typically an instance of TimeConverter; defaults to TimeConverter(useUTC=False)
"""
tkinter.Frame.__init__(self, master)
self._timeRange = timeRange
self._isVisible = self.winfo_ismapped()
self._isFirst = True
if updateInterval is None:
updateInterval = max(0.1, min(5.0, timeRange / 2000.0))
self.updateInterval = float(updateInterval)
# print "updateInterval=", self.updateInterval
if cnvTimeFunc is None:
cnvTimeFunc = TimeConverter(useUTC=False)
self._cnvTimeFunc = cnvTimeFunc
# how many time axis updates occur before purging old data
self._maxPurgeCounter = max(1, int(0.5 + (5.0 / self.updateInterval)))
self._purgeCounter = 0
self.figure = matplotlib.figure.Figure(figsize=(width, height), frameon=True)
self.canvas = FigureCanvasTkAgg(self.figure, self)
self.canvas.get_tk_widget().grid(row=0, column=0, sticky="news")
self.canvas.mpl_connect('draw_event', self._handleDrawEvent)
self.grid_rowconfigure(0, weight=1)
self.grid_columnconfigure(0, weight=1)
bottomSubplot = self.figure.add_subplot(numSubplots, 1, numSubplots)
self.subplotArr = [self.figure.add_subplot(numSubplots, 1, n+1, sharex=bottomSubplot) \
for n in range(numSubplots-1)] + [bottomSubplot]
if showGrid:
for subplot in self.subplotArr:
subplot.grid(True)
self.xaxis = bottomSubplot.xaxis
bottomSubplot.xaxis_date()
self.xaxis.set_major_formatter(matplotlib.dates.DateFormatter(dateFormat))
# dictionary of constant line name: (matplotlib Line2D, matplotlib Subplot)
self._constLineDict = dict()
for subplot in self.subplotArr:
subplot._scwLines = [] # a list of contained _Line objects;
# different than the standard lines property in that:
# - lines contains Line2D objects
# - lines contains constant lines as well as data lines
subplot._scwBackground = None # background for animation
subplot.label_outer() # disable axis labels on all but the bottom subplot
subplot.set_ylim(auto=True) # set auto scaling for the y axis
self.bind("<Map>", self._handleMap)
self.bind("<Unmap>", self._handleUnmap)
self._timeAxisTimer = Timer()
self._updateTimeAxis()
def addConstantLine(self, y, subplotInd=0, **kargs):
"""Add a new constant to plot
Inputs:
- y: value of constant line
- subplotInd: index of subplot
- All other keyword arguments are sent to the matplotlib Line2D constructor
to control the appearance of the data. See addLine for more information.
"""
subplot = self.subplotArr[subplotInd]
line2d = subplot.axhline(y, **kargs)
yMin, yMax = subplot.get_ylim()
if subplot.get_autoscaley_on() and numpy.isfinite(y) and not (yMin <= y <= yMax):
subplot.relim()
subplot.autoscale_view(scalex=False, scaley=True)
return line2d
def addLine(self, subplotInd=0, **kargs):
"""Add a new quantity to plot
Inputs:
- subplotInd: index of subplot
- All other keyword arguments are sent to the matplotlib Line2D constructor
to control the appearance of the data. Useful arguments include:
- label: name of line (displayed in a Legend)
- color: color of line
- linestyle: style of line (defaults to a solid line); "" for no line, "- -" for dashed, etc.
- marker: marker shape, e.g. "+"
Please do not attempt to control other sorts of line properties, such as its data.
Arguments to avoid include: animated, data, xdata, ydata, zdata, figure.
"""
subplot = self.subplotArr[subplotInd]
return _Line(
subplot = subplot,
cnvTimeFunc = self._cnvTimeFunc,
wdg = self,
**kargs)
def clear(self):
"""Clear data in all non-constant lines
"""
for subplot in self.subplotArr:
for line in subplot._scwLines:
line.clear()
def getDoAutoscale(self, subplotInd=0):
return self.subplotArr[subplotInd].get_autoscaley_on()
def removeLine(self, line):
"""Remove an existing line added by addLine or addConstantLine
Raise an exception if the line is not found
"""
if isinstance(line, _Line):
# a _Line object needs to be removed from _scwLines as well as the subplot
line2d = line.line2d
subplot = line.subplot
subplot._scwLines.remove(line)
else:
# a constant line is just a matplotlib Line2D instance
line2d = line
subplot = line.axes
subplot.lines.remove(line2d)
if subplot.get_autoscaley_on():
subplot.relim()
subplot.autoscale_view(scalex=False, scaley=True)
self.canvas.draw()
def setDoAutoscale(self, doAutoscale, subplotInd=0):
"""Turn autoscaling on or off for the specified subplot
You can also turn off autoscaling by calling setYLimits.
"""
doAutoscale = bool(doAutoscale)
subplot = self.subplotArr[subplotInd]
subplot.set_ylim(auto=doAutoscale)
if doAutoscale:
subplot.relim()
subplot.autoscale_view(scalex=False, scaley=True)
def setYLimits(self, minY, maxY, subplotInd=0):
"""Set y limits for the specified subplot and disable autoscaling.
Note: if you want to autoscale with a minimum range, use showY.
"""
self.subplotArr[subplotInd].set_ylim(minY, maxY, auto=False)
def showY(self, y0, y1=None, subplotInd=0):
"""Specify one or two values to always show in the y range.
Inputs:
- subplotInd: index of subplot
- y0: first y value to show
- y1: second y value to show; None to omit
Warning: setYLimits overrides this method (but the values are remembered in case you turn
autoscaling back on).
"""
subplot = self.subplotArr[subplotInd]
yMin, yMax = subplot.get_ylim()
if y1 is not None:
yList = [y0, y1]
else:
yList = [y0]
doRescale = False
for y in yList:
subplot.axhline(y, linestyle=" ")
if subplot.get_autoscaley_on() and numpy.isfinite(y) and not (yMin <= y <= yMax):
doRescale = True
if doRescale:
subplot.relim()
subplot.autoscale_view(scalex=False, scaley=True)
def _handleDrawEvent(self, event=None):
"""Handle draw event
"""
# print "handleDrawEvent"
for subplot in self.subplotArr:
subplot._scwBackground = self.canvas.copy_from_bbox(subplot.bbox)
for line in subplot._scwLines:
subplot.draw_artist(line.line2d)
self.canvas.blit(subplot.bbox)
def _handleMap(self, evt):
"""Handle map event (widget made visible)
"""
self._isVisible = True
self._handleDrawEvent()
self._updateTimeAxis()
def _handleUnmap(self, evt):
"""Handle unmap event (widget made not visible)
"""
self._isVisible = False
def _updateTimeAxis(self):
"""Update the time axis; calls itself
"""
tMax = time.time() + self.updateInterval
tMin = tMax - self._timeRange
minMplDays = self._cnvTimeFunc(tMin)
maxMplDays = self._cnvTimeFunc(tMax)
self._purgeCounter = (self._purgeCounter + 1) % self._maxPurgeCounter
doPurge = self._purgeCounter == 0
if doPurge:
for subplot in self.subplotArr:
for line in subplot._scwLines:
line._purgeOldData(minMplDays)
if self._isVisible or self._isFirst:
for subplot in self.subplotArr:
subplot.set_xlim(minMplDays, maxMplDays)
if doPurge:
if subplot.get_autoscaley_on():
# since data is being purged the y limits may have changed
subplot.relim()
subplot.autoscale_view(scalex=False, scaley=True)
self._isFirst = False
self.canvas.draw()
self._timeAxisTimer.start(self.updateInterval, self._updateTimeAxis)
class matplotlibSwitchGraphs:
def __init__(self, master):
self.master = master
self.frame = Frame(self.master)
self.fig, self.ax = config_plot()
self.graphIndex = 0
self.canvas = FigureCanvasTkAgg(self.fig, self.master)
self.config_window()
self.draw_graph('janvier')
self.frame.pack(expand=YES, fill=BOTH)
def config_window(self):
self.canvas.mpl_connect("key_press_event", self.on_key_press)
toolbar = NavigationToolbar2Tk(self.canvas, self.master)
toolbar.update()
self.canvas.get_tk_widget().pack(side=TOP, fill=BOTH, expand=1)
self.button = Button(self.master, text="Quit", command=self._quit)
self.button.pack(side=BOTTOM)
self.button_back = Button(self.master,
text="Graphique précédent",
command=self.back_graph)
self.button_back.pack(side=BOTTOM)
self.button_next = Button(self.master,
text="Graphique suivant",
command=self.next_graph)
self.button_next.pack(side=BOTTOM)
def draw_graph(self, month):
if (month == 'année'):
df_temp = pd.DataFrame(columns=['Température'])
df_temp_error = pd.DataFrame(columns=['Température'])
for column in df:
for value in df[column]:
df_temp = df_temp.append({'Température': value},
ignore_index=True)
for column in df_error:
for value in df_error[column]:
df_temp_error = df_temp_error.append(
{'Température': value}, ignore_index=True)
df_temp.dropna()
df_temp_error.dropna()
self.ax.clear()
self.ax.plot(df_temp['Température'])
self.ax.plot(df_temp_error['Température'])
self.ax.set(title='Année')
self.canvas.draw()
else:
for df, index in enumerate(array_df):
clear_data(df[month])
self.ax.clear()
self.ax.plot(df[month], label=array_csv[index])
self.ax.plot(df[month], label='Jeux de données propre')
self.ax.legend()
self.ax.set(title=month)
self.canvas.draw()
def on_key_press(event):
key_press_handler(event, self.canvas, toolbar)
def _quit(self):
self.master.quit()
def next_graph(self):
if self.graphIndex == 0:
self.draw_graph('février')
self.graphIndex = 1
elif self.graphIndex == 1:
self.draw_graph('mars')
self.graphIndex = 2
elif self.graphIndex == 2:
self.draw_graph('avril')
self.graphIndex = 3
elif self.graphIndex == 3:
self.draw_graph('mai')
self.graphIndex = 4
elif self.graphIndex == 4:
self.draw_graph('juin')
self.graphIndex = 5
elif self.graphIndex == 5:
self.draw_graph('juillet')
self.graphIndex = 6
elif self.graphIndex == 6:
self.draw_graph('août')
self.graphIndex = 7
elif self.graphIndex == 7:
self.draw_graph('septembre')
self.graphIndex = 8
elif self.graphIndex == 8:
self.draw_graph('octobre')
self.graphIndex = 9
elif self.graphIndex == 9:
self.draw_graph('novembre')
self.graphIndex = 10
elif self.graphIndex == 10:
self.draw_graph('décembre')
self.graphIndex = 11
elif self.graphIndex == 11:
self.draw_graph('janvier')
self.graphIndex = 12
elif self.graphIndex == 12:
self.draw_graph('année')
self.graphIndex = 0
def back_graph(self):
if self.graphIndex == 0:
self.draw_graph('décembre')
self.graphIndex = 11
elif self.graphIndex == 11:
self.draw_graph('novembre')
self.graphIndex = 10
elif self.graphIndex == 10:
self.draw_graph('octobre')
self.graphIndex = 9
elif self.graphIndex == 9:
self.draw_graph('septembre')
self.graphIndex = 8
elif self.graphIndex == 8:
self.draw_graph('août')
self.graphIndex = 7
elif self.graphIndex == 7:
self.draw_graph('juillet')
self.graphIndex = 6
elif self.graphIndex == 6:
self.draw_graph('juin')
self.graphIndex = 5
elif self.graphIndex == 5:
self.draw_graph('mai')
self.graphIndex = 4
elif self.graphIndex == 4:
self.draw_graph('avril')
self.graphIndex = 3
elif self.graphIndex == 3:
self.draw_graph('mars')
self.graphIndex = 2
elif self.graphIndex == 2:
self.draw_graph('février')
self.graphIndex = 1
elif self.graphIndex == 1:
self.draw_graph('janvier')
self.graphIndex = 12
elif self.graphIndex == 12:
self.draw_graph('année')
self.graphIndex = 0
class tk_int_plot(object):
def __init__(self):
self.root = Tk.Tk()
self.root.wm_title("Fatigue strength curves for direct stress ranges")
## PLOT INITIALIZATION ##
self.f = plt.Figure(figsize=(10,6), dpi=100)
dictt = {'pad':0,'w_pad':0,'h_pad':0}
self.f.set_tight_layout(dictt)
#self.f.subplots_adjust(left=0.1, right=0.98, top=0.97, bottom=0.1) # plot-borders
## PLOT INPUT ##
self.N = np.logspace(4.0,9.0,num=1000)
self.C = [160,140,125,112,100,90,80,71,63,56,50,45,40,36]
self.C_org = self.C
self.general_plot(self.N,self.C)
# a tk.DrawingArea
self.canvas = FigureCanvasTkAgg(self.f, master=self.root)
self.canvas.show()
#self.canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) # used with pack
# #self.toolbar = NavigationToolbar2TkAgg( self.canvas, self.root ) # used with pack
toolbar_frame = Tk.Frame(self.root)
toolbar_frame.grid(row=1,column=0,columnspan=2)
self.toolbar = NavigationToolbar2TkAgg( self.canvas, toolbar_frame )
#self.toolbar.update() # used with pack
self.canvas._tkcanvas.grid(row=0, column=0)#pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
## BUTTONS ##
# Detail catagory optionMenu
self.label = Tk.Label(self.root, text= 'Detail Catagory: ').grid(row=2, column=1) #self.label.pack(side=Tk.LEFT)
optionList = self.C
self.optionList = Tk.StringVar()
self.optionList.set(optionList[0])
self.om = Tk.OptionMenu(self.root,self.optionList,*optionList).grid(row=2, column=2) #self.om.pack(side=Tk.TOP)
# N cycles Entry
self.label_n = Tk.Label(self.root, text= 'No. of Cycles: ').grid(row=3, column=1) #self.label.pack(side=Tk.LEFT)
self.entrytext_n = Tk.StringVar(0,'2e6')
self.entrybutton = Tk.Entry(master=self.root, textvariable=self.entrytext_n).grid(row=3, column=2) #self.button.pack(side=Tk.TOP)
# Stress range Entry
self.label_s = Tk.Label(self.root, text= 'Δσ_R: ').grid(row=4, column=1) #self.label.pack(side=Tk.LEFT)
self.entrytext_s = Tk.StringVar(0,'160')
self.entrybutton = Tk.Entry(master=self.root, textvariable=self.entrytext_s).grid(row=4, column=2) #self.button.pack(side=Tk.TOP)
# Replot button (cycles)
button = Tk.Button(master=self.root, text='Replot', command=self._replot_n).grid(row=3, column=3) #button.pack(side=Tk.BOTTOM)
# Replot button (stress)
button = Tk.Button(master=self.root, text='Replot', command=self._replot_s).grid(row=4, column=3) #button.pack(side=Tk.BOTTOM)
# Quit button
button = Tk.Button(master=self.root, text='Quit', command=self._quit).grid(row=5, column=3) #button.pack(side=Tk.BOTTOM)
# Plot save button
button = Tk.Button(master=self.root, text='Save Plot', command=self._save_plot).grid(row=6, column=3) #button.pack(side=Tk.BOTTOM)
# Rainflow_count button (range,freq,accu_freq)
button = Tk.Button(master=self.root, text='Load rainflow count', command=self._load_rainflow_count).grid(row=7, column=3) #button.pack(side=Tk.BOTTOM)
# Reset
button = Tk.Button(master=self.root, text='Reset', command=self._plot_reset).grid(row=8, column=3) #button.pack(side=Tk.BOTTOM)
#self.root.rowconfigure(index=1, weight=1)
# Key logger initiated - NK
self.canvas.mpl_connect('key_press_event', self.on_key_event)
Tk.mainloop()
# If you put root.destroy() here, it will cause an error if
# the window is closed with the window manager.
## Picked data plot ##
def general_plot(self,N,C):
self.gca = self.f.gca()
self.a = self.f.add_subplot(111)
self.gca.set_yscale('log')
self.a.set_xlabel('Endurance, number of cycles N')
self.a.set_ylabel('Direct stress range $\Delta \sigma_R$ [N/mm$^2$]')
self.gca.set_xticks([1E4, 1E5, 1E6, 1E7, 1E8, 1E9], minor=False)
####self.gca.set_xticks([2E6, 5E6], minor=True)
#self.gca.set_xticklabels(("1E4", "2E6", "5E6", "1E8"))
self.gca.xaxis.grid(True, which='major')
self.gca.xaxis.grid(True, which='minor')
self.gca.yaxis.grid(True, which='major')
self.gca.yaxis.grid(True, which='minor')
####self.gca.xaxis.grid(True, which='minor')
# Second y-axis setup
#self.ax2 = self.a.twinx()
for j in range(len(C)-1):
self.a.semilogx( N , [self.stress_range(N[i],C[j]) for i in range(len(N))] , 'k-')#,label='$\Delta \sigma_R$')
self.a.annotate('%s' % (str(self.C[j])), xy=(1e9,self.stress_range(1e9,C[j])), xycoords='data',xytext=(-40,0), textcoords='offset points', fontsize=7, bbox=dict(boxstyle="round", fc="1.0"))
self.a.semilogx( N , [self.stress_range(N[i],C[-1]) for i in range(len(N))] , 'r--', label='$\Delta \sigma_R(\Delta \sigma_C$ = ' + str(C[-1]) + ')' )
self.a.annotate('%s' % (str(self.C[-1])), xy=(1e9,self.stress_range(1e9,C[-1])), xycoords='data',xytext=(-40,0), textcoords='offset points', fontsize=7, bbox=dict(boxstyle="round", fc="1.0"))
## Picked data plot , N cycles##
def N_plot(self,N,fig_clear=1):
self.f.clf() # clear figure
# Update datail category
self.C_temp = round(float(self.optionList.get()),3)
if self.C_temp in self.C:
self.C.pop(self.C.index(self.C_temp))
self.C.append(self.C_temp)
# Run general_plot
self.general_plot(self.N,self.C)
# Calc. stress range (N)
self.N_req = N
self.N_req_stress = self.stress_range(self.N_req,self.C[-1])
print 'N=',self.N_req, ', dS_R=',self.N_req_stress
# Update calculated stress range
self.entrytext_s.set(round(self.N_req_stress,2))
## Picked data plot , Stress range##
def S_plot(self,S,fig_clear=1):
self.f.clf() # clear figure
# Update datail category
self.C_temp = round(float(self.optionList.get()),3)
if self.C_temp in self.C:
self.C.pop(self.C.index(self.C_temp))
self.C.append(self.C_temp)
# Run general_plot
self.general_plot(self.N,self.C)
# Calc. N (stress range)
self.N_req_stress = S
self.N_req = self.N_cycles(self.N_req_stress,self.C[-1])
print 'N=',self.N_req, ', dS_R=',self.N_req_stress
# Update calculated N cycles
self.entrytext_n.set(self.format_e(self.N_req))
def marked_lines_plot(self):
self.a.semilogx( [1e4,self.N_req,self.N_req], [self.N_req_stress,self.N_req_stress,1e1] , 'k--',linewidth=2.0)
self.a.annotate(r'$ N=$'+self.format_e(self.N_req) + '\n' + '$\Delta \sigma_R=$' + str(round(self.N_req_stress,1)), xy=(self.N_req,self.N_req_stress), xycoords='data',xytext=(+25,+15+(max(self.C)-self.C[-1])), textcoords='offset points', fontsize=10, arrowprops=dict(arrowstyle="->", connectionstyle="arc3,rad=.2"), bbox=dict(boxstyle="round4,pad=0.6", fc="1.0"))
self.a.set_title('Detail category ' + str(self.C[-1]) + ' of EN1993-1-9')
self.a.legend(loc='upper center')
# Determine fatigue stress range based on N, (dS_C, m1 and m2)
def stress_range(self,N,dS_C=160,m1=3,m2=5):
dS_D = (2./5)**(1./m1)*dS_C
dS_L = (5./100)**(1./m2)*dS_D
if N < 5E6:
dS_R = ((dS_C**m1)*2E6/N)**(1./m1)
elif N < 1E8:
dS_R = ((dS_D**m2)*5E6/N)**(1./m2)
else:
dS_R = dS_L
return dS_R
# Determine N cycles basted on fatigue stress range, (dS_C, m1 and m2)
def N_cycles(self,dS_R,dS_C=160,m1=3,m2=5):
dS_D = (2./5)**(1./m1)*dS_C
dS_L = (5./100)**(1./m2)*dS_D
N = ((dS_C**m1)*2E6/dS_R**m1)
if N > 5E6:
N = ((dS_D**m2)*5E6/dS_R**m2)
if N > 1E8:
N = 1E10
return N
def format_e(self,n):
n = round(n,2)
a = '%E' % n
return a.split('E')[0][0:4].rstrip('0').rstrip('.') + 'E' + a.split('E')[1]
def on_key_event(self, event):
print('you pressed %s'%event.key)
key_press_handler(event, self.canvas, self.toolbar)
def _quit(self):
self.root.quit() # stops mainloop
self.root.destroy() # this is necessary on Windows to prevent
# Fatal Python Error: PyEval_RestoreThread: NULL tstate
def _replot_n(self):
N=float(self.entrytext_n.get())
if type(float(N)) == float:
self.N_plot(N)
# Plot marker lines for N cycles
self.marked_lines_plot()
if N == 5e6: # plot both for N = 5e6 and N = 1e8
# Calc. stress range (N=1e8)
self.N_req = 1e8
self.N_req_stress = self.stress_range(self.N_req,self.C[-1])
self.marked_lines_plot()
# Update figure
self.canvas.show()
def _replot_s(self):
S=float(self.entrytext_s.get())
if type(float(S)) == float:
self.S_plot(S)
# Plot marker lines for N cycles
self.marked_lines_plot()
# Update figure
self.canvas.show()
def _plot_reset(self):
#self._quit()
#run = tk_int_plot()
self.f.clf()
self.canvas.show()
print "cleared"
self.N = np.logspace(4.0,9.0,num=1000)
self.C = [160,140,125,112,100,90,80,71,63,56,50,45,40,36]
self.C_org = self.C
self.general_plot(self.N,self.C)
# Update figure
self.canvas.show()
def _save_plot(self):
import decimal
N_temp = decimal.Decimal(str(round(self.N_req)))
try:
self.f.savefig("SN_curve_DC%s_N%s_d_sR%s_fname_%s.png" %(str(self.C_temp),str(N_temp.normalize()),str(round(self.N_req_stress,1)),str(self.filename[-self.filename[::-1].find('/'):])) ,dpi=600,transparent=False,bbox_inches='tight',pad_inches=0)
except NameError:
self.f.savefig("SN_curve_DC%s_N%s_d_sR%s.png" %(str(self.C_temp),str(N_temp.normalize()),str(round(self.N_req_stress,1))) ,dpi=600,transparent=False,bbox_inches='tight',pad_inches=0)
def _load_rainflow_count(self):
self.filename = tkFileDialog.askopenfilename(initialdir = "L:\\FEA\\Documentation\\Fatigue\\SquareProfiles\\rainflow" , filetypes = (("Template files", "*.rfo") , ("HTML files", "*.html;*.htm") , ("All files", "*.*") ))
print self.filename
data = []
with open(self.filename,'r') as fin:
reader=csv.reader(fin,delimiter='\t',skipinitialspace=True)
for row in reader:
if len(row) > 0:
temp=row[0].split()
else:
temp = ['']
data.append(temp)
self.data_numbers = data[:]
row_length = []
for i in range(len(data)-2,-1,-1):
for j in range(len(data[i])):
try:
self.data_numbers[i][j] = float(data[i][j])
except:
pass#print "No number for i,j = (%d,%d)" %(i,j)
line_start = 13-1#int(raw_input('Line start: '))-1
line_end = 63#int(raw_input('Line end: '))
self.A = 5375
#self.A = 5625
#self.A = 9063
self.gamma_M = 1.2*1.15
self.rfo = np.reshape(self.data_numbers[line_start:line_end],(line_end-line_start,3))
self.Fat_plot()
def Fat_plot(self):
self.N_req = 2e6
self.C = [round(56/self.gamma_M,3)]
self.N_req_stress = self.stress_range(self.N_req,dS_C=56/self.gamma_M)
self.N_knee = 5e6
self.dS_knee = self.stress_range(self.N_knee,dS_C=56/self.gamma_M)
self.optionList.set(round(float(self.N_req_stress),3))
self.N_plot(self.N_knee)
self.marked_lines_plot()
self.cross_section_stress = []
self.m = []
self.allowed_cycles = []
self.PM = []
for i in range(len(self.rfo)):
self.cross_section_stress.append( self.rfo[i][0]*1000/self.A )
if self.cross_section_stress[i] > self.dS_knee:
self.m.append( 3 )
else:
self.m.append( 5 )
if self.cross_section_stress[i] > 0:
self.allowed_cycles.append( self.N_knee*(self.dS_knee/self.cross_section_stress[i])**(self.m[i]) )
else:
self.allowed_cycles.append( 1e100 )
self.PM.append( self.rfo[i,1]/self.allowed_cycles[i] )
print "PMsum =", sum(self.PM)
pp( self.PM )
pp(self.m)
pp(self.cross_section_stress)
pp(self.allowed_cycles)
#self.marked_lines_plot()
# Second y-axis setup + coloring
self.ax2 = self.a.twinx()
self.ax2.set_ylabel('Accu. PMsum' , color='blue')
for tl in self.ax2.get_yticklabels():
tl.set_color('blue')
for i in range(len(self.rfo)):
if self.rfo[i,1] > 1e4 and self.rfo[i,1] < 1e9:
self.ax2.semilogx(self.rfo[i,1],np.cumsum(self.PM)[i],'bs')
self.ax2.legend([str(self.filename[-self.filename[::-1].find('/'):])],loc='right')
for i in range(len(self.rfo)):
if self.rfo[i,1] > 1e4 and self.rfo[i,1] < 1e9 and self.rfo[i,0]*1000/self.A > 10:
self.gca.semilogx(self.rfo[i,1],self.rfo[i,0]*1000/self.A,'k.')
self.canvas.show()
class Window(Frame):
def __init__(self, master):
Frame.__init__(self, master)
self.master = master
self.master.title("Decline Curve Analysis | NeuDax")
self.pack(fill=BOTH, expand=1, padx=20)
self.summary_parameters = pd.DataFrame(columns=[
'API_NUMBER', 'qi', 'di', 'b', 'sqrt_error', 'skipped_days',
'TimeStamp'
])
self.read_data()
row = 0
label_API = Label(self, text="Well API Number:")
label_API.grid(row=row, column=0, sticky=E)
self.API_value = StringVar()
self.API = ttk.Combobox(self,
textvariable=self.API_value,
state='readonly')
self.API['values'] = self.list_of_API_numbers
self.API.current(0)
self.API.grid(row=row, column=1, columnspan=2, sticky=W + E)
button_prev_well = ttk.Button(self,
text="<<< Previous Well",
command=lambda: self.go_to_prev_well())
button_prev_well.grid(row=row, column=3, sticky=W + E)
button_next_well = ttk.Button(self,
text=" Next Well >>>",
command=lambda: self.go_to_next_well())
button_next_well.grid(row=row, column=4, sticky=W + E)
label_typ_plot = Label(self, text="Type of Plot:")
label_typ_plot.grid(row=row, column=5, sticky=E)
self.typ_plot_value = StringVar()
self.typ_plot = ttk.Combobox(self,
textvariable=self.typ_plot_value,
state='readonly')
self.typ_plot['values'] = [
'Linear Plot', 'Semi-Log Plot', 'Log-Log Plot', 'Rate vs. Cum'
]
self.typ_plot.current(0)
self.typ_plot.grid(row=row, column=6, sticky=W + E)
row += 1
label_guide_uncertainty = Label(self,
text="Uncertianty Guide Plots (%)")
label_guide_uncertainty.grid(row=row, column=0, sticky=E)
self.guide_uncertainty_percent = tk.Entry(self)
self.guide_uncertainty_percent.grid(row=row, column=1, sticky=W + E)
self.guide_uncertainty_percent.delete(0, END)
self.guide_uncertainty_percent.insert(0, "0.2")
self.guide_uncertainty_plot_var = BooleanVar()
self.guide_uncertainty_plot = Checkbutton(
self,
text="Plot Guide Lines",
variable=self.guide_uncertainty_plot_var,
anchor=W,
command=lambda: self.plot())
self.guide_uncertainty_plot.grid(row=row, column=2, sticky=W + E)
row += 1
label_skip_days = Label(self, text="Skip Data Until Day:")
label_skip_days.grid(row=row, column=0, sticky=E)
self.skip_days = tk.Entry(self)
self.skip_days.grid(row=row, column=1, sticky=W + E)
row += 1
button_load = ttk.Button(self,
text="Step 1) Load Data and Reset Values",
command=lambda: self.load_data())
button_load.grid(row=row, column=1, columnspan=2, sticky=W + E)
row += 1
label_lower_limit_t = Label(self, text="Time Interval (Days):")
label_lower_limit_t.grid(row=row, column=0, sticky=E)
self.lower_limit_t = tk.Entry(self)
self.lower_limit_t.grid(row=row, column=1, sticky=W + E)
self.upper_limit_t = tk.Entry(self)
self.upper_limit_t.grid(row=row, column=2, sticky=W + E)
row += 1
label_lower_limit_qi = Label(self, text="Limit for qi:")
label_lower_limit_qi.grid(row=row, column=0, sticky=E)
self.lower_limit_qi = tk.Entry(self)
self.lower_limit_qi.grid(row=row, column=1, sticky=W + E)
self.upper_limit_qi = tk.Entry(self)
self.upper_limit_qi.grid(row=row, column=2, sticky=W + E)
row += 1
label_lower_limit_di = Label(self, text="Limit for di:")
label_lower_limit_di.grid(row=row, column=0, sticky=E)
self.lower_limit_di = tk.Entry(self)
self.lower_limit_di.grid(row=row, column=1, sticky=W + E)
self.upper_limit_di = tk.Entry(self)
self.upper_limit_di.grid(row=row, column=2, sticky=W + E)
row += 1
label_lower_limit_b = Label(self, text="Limit for b:")
label_lower_limit_b.grid(row=row, column=0, sticky=E)
self.lower_limit_b = tk.Entry(self)
self.lower_limit_b.grid(row=row, column=1, sticky=W + E)
self.upper_limit_b = tk.Entry(self)
self.upper_limit_b.grid(row=row, column=2, sticky=W + E)
row += 1
label_method = Label(self, text="Method:")
label_method.grid(row=row, column=0, sticky=E)
self.method_value = StringVar()
self.method = ttk.Combobox(self,
textvariable=self.method_value,
state='readonly')
self.method['values'] = ['trf', 'dogbox']
self.method.current(0)
self.method.grid(row=row, column=1, sticky=W + E)
self.fit_on_cum_var = IntVar()
self.fit_on_cum = Checkbutton(self,
text="Fit on Cumulative",
variable=self.fit_on_cum_var,
anchor=W)
self.fit_on_cum.grid(row=row, column=2, sticky=W + E)
row += 1
label_loss = Label(self, text="Loss Function:")
label_loss.grid(row=row, column=0, sticky=E)
self.loss_value = StringVar()
self.loss = ttk.Combobox(self,
textvariable=self.loss_value,
state='readonly')
self.loss['values'] = [
'linear', 'soft_l1', 'huber', 'cauchy', 'arctan'
]
self.loss.current(0)
self.loss.grid(row=row, column=1, sticky=W + E)
self.auto_fit_var = BooleanVar()
self.auto_fit = Checkbutton(self,
text="Auto Fit",
variable=self.auto_fit_var,
anchor=W)
self.auto_fit.grid(row=row, column=2, sticky=W + E)
row += 1
button_fit_hyp = ttk.Button(self,
text="Step 2) Fit Hyperbolic",
command=lambda: self.fit())
button_fit_hyp.grid(row=row, column=1, columnspan=2, sticky=W + E)
row += 1
label_qi = Label(self, text="Initial Rate (qi):")
label_qi.grid(row=row, column=0, sticky=E)
self.par_qi = tk.Entry(self)
self.par_qi.grid(row=row, column=1, sticky=W + E)
label_qi = Label(self, text="Previous Parameters:")
label_qi.grid(row=row, column=2, sticky=W + E)
row += 1
label_di = Label(self, text="Initial Decline Rate (di):")
label_di.grid(row=row, column=0, sticky=E)
self.par_di = tk.Entry(self)
self.par_di.grid(row=row, column=1, sticky=W + E)
self.prev_par_value = StringVar()
self.prev_par = ttk.Combobox(self,
textvariable=self.prev_par_value,
state='readonly')
self.prev_par.grid(row=row, column=2, sticky=W + E)
row += 1
label_b = Label(self, text="Curvature (b):")
label_b.grid(row=row, column=0, sticky=E)
self.par_b = tk.Entry(self)
self.par_b.grid(row=row, column=1, sticky=W + E)
button_prev_par = ttk.Button(self,
text="Load Previous Parameters",
command=lambda: self.load_prev_par())
button_prev_par.grid(row=row, column=2, sticky=W + E)
row += 1
self.label_error1 = Label(self, text='Root Mean Squared Error:')
self.label_error1.grid(row=row, column=1, sticky=E)
row += 3
button_plot = ttk.Button(self,
text="Step 3) Manual Modification",
command=lambda: self.plot())
button_plot.grid(row=row, column=1, columnspan=2, sticky=W + E)
row += 1
button_save = ttk.Button(self,
text="Step 4) Save",
command=lambda: self.save())
button_save.grid(row=row, column=1, columnspan=2, sticky=W + E)
row += 1
button_exit = ttk.Button(self,
text="Exit",
command=lambda: self.quit())
button_exit.grid(row=row, column=1, columnspan=2, sticky=W + E)
row += 1
self.fr = tk.Frame(self)
self.fr.grid(row=1,
column=3,
rowspan=26,
columnspan=4,
sticky=N + E + W + S)
row += 1
self.f, self.ax = plt.subplots()
self.canvas = FigureCanvasTkAgg(self.f, master=self.fr)
self.canvas.show()
self.canvas.get_tk_widget().pack(fill=tk.BOTH, expand=1)
self.toolbar = NavigationToolbar2TkAgg(self.canvas, self.fr)
self.toolbar.update()
self.canvas._tkcanvas.pack(fill=tk.BOTH, expand=1)
self.canvas.mpl_connect('button_press_event', self.selecting_point)
self.load_data()
self.API.bind("<<ComboboxSelected>>", lambda _: self.load_data())
self.prev_par.bind("<<ComboboxSelected>>",
lambda _: self.load_prev_par())
self.typ_plot.bind("<<ComboboxSelected>>", lambda _: self.plot())
def read_data(self):
#input_file_path = filedialog.askopenfilename(title = "Select file to open",filetypes = (("csv files","*.csv"),("all files","*.*")))
input_file_path = 'Small_Dataset_of_Good_APIs_2.csv'
self.production_data = pd.read_csv(input_file_path)
temp_list_of_APIs = self.production_data['API_NUMBER'].drop_duplicates(
)
self.list_of_API_numbers = temp_list_of_APIs.tolist()
def load_data(self):
try:
self.skipped_days = float(self.skip_days.get())
except:
self.skipped_days = 0
selected_production_data = pd.DataFrame()
selected_production_data = self.production_data.loc[
self.production_data['API_NUMBER'] == float(self.API.get()),
['OIL_PROD_DAYS', 'OIL_PRODUCTION_BBL']]
selected_production_data = selected_production_data.dropna()
selected_production_data = selected_production_data.loc[
selected_production_data['OIL_PRODUCTION_BBL'] > 0]
selected_production_data['RATE_PROD'] = selected_production_data[
'OIL_PRODUCTION_BBL'] / selected_production_data['OIL_PROD_DAYS']
selected_production_data['CUM_DAYS'] = selected_production_data[
'OIL_PROD_DAYS'].cumsum()
selected_production_data['CUM_PROD'] = selected_production_data.loc[
selected_production_data['CUM_DAYS'] > self.skipped_days,
'OIL_PRODUCTION_BBL'].cumsum()
self.t = selected_production_data.loc[
selected_production_data['CUM_DAYS'] > self.skipped_days,
'CUM_DAYS'] - self.skipped_days
self.q = selected_production_data.loc[
selected_production_data['CUM_DAYS'] > self.skipped_days,
'RATE_PROD']
self.q_cum = selected_production_data['CUM_PROD'].dropna()
print('t', self.t)
print('q', self.q)
print('cum', self.q_cum)
self.selected_t = np.array([])
self.selected_q = np.array([])
self.selected_q_cum = np.array([])
self.valid_t = np.array(self.t)
self.valid_q = np.array(self.q)
self.valid_q_cum = np.array(self.q_cum)
self.par_qi.delete(0, END)
self.par_qi.insert(0, "0.0")
self.par_di.delete(0, END)
self.par_di.insert(0, "1.0")
self.par_b.delete(0, END)
self.par_b.insert(0, "0.5")
self.lower_limit_t.delete(0, END)
self.lower_limit_t.insert(0, "0")
self.upper_limit_t.delete(0, END)
self.upper_limit_t.insert(0, str(self.t.max()))
self.lower_limit_qi.delete(0, END)
self.lower_limit_qi.insert(0, "0.0")
self.upper_limit_qi.delete(0, END)
self.upper_limit_qi.insert(0, "50000.0")
self.lower_limit_di.delete(0, END)
self.lower_limit_di.insert(0, "0.0")
self.upper_limit_di.delete(0, END)
self.upper_limit_di.insert(0, "1.0")
self.lower_limit_b.delete(0, END)
self.lower_limit_b.insert(0, "0.001")
self.upper_limit_b.delete(0, END)
self.upper_limit_b.insert(0, "2.0")
self.prev_par.set('')
if self.auto_fit_var.get():
self.fit()
else:
self.plot()
self.load_prev_timestamps()
def load_prev_timestamps(self):
# Loading previous analysis and parameters (if exists)
previous_parameters = pd.DataFrame()
previous_parameters = self.summary_parameters.loc[
self.summary_parameters['API_NUMBER'] == self.API.get(), :]
temp_list_of_prev_par = []
temp_list_of_prev_par = previous_parameters[
'TimeStamp'].drop_duplicates()
self.list_of_prev_par = temp_list_of_prev_par.tolist()
self.prev_par['values'] = self.list_of_prev_par
def load_prev_par(self):
previous_parameters = pd.DataFrame()
previous_parameters = self.summary_parameters.loc[
(self.summary_parameters['API_NUMBER'] == self.API.get()) &
(self.summary_parameters['TimeStamp'] == self.prev_par.get()), :]
self.skip_days.delete(0, END)
self.skip_days.insert(0, previous_parameters['skipped_days'].values[0])
self.load_data()
self.par_qi.delete(0, END)
self.par_qi.insert(0, previous_parameters['qi'].values[0])
self.par_di.delete(0, END)
self.par_di.insert(0, previous_parameters['di'].values[0])
self.par_b.delete(0, END)
self.par_b.insert(0, previous_parameters['b'].values[0])
self.plot()
def save(self):
self.summary_parameters = self.summary_parameters.append(
{
'API_NUMBER': self.API.get(),
'qi': self.par_qi.get(),
'di': self.par_di.get(),
'b': self.par_b.get(),
'sqrt_error': self.sqrt_error,
'skipped_days': self.skipped_days,
'TimeStamp': self.now_code2()
},
ignore_index=True)
now_code = self.now_code()
par_filepath = './save/saved_parameters_' + str(now_code) + '.csv'
self.summary_parameters.to_csv(par_filepath, index=False)
self.load_prev_timestamps()
def now_code(self):
now = datetime.datetime.now()
now_code = now.year * 10000000000 + now.month * 100000000 + now.day * 1000000 + now.hour * 10000 + now.minute * 100 + now.second
return now_code
def now_code2(self):
now = datetime.datetime.now()
now_code = str(now.year) + '/' + str(now.month) + '/' + str(
now.day) + ' ' + str(now.hour) + ':' + str(now.minute) + ':' + str(
now.second)
return now_code
def plot(self):
self.popt = [
float(self.par_qi.get()),
float(self.par_di.get()),
float(self.par_b.get())
]
self.t_model = np.arange(int(np.max(self.t)))
# This q_model will be plotted as model interpolation
self.q_model = self.func_hyp(self.t_model, *self.popt)
# We increase and decrease "b" factor by 10% as guiding plots
self.q_model_qi_low = self.func_hyp(
self.t_model,
self.popt[0] * (1 - float(self.guide_uncertainty_percent.get())),
self.popt[1], self.popt[2])
self.q_model_qi_up = self.func_hyp(
self.t_model,
self.popt[0] * (1 + float(self.guide_uncertainty_percent.get())),
self.popt[1], self.popt[2])
self.q_model_di_low = self.func_hyp(
self.t_model, self.popt[0],
self.popt[1] * (1 - float(self.guide_uncertainty_percent.get())),
self.popt[2])
self.q_model_di_up = self.func_hyp(
self.t_model, self.popt[0],
self.popt[1] * (1 + float(self.guide_uncertainty_percent.get())),
self.popt[2])
self.q_model_b_low = self.func_hyp(
self.t_model, self.popt[0], self.popt[1],
self.popt[2] * (1 - float(self.guide_uncertainty_percent.get())))
self.q_model_b_up = self.func_hyp(
self.t_model, self.popt[0], self.popt[1],
self.popt[2] * (1 + float(self.guide_uncertainty_percent.get())))
# This q_model2 will be used for error calculation
self.q_model2 = self.func_hyp(self.t, *self.popt)
# Here, we compute cum model
#self.q_cum_model = self.q_model.cumsum()
self.q_cum_model = self.func_cum_hyp(self.t_model, *self.popt)
# We increase and decrease "b" factor by 10% as guiding plots (for cumulative plots)
self.q_cum_model_qi_low = self.func_cum_hyp(
self.t_model,
self.popt[0] * (1 - float(self.guide_uncertainty_percent.get())),
self.popt[1], self.popt[2])
self.q_cum_model_qi_up = self.func_cum_hyp(
self.t_model,
self.popt[0] * (1 + float(self.guide_uncertainty_percent.get())),
self.popt[1], self.popt[2])
self.q_cum_model_di_low = self.func_cum_hyp(
self.t_model, self.popt[0],
self.popt[1] * (1 - float(self.guide_uncertainty_percent.get())),
self.popt[2])
self.q_cum_model_di_up = self.func_cum_hyp(
self.t_model, self.popt[0],
self.popt[1] * (1 + float(self.guide_uncertainty_percent.get())),
self.popt[2])
self.q_cum_model_b_low = self.func_cum_hyp(
self.t_model, self.popt[0], self.popt[1],
self.popt[2] * (1 - float(self.guide_uncertainty_percent.get())))
self.q_cum_model_b_up = self.func_cum_hyp(
self.t_model, self.popt[0], self.popt[1],
self.popt[2] * (1 + float(self.guide_uncertainty_percent.get())))
t_lim = np.array([
float(self.lower_limit_t.get()),
float(self.lower_limit_t.get()), 0.0
])
q_lim = np.array(
[0.0, float(self.par_qi.get()),
float(self.par_qi.get())])
self.f.clear()
if self.typ_plot.get() == "Rate vs. Cum":
self.ax = plt.semilogy(self.q_cum, self.q, 'g.')
self.ax = plt.semilogy(self.q_cum_model, self.q_model, 'k-')
self.ax = plt.semilogy(self.selected_q_cum, self.selected_q, 'kx')
plt.gca().set_xlabel('Cumulative Rate (Bbl)')
plt.gca().set_ylabel('Rate (Bbl)')
else:
if self.typ_plot.get() == "Linear Plot":
self.ax = plt.plot(self.t, self.q, 'b.', label='Rate Data')
self.ax = plt.plot(self.selected_t, self.selected_q, 'kx')
self.ax = plt.plot(t_lim, q_lim, 'g-')
self.ax = plt.plot(self.t_model,
self.q_model,
'r-',
linewidth=2,
label='Rate Model')
if self.guide_uncertainty_plot_var.get():
self.ax = plt.plot(self.t_model,
self.q_model_b_low,
'r:',
linewidth=1)
self.ax = plt.plot(self.t_model,
self.q_model_b_up,
'r-.',
linewidth=1)
self.ax = plt.plot(self.t_model,
self.q_model_qi_low,
'b:',
linewidth=1)
self.ax = plt.plot(self.t_model,
self.q_model_qi_up,
'b-.',
linewidth=1)
self.ax = plt.plot(self.t_model,
self.q_model_di_low,
'g:',
linewidth=1)
self.ax = plt.plot(self.t_model,
self.q_model_di_up,
'g-.',
linewidth=1)
elif self.typ_plot.get() == "Semi-Log Plot":
self.ax = plt.semilogy(self.t, self.q, 'b.')
self.ax = plt.semilogy(self.selected_t, self.selected_q, 'kx')
self.ax = plt.semilogy(t_lim, q_lim, 'g-')
self.ax = plt.semilogy(self.t_model,
self.q_model,
'r-',
linewidth=2)
if self.guide_uncertainty_plot_var.get():
self.ax = plt.semilogy(self.t_model,
self.q_model_b_low,
'r:',
linewidth=1)
self.ax = plt.semilogy(self.t_model,
self.q_model_b_up,
'r-.',
linewidth=1)
self.ax = plt.semilogy(self.t_model,
self.q_model_qi_low,
'b:',
linewidth=1)
self.ax = plt.semilogy(self.t_model,
self.q_model_qi_up,
'b-.',
linewidth=1)
self.ax = plt.semilogy(self.t_model,
self.q_model_di_low,
'g:',
linewidth=1)
self.ax = plt.semilogy(self.t_model,
self.q_model_di_up,
'g-.',
linewidth=1)
elif self.typ_plot.get() == "Log-Log Plot":
self.ax = plt.loglog(self.t, self.q, 'b.')
self.ax = plt.semilogy(self.selected_t, self.selected_q, 'kx')
self.ax = plt.loglog(t_lim, q_lim, 'g-')
self.ax = plt.loglog(self.t_model,
self.q_model,
'r-',
linewidth=2)
if self.guide_uncertainty_plot_var.get():
self.ax = plt.loglog(self.t_model,
self.q_model_b_low,
'r:',
linewidth=1)
self.ax = plt.loglog(self.t_model,
self.q_model_b_up,
'r-.',
linewidth=1)
self.ax = plt.loglog(self.t_model,
self.q_model_qi_low,
'b:',
linewidth=1)
self.ax = plt.loglog(self.t_model,
self.q_model_qi_up,
'b-.',
linewidth=1)
self.ax = plt.loglog(self.t_model,
self.q_model_di_low,
'g:',
linewidth=1)
self.ax = plt.loglog(self.t_model,
self.q_model_di_up,
'g-.',
linewidth=1)
plt.gca().set_xlabel('Time (Days)')
plt.gca().set_ylabel('Rate (Bbl)')
plt.gca().set_title(self.API.get() + " | qi:" + self.par_qi.get() +
" | di:" + self.par_di.get() + " | b:" +
self.par_b.get() + " | " + self.now_code2(),
fontsize=8)
self.ax2 = plt.gca().twinx()
self.ax2 = plt.plot(self.t, self.q_cum, 'c+', label='Cum Data')
self.ax2 = plt.plot(self.t_model,
self.q_cum_model,
'm-',
linewidth=2,
label='Cum Model')
if self.guide_uncertainty_plot_var.get():
self.ax2 = plt.plot(self.t_model,
self.q_cum_model_b_low,
'r:',
linewidth=1)
self.ax2 = plt.plot(self.t_model,
self.q_cum_model_b_up,
'r-.',
linewidth=1)
self.ax2 = plt.plot(self.t_model,
self.q_cum_model_qi_low,
'b:',
linewidth=1)
self.ax2 = plt.plot(self.t_model,
self.q_cum_model_qi_up,
'b-.',
linewidth=1)
self.ax2 = plt.plot(self.t_model,
self.q_cum_model_di_low,
'g:',
linewidth=1)
self.ax2 = plt.plot(self.t_model,
self.q_cum_model_di_up,
'g-.',
linewidth=1)
self.f.tight_layout()
self.canvas.draw()
self.sqrt_error = self.error()
self.label_error2 = Label(self, text=' ')
self.label_error2.grid(row=14, column=2, sticky=W)
self.label_error2 = Label(self, text=str(round(self.sqrt_error, 5)))
self.label_error2.grid(row=14, column=2, sticky=W)
self.forecast()
def error(self):
diff = (self.q_model2 - self.q)**2
return (diff.mean())**0.5
def func_hyp(self, t, qi, di, b):
return qi / ((1 + di * b * t)**(1 / b))
def func_cum_hyp(self, t, qi, di, b):
return (qi / ((1 - b) * di)) * (1 - (1 + b * di * t)**(1 - 1 / b))
def func_duong(self, t, qi, a, m):
return qi * t**(-m) * np.exp((a) / (1 - m) * (t**(1 - m)) - 1)
def fit(self):
t = self.valid_t[(self.valid_t < float(self.upper_limit_t.get()))]
q = self.valid_q[(self.valid_t < float(self.upper_limit_t.get()))]
t_cum = self.t.loc[(self.t > float(self.lower_limit_t.get()))
& (self.t < float(self.upper_limit_t.get()))]
q_cum = self.q_cum.loc[(self.t > float(self.lower_limit_t.get()))
& (self.t < float(self.upper_limit_t.get()))]
lo_qi = float(self.lower_limit_qi.get())
up_qi = float(self.upper_limit_qi.get())
lo_di = float(self.lower_limit_di.get())
up_di = float(self.upper_limit_di.get())
lo_b = float(self.lower_limit_b.get())
up_b = float(self.upper_limit_b.get())
method = self.method.get()
loss = self.loss.get()
if self.fit_on_cum_var.get() == 0:
self.popt, self.pcov = curve_fit(f=self.func_hyp,
xdata=t,
ydata=q,
check_finite=True,
method=method,
loss=loss,
bounds=([lo_qi, lo_di, lo_b],
[up_qi, up_di, up_b]))
elif self.fit_on_cum_var.get() == 1:
self.popt, self.pcov = curve_fit(f=self.func_cum_hyp,
xdata=t_cum,
ydata=q_cum,
check_finite=True,
method=method,
loss=loss,
bounds=([lo_qi, lo_di, lo_b],
[up_qi, up_di, up_b]))
self.popt = np.round(self.popt, decimals=5)
self.q_model = self.func_hyp(self.t, *self.popt)
self.par_qi.delete(0, END)
self.par_qi.insert(0, self.popt[0])
self.par_di.delete(0, END)
self.par_di.insert(0, self.popt[1])
self.par_b.delete(0, END)
self.par_b.insert(0, self.popt[2])
self.plot()
def forecast(self):
days = np.array([90.0, 180.0, 365.0])
qi = float(self.par_qi.get())
di = float(self.par_di.get())
b = float(self.par_b.get())
self.production_forecast = np.round(self.func_cum_hyp(days, qi, di, b),
decimals=0)
EUR = np.round(self.EUR(), decimals=0)
production_statement = "IP90:" + str(
self.production_forecast[0]) + " | IP180:" + str(
self.production_forecast[1]) + " | IP365:" + str(
self.production_forecast[2]) + " | EUR:" + str(EUR)
self.label_forecast = Label(
self, text=" ")
self.label_forecast.grid(row=15, column=1, columnspan=2, sticky=E + W)
self.label_forecast = Label(self, text=production_statement)
self.label_forecast.grid(row=15, column=1, columnspan=2, sticky=E + W)
def go_to_next_well(self):
try:
current_well_index = self.API.current()
self.API.current(current_well_index + 1)
self.reset_skip_days()
self.load_data()
except:
return
def go_to_prev_well(self):
try:
current_well_index = self.API.current()
self.API.current(current_well_index - 1)
self.reset_skip_days()
self.load_data()
except:
return
def reset_skip_days(self):
self.skip_days.delete(0, END)
self.skip_days.insert(0, "0.0")
def selecting_point(self, event):
try:
self.find_nearest(event.xdata)
self.plot()
except:
return
def find_nearest(self, value):
vector_t = np.copy(self.valid_t)
vector_q = np.copy(self.valid_q)
vector_q_cum = np.copy(self.valid_q_cum)
idx = (np.abs(vector_t - value)).argmin()
self.selected_t = np.append(self.selected_t, vector_t[idx])
self.selected_q = np.append(self.selected_q, vector_q[idx])
self.selected_q_cum = np.append(self.selected_q_cum, vector_q_cum[idx])
self.valid_t = np.delete(self.valid_t, idx)
self.valid_q = np.delete(self.valid_q, idx)
self.valid_q_cum = np.delete(self.valid_q_cum, idx)
def EUR(self):
qi = float(self.par_qi.get())
di = float(self.par_di.get())
b = float(self.par_b.get())
q_lowest_for_EUR = 1.0
for t in range(1000000):
if self.func_hyp(t, qi, di, b) <= q_lowest_for_EUR:
return self.func_cum_hyp(t, qi, di, b)
def quit(self):
global root
root.destroy()
root.quit()
class ViewerApp():
def __init__(self, master, RNdata, ppc = 20, dpi = 96, colors='coolwarm'):
self.master = master
self.master.title('Network Visualization')
# =========================== Figure preparation ===========================
self.colors = colors
self._ppc = ppc
self._dpi = dpi
self.bfs = self._set_bfs()
self.RNdata = RNdata
self.figure = self.create_fig()
board = vis.prep_figure(self.RNdata, self.figure)
self.panelBoard = board[0]
self.boardWidth = board[1]
self.boardHeight = board[2]
figSize = self.figure.get_size_inches() * self._dpi
# ============================= Parent Windows =============================
# ---------------------- Figure and window parameteres----------------------
figWidth, figHeight = [int(x) for x in figSize]
maxWindWidth = 900
maxWindHeight = 600
w = min(figWidth, maxWindWidth)
h = min(figHeight, maxWindHeight)
master.geometry(
'{}x{}+0+0'.format(
w+20,
h))
# --------------------------------- Canvas ---------------------------------
self.master.rowconfigure(0, weight=1)
self.master.columnconfigure(0, weight=1)
# Frames
self.canvasFrame = ttk.Frame(master, width = w+20, height = h+20)
self.canvasFrame.grid(row=0, column=0, columnspan = 2, sticky='nsew')
self.canvasFrame.rowconfigure(0, weight=1)
self.canvasFrame.columnconfigure(0, weight=1)
# Widgets
self.backCanvas = tk.Canvas(self.canvasFrame, scrollregion=(0, 0, w, h))
self.backCanvas.grid(row=0, column=0, columnspan = 2, sticky='nsew')
self.yScroll = tk.Scrollbar(self.canvasFrame,
orient=tk.VERTICAL,
command=self.backCanvas.yview)
self.xScroll = tk.Scrollbar(self.canvasFrame,
orient=tk.HORIZONTAL,
command=self.backCanvas.xview)
self.yScroll.grid(row=0, column=1, columnspan = 1, sticky='ns')
self.xScroll.grid(row=1, column=0, columnspan = 1, sticky='ew')
self.backCanvas.config(xscrollcommand=self.xScroll.set,
yscrollcommand=self.yScroll.set)
self.figureRenderer = FigureCanvasTkAgg(self.figure, self.backCanvas)
self.mplCanvasWidget = self.figureRenderer.get_tk_widget()
self.mplCanvasWidget.grid(sticky = 'nsew')
self.liftControlsButton = ttk.Button(self.master,
text = 'Lift controls',
command=self.onLiftControls)
self.liftControlsButton.grid(row=2, column=0, sticky='ew')
self.colprefsButton = ttk.Button(self.master,
text = 'Color preferences',
command = self.onColorPrefs)
self.colprefsButton.grid(row=2, column=1, sticky='ew')
# Integrate mpl and tk
self.backCanvasWind = self.backCanvas.create_window(0, 0, window=self.mplCanvasWidget, anchor = 'nw')
self.backCanvas.config(scrollregion=self.backCanvas.bbox(tk.ALL))
self.figureRenderer.mpl_connect('pick_event', self.onPick)
# ================================ CONTROLS ================================
# --------------------------- Window parameteres ---------------------------
controlsWidth = 230
controlsHeight = 340
self.controlsWindow = tk.Toplevel(master)
self.controlsWindow.title('Controls')
self.controlsWindow.lift(master)
self.controlsWindow.resizable('False','False')
self.controlsWindow.geometry(
'{}x{}+0+0'.format(
controlsWidth,
controlsHeight
)
)
# --------------------------------- Frames ---------------------------------
# Info
self.infoFrame = ttk.Frame(self.controlsWindow, width = 230, height = 115)
self.epochSubFrame = ttk.Frame(self.infoFrame,
width = 111,
height = 105,
relief = tk.GROOVE)
self.cellSubFrame = ttk.Frame(self.infoFrame,
width=111,
height=105,
relief = tk.GROOVE)
self.tinySub = ttk.Frame(self.cellSubFrame,
width = 40,
height = 40,
relief = tk.SUNKEN)
# Slide and combobox
self.selectorFrame = ttk.Frame(self.controlsWindow,
width = 230,
height = 95)
# Buttons
self.buttonFrame = ttk.Frame(self.controlsWindow)
self.continueFrame = ttk.Frame(self.controlsWindow)
# Progress bar
self.progressFrame = ttk.Frame(self.controlsWindow,
width = 230,
height = 20)
# -------------------------------- tk Vars ---------------------------------
self.patternVar = tk.StringVar()
# -------------------------------- Widgets ---------------------------------
# Selectors:
self.epochSlider = ttk.Scale(self.selectorFrame,
orient = tk.HORIZONTAL,
length = 200,
value = self.RNdata.num_epochs - 1,
from_ = 0,
to = self.RNdata.num_epochs - 1)
self.epochSlider.set(str(self.RNdata.num_epochs))
self.patternSelector = ttk.Combobox(self.selectorFrame,
textvariable = self.patternVar,
values = RNdata.main[int(self.epochSlider.get())]['strings'])
self.patternSelector.current(0)
# Buttons
self.updateButton = ttk.Button(self.buttonFrame,
text='Update',
command=self.onUpdate)
self.labelsButton = ttk.Button(self.buttonFrame,
text='Hide labels',
command=self.onLabels)
self.zoominButton = ttk.Button(self.buttonFrame,
text = 'Zoom in',
command = lambda: self.changeSize(1))
self.zoomoutButton = ttk.Button(self.buttonFrame,
text='Zoom out',
command=lambda: self.changeSize(-1))
self.continueButton = ttk.Button(self.continueFrame,
text='Continue',
command=self.onContinue)
# Labels:
# epoch info
self.epochValLabel = ttk.Label(self.epochSubFrame,
text = str(self._get_epoch(int(self.epochSlider.get()))),
font = ('Menlo', 30),
justify = tk.CENTER)
self.epochSlider.config(command = self.onSlide)
self.epochLabel = ttk.Label(self.epochSubFrame,
text = 'epoch',
font = ('Menlo', 11),
justify = tk.CENTER)
# draw cell onto tiny canvas
self.tinyFig = plt.figure(3, figsize=(40 / 96, 40 / 96), facecolor='white')
self.tinyRenderer = FigureCanvasTkAgg(self.tinyFig, self.tinySub)
self.tinyCanvas = self.tinyRenderer.get_tk_widget()
self.tinyRenderer.draw()
self.cellWeight = ttk.Label(self.cellSubFrame,
text = '-',
font = ('Menlo', 11),
justify = tk.CENTER)
self.cellCoords = ttk.Label(self.cellSubFrame,
text = 'r: - | c: -',
font = ('Menlo', 11),
justify = tk.CENTER)
# Progress bar:
self.progBar = ttk.Progressbar(self.progressFrame,
orient = tk.HORIZONTAL,
length = 200)
# -------------------------------- Geometry --------------------------------
# Info
self.infoFrame.pack(side = tk.TOP, fill = tk.BOTH)
# Epoch info
self.epochSubFrame.pack(side = tk.LEFT, padx = 2, pady = 10)
self.epochValLabel.place(relx = 0.50, rely = 0.45, anchor = tk.CENTER)
self.epochLabel.place(relx = 0.50, rely = 0.75, anchor = tk.CENTER)
# Cell info
self.cellSubFrame.pack(side = tk.RIGHT, padx = 2, pady = 10)
self.tinySub.place(relx = 0.50, rely = 0.40, anchor = tk.CENTER)
self.tinyCanvas.pack()
self.cellWeight.place(relx = 0.50, rely = 0.70, anchor = tk.CENTER)
self.cellCoords.place(relx = 0.50, rely = 0.84, anchor = tk.CENTER)
# Selectors
self.selectorFrame.pack(fill = tk.BOTH)
self.patternSelector.pack(fill = tk.Y, expand = True, pady=5)
self.epochSlider.pack(fill = tk.Y, expand = True, pady=5)
#
# Buttons
self.buttonFrame.pack(fill = tk.BOTH, expand = True)
self.buttonFrame.columnconfigure(0,weight=1)
self.buttonFrame.columnconfigure(1, weight=1)
self.labelsButton.grid(row=0, column = 0, columnspan=2, sticky='ew', padx=10)
self.zoominButton.grid(row=1, column = 1, columnspan=1, sticky='ew', padx=10)
self.zoomoutButton.grid(row=1, column = 0, columnspan=1, sticky='ew', padx=10)
self.updateButton.grid(row=2, column=0, columnspan=2, sticky='ew', padx=10)
self.continueFrame.pack(fill=tk.X)
self.continueButton.pack(fill = tk.X, padx = 10)
# Progress Bar
self.progressFrame.pack(fill = tk.BOTH, expand = True)
self.progBar.place(relx = 0.5, rely = 0.5, anchor = tk.CENTER)
self.progBar.config(mode='indeterminate')
# ================================ COLORS ==================================
mpl_color_maps = (['BrBG', 'bwr', 'coolwarm', 'PiYG',
'PRGn', 'PuOr','RdBu', 'RdGy',
'RdYlBu', 'RdYlGn', 'Spectral',
'seismic', 'jet', 'rainbow', 'terrain'])
self.colorsWindow = tk.Toplevel(self.master, )
self.colorsWindow.title('Color Preferences')
self.colorsWindow.resizable('False','False')
self.colorsWindow.geometry('{}x{}+0+0'.format(350, 150))
self.colorsWindow.withdraw()
self.colorsFrame = ttk.Frame(self.colorsWindow)
self.colorsFrame.place(relx=0.5, rely=0.5, anchor = tk.CENTER, width = 350, height = 150)
self.colorsFrame.columnconfigure(0, weight = 1)
self.colorsFrame.columnconfigure(1, weight = 1)
self.colorsFrame.columnconfigure(2, weight=1)
self.normMode = tk.StringVar()
self.normMode.set('cus')
self.colMap = tk.StringVar()
self.absRadio = ttk.Radiobutton(self.colorsFrame, variable = self.normMode, value = 'abs', text = 'Absolute')
self.relRadio = ttk.Radiobutton(self.colorsFrame, variable = self.normMode, value = 'rel', text = 'Relative')
self.cusRadio = ttk.Radiobutton(self.colorsFrame, variable = self.normMode, value = 'cus', text = 'Custom')
self.colmapLabel = ttk.Label(self.colorsFrame, text='color map', font=('Helvetica', 10))
self.nrangeLabel = ttk.Label(self.colorsFrame, text='nrange', font=('Helvetica', 10))
self.colmapCombo = ttk.Combobox(self.colorsFrame, textvariable = self.colMap, values = mpl_color_maps)
self.colmapCombo.set(self.colors)
self.nrangeEntry = tk.Entry(self.colorsFrame, width = 7)
self.nrangeEntry.insert(0, '1')
self.applyButton = ttk.Button(self.colorsFrame, text = 'Apply', command = self.onApply)
self.helpButton = ttk.Button(self.colorsFrame, text = '?', command = self.onHelp)
self.absRadio.grid(row = 0, column = 0, columnspan = 1, padx = 15, pady = 10, sticky = 'w')
self.relRadio.grid(row = 0, column = 1, columnspan = 1, padx = 15, pady = 10, sticky = 'w')
self.cusRadio.grid(row = 0, column = 2, columnspan = 1, padx = 15, pady = 10, sticky = 'w')
self.colmapLabel.grid(row = 1, column = 0, columnspan = 2, padx = 17, sticky = 'ws')
self.nrangeLabel.grid(row = 1, column = 2, columnspan = 1, padx = 15, sticky = 'ws')
self.colmapCombo.grid(row = 2, column = 0, columnspan = 2, padx = 15, sticky = 'ews')
self.nrangeEntry.grid(row = 2, column = 2, columnspan = 1)
self.applyButton.grid(row = 3, column = 1, columnspan = 2, padx = 15, pady = 20, sticky = 'nesw')
self.helpButton.grid(row = 3, column = 0, columnspan = 1, padx = 15, pady = 20, sticky = 'w')
# ============================ Initial Figure ============================
self._label_groups = vis.annotate(self.panelBoard,
self.boardHeight,
self.RNdata.data_dim,
self.RNdata.hid_size,
self._set_bfs())
self._labels_on = True
self._plotLatest()
# ============================== PROTOCOLS ===============================
self.master.protocol('WM_DELETE_WINDOW', self.onMasterX)
self.controlsWindow.protocol('WM_DELETE_WINDOW', self.onControlsX)
self.colorsWindow.protocol('WM_DELETE_WINDOW', self.onColorsX)
self.master.mainloop()
def create_fig(self):
# Create a figure
max_width = self.RNdata.hid_size + self.RNdata.data_dim * 2
width_cells = max_width + 5
width_pixels = width_cells * self._ppc
width_inches = width_pixels / self._dpi
num_steps = self.RNdata.max_len
height_cells = 2 * num_steps + 2
height_pixels = height_cells * self._ppc
height_inches = height_pixels / self._dpi
fig = plt.figure(1, figsize=(width_inches, height_inches), facecolor='w', dpi=self._dpi)
return fig
def onUpdate(self):
epoch_ind = int(self.epochSlider.get())
snap = self.RNdata.main[epoch_ind]
key = self.patternSelector.get()
if key in snap['strings']:
pattern_ind = snap['strings'].index(key)
self.progBar.start()
self.panelBoard.clear()
inp_seq, hid_seq, init_hid, out_seq, targ_seq = get_vecs(snap, pattern_ind, self.RNdata.max_len)
vis.draw_epoch(self.panelBoard, self.boardHeight, inp_seq, hid_seq, init_hid, out_seq, targ_seq, self.colors, 1)
self._label_groups = vis.annotate(self.panelBoard,
self.boardHeight,
self.RNdata.data_dim,
self.RNdata.hid_size,
self._set_bfs())
self.figureRenderer.draw()
self.progBar.stop()
else:
messagebox.showinfo(title='Wrong selection',
message='No such pattern. Please select a pattern from the list')
def onContinue(self):
self._sleep()
def changeSize(self, direction):
oldSize_inches = self.figure.get_size_inches()
oldSize_pixels = [s_i * self._dpi for s_i in oldSize_inches]
Size_cells = [s_p / self._ppc for s_p in oldSize_pixels]
self._ppc += 10 * direction
newSize_pixels = [s_c * self._ppc for s_c in Size_cells]
newSize_inches = [s_p / self._dpi for s_p in newSize_pixels]
self.figure.set_size_inches(newSize_inches)
nW, nH = newSize_pixels[0], newSize_pixels[1]
self.canvasFrame.config(width = nW, height = nH)
self.mplCanvasWidget.config(width = nW, height = nH)
self.backCanvas.itemconfigure(self.backCanvasWind, width=nW, height=nH)
self.backCanvas.config(scrollregion=self.backCanvas.bbox(tk.ALL), width=nW, height=nH)
self.checkPPC()
vis.deannotate(self._label_groups)
self._label_groups = vis.annotate(self.panelBoard,
self.boardHeight,
self.RNdata.data_dim,
self.RNdata.hid_size,
self._set_bfs())
self.figure.canvas.draw()
def checkPPC(self):
upperlim = 60
lowerlim = 10
if self._ppc <= lowerlim:
self.zoomoutButton.state(['disabled'])
elif self._ppc >= upperlim:
self.zoominButton.state(['disabled'])
else:
if self.zoomoutButton.instate(['disabled']): self.zoomoutButton.state(['!disabled'])
if self.zoominButton.instate(['disabled']): self.zoominButton.state(['!disabled'])
def onPick(self, event):
thiscell = event.artist
value = thiscell.get_cellval()
r, c = thiscell.get_inds()
weight = str(round(value, 4))
rc = 'r: {} | c: {}'.format(r,c)
self.cellCoords.config(text = rc)
self.cellWeight.config(text = weight)
self.tinyFig.set_facecolor(vis.v2c(value, self.colors, 1))
self.tinyRenderer.draw()
def onSlide(self, val):
val = float(val)
self.epochValLabel.config(text = str(self._get_epoch(val)))
self.patternSelector['values'] = self.RNdata[int(val)]['strings']
self.patternSelector.current(0)
def onApply(self):
print('Applying changes')
print('Normalization scope: {}'.format(self.normMode.get()))
print('Normalization range: {}'.format(self.nrangeEntry.get()))
print('Color map: {}'.format(self.colmapCombo.get()))
self.colorsWindow.withdraw()
def onHelp(self):
messagebox.showinfo('Need some explanation?',
'Too bad, we are still working on it. '
'Try playing around with the preferences '
'to see what\'s going on :)')
def onLiftControls(self):
if self.controlsWindow.state() == 'withdrawn': self.controlsWindow.state('normal')
self.controlsWindow.lift()
def onColorPrefs(self):
if self.colorsWindow.state() == 'withdrawn': self.colorsWindow.state('normal')
self.colorsWindow.lift()
def onMasterX(self):
self._sleep()
def onControlsX(self):
self.controlsWindow.withdraw()
def onColorsX(self):
positive = messagebox.askyesno('O_o', 'Do you want to apply changes')
if positive:
self.onApply()
self.colorsWindow.withdraw()
def catch_up(self, snap):
self.RNdata = snap
self._plotLatest()
self.master.state('normal')
self.controlsWindow.state('normal')
self.master.mainloop()
def _sleep(self):
self.master.withdraw()
self.controlsWindow.withdraw()
self.colorsWindow.withdraw()
self.master.quit()
def _plotLatest(self):
latest_epoch_ind = self.RNdata.num_epochs - 1
latest_snap = self.RNdata[latest_epoch_ind]
inp_seq, hid_seq, prevhid_seq, out_seq, targ_seq = get_vecs(latest_snap, 0, self.RNdata.max_len)
vis.draw_epoch(self.panelBoard, self.boardHeight, inp_seq, hid_seq, prevhid_seq, out_seq, targ_seq, self.colors, 1)
self.epochSlider.config(to = float(latest_epoch_ind))
self.figureRenderer.draw()
def _get_epoch(self, slider_value):
return self.RNdata[int(slider_value)]['ep_num']
def _get_pattern(self):
try:
ind = self.RNdata.inp_names.index(self.patternVar.get())
print('You selected pattern {}'.format(ind))
except ValueError:
print('No such pattern')
def _set_bfs(self, scale = 0.4):
return self._ppc * scale
def onLabels(self):
pass
# z
plt.plot3D(zx, zy, zz)
plt.plot(int(x_width.get()), int(y_width.get()), y_len, 'ro')
canvas.draw()
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():
root.quit()
root.destroy()
def _draw():
cartesian()
x_label = tkinter.Label(master=root, text="X", font="times 15")
x_width = tkinter.Entry(master=root)