def Plotting(queue):
while queue.get() != "Start Plotting Process":
wait = "Waiting"
timeNow = datetime.time(datetime.now())
time = timeNow.minute + (timeNow.second +
timeNow.microsecond / 1000000.0) / 60.0
lastX = time
lastY = 90250
connect = True
step = 0
x = []
y = []
mode = "24-Hour-Plot"
root = tk.Tk()
root.wm_title("PyAmaseis v1.0")
root.iconbitmap(r'icons/icon.ico')
root.wm_state('zoomed')
graphHeightConst = 2500
fig = plt.figure(figsize=(15, 10))
fig.set_tight_layout(0.4)
ax = fig.add_subplot(1, 1, 1)
ax.set_xlim(0, 60)
ax.set_ylim(30250, 92750)
ax.set_xlabel('Time(minutes)')
xAxis = [0, 60]
yAxis = [30250, 92750]
y1 = (np.arange(min(yAxis), max(yAxis) + 1, graphHeightConst))
y2 = calculateYAxisLabels()
ax.set_xticks(np.arange(min(xAxis), max(xAxis) + 1, 1))
plt.yticks(y1, y2)
ax.yaxis.grid(color='#0000FF')
ax.set_axisbelow(True)
line, = ax.plot(x, y, color='k')
canvas = FigureCanvasTkAgg(fig, master=root)
canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
label = tk.Label(text="")
label.pack()
background = canvas.copy_from_bbox(ax.bbox)
canvas.draw()
root.after(0, plotData, queue, fig, ax, canvas, label, root, lastY, lastX,
connect, background, line, mode)
root.mainloop()
def Plotting(queue):
while queue.get() != "Start Plotting Process":
wait = "Waiting"
timeNow = datetime.time(datetime.now())
time = timeNow.minute + (timeNow.second + timeNow.microsecond/1000000.0)/60.0
lastX = time
lastY = 90250
connect = True
step = 0
x=[]
y=[]
mode = "24-Hour-Plot"
root = tk.Tk()
root.wm_title("PyAmaseis v1.0")
root.iconbitmap(r'icons/icon.ico')
root.wm_state('zoomed')
graphHeightConst = 2500
fig = plt.figure(figsize=(15,10))
fig.set_tight_layout(0.4)
ax = fig.add_subplot(1,1,1)
ax.set_xlim(0,60)
ax.set_ylim(30250,92750)
ax.set_xlabel('Time(minutes)')
xAxis = [0,60]
yAxis = [30250,92750]
y1 = (np.arange(min(yAxis), max(yAxis)+1,graphHeightConst))
y2 = calculateYAxisLabels()
ax.set_xticks(np.arange(min(xAxis), max(xAxis)+1,1))
plt.yticks(y1, y2)
ax.yaxis.grid(color = '#0000FF' )
ax.set_axisbelow(True)
line, = ax.plot(x, y, color='k')
canvas = FigureCanvasTkAgg(fig, master=root)
canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
label = tk.Label(text="")
label.pack()
background = canvas.copy_from_bbox(ax.bbox)
canvas.draw()
root.after(0, plotData,queue, fig, ax, canvas, label, root, lastY, lastX, connect, background, line, mode)
root.mainloop()
def __init__(self, parent, controller):
tk.Frame.__init__(self, parent)
#bring up vertical scroll frame and place it
scframe = VerticalScrolledFrame(self)
scframe.place(x=130, y=40)
#bring up canvas with plot in the frame with vertical scroll bar
canvas = FigureCanvasTkAgg(f, scframe.interior)
background = canvas.copy_from_bbox(f.bbox)
canvas.draw()
#create title label
label = tk.Label(self, text="Dashboard", bg='white', font=TITLE_FONT)
label.place(x=460, y=10)
#embed graph into canvas
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)
#add navigation bar
toolbar = NavigationToolbar2Tk(canvas, self)
toolbar.update()
#color variables
#data table labels
table_title = tk.Label(self,
text="Data Summary",
bg="white",
font=LARGE_FONT)
table_title.place(x=28, y=40)
for i, param in enumerate(
param_list): #tk.Label self refers to Homepage
param_label = tk.Label(self,
text=param,
fg="black",
bg="white",
font=MEDIUM_FONT,
borderwidth=2,
relief="ridge",
width=18,
height=1,
anchor=W,
justify=LEFT)
param_label.place(x=5, y=65 + 22 * i)
for i, param in enumerate(param_list):
loading_text = tk.Label(self,
text="Loading",
fg="black",
bg="white",
font=MEDIUM_FONT,
borderwidth=2,
relief="ridge",
width=5,
height=1)
loading_text.place(x=156, y=65 + 22 * i)
current_text = Live_Text(loading_text)
live_dict[param] = current_text
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 Annotator:
def __init__(self, parent):
self.parent = parent
parent.title("Sound Annotation/Analyzation Tool")
self.initUI()
def initUI(self):
self.labeldict = {}
self.show = []
self.timeValues = []
self.stamp = -1
self.stampHistory = []
self.funclist = {
"rms", "hfc", "complex", "complex_phase", "flux", "superflux",
"noveltycurve", "CNNOnsetDetector", "RNNOnsetDetector",
"modifiedKL", "weightedPhaseDev", "PhaseDev",
"rectifiedComplexDomain", "ninos"
}
self.featurelist = [
"Audio", "rms", "spectralCentroid", "spectralRolloff", "zcr",
"spectralEntropy", "spectralFlux", "StrongDecay", "stft"
]
self.hopsizes = []
self.calculated_features_dict = {}
self.calculated_features = []
self.calculated_featuresParams = []
self.defaultParams = {
'rms': (512, 1024, 'hann'),
'Audio': (),
'spectralCentroid': (512, 1024, 'hann'),
'spectralRolloff': (512, 1024, 'hann'),
'spectralFlux': (512, 1024, 'hann'),
'zcr': (512, 1024),
'spectralEntropy': (512, 1024, 'hann'),
'StrongDecay': (512, 1024),
'stft': (512, 1024)
}
self.chunk_size = 2048
self.mag = []
self.phase = []
self.sem = asyncio.Semaphore()
# Info text
self.info = StringVar()
self.info.set("welcome")
self.info_widget = Message(self.parent,
textvariable=self.info,
width=300)
self.info_widget.grid(row=0, column=3, sticky=W + N + E + S, rowspan=2)
# define options for opening file
self.file_opt = options = {}
options['defaultextension'] = '.wav'
options['filetypes'] = [('All files', '.*'), ('Wav files', '.wav')]
options['initialdir'] = os.getcwd() + "/sounds"
if (options['initialdir'][-1] != '/'):
options['initialdir'] += '/'
# BUTTON TO SET DIRECTORY
self.directory_button = Button(self.parent,
text="Directory",
command=self.set_directory)
self.directory_button.grid(row=1, column=0, sticky=W)
#TEXTBOX TO PRINT PATH OF THE SOUND FILE
self.filelocation = Entry(self.parent)
self.filelocation["width"] = 25
self.filelocation.grid(row=0, column=0, sticky=W, padx=10)
self.filelocation.delete(0, END)
self.filename = '' # initial file
self.filelocation.insert(0,
self.file_opt['initialdir'] + self.filename)
#BUTTON TO BROWSE SOUND FILE
self.open_file = Button(self.parent,
text="Browse...",
command=self.browse_file)
self.open_file.grid(row=0, column=0, sticky=W, padx=(220, 6))
#BUTTON TO PLOT SOUND FILE
self.preview = Button(self.parent,
text="Plot",
command=self.plot,
bg="gray30",
fg="white")
self.preview.grid(row=0, column=0, sticky=W, padx=(300, 6))
#BUTTON TO draw stamps
self.draw = Button(self.parent,
text="Draw",
command=self.drawAllStamps,
bg="gray30",
fg="white")
self.draw.grid(row=1, column=0, sticky=W, padx=(420, 6))
# Dropdown Function Select
self.funcname = StringVar()
self.funcname.set("Select a function")
self.fselect = OptionMenu(self.parent, self.funcname, *self.funclist)
self.fselect.grid(row=1, column=2, sticky=W)
# Button to Apply function
self.afuncbtn = Button(self.parent,
text="Apply",
command=self.applyfunction,
bg="gray30",
fg="white")
self.afuncbtn.grid(row=1, column=2, sticky=W, padx=(300, 6))
# Dropdown SHOW FEATURE
self.featurename = StringVar()
self.featurename.set("Audio")
self.featurename.trace("w", self.changeparams)
self.ftselect = OptionMenu(self.parent, self.featurename,
*self.featurelist)
self.ftselect.grid(row=0, column=2, sticky=W)
# Entry for feature params
self.featureParamsEntry = Entry(self.parent)
self.featureParamsEntry.grid(row=0, column=2, sticky=W, padx=(150, 6))
self.featureParamsEntry.bind("<Enter>", self.updateinfo)
# Button to show feature
self.afuncbtn = Button(self.parent,
text="Show",
command=self.showfeature,
bg="gray30",
fg="white")
self.afuncbtn.grid(row=0, column=2, sticky=W, padx=(300, 6))
# Button to send top feature to below plot
self.sendbelowbtn = Button(self.parent,
text="v",
command=self.sendbelow)
self.sendbelowbtn.grid(row=0, column=2, sticky=W, padx=(360, 6))
#BUTTON TO PLAY/STOP , shortcut: spacebar
self.play_mode = tk.BooleanVar(self.parent, False)
self.new_sound = tk.BooleanVar(self.parent, False)
self.playbutton = Button(self.parent,
text="Play",
command=self.playsound)
self.playbutton.grid(row=0, column=0, sticky=W, padx=(350, 6))
self.parent.bind("<space>", self.playsound)
#BUTTON TO SAVE AND LOAD NEXT SOUND FILE
self.saveload = Button(self.parent,
text="Save& Load Next",
command=self.saveAndNext)
self.saveload.grid(row=0, column=1, sticky=W)
#BUTTON TO ADD LABELS
self.addlabel_button = Button(self.parent,
text="Add/Manage Labels",
command=self.addlabel_gui)
self.addlabel_button.grid(row=0, column=0, sticky=W, padx=(420, 6))
# BUTTON TO DISCARD CURRENT ANNOTATIONS
self.discardbutton = Button(self.parent,
text="Discard",
command=self.discard)
self.discardbutton.grid(row=0, column=4, sticky=W)
#BUTTON TO get next
self.load_next = Button(self.parent,
text="Next Sound",
command=self.getNext)
self.load_next.grid(row=1, column=0, sticky=W, padx=(220, 6))
# BUTTON TO QUIT
self.quitbutton = Button(self.parent, text="Quit", command=self.quit)
self.quitbutton.grid(row=3, column=4, sticky=W)
# tickbox to autoload existing annotations
self.ALoad = IntVar()
self.autoload_annotations = Checkbutton(master=self.parent,
text="Autoload Annotations?",
variable=self.ALoad,
onvalue=1,
offvalue=0)
self.autoload_annotations.grid(row=1, column=1, sticky=W)
# tickbox to convert time to samples
self.isTime = IntVar()
self.timeorsamples = Checkbutton(master=self.parent,
text="time?",
variable=self.isTime,
onvalue=1,
offvalue=0)
self.timeorsamples.grid(row=1, column=0, sticky=W, padx=(500, 6))
# tickbox to enable discarding labels
self.DLabels = IntVar()
self.discardlabels_check = Checkbutton(master=self.parent,
text="Discard Labels?",
variable=self.DLabels,
onvalue=1,
offvalue=0)
self.discardlabels_check.grid(row=1, column=4, sticky=W)
# init figure for plotting
self.currentplot = 0
fig = plt.figure(figsize=(18, 7), dpi=100)
self.mainplot = fig.add_subplot(211)
self.secplot = fig.add_subplot(212)
self.canvas = FigureCanvasTkAgg(fig, self.parent)
self.canvaswidget = self.canvas.get_tk_widget()
self.canvaswidget.grid(row=2, column=0, columnspan=5, sticky=W)
toolbarFrame = Frame(master=self.parent)
toolbarFrame.grid(row=3, column=0, columnspan=7)
self.toolbar = NavigationToolbar2Tk(self.canvas, toolbarFrame)
self.toolbar.update()
self.canvas._tkcanvas.grid(row=2, column=0, columnspan=7, sticky=W)
self.background = self.canvas.copy_from_bbox(self.mainplot.bbox)
self.cursor = self.mainplot.axvline(color="k", animated=True)
self.cursor.set_xdata(0)
self.colors = [
'r', 'g', 'c', 'm', 'y', '#FFBD33', '#924A03', '#D00000',
'#D000D0', '#6800D0', '#095549', 'b', 'r', 'r'
]
# modification to original handler of 'release_zoom', "release_pan" and "_update_view" from NavigationToolbar2
# latest one is for forward, backward and home buttons
self.release_zoom_orig = self.toolbar.release_zoom
self.toolbar.release_zoom = self.new_release_zoom
self.release_pan_orig = self.toolbar.release_pan
self.toolbar.release_pan = self.new_release_pan
self._update_view_orig = self.toolbar._update_view
self.toolbar._update_view = self.new_update_view
self.canvas.mpl_connect('toolbar_event', self.handle_toolbar)
cid1 = self.canvas.mpl_connect("button_press_event", self.onclick)
self.parent.bind("<Escape>", self.release_stamp)
self.parent.bind("x", self.discard_last)
self.p = pyaudio.PyAudio()
self.parent.bind("<<playbackmove>>", self.playbackMove)
def callbackstream(in_data, frame_count, time_info, status):
self.sem.acquire()
data = self.wf.readframes(frame_count)
self.parent.event_generate("<<playbackmove>>", when="now")
self.sem.release()
return (data, pyaudio.paContinue)
self._callbackstream = callbackstream
def updateinfo(self, event, *args):
caller = event.widget
if str(caller) == '.!entry2':
self.info.set(getattr(features, self.featurename.get()).__doc__)
def applyfunction(self):
values = getattr(libod, self.funcname.get())(self.filelocation.get())
if len(values) == 0:
self.info.set("No detections")
else:
self.labeldict[len(self.labeldict)] = self.funcname.get()
var = IntVar()
var.set(1)
self.show.append(var)
self.timeValues.append([i * 44100 for i in values])
self.drawAllStamps()
def set_directory(self):
directory = tkFileDialog.askdirectory() + '/'
self.file_opt['initialdir'] = directory
def release_stamp(self, event=None):
self.stamp = -1
self.info.set("Cursor")
def discard_last(self,
event=None
): # discard last annotation for current sound. button: X
self.mainplot.lines.pop()
self.canvas.draw()
self.background = self.canvas.copy_from_bbox(self.mainplot.bbox)
self.timeValues[self.stampHistory[-1]].pop()
self.stampHistory.pop()
def discard(self): # discard all annotations
self.timeValues = []
if (self.DLabels.get() == True or self.ALoad.get() == True):
self.labeldict = {}
self.show = []
else:
for i in range(len(self.labeldict)):
self.timeValues.append([])
self.stamp = -1
self.stampHistory = []
self.mag = []
self.phase = []
self.hopsizes = []
self.calculated_features_dict = {}
self.calculated_features = []
self.calculated_featuresParams = {}
self.currentplot = 0
def label(self, event):
self.info.set(self.labeldict[int(event.char) - 1] + " is selected")
self.stamp = int(event.char) - 1
def addlabel(self):
self.labeldict[len(self.labeldict)] = self.newlabel_entry.get()
var = IntVar()
var.set(1)
self.show.append(var)
self.parent.bind("%d" % len(self.labeldict), self.label)
self.timeValues.append([])
def deselect(self):
for cb in self.checkbuttons:
cb.deselect()
def addlabel_gui(self):
frame_addlabel = Toplevel(master=self.parent)
frame_addlabel.geometry(
"%dx%d%+d%+d" % (400, 100 + 33 * len(self.labeldict), 200, 200))
frame_addlabel.title("Add Labels")
self.newlabel_entry = Entry(frame_addlabel)
self.newlabel_entry.grid(row=0, column=0)
labels_text = "Current Labels:"
w = Message(frame_addlabel, text=labels_text, width=150)
w.grid(row=1, column=0)
labels_text = "Display?"
w = Message(frame_addlabel, text=labels_text, width=150)
w.grid(row=1, column=1)
self.checkbuttons = []
for i in range(len(self.labeldict)):
labels_text = '%d' % (i + 1) + '. ' + self.labeldict[i]
w = Message(frame_addlabel, text=labels_text, width=150)
w.grid(row=i + 2, column=0)
check = Checkbutton(master=frame_addlabel,
text="",
variable=self.show[i],
onvalue=1,
offvalue=0)
check.grid(row=i + 2, column=1, sticky=W)
self.checkbuttons.append(check)
addbutton = Button(frame_addlabel, text="Add", command=self.addlabel)
addbutton.grid(row=0, column=1, sticky=W)
togglebutton = Button(frame_addlabel,
text="Deselect",
command=self.deselect)
togglebutton.grid(row=1, column=2, sticky=W)
def quit(self):
try:
self.stream.close()
self.wf.close()
self.p.terminate()
except:
print("no audio init")
finally:
self.parent.destroy()
def initStream(self):
self.stream = self.p.open(format=8,
channels=1,
rate=44100,
output=True,
stream_callback=self._callbackstream,
start=True,
frames_per_buffer=self.chunk_size)
def playsound(self, event=None):
if self.sem.locked():
return
if self.play_mode.get() == True:
try:
self.playbutton.config(text="Play")
self.stream.close()
self.stream.close()
self.play_mode.set(False)
except:
print("stop failed")
else:
try:
self.initStream()
self.play_mode.set(True)
self.playbutton.config(text="Stop")
except:
print("stop failed")
def playbackMove(self, event=None): # move cursor by audio chunk size
incr = (self.chunk_size) // self.hopsizes[self.currentplot]
self.cursor.set_xdata(self.cursor.get_xdata() + incr)
self.updateCursor()
def new_release_zoom(self, *args, **kwargs):
self.release_zoom_orig(*args, **kwargs)
s = 'toolbar_event'
event = Event(s, self)
self.canvas.callbacks.process(s, Event('toolbar_event', self))
def new_release_pan(self, *args, **kwargs):
self.release_pan_orig(*args, **kwargs)
s = 'toolbar_event'
event = Event(s, self)
self.canvas.callbacks.process(s, Event('toolbar_event', self))
def new_update_view(self, *args, **kwargs):
self._update_view_orig(*args, **kwargs)
s = 'toolbar_event'
event = Event(s, self)
self.canvas.callbacks.process(s, Event('toolbar_event', self))
def handle_toolbar(self, event):
self.canvas.draw()
self.background = self.canvas.copy_from_bbox(self.mainplot.bbox)
def onclick(self, event):
if (self.toolbar._active == 'ZOOM' or self.toolbar._active == 'PAN'):
pass
elif (self.stamp > -1):
self.stampHistory.append(self.stamp)
self.timeValues[self.stamp].append(event.xdata *
self.hopsizes[self.currentplot])
self.mainplot.draw_artist(
self.mainplot.axvline(x=event.xdata,
color=self.colors[self.stamp]))
self.canvas.draw()
self.background = self.canvas.copy_from_bbox(self.mainplot.bbox)
self.info.set("Cursor")
self.stamp = -1
else:
self.cursor.set_xdata(event.xdata)
self.wf.setpos(int(event.xdata * self.hopsizes[self.currentplot]))
self.updateCursor()
def updateCursor(self):
self.canvas.restore_region(self.background)
self.mainplot.draw_artist(self.cursor)
self.canvas.blit(self.mainplot.bbox)
def browse_file(self):
self.filename = os.path.basename(
tkFileDialog.askopenfilename(**self.file_opt))
self.filelocation.delete(0, END)
self.filelocation.insert(0,
self.file_opt['initialdir'] + self.filename)
def changeparams(self, *args):
self.featureParamsEntry.delete(0, END)
try:
self.featureParamsEntry.insert(
0, str(self.defaultParams[self.featurename.get()]))
except:
self.featureParamsEntry.insert(0, "()")
print("No default params for selected feature")
def showfeature(self):
self.mainplot.clear()
featureName = self.featurename.get()
featureParams = eval(self.featureParamsEntry.get())
if featureName in self.calculated_features_dict and self.calculated_featuresParams[
featureName] != featureParams:
# if a feature is calculated before and params are the same; plot the saved result
self.currentplot = self.calculated_features_dict[featureName]
if len(self.calculated_features[self.currentplot].shape) == 2:
ylim = 5000
binToFreq = np.arange(0, ylim, 43.066) # Fs/N
self.mainplot.pcolormesh(
np.arange(
self.calculated_features[self.currentplot].shape[0]),
binToFreq, self.calculated_features[
self.currentplot].T[:binToFreq.size, :])
else:
self.mainplot.plot(self.calculated_features[self.currentplot])
self.canvas.draw()
self.background = self.canvas.copy_from_bbox(self.mainplot.bbox)
hopSize = self.hopsizes[self.calculated_features_dict[featureName]]
else:
self.currentplot = len(self.calculated_features)
self.calculated_features_dict[featureName] = self.currentplot
result, hopSize = getattr(features, featureName)(self.audio,
featureParams)
if len(result.shape) == 2:
ylim = 5000
binToFreq = np.arange(0, ylim, 43.066) # Fs/N
self.mainplot.pcolormesh(np.arange(result.shape[0]), binToFreq,
result.T[:binToFreq.size, :])
else:
self.mainplot.plot(result)
self.canvas.draw()
self.background = self.canvas.copy_from_bbox(self.mainplot.bbox)
self.calculated_features.append(result)
self.hopsizes.append(hopSize)
self.calculated_featuresParams[featureName] = featureParams
self.drawAllStamps()
def sendbelow(self):
self.secplot.clear()
if len(self.calculated_features[self.currentplot].shape) == 2:
ylim = 5000
binToFreq = np.arange(0, ylim, 43.066) # Fs/N
self.secplot.pcolormesh(
np.arange(self.calculated_features[self.currentplot].shape[0]),
binToFreq, self.calculated_features[
self.currentplot].T[:binToFreq.size, :])
else:
self.secplot.plot(self.calculated_features[self.currentplot])
self.canvas.draw()
def plot(self):
self.discard()
inputFile = self.filelocation.get()
self.wf = wave.open(inputFile, 'rb')
self.featurename.set("Audio")
self.audio = MonoLoader(filename=inputFile, sampleRate=44100)()
self.showfeature()
self.cursor.set_xdata(0)
self.canvaswidget.focus_set()
if (self.ALoad.get() == 1):
self.loadAnnotations()
def saveAnnotations(self):
directory = self.file_opt[
'initialdir'] + "Annotations/" + self.filename.split('.')[
0] # deleting .wav
if not os.path.exists(directory):
os.makedirs(directory)
for i in self.labeldict:
with open(directory + '/%s.txt' % self.labeldict[i],
'w') as filehandle:
json.dump(self.timeValues[i], filehandle)
def loadAnnotations(self):
directory = self.file_opt[
'initialdir'] + "Annotations/" + self.filename.split('.')[0] + "/"
if not os.path.exists(directory):
print("No annotations")
else:
for x in sorted(os.listdir(directory)):
with open(directory + x, 'r') as filehandle:
values = json.load(filehandle)
if self.isTime.get() == 1:
values = [v * 44100 for v in values]
self.labeldict[len(self.labeldict)] = x.split('.')[0]
var = IntVar()
var.set(1)
self.show.append(var)
self.timeValues.append(values)
def getNext(self):
self.discard()
fileList = sorted(os.listdir(self.file_opt['initialdir']))
nextIndex = fileList.index(self.filename) + 1
if nextIndex == 0 or nextIndex == len(fileList):
print("No more files")
else:
self.filename = fileList[nextIndex]
self.filelocation.delete(0, END)
self.filelocation.insert(
0, self.file_opt['initialdir'] + fileList[nextIndex])
self.plot()
def drawAllStamps(self):
hs = self.hopsizes[self.currentplot]
try:
del self.mainplot.lines[1:]
except:
pass
for i in self.labeldict:
if self.show[i].get() == 1:
for j in self.timeValues[i]:
self.mainplot.draw_artist(
self.mainplot.axvline(x=j // hs, color=self.colors[i]))
self.canvas.draw()
self.background = self.canvas.copy_from_bbox(self.mainplot.bbox)
def saveAndNext(self):
self.saveAnnotations()
self.getNext()
self.plot()
class App(Tk):
def __init__(self):
Tk.__init__(self)
self.title("Baja GUI")
self.grid()
cw = 1 # cell width
ch = 2
cr = self.winfo_screenwidth() / 32
print(self.winfo_screenheight())
print(self.winfo_screenwidth())
# Root level frames
self.controlFrame = Frame(self, bg='grey', borderwidth=0, width=self.winfo_screenwidth(), height=(self.winfo_screenheight()/4))
self.displayFrame = Frame(self, bg='grey', borderwidth=0)
# Serial Control Frame
self.serialFrame = Frame(self.controlFrame, borderwidth=0)
self.COMPort = StringVar()
self.COMPortTextBox = Entry(self.serialFrame, textvariable = self.COMPort)
self.COMPort.set('/dev/ttyUSB0')
self.COMBaud = StringVar()
self.COMBaudTextBox = Entry(self.serialFrame, textvariable = self.COMBaud)
self.COMBaud.set('9600')
self.COMButton = Button(self.serialFrame, text = "Start Serial", command = self.StartSerial)
self.SerialSendButton = Button(self.serialFrame, text = "Send to Board", command = self.SendToSerial)
self.SerialSendToDriverButton = Button(self.serialFrame, text = "Send to Driver", command = self.SendToDriver)
self.SerialSendTextBox = Entry(self.serialFrame)
# Extra Buttons
self.SerialStopButton = Button(self.serialFrame, text = "Stop Serial", command = self.StopSerial)
self.comeBackToPitNowButton = Button(self.controlFrame, text = "Pit Now", command = self.PitNow)
self.comeBackToPitNextLapButton = Button(self.controlFrame, text = "Pit Next Lap", command = self.PitNextLap)
# Informative Things
self.dataBarFrame = Frame(self.controlFrame)
self.numActiveThreads = StringVar()
self.numThreadsLabel = Label(self.dataBarFrame, textvariable = self.numActiveThreads)
self.numActiveThreads.set('Threads\n' + str(threading.enumerate().__len__()))
self.numThreadsLabel.grid(column = 0, row = 0)
self.counter = StringVar()
self.counterLabel = Label(self.dataBarFrame, textvariable = self.counter)
self.counter.set('Counter\n' + 'N/A')
self.counterLabel.grid(column = 1, row = 0)
self.gpsDate = StringVar()
self.gpsDateLabel = Label(self.dataBarFrame, textvariable = self.gpsDate)
self.gpsDate.set('Date\n' + '010100')
self.gpsDateLabel.grid(column = 2, row = 0)
self.gpsTime = StringVar()
self.gpsTimeLabel = Label(self.dataBarFrame, textvariable = self.gpsTime)
self.gpsTime.set('Time\n' + '00000000')
self.gpsTimeLabel.grid(column = 3, row = 0)
self.numSats = StringVar()
self.numSatsLabel = Label(self.dataBarFrame, textvariable = self.numSats)
self.numSats.set('Sats\n' + 'NSA')
self.numSatsLabel.grid(column = 4, row = 0)
self.currentLatitude = StringVar()
self.latitudeLabel = Label(self.dataBarFrame, textvariable = self.currentLatitude)
self.currentLatitude.set("Latitude\n" + 'Unknown')
self.latitudeLabel.grid(column = 5, row = 0)
self.currentLongitude = StringVar()
self.longitudeLabel = Label(self.dataBarFrame, textvariable = self.currentLongitude)
self.currentLongitude.set("Longitude\n" + 'Unknown')
self.longitudeLabel.grid(column = 6, row = 0)
self.currentSpeed = StringVar()
self.speedLabel = Label(self.dataBarFrame, textvariable=self.currentSpeed)
self.currentSpeed.set("Speed\n" + "86")
self.speedLabel.grid(column = 7, row = 0)
self.currentDashTemp = StringVar()
self.dashTempLabel = Label(self.dataBarFrame, textvariable=self.currentDashTemp)
self.currentDashTemp.set("Dash Temp\n" + "N/A")
self.dashTempLabel.grid(column = 8, row = 0)
self.batteryVoltage = StringVar()
self.batteryVoltageLabel = Label(self.dataBarFrame, textvariable = self.batteryVoltage)
self.batteryVoltage.set("BATT\n" + "N/A")
self.batteryVoltageLabel.grid(column = 9, row = 0)
self.xbeeSignalStrength = StringVar()
self.xbeeSignalStrengthLabel = Label(self.dataBarFrame, textvariable = self.xbeeSignalStrength)
self.xbeeSignalStrength.set("XBee\n" + "N/A")
self.xbeeSignalStrengthLabel.grid(column = 10, row = 0)
self.currentFrontBrakeAvg = StringVar()
self.frontBrakeAvgLabel = Label(self.dataBarFrame, textvariable = self.currentFrontBrakeAvg)
self.currentFrontBrakeAvg.set("Front Brake Avg\n" + "N/A")
self.frontBrakeAvgLabel.grid(column = 11, row = 0)
self.currentFrontBrakeMax = StringVar()
self.frontBrakeMaxLabel = Label(self.dataBarFrame, textvariable = self.currentFrontBrakeMax)
self.currentFrontBrakeMax.set("Front Brake Max\n" + "N/A")
self.frontBrakeMaxLabel.grid(column = 12, row = 0)
self.currentRearBrakeAvg = StringVar()
self.rearBrakeAvgLabel = Label(self.dataBarFrame, textvariable = self.currentRearBrakeAvg)
self.currentRearBrakeAvg.set("Rear Brake Avg\n" + "N/A")
self.rearBrakeAvgLabel.grid(column = 13, row = 0)
self.currentRearBrakeMax = StringVar()
self.rearBrakeMaxLabel = Label(self.dataBarFrame, textvariable = self.currentRearBrakeMax)
self.currentRearBrakeMax.set("Rear Brake Max\n" + "N/A")
self.rearBrakeMaxLabel.grid(column = 14, row = 0)
self.currentSteeringAvg = StringVar()
self.steeringAvgLabel = Label(self.dataBarFrame, textvariable = self.currentSteeringAvg)
self.currentSteeringAvg.set("Steering\n" + "Yes")
self.steeringAvgLabel.grid(column = 15, row = 0)
self.buttonPressed = StringVar()
self.buttonPressedLabel = Label(self.dataBarFrame, textvariable = self.buttonPressed, borderwidth = 1)
self.buttonPressed.set("Button\n" + "No")
self.buttonPressedLabel.grid(column = 16, row = 0)
self.currentPrimaryRPM = StringVar()
self.currentSecondaryRPM = StringVar()
# Accelerometer
self.accX = [0]
self.maxX = [0]
self.accY = [0]
self.maxY = [0]
self.accZ = [0]
self.maxZ = [0]
#
self.rearTemp = [0]
self.listbox = Listbox(self.controlFrame)
# Set to full screen
self.attributes('-fullscreen', True)
# Bind <Return> Keypress to text boxes
self.SerialSendTextBox.bind("<Return>", self.SendOnReturn)
self.COMBaudTextBox.bind("<Return>", self.StartSerialOnReturn)
# Pack Serial Controls into Serial Frame
self.SerialSendTextBox.grid(column = 0, row=0, sticky=EW)
self.SerialSendButton.grid(column = 2, row=0)
self.SerialSendToDriverButton.grid(column = 3, row = 0)
self.COMPortTextBox.grid(column = 4, row=0, sticky = E)
self.COMBaudTextBox.grid(column=6, row=0, sticky = E)
self.COMButton.grid(column = 8, row=0, sticky = NE)
self.SerialStopButton.grid(row = 0, column = 9, sticky=NE)
# Pack Control Widgets into Control Frame
self.serialFrame.grid(row = 0, column=0, columnspan=12, sticky=EW)
self.comeBackToPitNowButton.grid(row=0, column=10, sticky=NSEW)
self.comeBackToPitNextLapButton.grid(row=1, column=10, sticky=NSEW)
self.dataBarFrame.grid(row = 1, column = 0, columnspan = 10, sticky = EW)
self.listbox.grid(row = 2, column = 0, columnspan=10, sticky = EW)
# Pack Control Frame into root
self.controlFrame.grid(row = 0, sticky=EW)
# Top Level Display Frames
self.leftDisplayFrame = Frame(self.displayFrame, bg='grey', borderwidth=0, width=(self.winfo_screenwidth()/2))
self.rightDisplayFrame = Frame(self.displayFrame, bg='grey', borderwidth=0, width=(self.winfo_screenwidth()/2))
# Inside Left Display Frames
self.topLeftDisplayFrame = Frame(self.leftDisplayFrame, bg='grey', borderwidth=0, height=(self.winfo_screenheight()/4))
self.middleLeftDisplayFrame = Frame(self.leftDisplayFrame, bg='grey', borderwidth=0, height=(self.winfo_screenheight()/4))
self.bottomLeftDisplayFrame = Frame(self.leftDisplayFrame, bg='grey', borderwidth=0, height=(self.winfo_screenheight()/4))
# Inside Top Left Display Frames
# Inside Middle Left Display Frames
self.brakeFrame = Frame(self.middleLeftDisplayFrame, borderwidth=0)
# Inside Bottom Left Display Frames
self.driveTrainTempFrame = Frame(self.bottomLeftDisplayFrame, borderwidth=0)
self.driveTrainRPMFrame = Frame(self.bottomLeftDisplayFrame, borderwidth=0)
# Inside Rigt Display Frames
self.shieldTempFrame = Frame(self.rightDisplayFrame, borderwidth=0, bg='grey', height=(self.winfo_screenheight()/8))
self.shieldHealthFrame = Frame(self.rightDisplayFrame, borderwidth=0, bg='grey')
# Construct Items for Display Frame
self.gpsFigure, self.gpsAxes = plt.subplots(figsize=(2*ch,2*ch), dpi=cr*2)
self.speedFigure, self.speedAxes = plt.subplots(figsize=(2*ch,2*ch), dpi=cr)
self.rpmFigure, self.rpmAxes = plt.subplots(figsize=(ch,ch), dpi=cr)
self.dashTempFigure, self.dashTempAxes = plt.subplots(figsize=(2*ch,ch), dpi=cr)
self.rearTempFigure, self.rearTempAxes = plt.subplots(figsize=(2*ch,ch), dpi=cr)
self.gearTempFigure, self.gearTempAxes = plt.subplots(figsize=(2*ch,ch), dpi=cr)
self.cvtTempFigure, self.cvtTempAxes = plt.subplots(figsize=(2*ch,ch), dpi=cr)
self.battFigure, self.battAxes = plt.subplots(figsize=(ch,ch), dpi=cr)
self.frontBrakeFigure, self.frontBrakeAxes = plt.subplots(figsize=(2*ch,ch), dpi=cr)
self.rearBrakeFigure, self.rearBrakeAxes = plt.subplots(figsize=(2*ch,ch), dpi=cr)
self.steeringFigure, self.steeringAxes = plt.subplots(figsize=(ch,2*ch), dpi=cr)
self.buttonFigure, self.buttonGraph = plt.subplots(figsize=(ch,ch), dpi=cr)
self.accFigure, self.accAxes = plt.subplots(figsize=(2*ch,2*ch), dpi=cr)
self.zFigure, self.zAxes = plt.subplots(figsize=(ch, 2*ch), dpi=cr)
# GPS Axes Setup
self.gpsFigure.patch.set_visible(False)
self.gpsAxes.set_title('GPS')
#self.gpsAxes.set_xlim(-110.953,-110.952)
self.gpsAxes.set_xlim(-118823207 - 3000,-118823207 + 3000)
self.gpsAxes.set_ylim(34749085 - 3000,34749085 + 3000)
self.gpsAxes.hold(True)
self.gpsCanvas = FigureCanvasTkAgg(self.gpsFigure, master=self.rightDisplayFrame)
self.gpsCanvas.show()
# speed Axes Setup
self.speedFigure.patch.set_visible(False)
self.speedAxes.set_title('Speed')
self.speedAxes.set_xlim(0,100)
self.speedAxes.set_ylim(0,50)
self.speedAxes.hold(True)
self.speedCanvas = FigureCanvasTkAgg(self.speedFigure, master=self.topLeftDisplayFrame)
self.speedCanvas.show()
# Speed Textbox Setup
# Dash Temperature Axes Setup
self.dashTempFigure.patch.set_visible(False)
self.dashTempAxes.set_title('Dash Temperature')
# self.ten_wide = [0,1,2,3,4,5,6,7,8,9]
self.dashTempAxes.set_xlim(0,100)
# self.dashTempAxes.autoscale(enable=True, axis='x')
self.dashTempAxes.set_ylim(0,100)
self.dashTempAxes.hold(True)
self.dashTempCanvas = FigureCanvasTkAgg(self.dashTempFigure, master=self.shieldTempFrame)
self.dashTempCanvas.show()
# self.dashTempCanvas.draw()
# Rear Temperature Axes Setup
self.rearTempFigure.patch.set_visible(False)
self.rearTempAxes.set_title('Rear Temperature')
self.rearTempAxes.set_xlim(0,500)
self.rearTempAxes.set_ylim(0,100)
self.rearTempAxes.hold(True)
self.rearTempCanvas = FigureCanvasTkAgg(self.rearTempFigure, master=self.shieldTempFrame)
self.rearTempCanvas.show()
#
# Gearbox Temperature Axes Setup
self.gearTempFigure.patch.set_visible(False)
self.gearTempAxes.set_title('Gearbox Temperature')
self.gearTempAxes.set_xlim(0,500)
self.gearTempAxes.set_ylim(0,100)
self.gearTempAxes.hold(True)
self.gearTempCanvas = FigureCanvasTkAgg(self.gearTempFigure, master=self.driveTrainTempFrame)
self.gearTempCanvas.show()
#
# CVT Temperature Axes Setup
self.cvtTempAxes.set_title('CVT Temperature')
self.cvtTempAxes.set_xlim(0,500)
self.cvtTempAxes.set_ylim(0,100)
self.cvtTempAxes.hold(True)
self.cvtTempCanvas = FigureCanvasTkAgg(self.cvtTempFigure, master=self.driveTrainTempFrame)
self.cvtTempCanvas.show()
#
# Acceleration Axes Setup
self.accFigure.patch.set_visible(False)
self.accAxes.set_title('Acceleration 2-D')
self.accAxes.set_xlim(-2, 2)
self.accAxes.set_ylim(-2, 2)
self.accAxes.hold(True)
self.accCanvas = FigureCanvasTkAgg(self.accFigure, master=self.middleLeftDisplayFrame)
self.accCanvas.show()
self.zFigure.patch.set_visible(False)
self.zAxes.set_title('Z-Acc')
self.zAxes.set_xlim(-2, 2)
self.zAxes.set_ylim(-2, 2)
self.zAxes.hold(True)
self.zCanvas = FigureCanvasTkAgg(self.zFigure, master=self.topLeftDisplayFrame)
self.zCanvas.show()
self.steeringFigure.patch.set_visible(False)
self.steeringAxes.set_title('Steering')
self.steeringAxes.set_xlim(-2, 2)
self.steeringAxes.set_ylim(-2, 2)
self.steeringAxes.hold(True)
self.steeringCanvas = FigureCanvasTkAgg(self.steeringFigure, master=self.topLeftDisplayFrame)
self.steeringCanvas.show()
# Front Brake Axes Setup
self.frontBrakeFigure.patch.set_visible(False)
self.frontBrakeAxes.set_title('Front Brake Pressure')
self.frontBrakeAxes.set_xlim(0,500)
self.frontBrakeAxes.set_ylim(0,100)
self.frontBrakeAxes.hold(True)
self.frontBrakeCanvas = FigureCanvasTkAgg(self.frontBrakeFigure, master=self.brakeFrame)
self.frontBrakeCanvas.show()
# Rear Brake Axes Setup
self.rearBrakeFigure.patch.set_visible(False)
self.rearBrakeAxes.set_title('Rear Brake Pressure')
self.rearBrakeAxes.set_xlim(0,500)
self.rearBrakeAxes.set_ylim(0,100)
self.rearBrakeAxes.hold(True)
self.rearBrakeCanvas = FigureCanvasTkAgg(self.rearBrakeFigure, master=self.brakeFrame)
self.rearBrakeCanvas.show()
# Layout
# Pack Brake Pressure
self.frontBrakeCanvas.get_tk_widget().grid(column = 0, row=0, sticky=N)
# self.frontBrakeCanvas._tkcanvas.grid(column=0, row=0, sticky=N)
self.rearBrakeCanvas.get_tk_widget().grid(column=0, row=1, sticky=S)
# self.rearBrakeCanvas._tkcanvas.grid(column=0, row=1, sticky=S)
# Pack Drive Train RPM
# Pack Drive Train Temp
self.gearTempCanvas.get_tk_widget().grid(column = 0, row=0, sticky=W)
# self.gearTempCanvas._tkcanvas.grid(column=0, row=0, sticky=W)
self.cvtTempCanvas.get_tk_widget().grid(column=1, row=0, sticky=E)
# self.cvtTempCanvas._tkcanvas.grid(column=1, row=0, sticky=E)
# Pack stuff into top left
# self.speedTextBox.grid(column=1, row=0, sticky=NSEW)
self.zCanvas.get_tk_widget().grid(column=0, row=0, sticky=NSEW)
self.steeringCanvas.get_tk_widget().grid(column=1, row=0, sticky=NSEW)
self.speedCanvas.get_tk_widget().grid(column=2, row=0 , sticky=NSEW)
# self.speedCanvas._tkcanvas.grid(column=2 , row=0 , sticky=NSEW)
# Pack stuff into middle left
self.accCanvas.get_tk_widget().grid(column=0 , row=1 , sticky=W )
# self.accCanvas._tkcanvas.grid(column=0 , row=1 , sticky=W )
self.brakeFrame.grid(column=1 , row=1 , sticky=E)
# Pack stuff into bottom left
self.driveTrainTempFrame.grid(column=0 , row=5 , sticky=N )
self.driveTrainRPMFrame.grid(column=0 , row=6 , sticky=S )
# Pack Left Display
self.topLeftDisplayFrame.grid(column=0 , row=2 , sticky=NSEW )
self.middleLeftDisplayFrame.grid(column=0 , row=4 , sticky=NSEW )
self.bottomLeftDisplayFrame.grid(column=0 , row=6 , sticky=NSEW )
# Pack Shield Temp
self.dashTempCanvas.get_tk_widget().grid(column=0 , row=5 )
# self.dashTempCanvas._tkcanvas.grid(column=0 , row=5 , sticky=W )
self.rearTempCanvas.get_tk_widget().grid(column=1 , row=5 )
# self.rearTempCanvas._tkcanvas.grid(column=1 , row=5 , sticky=E )
# Pack Shield Health
# Pack stuff inside right display
self.gpsCanvas.get_tk_widget().grid(column=4 , row=2 , sticky=NSEW )
# self.gpsCanvas._tkcanvas.grid(column=4 , row=2 , sticky=NSEW )
self.shieldTempFrame.grid(column=4 , row=5 , sticky=N )
self.shieldHealthFrame.grid(column=4 , row=6 , sticky=N )
# TODO: Button Press notification goes here...
# Pack Display Frame
self.leftDisplayFrame.grid(column=0 , row=3 , sticky=NS )
self.rightDisplayFrame.grid(column=5 , row=3 , sticky=NS )
# Pack Display Into Root
self.displayFrame.grid(column=0 , row=2 , sticky=NSEW )
# Initialize Data Variables
# Dash Data
# self.counter.set(0) # Commented to preserve initial text value, left here to preserve variable order/index
# self.gpsDate = 0
# self.gpsTime = 0
# self.numSats = 0
self.latitude = [32236562]
self.longitude = [-110952322]
self.speed = [0]*102
self.dashTemp = [0]*102
# self.batteryVoltage = 0
# self.xbeeSignalStrength = 0
self.frontBrakeAvg = [0]
self.frontBrakeMax = [0]
self.rearBrakeAvg = [0]
self.rearBrakeMax = [0]
self.steeringAvg = [0]
# self.buttonPressed = 0
# Rear Board Data
self.primaryRPM = 0
self.secondaryRPM = 0
# Accelerometer
self.accX = [0]
self.maxX = [0]
self.accY = [0]
self.maxY = [0]
self.accZ = [0]
self.maxZ = [0]
#
self.rearTemp = [0]
self.hundred_array = list(range(0,102))
self.gpsBackground = self.gpsCanvas.copy_from_bbox(self.gpsAxes.bbox)
self.speedBackground = self.speedCanvas.copy_from_bbox(self.speedAxes.bbox)
self.dashTempBackground = self.dashTempCanvas.copy_from_bbox(self.dashTempAxes.bbox)
self.gpsPlot = self.gpsAxes.plot(self.longitude, self.latitude, '-')[0]
self.speedPlot = self.speedAxes.plot(self.hundred_array,self.speed)[0]
self.dashTempPlot = self.dashTempAxes.plot(self.hundred_array, self.dashTemp)[0]
# Create Queues for talking to serial line asyncronously
self.rx = queue.Queue()
self.tx = queue.Queue()
def StartSerial(self):
self.listbox.insert(0, "Baud Rate: " + self.COMBaud.get())
self.listbox.insert(0, "COM Port: " + self.COMPort.get())
self.numActiveThreads.set('Threads\n' + str(threading.enumerate().__len__()))
if (threading.enumerate().__len__()!=1):
self.serialThread.join()
#print(threading.enumerate().__len__())
self.numActiveThreads.set('Threads\n' + str(threading.enumerate().__len__()))
self.serialThread = SerialThread(self.COMPort, self.COMBaud, self.rx, self.tx)
self.serialThread.start()
self.numActiveThreads.set('Threads\n' + str(threading.enumerate().__len__()))
self.process_serial()
def StopSerial(self):
self.listbox.insert(0, "Serial Stopped")
if (threading.enumerate().__len__()!=1):
self.serialThread.join()
self.numActiveThreads.set('Threads\n' + str(threading.enumerate().__len__()))
def PitNow(self):
self.listbox.insert(0, "Pit Now")
self.tx.put("<PIT NOW>\n")
def PitNextLap(self):
self.listbox.insert(0, "Pit Next Lap")
self.tx.put("<PIT NEXT LAP>\n")
def SendOnReturn(self, event):
self.SendToSerial()
def StartSerialOnReturn(self, event):
self.StartSerial()
def SendToSerial(self):
text_contents = self.SerialSendTextBox.get()
self.listbox.insert(0, text_contents)
self.tx.put(text_contents)
self.SerialSendTextBox.delete(0,END)
def SendToDriver(self):
text_contents = self.SerialSendTextBox.get()
self.listbox.insert(0, text_contents)
self.tx.put('<')
self.tx.put(text_contents)
self.tx.put('>')
self.SerialSendTextBox.delete(0,END)
def process_serial(self):
text = StringVar()
if self.rx.qsize():
# self.listbox.delete(0,END)
try:
dataString = self.rx.get()
except Queue.Empty:
pass
self.listbox.insert(0, dataString)
data = dataString.split(bytes(', ','UTF-8'))
print(data.__len__())
if(data.__len__()==18 or data.__len__()==28):
try:
i = 0
# Dash Data
self.counter.set('Counter\n' + str(int(data[0])))
i = 1
self.gpsDate.set('Date\n' + str(int(data[1])))
i = 2
self.gpsTime.set('Time\n' + str(int(data[2])))
i = 3
self.numSats.set('Sats\n' + str(int(data[3])))
if (float(data[4])/1000000 < 100 and float(data[5])/1000000 < 200):
i = 4
self.latitude.append(int(data[4]))
self.currentLatitude.set('Latitude\n' + str(int(data[4])))
i = 5
self.longitude.append(int(data[5]))
self.currentLongitude.set('Longitude\n' + str(int(data[5])))
i = 6
self.speed.append(float(data[6]))
self.currentSpeed.set('Speed\n' + str(float(data[6])))
self.currentSpeed.set('Speed\n' + str(float(data[6])))
i = 7
self.dashTemp.append(float(data[7]))
self.currentDashTemp.set('Dash Temp\n' + str(float(data[7])) + 'C')
i = 8
self.batteryVoltage.set('Batt\n' + str(int(data[8])))
i = 9
self.xbeeSignalStrength.set('XBee\n' + str(int(data[9])))
i = 10
self.frontBrakeAvg.append(float(data[10]))
i = 11
self.frontBrakeMax.append(int(data[11]))
i = 12
self.rearBrakeAvg.append(float(data[12]))
i = 13
self.rearBrakeMax.append(int(data[13]))
i = 14
self.steeringAvg.append(float(data[14]))
i = 15
# self.buttonPressed = int(data[15])
i = 16
#
# # Rear Board Data
# self.primaryRPM = 0
# self.secondaryRPM = 0
#
#
# # Accelerometer
# self.accX = [0]
# self.maxX = [0]
# self.accY = [0]
# self.maxY = [0]
# self.accZ = [0]
# self.maxZ = [0]
#
# #
# self.rearTemp = [0]
except:
print('Exception Raised!' + str(i))
pass
self.gpsCanvas.restore_region(self.gpsBackground)
self.gpsPlot.set_data(self.longitude[1:], self.latitude[1:])
self.gpsAxes.draw_artist(self.gpsPlot)
self.gpsCanvas.blit(self.gpsAxes.bbox)
self.speedCanvas.restore_region(self.speedBackground)
self.speedPlot.set_data(self.hundred_array[-101:], self.speed[-101:])
self.speedAxes.draw_artist(self.speedPlot)
self.speedCanvas.blit(self.speedAxes.bbox)
self.dashTempCanvas.restore_region(self.dashTempBackground)
self.dashTempPlot.set_data(self.hundred_array[-101:], self.dashTemp[-101:])
self.dashTempAxes.draw_artist(self.dashTempPlot)
self.dashTempCanvas.blit(self.dashTempAxes.bbox)
self.after(100, self.process_serial)
# Graceful Exit
def destroy(e):
sys.exit()
class Root(Widget, Generic[_T]):
tk_widget: Optional[tk.Frame]
canvas: Optional[FigureCanvasTkAgg]
background_img: Optional[FigureImage]
def __init__(self,
params,
w: int = 1429,
h: int = 799,
dpi: int = 141,
color: str = '#000000',
**kwargs) -> None:
Widget.__init__(self)
self.params = params
self.w = w
self.h = h
self.dpi = dpi
self.face_color = color
matplotlib_config()
self.fig: plt.Figure = plt.figure(
figsize=(self.w / self.dpi, self.h / self.dpi),
dpi=self.dpi,
facecolor=self.face_color,
)
self.gs = self.fig.add_gridspec(nrows=90,
ncols=160,
left=0,
right=1,
top=1,
bottom=0,
hspace=0,
wspace=0)
self.properties = kwargs
self.artists = {}
self.tk_widget = None
self.canvas = None
self.background_img = None
self._bg = None
self._initialized = None
self.__post_init__()
def for_tk(self, parent: Union[tk.Tk, tk.Frame, tk.Canvas]) -> tk.Canvas:
self.tk_widget = parent
self.canvas = FigureCanvasTkAgg(self.fig, master=parent)
widget = self.canvas.get_tk_widget()
widget.pack(fill=tk.BOTH, expand=1)
return widget
@staticmethod
def load_img(fp: PATH_LIKE) -> np.array:
return plt.imread(cbook.get_sample_data(fp))
@timer
def save_img(self, fp: PATH_LIKE) -> None:
self.fig.savefig(fp, transparent=True)
@timer
def set_background_from_img(self, img_array: np.array) -> None:
self.background_img = plt.figimage(img_array)
self.background_img.set_zorder(-999)
def update(self, iteration_data: ITERATION_DATA) -> None:
raise NotImplementedError
def init(self) -> None:
self._initialized = self._initialized or self.init_results() or True
self.reset_results()
self._bg = self._bg or self.canvas.copy_from_bbox(
self.canvas.figure.bbox)
self.draw_artists()
def draw_artists(self) -> None:
self.canvas.restore_region(self._bg)
list(map(self.canvas.figure.draw_artist, self.animated))
self.canvas.blit(self.canvas.figure.bbox)
def __call__(self, iteration_data: List[ITERATION_DATA]):
if hasattr(iteration_data, '__iter__'):
list(map(self.update, iteration_data))
else:
self.update(iteration_data)
self.draw_artists()
def _set_background(self) -> None:
pass
def populate_from_iteration(self, iteration) -> None:
raise NotImplementedError
def _init_results(self) -> None:
pass
def set_result(self, *args) -> None:
pass
def _reset_results(self) -> None:
pass
def add_elements():
global sa, playing, segment_playing, txt, my_thread, listbox, selection_A, ax1, ax2, bg
global selection_B, left_select, right_select, max_wpm, x_scale, words_inwin
global words_inwin, left_sel, audiopos, zoom_in, constructed
global time_axis, fig, fig2, canvas, canvas2, step_width, stream
constructed = True
#audioname = 'semi_files//data//grav1.wav'
#textname = 'semi_files//data//grav1.txt'
tmpfolder = 'semi_files//data//tempalign'
sa = SegmentAligner(audioname, textname, tmpfolder)
#%% read all the data
n_frames = sa.audio.getnframes()
sr = sa.audio.getframerate()
time_axis = np.arange(0, n_frames / sr, 1 / sr)
sa.audio.setpos(sa.audio_sel[0])
#struct.unpack(str(2*n_frames) + 'B', sa.audio.readframes(n_frames))
data_all = np.frombuffer(sa.audio.readframes(n_frames), dtype=np.int16)
sa.audio.setpos(sa.audio_sel[0])
playing = False
segment_playing = False
txt = None
my_thread = None
listbox = None
selection_A = 0
selection_B = time_axis[-1]
left_select = False
right_select = False
max_wpm = 400 # 200 is realistic
x_scale = 20
words_inwin = round(x_scale * (max_wpm / 60))
step_width = 5
left_sel = 0
audiopos = 0
zoom_in = 1
#% --- create the figure for the audioplot
fig = Figure(figsize=(8.5, 1.5), dpi=100,
frameon=False) #means 1 inch = 100 pixels
gs = fig.add_gridspec(5, 1)
fig.add_subplot(gs[0:3, 0])
ax1 = fig.gca()
ax1.plot(time_axis[0:-1:200],
data_all[0:-1:200],
'-',
color='dimgray',
lw=0.5)
ax1.get_yaxis().set_ticks([])
ax1.set_xlim([0, x_scale]) # this works in audio, if pos> half of time a
# ax1.text(1, 0,"test", fontsize = 6, bbox=dict(pad = 0, facecolor='red', lw = 0 ), animated=False)
# fig.set_tight_layout(True)
# fig.tight_layout()
fig.tight_layout(pad=0.01, w_pad=0.01, h_pad=0.01)
fig.add_subplot(212).plot(time_axis,
np.empty((len(time_axis), 1)),
color='dimgray',
lw=0.2)
ax2 = fig.gca()
ax2.get_yaxis().set_ticks([])
ax2.get_xaxis().set_ticks([])
ax2.set_ylim([0, 1])
ax2.set_xlim([0, x_scale])
canvas = FigureCanvasTkAgg(fig, master=root)
canvas.draw()
# canvas.flush_events()
# lines = ax1.get_lines()
# for line in lines:
# line.set_animated(True)
# fig.draw_artist(line)
canvas.get_tk_widget().place(x=0, y=30, width=850, height=220)
#% --- create the figure for the labelplot
# fig2 = Figure(figsize = (8.5,0.5), dpi=100,frameon=False) #means 1 inch = 100 pixels
# fig2.add_subplot(111).plot(time_axis, np.empty((len(time_axis),1))
# , color = 'dimgray', lw = 0.2)
# fig2.gca().get_yaxis().set_ticks([])
# fig2.gca().get_xaxis().set_ticks([])
# fig2.tight_layout(pad=0.1)
# fig2.gca().set_ylim([0,1])
# fig2.gca().set_xlim([0,x_scale]) # this works in audio, if pos> half of time a
# canvas2 = FigureCanvasTkAgg(fig2, master = root)
# canvas2.draw()
# canvas2.get_tk_widget().place(x = 0, y = 180, width=850, height=150)
# define the audio stream which also updates the xposition
#frame_count = 1024
p = pyaudio.PyAudio()
stream = p.open(format=p.get_format_from_width(sa.audio.getsampwidth()),
channels=sa.audio.getnchannels(),
rate=sa.audio.getframerate(),
output=True,
stream_callback=callback,
start=False)
canvas.mpl_connect('button_press_event', onclick)
align_button = tk.Button(root, text="align", command=align)
align_button.place(x=850, y=505, width=150, height=25)
txt_update_button = tk.Button(root, text='update', command=txt_update)
txt_update_button.place(x=0, y=505, width=50, height=25)
txt = tk.Text(root,
wrap=tk.WORD,
bg='grey12',
fg='gold',
inactiveselectbackground="red",
selectbackground='red',
insertbackground='red')
# replace this with a canvas!
scroll = tk.Scrollbar(txt)
scroll.pack(side=tk.RIGHT, fill=tk.Y)
# Configure the scrollbars
# scroll.config(command=txt.yview)
txt['yscrollcommand'] = scroll.set
txt.place(x=0, y=270, width=850, height=240)
add_text()
#text['yscrollcommand'] = scrollbar1.set
#word_axis = np.arange(1/sr, len(time_axis)-1/sr, len(sa.all_aligned_words))
#txt.tag_config(word[0], background="yellow", foreground="red")
#for word in sa.all_aligned_words:
#print(txt.index('testtag'))
#print(txt.get("1.0","end" ))
#print(txt.get("%d.%d" % (1, 3),"%d.%d" % (1, 8)))
# Creating a Listbox and
# attaching it to root window
listbox = tk.Listbox(root, selectmode="extended")
# Adding Listbox
listbox.place(x=850, y=30, width=150, height=480)
# Creating a Scrollbar and
# attaching it to listbox
scrollbar = tk.Scrollbar(listbox)
# Adding Scrollbar to the right
# side of root window
scrollbar.pack(side=tk.RIGHT, fill=tk.BOTH)
fill_listbox()
# Attaching Listbox to Scrollbar
# Since we need to have a vertical
# scroll we use yscrollcommand
listbox.config(yscrollcommand=scrollbar.set)
# setting scrollbar command parameter
# to listbox.yview method its yview because
# we need to have a vertical view
scrollbar.config(command=listbox.yview)
if words_read:
for ii in range(len(words_read)):
if (words_read[ii][0] == sa.all_aligned_words[ii][0]) and (
words_read[ii][1] == sa.all_aligned_words[ii][1]):
sa.all_aligned_words[ii] = words_read[ii]
fill_listbox()
draw_words()
bg = canvas.copy_from_bbox(ax1.bbox)
class basemap(tk.Frame):
def __init__(self, parent, datPath, navcrs, body, to_gui):
self.parent = parent
self.datPath = datPath
self.navcrs = navcrs
self.body = body
self.to_gui = to_gui
# create tkinter toplevel window to display basemap
self.basemap_window = tk.Toplevel(self.parent)
img = tk.PhotoImage(file="../recs/basemap_icon.png")
self.basemap_window.tk.call("wm", "iconphoto", self.basemap_window._w,
img)
self.basemap_window.config(bg="#d9d9d9")
self.basemap_window.title("RAGU - Map Window")
self.map_display = tk.Frame(self.basemap_window)
self.map_display.pack(side="bottom", fill="both", expand=1)
# bind ctrl-q key to basemap_close()
self.basemap_window.bind("<Control-q>", self.basemap_close)
# bind x-out to basemap_close()
self.basemap_window.protocol("WM_DELETE_WINDOW", self.basemap_close)
self.cmap = tk.StringVar(value="Greys_r")
self.setup()
# setup the tkinter window
def setup(self):
# show basemap figure in basemap window
# generate menubar
menubar = tk.Menu(self.basemap_window)
fileMenu = tk.Menu(menubar, tearoff=0)
# settings submenu
loadMenu = tk.Menu(fileMenu, tearoff=0)
loadMenu.add_command(label="select files", command=self.load_tracks)
loadMenu.add_command(label="select folder",
command=lambda: self.load_tracks(dir=True))
fileMenu.add_cascade(label="load tracks", menu=loadMenu)
fileMenu.add_command(label="clear tracks", command=self.clear_nav)
fileMenu.add_command(label="preferences", command=self.settings)
fileMenu.add_command(label="exit [ctrl+q]",
command=self.basemap_close)
# add items to menubar
menubar.add_cascade(label="file", menu=fileMenu)
# add the menubar to the window
self.basemap_window.config(menu=menubar)
# set up info frame
infoFrame = tk.Frame(self.basemap_window)
infoFrame.pack(side="top", fill="both")
# button to toggle track visibility
self.track_viz = tk.BooleanVar(value=True)
tk.Label(infoFrame, text="track display: ").pack(side="left")
tk.Radiobutton(infoFrame,
text="all",
variable=self.track_viz,
value=True,
command=self.plot_tracks).pack(side="left")
tk.Radiobutton(infoFrame,
text="current",
variable=self.track_viz,
value=False,
command=self.plot_tracks).pack(side="left")
# initialize the basemap figure
self.map_fig = mpl.figure.Figure()
self.map_fig.patch.set_facecolor(self.parent.cget("bg"))
self.map_fig_ax = self.map_fig.add_subplot(111)
self.bm_im = self.map_fig_ax.imshow(np.ones((100, 100)),
cmap=self.cmap.get(),
aspect="auto")
self.map_fig_ax.set_visible(False)
self.map_fig_ax.set(xlabel="x [km]", ylabel="y [km]")
# initialize artists
self.track_ln, = self.map_fig_ax.plot([], [], "k.", ms=.1, picker=True)
self.track_start_ln, = self.map_fig_ax.plot([], [],
"go",
ms=3,
label="start")
self.track_end_ln, = self.map_fig_ax.plot([], [],
"ro",
ms=3,
label="end")
# pack mpl figure in canvas window
self.map_dataCanvas = FigureCanvasTkAgg(self.map_fig,
self.basemap_window)
self.map_dataCanvas.get_tk_widget().pack(in_=self.map_display,
side="bottom",
fill="both",
expand=1)
self.map_toolbar = NavigationToolbar2Tk(self.map_dataCanvas,
self.basemap_window)
self.map_dataCanvas._tkcanvas.pack()
self.basemap_state = 1
self.draw_cid = self.map_fig.canvas.mpl_connect(
"draw_event", self.update_bg)
self.pick_cid = self.map_fig.canvas.mpl_connect(
"pick_event", self.on_pick)
def set_vars(self):
# initialize arrays to hold track nav info
self.x = np.array(())
self.y = np.array(())
self.track_name = np.array(()).astype(dtype=np.str)
self.loaded_tracks = np.array(()).astype(dtype=np.str)
self.start_x = np.array(())
self.start_y = np.array(())
self.end_x = np.array(())
self.end_y = np.array(())
self.legend = None
self.pick_loc = None
self.profile_track = None
# map is a method to plot the basemap in the basemap window
def map(self, map_path):
# pull track up on dem basemap
if map_path:
print("Loading Basemap: ", map_path.split("/")[-1])
try:
# read in basemap
with rio.open(map_path, mode="r") as dataset:
# downsample if raster is too large
fac = 1
# if dataset.height >= 3e3 or dataset.width >= 3e3:
# fac = 4
# elif dataset.height >= 2e3 or dataset.width >= 2e3:
# fac = 3
if dataset.height >= 1e3 or dataset.width >= 1e3:
fac = 2
data = dataset.read(
out_shape=(dataset.count, int(dataset.height // fac),
int(dataset.width // fac)),
resampling=rio.enums.Resampling.nearest)
self.bmcrs = dataset.crs
# stack bands into numpy array
im = np.dstack((data))
if im.shape[-1] == 1:
im = im.reshape(im.shape[0], -1)
cmin = np.nanmin(im)
cmax = np.nanmax(im)
self.bm_im.set_clim([cmin, cmax])
self.bm_im.set_data(im)
# set bm image extent based on raster bounds - convert from m to km
self.bm_im.set_extent([
_i * 1e-3 for _i in [
dataset.bounds.left, dataset.bounds.right,
dataset.bounds.bottom, dataset.bounds.top
]
])
# save un-zoomed view to toolbar
self.map_toolbar.push_current()
self.map_fig_ax.set_visible(True)
self.map_dataCanvas.draw()
except Exception as err:
print("basemap load error: " + str(err))
pass
# set_track is a method to pass the track name loaded in profile view to the basemap class
def set_track(self, fn):
self.profile_track = fn
# set_nav is a method to update the navigation data plotted on the basemap
def set_nav(self, fn, navdf):
# skip if track already loaded to basemap
if fn in self.track_name:
return
# transform navcrs to basemap crs
x, y = pyproj.transform(
self.navcrs,
self.bmcrs,
navdf["lon"].to_numpy(),
navdf["lat"].to_numpy(),
)
# convert from m to km
x = x * 1e-3
y = y * 1e-3
# add x and y coords to x and y coord arrays
self.x = np.append(self.x, x)
self.y = np.append(self.y, y)
# add name to array to match with x,y
self.track_name = np.append(self.track_name, np.repeat(fn, len(x)))
self.start_x = np.append(self.start_x, x[0])
self.start_y = np.append(self.start_y, y[0])
self.end_x = np.append(self.end_x, x[-1])
self.end_y = np.append(self.end_y, y[-1])
# add name to list to match with endpoints
self.loaded_tracks = np.append(self.loaded_tracks, fn)
# plot_tracks is a method to plot track geom
def plot_tracks(self):
# if track_viz variable is true, add all track points to appropriate lines
if self.track_viz.get():
# set track line data
self.track_ln.set_data(self.x, self.y)
# set track ending line data
self.track_start_ln.set_data(self.start_x, self.start_y)
self.track_end_ln.set_data(self.end_x, self.end_y)
x_range = [np.amin(self.x) - 5, np.amax(self.x) + 5]
y_range = [np.amin(self.y) - 5, np.amax(self.y) + 5]
r = max(x_range[1] - x_range[0], y_range[1] - y_range[0])
x = np.median(x_range)
y = np.median(y_range)
self.map_fig_ax.axis([x - r, x + r, y - r, y + r])
# otherwise just set track points from last line to appropriate lines
else:
# set track ending line data
idx = np.where(self.loaded_tracks == self.profile_track)[0]
self.track_start_ln.set_data(self.start_x[idx], self.start_y[idx])
self.track_end_ln.set_data(self.end_x[idx], self.end_y[idx])
# set track line data
idx = np.where(self.track_name == self.profile_track)[0]
self.track_ln.set_data(self.x[idx], self.y[idx])
x_range = [np.amin(self.x[idx]) - 5, np.amax(self.x[idx]) + 5]
y_range = [np.amin(self.y[idx]) - 5, np.amax(self.y[idx]) + 5]
r = max(x_range[1] - x_range[0], y_range[1] - y_range[0])
x = np.median(x_range)
y = np.median(y_range)
self.map_fig_ax.axis([x - r, x + r, y - r, y + r])
if not self.legend:
self.legend = self.map_fig_ax.legend()
self.map_dataCanvas.draw()
self.blit()
# plot_idx is a method to plot the location of a click event on the datacanvas to the basemap
def plot_idx(self, fn, idx):
# basemap open, plot picked location regardless of picking state
if self.basemap_state == 1 and len(self.x) > 0:
# plot pick location on basemap
if self.pick_loc:
self.pick_loc.remove()
self.pick_loc = self.map_fig_ax.scatter(
self.x[self.track_name == fn][idx],
self.y[self.track_name == fn][idx],
c="b",
marker="X",
zorder=3)
self.blit()
# basemap_close is a method to close the basemap window
def basemap_close(self, event=None):
self.basemap_window.destroy()
self.basemap_state = 0
# get_state is a mathod to get the basemap state
def get_state(self):
return self.basemap_state
# clear_basemap is a method to clear the basemap
def clear_nav(self):
# clear arrays
self.track_name = np.array(()).astype(dtype=np.str)
self.loaded_tracks = np.array(()).astype(dtype=np.str)
self.x = np.array(())
self.y = np.array(())
self.start_x = np.array(())
self.start_y = np.array(())
self.end_x = np.array(())
self.end_y = np.array(())
# set lines
self.track_ln.set_data(self.x, self.y)
self.track_start_ln.set_data(self.start_x, self.start_y)
self.track_end_ln.set_data(self.end_x, self.end_y)
if self.legend:
self.legend.remove()
self.legend = None
if self.pick_loc:
self.pick_loc.remove()
self.pick_loc = None
self.map_fig.canvas.draw()
def safe_draw(self):
"""temporarily disconnect the draw_event callback to avoid recursion"""
canvas = self.map_fig.canvas
canvas.mpl_disconnect(self.draw_cid)
canvas.draw()
self.draw_cid = canvas.mpl_connect("draw_event", self.update_bg)
def update_bg(self, event=None):
"""
when the figure is resized, hide picks, draw everything,
and update the background.
"""
if self.pick_loc:
self.pick_loc.set_visible(False)
self.safe_draw()
self.axbg = self.map_dataCanvas.copy_from_bbox(
self.map_fig_ax.bbox)
self.pick_loc.set_visible(True)
self.blit()
else:
self.safe_draw()
self.axbg = self.map_dataCanvas.copy_from_bbox(
self.map_fig_ax.bbox)
self.blit()
def blit(self):
"""
update the figure, without needing to redraw the
"axbg" artists.
"""
self.map_fig.canvas.restore_region(self.axbg)
if self.pick_loc:
self.map_fig_ax.draw_artist(self.pick_loc)
self.map_fig.canvas.blit(self.map_fig_ax.bbox)
# load all tracks within a directory to basemap
def load_tracks(self, dir=False):
if dir:
tmp_datPath = ""
# select input file
tmp_datPath = tk.filedialog.askdirectory(title="select folder",
initialdir=self.datPath,
mustexist=True)
# if input selected, clear impick canvas, ingest data and pass to impick
if tmp_datPath:
# get list of data files in dir
flist = glob.glob(tmp_datPath + "/*")
print(tmp_datPath)
else:
flist = ""
# select input files
flist = tk.filedialog.askopenfilenames(title="select files",
initialdir=self.datPath,
multiple=True)
if flist:
flist = list(flist)
# iterate through file list and retrieve navdat from proper getnav function
for f in flist:
if f.endswith("h5"):
navdf = navparse.getnav_oibAK_h5(f, self.navcrs, self.body)
fn = f.split("/")[-1].rstrip(".h5")
elif f.endswith("mat"):
try:
navdf = navparse.getnav_cresis_mat(f, self.navcrs,
self.body)
fn = f.split("/")[-1].rstrip(".mat")
except:
navdf = navparse.getnav_oibAK_h5(f, self.navcrs, self.body)
fn = f.split("/")[-1].rstrip(".mat")
elif f.lower().endswith("dzg"):
navdf = navparse.getnav_gssi(f, self.navcrs, self.body)
fn = f.split("/")[-1].rstrip(".DZG")
elif f.endswith("tab"):
navdf = navparse.getnav_sharad(f, self.navcrs, self.body)
fn = f.split("/")[-1].rstrip("_geom.tab")
else:
continue
self.set_nav(fn, navdf)
# update datPath
self.datPath = os.path.dirname(os.path.abspath(f)) + "/"
# update extent
self.plot_tracks()
# settings menu
def settings(self):
settingsWindow = tk.Toplevel(self.basemap_window)
row = tk.Frame(settingsWindow)
row.pack(side=tk.TOP, fill=tk.X, padx=5, pady=5)
lab = tk.Label(row, width=10, text="cmap", anchor="w")
lab.pack(side=tk.LEFT)
tk.Radiobutton(row,
text="greys_r",
variable=self.cmap,
value="Greys_r").pack(side="top", anchor="w")
tk.Radiobutton(row, text="gray", variable=self.cmap,
value="gray").pack(side="top", anchor="w")
tk.Radiobutton(row,
text="terrain",
variable=self.cmap,
value="terrain").pack(side="top", anchor="w")
row = tk.Frame(settingsWindow)
row.pack(side=tk.TOP, anchor="c")
b1 = tk.Button(row, text="save", command=self.updateSettings)
b1.pack(side="left")
b2 = tk.Button(row, text="close", command=settingsWindow.destroy)
b2.pack(side="left")
# update settings
def updateSettings(self):
# pass cmap
self.bm_im.set_cmap(self.cmap.get())
# redraw
self.map_dataCanvas.draw()
# on_pick gets the picked track from user click
def on_pick(self, event):
# determine which track was selected
xdata = event.mouseevent.xdata
idx = utils.find_nearest(self.x, xdata)
track = self.track_name[idx]
# pass track to impick
if (track != self.profile_track) and (tk.messagebox.askyesno(
"Load", "Load track: " + str(track) + "?") == True):
self.to_gui(self.datPath, track)
class TensileTestView(tk.Frame):
def __init__(self, parent):
tk.Frame.__init__(self, parent) # Initialize this class as a frame
self.animationBgCol = "black" # Animation canvas background colour
# Create and configure main frame
mainArea = tk.Frame(self, bg=st.MAIN_AREA_BG)
mainArea.grid(row=0, column=0, sticky="nsew")
mainArea.grid_propagate(0)
self.grid_rowconfigure(0, weight=1)
self.grid_columnconfigure(0, weight=1)
# Create and configure main grids
grid = tuple([i for i in range(20)])
mainArea.grid_columnconfigure(grid, weight=1, minsize=50)
mainArea.grid_rowconfigure(grid, weight=1, minsize=35)
# Create title
label = tk.Label(mainArea,
text="Mechanical Workshop",
font=st.LARGE_FONT,
bg=st.MAIN_AREA_BG,
fg=st.TITLE_COLOUR)
label.grid(row=0, column=14, columnspan=6, sticky='nse')
# Create description
label = tk.Label(
mainArea,
text="We are now going to perform a tensile test on the " +
"sheet of aluminum that we cold rolled! We can see our sample of aluminum on the left side of "
+
"the screen as well as a stress-strain graph on the right side of the screen. "
+ "Press the start button to begin the tensile test!",
bg=st.INPUT_BG,
wraplength=650,
fg='black',
justify='left',
relief='ridge')
label.grid(row=1, column=6, rowspan=2, columnspan=14, sticky='nesw')
# Canvas for graphic simulation
self.height = 595
self.width = 250
self.animationWindow = tk.Canvas(mainArea,
bg=self.animationBgCol,
height=self.height,
width=self.width,
bd=0,
highlightthickness=0,
relief='ridge')
self.animationWindow.grid(row=2,
column=1,
columnspan=5,
rowspan=17,
sticky='ne')
# Create Plot
self.f = Figure(figsize=(6, 6), dpi=100)
self.a = self.f.add_subplot(111)
self.a.grid(color='grey', linestyle='-', linewidth=0.3)
self.a.set_ylabel('Stress (MPa)')
self.a.set_xlabel('Strain (-)')
self.line = self.a.plot([], [], "-")
self.a.format_coord = lambda x, y: "Strain (-)={:6.4f}, Stress (MPa)={:6.3f}".format(
x, y)
# Create canvas for plot
self.graphWindow = FigureCanvasTkAgg(self.f, mainArea)
self.graphWindow.get_tk_widget().grid(row=5,
column=6,
rowspan=12,
columnspan=12)
self.BG = self.graphWindow.copy_from_bbox(self.a.bbox)
self.OG = self.BG
# Load arrow images
self.arrow = ImageTk.PhotoImage(file=st.IMG_PATH + "left_arrow.png")
self.arrowClicked = ImageTk.PhotoImage(file=st.IMG_PATH +
"left_arrow_clicked.png")
self.arrowDisabled = ImageTk.PhotoImage(file=st.IMG_PATH +
"left_arrow_disabled.png")
# Arrow for previous page
self.nextPage = tk.Button(mainArea, image=self.arrow, borderwidth=0)
self.nextPage.image = self.arrow
self.nextPage.grid(row=9, rowspan=2, column=0, sticky='nesw')
# Button to start simulation
self.animationButton = ttk.Button(mainArea, text="Start")
self.animationButton.grid(row=3,
rowspan=2,
column=6,
columnspan=3,
sticky='nesw')
# Text for displaying cold work
self.CW_text = tk.Label(mainArea,
text='',
borderwidth=2,
bg=st.INPUT_BG,
font=st.MEDIUM_FONT)
self.CW_text.grid(row=0,
rowspan=2,
column=2,
columnspan=3,
sticky='nsew')
# Draw the rod
self.rod = Rod(self.animationWindow, self.width, self.height,
self.animationBgCol)
self.rod.drawRod()
# Create toolbar for plot
self.toolbar = NavigationToolbar2Tk(self.graphWindow, mainArea)
self.toolbar.update()
self.toolbar.grid(row=17,
column=6,
rowspan=2,
columnspan=10,
sticky='nsew')
# Draw mac logo
logoImg = ImageTk.PhotoImage(Image.open(st.IMG_PATH + "macLogo.png"))
canvas = tk.Canvas(mainArea,
bg=st.MAIN_AREA_BG,
width=130,
height=71,
bd=0,
highlightthickness=0,
relief='ridge')
canvas.create_image(130 / 2, 71 / 2, image=logoImg, anchor="center")
canvas.image = logoImg
canvas.grid(row=17, column=17, rowspan=3, columnspan=3)
def setGraphSize(self, x, y):
"""
Set the graph size. Assume it is called before any other function
"""
self.a.set_xlim([-0.01, x + 0.3])
self.a.set_ylim([0, y + 50])
self.graphWindow.draw()
self.BG = self.graphWindow.copy_from_bbox(self.a.bbox)
def pressArrow(self):
"""
Change arrow picture to "pressed arrow"
"""
self.nextPage.config(image=self.arrowClicked)
self.nextPage.image = self.arrowClicked
def normalArrow(self):
"""
Change arrow picture to "normal arrow"
"""
self.nextPage.config(image=self.arrow)
self.nextPage.image = self.arrow
def disableArrow(self):
"""
Change arrow picture to "disabled arrow"
"""
self.nextPage.config(image=self.arrowDisabled)
self.nextPage.image = self.arrowDisabled
def resetCanvas(self):
"""
Reset the rod on canvas
"""
self.rod.resetRod()
def setCW(self, val):
"""
Set the coldwork text
"""
self.CW_text.config(text="%CW = " + str(val))
def updateGraph(self, xvals, yvals):
"""
Update the graph with xvals and yvals. This function is called at a given framerate
"""
self.line[0].set_data(xvals, yvals)
self.graphWindow.restore_region(self.BG)
self.a.draw_artist(self.line[0])
self.graphWindow.blit(self.a.bbox)
self.graphWindow.flush_events()
def updateAnimation(self, elongation, widthFact, neckWidthFact,
neckHeightFact):
"""
Update the canvas based on given values. This function is called at a given framerate
"""
self.rod.updateRod(elongation, widthFact, neckWidthFact,
neckHeightFact)
def generateFracture(self, EL):
"""
Generate a fracture in the Rod. Function is called at the end of the animation
"""
self.rod.drawFracture(EL)
class MultichannelPlot(matplotlib.figure.Figure):
def __init__(self, master, row=0, column=0, rowspan=5, columnspan=5, width=5, height=3, update_prot="blit"):
matplotlib.figure.Figure.__init__(self, figsize=(width, height))
self.update_prot = update_prot
self.frame = Frame(master=master)
self.frame.config(bd=5)
self.frame.grid(row=row, column=column, padx=5, pady=5)
self.channel_list = []
self.array_list = []
self.color_list = ["r", "b", "g", "c", "m", "y", "k"]
self.a = self.add_subplot(MultichannelAxis(self, 111))
self.canvas = FigureCanvasTkAgg(self, master=self.frame)
self.canvas.show()
self.canvas._tkcanvas.pack(side=TOP, fill=BOTH, expand=True)
self.toolbar = NavigationToolbar2TkAgg(self.canvas, self.frame)
self.toolbar.update()
self.toolbar.pack(side=BOTTOM, fill=BOTH, expand=True) # ,expand = True)#fill=BOTH)#, expand=1)
self.canvas.draw()
self.background = self.canvas.copy_from_bbox(self.a.bbox)
return None
def AddChannel(self, spec_array, channel_type, color=None):
if color == None or color == "":
self.a.add_line(Channel([], [], self, spec_array, channel_type, color=self.color_list[0]))
self.color_list.append(self.color_list[0])
del (self.color_list[0])
else:
self.a.add_line(Channel([], [], self, spec_array, channel_type, color=color))
# self.Update()
self.Redraw()
return self.a.lines[-1]
def RemoveChannel(self, channel):
self.a.lines.remove(channel)
self.Redraw()
return 0
def SetChannelColor(self, channel, clr):
if clr != "":
channel.color = clr
else:
channel.color = self.color_list[0]
self.color_list.append(self.color_list[0])
del (self.color_list[0])
return 0
def ShowChannel(self, channel):
channel.set_visible(True)
self.Update()
return 0
def HideChannel(self, channel):
channel.set_visible(False)
self.Update()
return 0
def Redraw(self):
self.a.relim()
self.a.autoscale_view(tight=False)
self.canvas.draw()
self.canvas.restore_region(self.background)
for line in self.a.lines:
self.a.draw_artist(line)
self.canvas.blit(self.a.bbox)
return 0
def SaveFigure(self, filename):
self.f_copy = self.a
self.f_copy.savefig("a.png")
return 0
def Update(self):
if self.update_prot == "draw":
self.canvas.draw()
return 0
(lower_y_lim, upper_y_lim) = self.a.get_ylim()
(lower_x_lim, upper_x_lim) = self.a.get_xlim()
scaley_bool = False
scalex_bool = False
scaley_down_bool = True
for channel in self.a.lines:
if channel.get_visible() == True:
channel.ChannelUpdate()
scaley_bool = (
scaley_bool or max(channel.get_ydata()) > upper_y_lim or min(channel.get_ydata()) < lower_y_lim
)
scaley_down_bool = scaley_down_bool and max(channel.get_ydata()) < upper_y_lim * 0.6
scalex_bool = (
scalex_bool or max(channel.get_xdata()) != upper_x_lim or min(channel.get_xdata()) != lower_x_lim
)
if scaley_bool or scalex_bool or scaley_down_bool:
self.Redraw()
else:
self.canvas.restore_region(self.background)
for line in self.a.lines:
self.a.draw_artist(line)
self.canvas.blit(self.a.bbox)
return 0
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 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 wvpick(tk.Frame):
# wvpick is a class to optimize the picking of horizons from radar data
def __init__(self, parent, button_tip, reset_picks, *args, **kwargs):
tk.Frame.__init__(self, parent, *args, **kwargs)
self.parent = parent
self.button_tip = button_tip
self.reset_picks = reset_picks
self.winSize = tk.IntVar(value=100)
self.stepSize = tk.IntVar(value=10)
self.horVar = tk.StringVar()
self.segVar = tk.IntVar()
self.color = tk.StringVar()
self.interp_type = tk.StringVar()
self.interp_type.set("cubic")
self.setup()
def setup(self):
# set up frames
infoFrame0 = tk.Frame(self.parent)
infoFrame0.pack(side="top", fill="both")
infoFrame = tk.Frame(infoFrame0)
infoFrame.pack(side="left", fill="both")
interpFrame = tk.Frame(infoFrame0, width=450)
interpFrame.pack(side="right", fill="both")
interpFrame.pack_propagate(0)
toolbarFrame = tk.Frame(infoFrame)
toolbarFrame.pack(side="bottom", fill="both")
self.dataFrame = tk.Frame(self.parent)
self.dataFrame.pack(side="bottom", fill="both", expand=1)
# infoFrame exists for options to be added based on optimization needs
tk.Label(infoFrame,
text="Amplitude Window [#Samples]: ").pack(side="left")
entry = tk.Entry(infoFrame, textvariable=self.winSize, width=5)
entry.pack(side="left")
self.button_tip(self.parent, entry, \
"Pick amplitude window size. Window size (number of samples) centered on \
manual picks from which to select maximum amplitude using auto-pick optimization." )
tk.ttk.Separator(infoFrame, orient="vertical").pack(side="left",
fill="both",
padx=10,
pady=4)
tk.Label(infoFrame, text="Step Size [#Traces]: ").pack(side="left")
entry = tk.Entry(infoFrame, textvariable=self.stepSize, width=5)
entry.pack(side="left")
self.button_tip(self.parent, entry, \
"Number of traces to move forward and backwards in radargram upon ←/→ button or key press.")
tk.ttk.Separator(infoFrame, orient="vertical").pack(side="left",
fill="both",
padx=10,
pady=4)
button = tk.Button(infoFrame,
text="←",
command=self.stepBackward,
pady=0)
button.pack(side="left")
self.button_tip(self.parent, button, "Step backwards")
button = tk.Button(infoFrame,
text="→",
command=self.stepForward,
pady=0)
button.pack(side="left")
self.button_tip(self.parent, button, "Step forwards")
tk.ttk.Separator(infoFrame, orient="vertical").pack(side="left",
fill="both",
padx=10,
pady=4)
# set up frame to hold pick information
interpFrameT = tk.Frame(interpFrame)
interpFrameT.pack(fill="both", expand=True)
interpFrameT.pack_propagate(0)
interpFrameB = tk.Frame(interpFrame)
interpFrameB.pack(fill="both", expand=True)
interpFrameB.pack_propagate(0)
interpFrameTl = tk.Frame(interpFrameT,
width=250,
relief="ridge",
borderwidth=1)
interpFrameTl.pack(side="left", fill="both", expand=True)
interpFrameTl.pack_propagate(0)
interpFrameTr = tk.Frame(interpFrameT, width=200)
interpFrameTr.pack(side="left", fill="both", expand=True)
interpFrameTr.pack_propagate(0)
interpFrameBl = tk.Frame(interpFrameB,
width=250,
relief="ridge",
borderwidth=1)
interpFrameBl.pack(side="left", fill="both", expand=True)
interpFrameBl.pack_propagate(0)
interpFrameBr = tk.Frame(interpFrameB, width=200)
interpFrameBr.pack(side="left", fill="both", expand=True)
interpFrameBr.pack_propagate(0)
tk.Label(interpFrameTl,
text="{0:<8}".format("Horizon:")).pack(side="left")
button = tk.Button(interpFrameTl,
text="Reset",
width=6,
command=self.reset)
button.pack(side="right")
self.button_tip(self.parent, button,
"Reset pick data from profile interpretations")
self.horMenu = tk.OptionMenu(interpFrameTl, self.horVar, *[None])
self.horMenu.pack(side="right")
self.horMenu.config(width=10)
self.horVar.trace("w", self.update_seg_opt_menu)
self.horVar.trace("w", self.seg_select)
self.horVar.trace(
"w", lambda *args, menu=self.horMenu: self.set_menu_color(menu))
tk.Label(interpFrameBl,
text="{0:<8}".format("Segment:")).pack(side="left")
button = tk.Button(interpFrameBl, text=None, width=6, command=None)
button.config(relief="sunken", state="disabled")
button.pack(side="right")
self.segMenu = tk.OptionMenu(interpFrameBl, self.segVar, *[None])
self.segMenu.pack(side="right")
self.segMenu.config(width=10)
self.segVar.trace("w", self.first_trace)
button = tk.Radiobutton(interpFrameTr,
text="Linear",
variable=self.interp_type,
value="linear")
button.pack(side="left", fill="both", expand=True)
self.button_tip(
self.parent, button,
"Linear interpolation between manual pick modifications")
button = tk.Radiobutton(interpFrameTr,
text="Cubic Spline",
variable=self.interp_type,
value="cubic")
button.pack(side="left", fill="both", expand=True)
self.button_tip(
self.parent, button,
"Cubic spline interpolation between manual pick modifications")
button = tk.Button(interpFrameBr,
text="Auto-Optimize",
command=self.auto_repick)
button.pack(side="left", fill="both", expand=True)
self.button_tip(
self.parent, button,
"Automatically optimize profile view interpretation picks for current horizon segment\
by selecting maximum aplitude sample for each radargram trace within a window of the\
specified size centered on existing profile picks."
)
button = tk.Button(interpFrameBr,
text="Interpolate",
command=self.interp_repick)
button.pack(side="left", fill="both", expand=True)
self.button_tip(
self.parent, button,
"Interpolate between manually updated waveform picks using the spefied interpolation method\
for current horizon segment.")
# create figure object and datacanvas from it
plt.rcParams.update({'font.size': 12})
self.fig = mpl.figure.Figure()
self.fig.patch.set_facecolor("#d9d9d9")
self.dataCanvas = FigureCanvasTkAgg(self.fig, self.parent)
self.dataCanvas.get_tk_widget().pack(in_=self.dataFrame,
side="bottom",
fill="both",
expand=1)
self.click = self.fig.canvas.mpl_connect("button_press_event",
self.onpress)
self.unclick = self.fig.canvas.mpl_connect('button_release_event',
self.onrelease)
self.draw_cid = self.fig.canvas.mpl_connect("draw_event",
self.update_bg)
self.mousemotion = self.fig.canvas.mpl_connect('motion_notify_event',
self.on_mouse_move)
# add toolbar to plot
self.toolbar = NavigationToolbar2Tk(self.dataCanvas, toolbarFrame)
self.toolbar.pack(side="left")
# self.toolbar.update()
# create the figure axes
self.ax = self.fig.add_subplot(111)
self.fig.tight_layout(rect=[.02, .05, .97, 1])
self.ax.set_visible(False)
# update the canvas
self.dataCanvas._tkcanvas.pack()
self.dataCanvas.draw()
# set up variables
def set_vars(self):
self.rdata = None
self.horizon_paths_opt = None
self.ln_colors = {}
self.horizons = []
self.repick_idx = {
} # dictionary of indeces of repicked traces for each seg
self.t = None # hold current trace number
# set_data is a method to receive the radar data
def set_data(self, rdata):
# get data in dB
self.rdata = rdata
# receive horizon paths from impick
def set_horizon_paths(self, horizon_paths):
self.horizon_paths = copy.deepcopy(horizon_paths)
self.horizon_paths_opt = copy.deepcopy(horizon_paths)
self.horizons = list(self.horizon_paths_opt)
self.nhorizons = len(self.horizons)
self.update_hor_opt_menu()
self.update_seg_opt_menu()
# return optimized horizon paths
def get_horizon_paths(self):
return self.horizon_paths_opt
# receive horizon line colors
def set_horizon_colors(self, ln_colors):
self.ln_colors = ln_colors
# reset returns updated picks from gui
def reset(self):
if tk.messagebox.askyesno("Reset",
"Reset optimized horizon interpretations?"):
self.reset_picks(force=True)
# set_picks is a method which receives horizon interpretations for optimization
def set_picks(self):
self.ax.set_visible(True)
# create lists of first and last picked trace number for each seg in each horizon
self.segment_traces = {}
# create dict to hold current trace number for each horizon
self.trace = {}
if self.nhorizons > 0:
# iterate through horizon_paths
for horizon, hdict in self.horizon_paths_opt.items():
self.segment_traces[horizon] = bounds([], [])
self.repick_idx[horizon] = []
self.trace[horizon] = None
# iterate through segments for each horizon
for seg, path in hdict.items():
picked_traces = np.where(~np.isnan(path.x))[0]
if picked_traces.shape[0] > 0:
self.segment_traces[horizon].first.append(
picked_traces[0])
self.segment_traces[horizon].last.append(
picked_traces[-1])
if seg == 0:
self.trace[horizon] = picked_traces[0]
# set horVar
self.horVar.set(self.horizons[-1])
else:
self.trace[""] = 0
# plot_wv is a method to draw the waveform on the datacanvas
def plot_wv(self, *args):
horizon = self.horVar.get()
seg = self.segVar.get()
winSize = self.winSize.get()
# get previous x_lim
xlim = self.ax.get_xlim()
self.ax.clear()
# plot trace power
self.t = self.trace[horizon]
self.ax.plot(self.rdata.proc.curr_dB[:, self.t], c="0.5")
self.ax.set(xlabel="Sample",
ylabel="Power [dB]",
title="Trace: " + str(int(self.trace[horizon] + 1)) + "/" +
str(int(self.rdata.tnum)))
# get pick value range
val = np.array(())
# if self.nhorizons > 0:
for horizon in self.horizons:
# get sample index of pick for given trace
for seg in self.horizon_paths_opt[horizon].keys():
pick_idx0 = self.horizon_paths[horizon][seg].y[self.t]
pick_idx1 = self.horizon_paths_opt[horizon][seg].y[self.t]
val = np.append(val, (pick_idx0 + pick_idx1) // 2)
if not np.isnan(pick_idx0):
self.ax.axvline(x=pick_idx0,
c=self.ln_colors[horizon],
label=horizon + "_" + str(seg))
if not np.isnan(pick_idx1) and (pick_idx0 != pick_idx1):
self.ax.axvline(x=pick_idx1,
c=self.ln_colors[horizon],
ls="--",
label=horizon + "_" + str(seg) + "_v2")
self.ax.set(xlim=(0, self.rdata.snum))
# save un-zoomed view to toolbar
self.toolbar.push_current()
# zoom in to window around horizons
if not np.isnan(val).all():
if xlim == (0, 1) or xlim == (0, self.rdata.snum):
min_ = np.nanmin(val) - (2 * winSize)
max_ = np.nanmax(val) + (2 * winSize)
self.ax.set(xlim=(min_, max_))
else:
self.ax.set(xlim=xlim)
if len(self.ax.lines) > 1:
self.ax.legend(loc="lower right")
# initialize cursor crosshair lines
self.horizontal_line = self.ax.axhline(color="r", lw=1, ls=":")
self.vertical_line = self.ax.axvline(color="r", lw=1, ls=":")
self.dataCanvas.draw()
# full extent for trace
def fullExtent(self):
horizon = self.horVar.get()
self.ax.set_xlim(0, self.rdata.snum)
self.ax.set_ylim(self.rdata.proc.curr_dB[:, self.trace[horizon]].min(),
self.rdata.proc.curr_dB[:, self.trace[horizon]].max())
self.dataCanvas.draw()
# stepBackward is a method to move backwards by the number of traces entered to stepSize
def stepBackward(self):
horizon = self.horVar.get()
seg = self.segVar.get()
step = self.stepSize.get()
newTrace = self.trace[horizon] - step
if self.nhorizons > 0:
firstTrace_seg = self.segment_traces[horizon].first[seg]
if newTrace >= firstTrace_seg:
self.trace[horizon] -= step
elif newTrace < firstTrace_seg:
if self.trace[horizon] == firstTrace_seg:
return
else:
self.trace[horizon] = firstTrace_seg
else:
if newTrace >= 0:
self.trace[0] -= step
elif newTrace < 0:
if self.trace[0] == 0:
return
else:
self.trace[0] = 0
self.plot_wv()
# stepForward is a method to move forward by the number of traces entered to stepSize
def stepForward(self):
horizon = self.horVar.get()
seg = self.segVar.get()
step = self.stepSize.get()
newTrace = self.trace[horizon] + step
if self.nhorizons > 0:
lastTrace_seg = self.segment_traces[horizon].last[seg]
if newTrace <= lastTrace_seg:
self.trace[horizon] += step
# if there are less traces left in the pick seg than the step size, move to the last trace in the seg
elif newTrace > lastTrace_seg:
if self.trace[horizon] == lastTrace_seg:
return
# if seg + 2 <= self.nhorizons and tk.messagebox.askokcancel("Next Sement","Finished optimization of current pick seg\n\tProceed to next seg?") == True:
# self.segVar.set(seg + 1)
else:
self.trace[horizon] = self.segment_traces[horizon].last[
seg]
else:
if newTrace <= self.rdata.tnum:
self.trace[0] += step
elif newTrace > self.rdata.tnum:
if self.trace[0] == self.rdata.tnum - 1:
return
else:
self.trace[0] = self.rdata.tnum - 1
self.plot_wv()
# seg_select
def seg_select(self, *args):
if self.t is None:
return
horizon = self.horVar.get()
seg = self.segVar.get()
self.trace[horizon] = self.t
t0_list = self.segment_traces[horizon].first
t1_list = self.segment_traces[horizon].last
# if switched horizon, select segment which has current trace, if any
for _i in range(len(t0_list)):
if (t0_list[_i] < self.t) and (t1_list[_i] > self.t):
self.segVar.set(_i)
self.t = None
break
else:
continue
# first_trace updates the segment selection sets self.trace[horizon] to the first trace for the selected segment and replots
def first_trace(self, *args):
if self.t is not None:
horizon = self.horVar.get()
seg = self.segVar.get()
t0_list = self.segment_traces[horizon].first
if seg > len(t0_list):
return
self.trace[horizon] = t0_list[seg]
# reset xlim
self.ax.set(xlim=(0, self.rdata.snum))
self.plot_wv()
# auto_repick is a method to automatically optimize subsurface picks by selecting the maximul amplitude sample within the specified window around existing picks
def auto_repick(self):
if self.nhorizons > 0:
horizon = self.horVar.get()
seg = self.segVar.get()
winSize = self.winSize.get()
x = np.arange(self.segment_traces[horizon].first[seg],
self.segment_traces[horizon].last[seg] + 1)
y = self.horizon_paths[horizon][seg].y[x]
for _i in range(len(x)):
if not np.isnan(y[_i]):
# find argmax for window for given data trace in pick
max_idx = np.nanargmax(self.rdata.proc.curr_dB[
int(y[_i] - (winSize / 2)):int(y[_i] + (winSize / 2)),
x[_i]])
# add argmax index to pick_dict1 - account for window index shift
self.horizon_paths_opt[horizon][seg].y[
x[_i]] = max_idx + int(y[_i] - (winSize / 2))
self.plot_wv()
# manual_repick is a method to manually adjust existing picks by clicking along the displayed waveform
def manual_repick(self, event):
if (not self.nhorizons > 0) or (event.inaxes != self.ax):
return
horizon = self.horVar.get()
seg = self.segVar.get()
# append trace number to repick_idx list to keep track of indeces for interpolation
if (len(self.repick_idx[horizon])
== 0) or (self.repick_idx[horizon][-1] != self.trace[horizon]):
self.repick_idx[horizon].append(self.trace[horizon])
self.horizon_paths_opt[horizon][seg].y[self.trace[horizon]] = int(
event.xdata)
self.plot_wv()
# interp_repick is a method to interpolate between manually refined subsurface picks
def interp_repick(self):
horizon = self.horVar.get()
seg = self.segVar.get()
interp = self.interp_type.get()
if len(self.repick_idx[horizon]) < 2:
return
# get indeces of repicked traces
xp = self.repick_idx[horizon]
# generate array of indices between first and last optimized pick
interp_idx = np.arange(xp[0], xp[-1] + 1)
if interp == "linear":
# get twtt values at repicked indicesself.pick_dict1
fp = self.horizon_paths_opt[horizon][seg].y[xp]
# interpolate repicked values for seg
self.horizon_paths_opt[horizon][seg].y[interp_idx] = np.interp(
interp_idx, xp, fp)
elif interp == "cubic":
# cubic spline between picks
cs = CubicSpline(xp, self.horizon_paths_opt[horizon][seg].y[xp])
# add cubic spline output interpolation to pick dictionary
self.horizon_paths_opt[horizon][seg].y[interp_idx] = cs(
[interp_idx]).astype(int)
# set tkinter menu font colors to match color name
def set_menu_color(self, menu=None, *args):
horizon = self.horVar.get()
if not horizon:
return
c = self.ln_colors[horizon]
menu.config(foreground=c, activeforeground=c, highlightcolor=c)
# update the horizon menu
def update_hor_opt_menu(self):
self.horizons = list(self.horizon_paths_opt.keys())
self.horMenu["menu"].delete(0, "end")
for i, horizon in enumerate(self.horizons):
c = self.ln_colors[horizon]
self.horMenu["menu"].add_command(label=horizon,
foreground=c,
activeforeground=c,
command=tk._setit(
self.horVar, horizon))
# update the horizon seg menu based on how many segments exist for given seg
def update_seg_opt_menu(self, *args):
horizon = self.horVar.get()
self.segMenu["menu"].delete(0, "end")
if horizon:
for seg in sorted(self.horizon_paths_opt[horizon].keys()):
self.segMenu["menu"].add_command(label=seg,
command=tk._setit(
self.segVar, seg))
# show_artists
def show_artists(self, val=True):
for _i in self.ax.lines:
_i.set_visible(val)
# temporarily disconnect the draw_event callback to avoid recursion
def safe_draw(self):
canvas = self.fig.canvas
canvas.mpl_disconnect(self.draw_cid)
canvas.draw()
self.draw_cid = canvas.mpl_connect("draw_event", self.update_bg)
# when the figure is resized, hide picks, draw everything, and update the background image
def update_bg(self, event=None):
# temporarily hide artists
self.show_artists(False)
self.safe_draw()
self.axbg = self.dataCanvas.copy_from_bbox(self.ax.bbox)
# return artists visiblity to former state
self.show_artists(True)
self.blit()
# update the figure, without needing to redraw the "axbg" artists
def blit(self):
self.fig.canvas.restore_region(self.axbg)
for _i in self.ax.lines:
self.ax.draw_artist(_i)
self.fig.canvas.blit(self.ax.bbox)
# onpress gets the time of the button_press_event
def onpress(self, event):
self.time_onclick = time.time()
# onrelease calls manual_repick if the time between the button press and release events
# is below a threshold so that segments aren't drawn while trying to zoom or pan
def onrelease(self, event):
if event.inaxes == self.ax:
if event.button == 1 and (
(time.time() - self.time_onclick) < 0.25):
self.manual_repick(event)
# on_mouse_move blit crosshairs
def on_mouse_move(self, event):
if self.rdata is None:
return
x = event.xdata
y = event.ydata
if event.inaxes == self.ax:
y = self.rdata.proc.curr_dB[int(x), self.trace[self.horVar.get()]]
self.horizontal_line.set_ydata(y)
self.vertical_line.set_xdata(x)
self.ax.figure.canvas.restore_region(self.axbg)
self.ax.draw_artist(self.horizontal_line)
self.ax.draw_artist(self.vertical_line)
self.blit()
# update_figsettings
def update_figsettings(self, figsettings):
self.figsettings = figsettings
plt.rcParams.update({'font.size': self.figsettings["fontsize"].get()})
for item in (
[self.ax.title, self.ax.xaxis.label, self.ax.yaxis.label] +
self.ax.get_xticklabels() + self.ax.get_yticklabels()):
item.set_fontsize(self.figsettings["fontsize"].get())
self.ax.title.set_visible(self.figsettings["figtitle"].get())
self.fig.canvas.draw()
# clear is a method to clear the wavePick tab and stored data when a new track is loaded
def clear(self):
self.ax.clear()
self.dataCanvas.draw()
self.set_vars()
class CellCounter(tk.Tk):
def __init__(self, *args, **kwargs):
# Set up overall GUI
tk.Tk.__init__(self, *args, **kwargs)
tk.Tk.wm_title(self, "Cell Counter")
tk.Grid.columnconfigure(self, 0, weight=1)
tk.Grid.rowconfigure(self, 0, weight=1)
# Set up container frame
container = tk.Frame(self)
tk.Grid.columnconfigure(container, 0, weight=100)
tk.Grid.columnconfigure(container, 1, weight=1)
tk.Grid.columnconfigure(container, 2, weight=1)
tk.Grid.rowconfigure(container, 0, weight=1)
tk.Grid.rowconfigure(container, 1, weight=100)
tk.Grid.rowconfigure(container, 2, weight=1)
container.grid(row=0, column=0, sticky=tk.N + tk.S + tk.E + tk.W)
# Set up matplotlib stuff
self.fig = Figure(figsize=(5, 5), dpi=100)
self.ax = self.fig.add_subplot(111)
self.canvas = FigureCanvasTkAgg(self.fig, container)
self.canvas.draw()
self.canvas.get_tk_widget().grid(row=1,
column=0,
columnspan=3,
padx=10,
pady=5,
sticky=tk.N + tk.S + tk.E + tk.W)
self.axbg = self.canvas.copy_from_bbox(self.ax.bbox)
toolbar_frame = tk.Frame(container)
toolbar_frame.grid(row=2,
column=0,
columnspan=3,
padx=10,
pady=5,
sticky=tk.N + tk.S + tk.E + tk.W)
self.toolbar = CustomToolbar(self.canvas, toolbar_frame, self)
self.toolbar.pack(side=tk.LEFT)
self.toolbar.update()
# Set up buttons / entries
self.fname = tk.StringVar()
self.fname.set("Image filename")
self.fname_entry = tk.Entry(container,
width=10,
textvariable=self.fname,
justify='left')
self.fname_entry.grid(row=0,
column=0,
padx=10,
pady=5,
sticky=tk.N + tk.S + tk.E + tk.W)
self.browse_button = tk.Button(container,
text="Browse",
command=self.selectFile)
self.browse_button.grid(row=0,
column=1,
padx=10,
pady=5,
sticky=tk.N + tk.S + tk.E + tk.W)
self.run_button = tk.Button(container, text="Run", command=self.run)
self.run_button.grid(row=0,
column=2,
padx=10,
pady=5,
sticky=tk.N + tk.S + tk.E + tk.W)
self.paint_button = tk.Button(toolbar_frame,
text="Paint",
command=self.paint)
self.paint_button.pack(side=tk.RIGHT)
self.erase_button = tk.Button(toolbar_frame,
text="Erase",
command=self.erase)
self.erase_button.pack(side=tk.RIGHT)
def run(self):
imageFile = self.fname.get()
if not path.isfile(imageFile):
return
self.greenImg, self.redImg, self.greenCells, self.redCells = cc.findCells(
imageFile)
self.greenImShow = self.ax.imshow(self.greenImg,
interpolation='None',
animated=True)
self.cellImShow = self.ax.imshow(self.greenCells,
alpha=.1,
interpolation='None',
animated=True)
self.ax.set_position([.05, .05, .9, .9])
self.canvas.draw()
def selectFile(self):
imageFile = filedialog.askopenfilename(
title="Select Image File",
filetypes=(("tif files", "*.tif"), ("all files", "*.*")))
self.fname.set(imageFile)
def paint(self):
return
def erase(self):
return
class Application(Frame):
def __init__(self, master=None):
Frame.__init__(self, master)
self.parent = master
self.top = Frame()
self.top.grid()
self.top.update_idletasks()
self.vertical_limit = 0.0
self.horizontal_limit_1 = 0.0
self.horizontal_limit_0 = 0.0
master.columnconfigure(0, weight=1)
master.rowconfigure(0, weight=1)
self.top.columnconfigure(0, weight=1)
self.top.rowconfigure(0, weight=1)
self.x = 0
self.i = 0
self.delta_i = 1
self.update = 2
# maximum number of points to acquire
self.n_data = 10000
self.xy_data = []
width = root.winfo_screenwidth() / dpi
# figsize (w,h tuple in inches) dpi (dots per inch)
self.figure = pyplot.figure(figsize=(width,12), dpi=dpi, facecolor='#DCDCDC')
self.subplot = self.figure.add_subplot(211, axisbg='#DCDCDC')
self.subplot.grid(True)
# define amplitude dos eixos
#self.subplot.axis([0, horizontal_scale, -vertical_scale, vertical_scale])
self.ax = self.subplot.axis([0, horizontal_scale, 0, vertical_scale])
self.subplot.set_xbound(lower=0, upper=None)
pyplot.xlabel('s')
pyplot.ylabel('mV')
self.tupla = self.subplot.transData.transform([(0,1),(1,0)])-self.subplot.transData.transform((0,0))
#print self.tupla
self.line, = self.subplot.plot([],[], animated=True) # initialize line to be drawn
# Note: The comma after line is because the right hand size returns
# a one element list, and we want to unpack that single element
# into line, not assign the list to line.
self.text = pyplot.figtext(0.05,0.25,"") # initialize text section
self.canvas = FigureCanvasTkAgg(self.figure, master=root)
self.canvas.get_tk_widget().configure(highlightcolor='#DCDCDC')
self.canvas.get_tk_widget().grid(row=2,column=0,columnspan=3)
self.background = self.canvas.copy_from_bbox(self.subplot.bbox)
#Cria a barra de ferramentas
toolbar_frame = Frame(self.parent)
toolbar_frame.grid(row=1, pady= 31, sticky=W+N)
#toolbar_frame.grid(row=1, sticky=W+S)
toolbar = CustomToolbar(self.canvas,toolbar_frame)
#toolbar.grid(row=0, column=1)
toolbar_frame.columnconfigure(0, weight=1)
toolbar_frame.rowconfigure(0, weight=1)
self.button_text = ['Iniciar','Pausar', 'Parar']
self.buttons = [None] * len(self.button_text)
self.buttonframe = Frame(root)
#self.buttonframe.columnconfigure(0, weight=10)
#self.buttonframe.rowconfigure(0, weight=30)
self.buttonframe.grid(row=1, sticky=N+W)
for button_index in range(len(self.button_text)):
button_id = Button(self.buttonframe, text = self.button_text[button_index])
#button_id.columnconfigure(button_index)
button_id.grid(row=0, column=button_index)
self.buttons[button_index] = button_id
def button_handler(event, self=self, button=button_index):
return self.service_buttons(button)
button_id.bind("<Button-1>", button_handler)
#variáveis de configuração do módulo
self.constant = 1
self.offset = 0
self.gain = 1
self.baud_rate = 115200
self.sampling_rate = 240
self.connect = 2
self.GDFile = open("gdf_data_" + time.strftime("%H:%M") +".dat", "wb")
self.flag_file = 0
#self.writer = csv.writer(GDFile)
self.module_frame()
def module_frame(self):
#criação do painel que mostra as configurações do módulo na tela principal da interface
self.ModuleBox = Text(self.parent, bg=mygreen, height= 6, width=45, relief="flat")
self.ModuleBox.grid(row = 1,sticky="n")
self.ModuleBox.tag_configure('title', justify='center', font=('Kreativ', 10), foreground='white')
self.ModuleBox.tag_configure('preferences', font=('Kreativ', 9), foreground='white')
self.ModuleBox.insert(INSERT, "Módulo" + "\n", 'title')
fields = 'Constante de Conversão para Volts: ' + str(self.constant), 'Deslocamento (Offset): ' + str(self.offset) + ' V', 'Ganho: ' + str(self.gain),'Taxa de Transmissão: ' + str(self.baud_rate) + ' Bps', 'Taxa de Amostragem: ' + str(self.sampling_rate)
for field in fields:
self.ModuleBox.insert(INSERT, field + "\n", 'preferences')
self.ModuleBox.configure(state='disable')
# buttons can be used to start and pause plotting
def service_buttons(self, toolbar_index):
if toolbar_index == 0:
self.stop = False
if self.connect == 0:
self.serial_data()
#plotter.plot(self, vertical_scale, horizontal_scale)
elif self.connect == 1:
self.bluetooth_data()
else:
tkMessageBox.showerror("Erro", "Nenhum módulo de aquisição conectado")
return
plotter.plot(self, vertical_scale, horizontal_scale)
else:
self.stop = True
if toolbar_index == 2:
if self.connect == 0:
self.proc.terminate()
self.ser.close()
self.serial_queue.close()
print("Porta serial fechada")
elif self.connect == 1:
self.procb.terminate()
print("Parar")
else:
print("Pausar")
def connect_serial(self, cb_port, cb_parity, cb_RTS, cb_DTR, win):
self.connect = 0
self.port = cb_port.get()
self.parity = cb_parity.get()
self.RTS = cb_RTS.get()
self.DTR = cb_DTR.get()
print("Conectando à porta serial %s" % self.port)
#print self.parity
win.destroy()
def serial_data(self):
self.serial_queue = Queue()
#abre a porta serial
try:
self.ser = serial.Serial(self.port, self.baud_rate) #conecta à porta correta
except:
print("Falhou ao conectar com a porta serial")
return
print("Conexão à porta serial com sucesso")
self.ser.close()
self.ser.open()
if self.parity == 'Par':
self.parity = serial.PARITY_EVEN
print("par")
elif self.parity == 'Ímpar':
self.parity = serial.PARITY_ODD
else:
self.parity = serial.PARITY_NONE
if self.RTS == 'Ativado':
self.ser.setRTS(True)
print("RTS Ativado")
if self.DTR == 'Ativado':
self.ser.setDTR(True)
print("DTR Ativado")
self.proc = Process(target=serialRead.leitura_serial_driver, args=(self.serial_queue, self.ser))
self.proc.start()
def connect_bluetooth(self, addr):
self.addr = addr
self.connect = 1
def bluetooth_data(self):
self.bluetooth_queue = Queue()
print("Procurando por um servidor em %s" % self.addr)
service_matches = find_service(address = self.addr)
flag = 0
if len(service_matches) == 0:
print("não foi possível encontrar um serviço")
port = 1
flag = 1
else:
first_match = service_matches[0]
port = first_match["port"]
name = first_match["name"]
addr = first_match["host"]
flag = 1
print ("conectando a \"%s\" em %s na porta %s" % (name, host, port))
sock = BluetoothSocket(RFCOMM)
addr = self.addr
sock.connect((addr, port))
print ("CONECTADO")
self.procb = Process(target=bluetoothRead.leitura_bluetooth_driver, args=(self.bluetooth_queue, sock))
self.procb.start()
def save_preferences(self, win, entries):
i = 0
for entry in entries:
if (entry[1].get() != ''):
if (i == 0):
self.constant = float(entry[1].get())
elif (i==1):
self.offset = float(entry[1].get())
print(self.offset)
elif (i==2):
self.gain = float(entry[1].get())
elif (i==3):
self.baud_rate = int(entry[1].get())
elif (i==4):
self.sampling_rate = float(entry[1].get())
i+=1
win.destroy()
self.module_frame()
def vertical_gain(self, gain):
self.vertical_limit = (((self.tupla[0][1] * 25.4) / dpi) * vertical_scale) / gain
if self.horizontal_limit_1 != 0:
self.subplot.axis([self.horizontal_limit_0, self.horizontal_limit_1, -(self.vertical_limit), self.vertical_limit])
else:
self.subplot.axis([self.subplot.get_xlim()[0], self.subplot.get_xlim()[1], -(self.vertical_limit), self.vertical_limit])
self.canvas.draw()
print ("ganho vertical setado para %.2f mm/mV" % gain)
def horizontal_gain(self, gain):
#limite superior
if (self.subplot.get_xlim()[1] - self.subplot.get_xlim()[0]) == horizontal_scale:
self.horizontal_limit_1 = ((((self.tupla[1][0] * 25.4) / dpi) * horizontal_scale) / gain) + self.subplot.get_xlim()[0]
print (self.horizontal_limit_1)
else:
if self.subplot.get_xlim()[0] > 0:
self.horizontal_limit_1 = (((self.tupla[1][0] * 25.4) / dpi) * (horizontal_scale+self.subplot.get_xlim()[0])) / gain
else:
self.horizontal_limit_1 = (((self.tupla[1][0] * 25.4) / dpi) * horizontal_scale) / gain
#limite inferior
self.horizontal_limit_0 = self.subplot.get_xlim()[0]
if self.vertical_limit != 0:
self.subplot.axis([self.horizontal_limit_0, self.horizontal_limit_1, -(self.vertical_limit), self.vertical_limit])
else:
self.subplot.axis([self.horizontal_limit_0, self.horizontal_limit_1, -(vertical_scale), vertical_scale])
self.canvas.draw()
print ("ganho horizontal setado para %.2f mm/s" % gain)
def serial_ports(self):
""" Lists serial port names
:raises EnvironmentError:
On unsupported or unknown platforms
:returns:
A list of the serial ports available on the system
"""
if sys.platform.startswith('win'):
ports = ['COM%s' % (i + 1) for i in range(256)]
elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):
# this excludes your current terminal "/dev/tty"
ports = glob.glob('/dev/tty[A-Za-z]*')
elif sys.platform.startswith('darwin'):
ports = glob.glob('/dev/tty.*')
else:
raise EnvironmentError('Unsupported platform')
result = []
for port in ports:
try:
s = serial.Serial(port)
s.close()
result.append(port)
except (OSError, serial.SerialException):
pass
return result
def gdfConstruct(self, win, entries, cb_valor1, cb_valor2, cb_valor3, cb_valor4, cb_valor5, cb_valor6, cb_valor7, cb_valor8):
if self.flag_file == 1:
self.GDFile = open("gdf_data_" + time.strftime("%H:%M") +".dat", "wb")
i = 0
out = ''
versionId = 'GDF 2.10'
self.GDFile.write(struct.pack('8s', versionId))
#out = ''.join(format(ord(i),'b').zfill(8) for i in versionId)
saida = []
saida.extend((cb_valor1.get(), cb_valor2.get(), cb_valor3.get(), cb_valor4.get(), cb_valor5.get(), cb_valor6.get(), cb_valor7.get(), cb_valor8.get()))
j = 0
for entry in entries:
if j == 0:
self.GDFile.write(struct.pack('66s', entry[1].get()))
#out += ''.join(format(ord(i),'b').zfill(8) for i in idP)
#campo reservado
self.GDFile.write(struct.pack('QH', 0, 0))
i = 0
while i<4:
if saida[i] == 'Desconhecido':
out += '00'
elif saida[i] == 'Sim':
out += '10'
else:
out += '01'
i+=1
self.GDFile.write(struct.pack('s', out))
if (j == 1 or j == 2 or j == 5):
if entry[1].get() != '':
self.GDFile.write(struct.pack('B', int(float(entry[1].get()))))
#out += '{0:08b}'.format(int(float(entry[1].get())))
if j == 2:
out = ''
i=0
while i < 4:
if i == 0:
if saida[i] == 'Masculino':
out += '01'
elif saida[i] == 'Feminino':
out+= '10'
else:
out += '11'
elif i == 1:
if saida[i] == 'Desconhecido':
out += '00'
elif saida[i] == 'Destro':
out += '01'
elif saida[i] == 'Canhoto':
out += '10'
else:
out+= '11'
else:
if saida[i] == 'Desconhecido':
out += '00'
elif unicode(saida[i]) == unicode(u'Não'):
out += '01'
elif saida[i] == 'Sim':
out += '10'
else:
out+= '11'
i+=1
self.GDFile.write(struct.pack('s', out))
if j == 3:
self.GDFile.write(struct.pack('I', int(time.strftime("%d%m"))))
self.GDFile.write(struct.pack('I', int(time.strftime("%H%M"))))
#startdate = time.strftime("%d%m") + time.strftime("%H%M")
#for sd in startdate:
# print '{0:08b}'.format(int(sd))
dates = entry[1].get().translate(None, "/")
for date in dates:
#out += '{0:08b}'.format(int(date))
self.GDFile.write(struct.pack('>i', int(date)))
elif j == 4:
self.GDFile.write(struct.pack('6s', entry[1].get()))
elif (j == 6 or j == 7):
#eletrodo positions
#number of data records
self.GDFile.write(struct.pack('q', -1))
j+=1
self.flag_file = 1
win.destroy()
def save_figure(self):
ftypes = [('PNG', '*.png')]
filename = tkFileDialog.asksaveasfilename(initialdir = "/home", filetypes = ftypes)
self.figure.savefig(filename, bbox_inches='tight')
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__))
img = Image.open(os.path.join(working_dir, "select.png"))
#self.select_icon = tk.PhotoImage(file=os.path.join(working_dir,"select.png"))
self.select_icon = tk.PhotoImage(img)
self.select_button = tk.Button(navbar,
width="24",
height="24",
image=img,
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()
ax = fig.add_subplot(111)
canvas = FigureCanvasTkAgg(fig, root) # A tk.DrawingArea
canvas.get_tk_widget().pack(side='top', fill='both',
expand=1) # Add fig to Tk Window
ax.grid(which='both', linestyle='--')
ax.set_xlabel("Time (s)")
line, = ax.plot(evo.time, evo.data)
ax.set_ylim([0, 100])
ax.get_xaxis().set_animated(True)
#ax.get_yaxis().set_animated(True)
line.set_animated(True)
canvas.draw()
background = canvas.copy_from_bbox(fig.bbox)
# now redraw and blit
ax.draw_artist(ax.get_xaxis())
ax.draw_artist(line)
canvas.blit(ax.clipbox)
while True:
evo.update()
line.set_xdata(evo.time)
line.set_ydata(evo.getData())
ax.set_xlim([evo.time[0], evo.time[-1]])
#ax.set_ylim([max(evo.data),min(evo.data)])
# restore the background, draw animation,blit
class FittingWindow:
def __init__(self, master,ramanspectrum =None):
global guessplot,dataplot
self.master = master
self.textframe= Frame(master = self.master)
self.scroll = Tkinter.Scrollbar(self.textframe)
self.scroll.grid(row=0,column=1)
self.t = Tkinter.Text(self.textframe,yscrollcommand=self.scroll.set,width=30)
self.scroll.config(command=self.t.yview)
self.t.grid(row=0,column=0)
self.plotframe = Frame(master = self.master)
self.frame = Frame(master = self.master)
self.textframe.grid(row=0,column=0,columnspan=3)
self.plotframe.grid(row = 0, column = 3, columnspan = 11,sticky = 'ew')
self.frame.grid(column = 1, row = 1,columnspan = 11, rowspan = 3,sticky = 'snew')
self.buttonframe = Frame(master = self.master)
self.buttonframe.grid(column=0, row =1)
##############################
self.menubar = Menu(self.master)
self.filemenu = Menu(self.menubar, tearoff=0)
self.filemenu.add_command(label="New window", command = lambda: FittingWindow(Toplevel()))
self.filemenu.add_command(label="Open", command = self.open_data)
self.filemenu.add_command(label="Save",command = None)
self.filemenu.add_command(label="SaveFig",command = None)
self.filemenu.add_command(label="ViewNotebook",command = None)
self.filemenu.add_command(label="Exit", command = self.quitproc)
self.menubar.add_cascade(label="File", menu=self.filemenu)
self.master.config(menu= self.menubar)
##############################
self.fit_button = Tkinter.Button(master = self.buttonframe, command = self.fit_and_draw, width = 5, text = 'FitNow')
self.fit_button.grid(row = 3, column = 0)
self.open_button = Tkinter.Button(master = self.buttonframe, command = self.open_data, width = 5, text = 'open')
self.open_button.grid(row = 4, column = 0)
# self.open_ref_button = Tkinter.Button(master = self.buttonframe, command = self.open_ref, width = 5, text = 'Choose reference')
# self.open_ref_button.grid(row = 5, column = 0)
# self.open_bkg_button = Tkinter.Button(master = self.buttonframe, command = self.open_bkg, width = 5, text = 'Choose background')
# self.open_bkg_button.grid(row = 6, column = 0)
#
# self.ref_label = Tkinter.Label(master = self.buttonframe, text = '')
# self.ref_label.grid(row = 7, column = 0)
#
# self.bkg_label = Tkinter.Label(master = self.buttonframe, text = '')
# self.bkg_label.grid(row = 8, column = 0)
self.smoothbutton = Tkinter.Button(master = self.buttonframe, command = self.smoothdata, width = 5, text = 'Smooth')
self.smoothbutton.grid(row = 5, column = 0)
self.function_list=[
'OneGaussian',
'TwoGaussian',
'ThreeGaussian',
'FourGaussian',
'FiveGaussian']
self.var_func = StringVar()
self.var_func.set(self.function_list[0])
self.MotorMenu = OptionMenu(self.buttonframe,self.var_func, *self.function_list, command = self.init_function)
self.MotorMenu.grid(row = 3,column =1,sticky = W)
self.normalization_constant = 1
self.scale_list = []
self.var_list = []
self.fig = Figure(figsize=(5,3))
self.ax1 = self.fig.add_subplot(111)
dataplot = self.ax1.plot(arange(2800,3605,5),zeros((161,)),animated = True)[0]#(ax = self.ax1).lines[-1]
guessplot = self.ax1.plot(arange(2800,3605,5),zeros((161,)),animated = True)[0]
self.canvas = FigureCanvasTkAgg(self.fig,master = self.plotframe)
self.canvas.show()
self.canvas._tkcanvas.pack(side=TOP, fill = BOTH,expand =True)
self.toolbar = NavigationToolbar2TkAgg(self.canvas, self.plotframe)
self.toolbar.update()
self.toolbar.pack(side= BOTTOM, fill = BOTH,expand =True)#,expand = True)#fill=BOTH)#, expand=1)
self.canvas.draw()
self.canvas.show()
self.background = self.canvas.copy_from_bbox(self.ax1.bbox)
self.reference = numpy.ndarray((161,))
self.reference[:] = 1
self.reference_name = ''
self.guess = list()
self.name = ['']
if ramanspectrum is None:
self.a = pandas.Series(zeros(161),arange(2800,3605,5))
else:
self.a = copy(ramanspectrum)
print self.a
self.t.insert(END,'data multiplied by'+str(1/max(self.a)))
self.a[:]/=max(self.a.values)
self.startfreq_text = Entry(self.buttonframe,width = 5)
self.startfreq = min(array(self.a.index))
self.startfreq_text.insert(END,str(self.startfreq))
self.startfreq_text.bind("<Return>", self.update_limits)
self.startfreq_text.grid(row = 0 , column =1,sticky = W)
self.endfreq_text = Entry(self.buttonframe,width = 5)
self.endfreq = max(array(self.a.index))
self.endfreq_text.insert(END,str(self.endfreq))
self.endfreq_text.bind("<Return>", self.update_limits)
self.endfreq_text.grid(row = 1 , column =1,sticky = W)
if self.init_function('OneLorentzian') == -1:
self.t.insert(END, 'error initializing fit function')
self.ax1.cla()
self.canvas.show()
self.background = self.canvas.copy_from_bbox(self.ax1.bbox)
dataplot = self.ax1.plot(array(self.a.index),self.a.values,animated=True)[0]
x= array(self.a.index)
guessplot = self.ax1.plot(x,zeros(self.a.size),animated=True)[0]
self.ax1.set_xlim(min(self.a.index),max(self.a.index))
self.ax1.set_ylim(min(self.a.values),1)
self.canvas.show()
self.raw = self.a.copy
self.startidx = 0
self.endidx = -1
self.update_limits(0)
return None
def nothing(self):
return 0
def quitproc(self):
self.master.destroy()
return 0
def init_function(self,functiontype):
global function
import inspect
if functiontype == None:
functiontype = self.var_func.get()
self.functiontype = functiontype
if functiontype == 'OneLorentzian':
def function(x,A1,w1,G1,m,b): return m*x/1000+b + A1**2/((x-w1)**2+G1**2)
elif functiontype == 'TwoLorentzian':
def function(x,A1,A2,w1,w2,G1,G2,m,b): return m*x/1000+b + A1**2/((x-w1)**2+G1**2) +A2**2/((x-w2)**2+G2**2)
elif functiontype == 'ThreeLorentzian':
def function(x,A1,A2,A3,w1,w2,w3,G1,G2,G3,m,b): return m*x/1000+b + A1**2/((x-w1)**2+G1**2) +A2**2/((x-w2)**2+G2**2) +A3**2/((x-w3)**2+G3**2)
elif functiontype == 'FourLorentzian':
def function(x,A1,A2,A3,A4,w1,w2,w3,w4,G1,G2,G3,G4,m,b): return m*x/1000+b + A1**2/((x-w1)**2+G1**2) +A2**2/((x-w2)**2+G2**2) +A3**2/((x-w3)**2+G3**2) +A4**2/((x-w4)**2+G4**2)
elif functiontype == 'FiveLorentzian':
def function(x,A1,A2,A3,A4,A5,w1,w2,w3,w4,w5,G1,G2,G3,G4,G5,m,b): return m*x/1000+b + A1**2/((x-w1)**2+G1**2) +A2**2/((x-w2)**2+G2**2) +A3**2/((x-w3)**2+G3**2) +A4**2/((x-w4)**2+G4**2)+A5**2/((x-w5)**2+G5**2)
elif functiontype == 'OneGaussian':
def function(x,A1,w1,G1,m,b): return m*x/1000+b + A1*exp(-(x-w1)**2/G1)
elif functiontype == 'TwoGaussian':
def function(x,A1,A2,w1,w2,G1,G2,m,b): return A1*exp(-(x-w1)**2/G1) +A2*exp(-(x-w2)**2/G2) +m*x/1000+b
elif functiontype == 'ThreeGaussian':
def function(x,A1,A2,A3,w1,w2,w3,G1,G2,G3,m,b): return m*x/1000+b + A1*exp(-(x-w1)**2/G1) +A2*exp(-(x-w2)**2/G2) +A3*exp(-(x-w3)**2/G3)
elif functiontype == 'FourGaussian':
def function(x,A1,A2,A3,A4,w1,w2,w3,w4,G1,G2,G3,G4,m,b): return m*x/1000+b +A1*exp(-(x-w1)**2/G1) +A2*exp(-(x-w2)**2/G2) +A3*exp(-(x-w3)**2/G3) +A4*exp(-(x-w4)**2/G4)
elif functiontype == 'FiveGaussian':
def function(x,A1,A2,A3,A4,A5,w1,w2,w3,w4,w5,G1,G2,G3,G4,G5,m,b): return m*x/1000+b + (A1/G1*numpy.sqrt(2*pi))*exp(-(x-w1)**2/(2*G1**2)) +(A2/G2*numpy.sqrt(2*pi))*exp(-(x-w2)**2/(2*G2**2)) +(A3/G3*numpy.sqrt(2*pi))*exp(-(x-w3)**2/(2*G3**2)) +(A4/G4*numpy.sqrt(2*pi))*exp(-(x-w4)**2/(2*G4**2)) +(A5/G5*numpy.sqrt(2*pi))*exp(-(x-w5)**2/(2*G5**2))
else:
tkMessageBox.showerror('Not regconized function')
def function(x,m,b): return m*x/1000+b
#==============================================================================
self.w_name = list()
self.w_name = inspect.getargspec(function).args[1:]
self.guess= []
for w in self.w_name:
if 'A' in w:
self.guess.append(0.1)
elif 'w' in w:
self.guess.append(1000)
elif 'G' in w:
self.guess.append(10)
else:
self.guess.append(0)
#================================================================================
for i in range(len(self.scale_list),len(self.w_name)):
self.scale_list.append(Scale(master = self.frame,command = self.guessdraw))
for i in range(len(self.w_name),len(self.scale_list)):
self.scale_list[i].grid_forget()
for i in range(len(self.w_name)):
self.scale_list[i].config(label = self.w_name[i])
self.scale_list[i].grid(row = int(i/8), column = i%8)
if self.w_name[i][0] == 'A':
self.scale_list[i].config(from_ =0, to = 5,resolution = 0.1)
self.scale_list[i].set(1)
elif self.w_name[i][0] == 'w':
self.scale_list[i].config(from_ = self.startfreq-20, to = self.endfreq+20,resolution = 1)
self.scale_list[i].set(2800)
elif self.w_name[i][0] == 'G':
self.scale_list[i].config(from_ = 1, to = 50)
self.scale_list[i].set(7)
elif self.w_name[i][0] == 'm':
self.scale_list[i].config(from_ = -5, to = 5, resolution = 0.05)
self.scale_list[i].set(0)
elif self.w_name[i][0] == 'b':
self.scale_list[i].config(from_ = -5, to = 5, resolution = 0.05)
self.scale_list[i].set(0)
else:
self.t.insert(END, "Variable not recognized:", self.w_name[i] )
self.scale_list[i].bind('<B1-Motion>',self.guessdraw)
return 0
def smoothdata(self):
self.a.smoooth()
self.guessdraw(0)
def update_limits(self,extra):
functiontype = self.var_func.get()
self.startfreq = max(float(self.startfreq_text.get()),min(array(self.a.index)))
self.endfreq = min(float(self.endfreq_text.get()),max(array(self.a.index)))
self.startidx = self.a.nearest(self.startfreq)
self.endidx = self.a.nearest(self.endfreq)
for i in range(len(self.guess)):
self.guess[i] = self.scale_list[i].get()
self.ax1.cla()
self.canvas.show()
self.background = self.canvas.copy_from_bbox(self.ax1.bbox)
dataplot = self.ax1.plot(array(self.a.index[self.startidx:self.endidx]),self.a.values[self.startidx:self.endidx],animated=True)[0]#(ax = self.ax1).lines[-1]
x= array(self.a.index[self.startidx:self.endidx])
guessplot = self.ax1.plot(x,zeros(x.size),animated=True)[0]
#self.ax1.set_xlim(min(self.a.index),max(self.a.index))
#self.ax1.set_ylim(min(self.a.values),1)
self.canvas.show()
self.guessdraw(0)
return 0
def open_data(self):
global dataplot,guessplot
self.name = self.DisplaySpectrum()
if self.name == -1:
return 0
try:
self.a = RamanSpectrum(self.name)
self.normalization_constant= 1/max(self.a)
self.startfreq = min(array(self.a.index))
self.startfreq_text.insert(END,str(self.startfreq))
self.endfreq = max(array(self.a.index))
self.endfreq_text.insert(END,str(self.endfreq))
except:
self.t.insert(END, 'error opening spectrum')
return -1
self.raw = self.a.copy
self.ax1.cla()
self.canvas.show()
self.background = self.canvas.copy_from_bbox(self.ax1.bbox)
dataplot = self.ax1.plot(array(self.a.index),self.a.values,animated=True)[0]#(ax = self.ax1).lines[-1]
x= array(self.a.index)
guessplot = self.ax1.plot(x,zeros(self.a.size),animated=True)[0]
self.ax1.set_xlim(min(self.a.index),max(self.a.index))
self.ax1.set_ylim(min(self.a.values),1)
self.canvas.show()
self.update_limits(0)
return 0
def open_ref(self):
pass
return 0
def open_bkg(self):
pass
return 0
def recalc_data(self):
if self.raw.shape == self.reference.shape:
self.a= SG_Smooth(self.raw,width = 11,order = 3)/self.reference/self.normalization_constant
self.ax1.cla()
plot(self.a[0],self.raw/self.reference)
plot(self.a[0],self.a[1])
else:
self.t.insert(END, "reference invalid")
self.reference_name = "No IR Reference"
self.ax1.cla()
self.ax1.plot(self.a[0],self.a[1])
self.canvas.draw()
return 0
def guessdraw(self,ex):
global function,guessplot,dataplot
x = array(self.a.index[self.startidx:self.endidx+1])
for i in range(len(self.guess)):
self.guess[i] = self.scale_list[i].get()
self.canvas.restore_region(self.background)
self.ax1.lines[-1].set_xdata(x)
self.ax1.lines[-1].set_ydata(function(x,*self.guess))
for l in self.ax1.lines:
self.ax1.draw_artist(l)
self.canvas.blit(self.ax1.bbox)
return 0
def fit_and_draw(self):
global function
print type(self.a)
if type(self.a) == pandas.core.series.Series:
self.a = RamanSpectrum(self.a)
#result = fitspectrum(self.a, (float(self.a.index[self.startidx]),float(self.a.index[self.endidx+1])),'Custom',self.guess,function = function)
print self.guess
result = fitspectrum(self.a, (self.startfreq,self.endfreq),'Custom',self.guess,function = function)
fittingparameters = result[0]
xfit = result[1]
yfit = result[2]
if result == -1:
tkMessageBox.showerror('Fit Failed')
return 0
z = list(fittingparameters[0])
self.canvas.restore_region(self.background)
self.ax1.lines[-1].set_xdata(xfit)
self.ax1.lines[-1].set_ydata(yfit)
for l in self.ax1.lines:
self.ax1.draw_artist(l)
for i in range(len(self.w_name)):
#self.scale_list[i].set(result[0][i])
if "w" in self.w_name[i]:
self.ax1.axvline(x = z[i], ymin = 0, ymax = 1 ,color = 'r')
self.canvas.blit(self.ax1.bbox)
self.t.insert(END, " \nResult Found for " + str(self.name))
self.t.insert(END, " \nReferenced to IR spectrum " +self.reference_name)
self.t.insert(END, " \nNormalized by constant "+str(self.normalization_constant))
for i in range(len(self.w_name)):
self.t.insert(END, ' \n'+self.w_name[i]+': '+str(z[i]))
return 0
def DisplaySpectrum(self):
import re
global name_list, str_name_list
file_opt = options = {}
options['defaultextension'] = '.spe'
options['filetypes'] = [('all files', '.*'),('SPE files', '.SPE'), ('csv files','.csv'),('text files','.txt')]
options['title'] = 'Open Spectrum...'
options['initialdir'] = '/home/chris/Documents/DataWeiss'
str_name_list = tkFileDialog.askopenfilename(**options)
if str_name_list == '':
return -1
return str_name_list
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 PlotFrame(tk.Frame):
def __init__(self, master):
tk.Frame.__init__(self, master)
self.fwidth = 512
self.fheight = 720
self.configure(bd=2,
width=self.fwidth,
height=self.fheight,
relief='sunken')
self.grid_propagate(0)
self.dpi = 100
self.f = Figure(figsize=(self.fwidth / self.dpi,
self.fheight / self.dpi),
dpi=self.dpi,
facecolor=(1, 1, 1, 0))
self.canvas = FigureCanvasTkAgg(self.f, self)
self.top = self.f.add_subplot(311)
self.middle = self.f.add_subplot(312)
self.bottom = self.f.add_subplot(313)
self.xData = np.linspace(0, 100 * np.pi, 1000, endpoint=False)
self.yDataB = np.sin(self.xData)
self.yDataM = np.sin(self.xData) * np.sin(self.xData * 0.5 + .4)
self.yDataT = np.sin(self.xData)**2 + np.cos(self.xData * 1.1 + 0.15)
self.startTime = time.time()
self.canvas.draw()
self.backgroundB = self.canvas.copy_from_bbox(self.bottom.bbox)
self.backgroundT = self.canvas.copy_from_bbox(self.top.bbox)
self.backgroundM = self.canvas.copy_from_bbox(self.middle.bbox)
self.pointsB = self.bottom.plot(self.xData, self.yDataB)[0]
self.pointsM = self.middle.plot(self.xData, self.yDataM)[0]
self.pointsT = self.top.plot(self.xData, self.yDataT)[0]
def animate2(self, reScaled):
scale = True
if reScaled:
self.f.clf()
self.showCanvas.grid_forget()
self.f = Figure(figsize=(self.fwidth / self.dpi,
self.fheight / self.dpi),
dpi=self.dpi,
facecolor=(1, 1, 1, 0))
self.canvas = FigureCanvasTkAgg(self.f, self)
self.top = self.f.add_subplot(311)
self.middle = self.f.add_subplot(312)
self.bottom = self.f.add_subplot(313)
self.canvas.draw()
self.backgroundB = self.canvas.copy_from_bbox(self.bottom.bbox)
self.backgroundT = self.canvas.copy_from_bbox(self.top.bbox)
self.backgroundM = self.canvas.copy_from_bbox(self.middle.bbox)
self.pointsB = self.bottom.plot(self.xData, self.yDataB)[0]
self.pointsM = self.middle.plot(self.xData, self.yDataM)[0]
self.pointsT = self.top.plot(self.xData, self.yDataT)[0]
scale = False
if scale:
t = time.time() - self.startTime
N = len(self.xData)
currentIdx = int(N * ((t / 4) % 1))
scalingNumber = N * 0.1
waveShape = np.exp(-np.arange(N) / scalingNumber)[::-1]
colorArray = np.array([(1, 0, 0, a)
for a in np.roll(waveShape, currentIdx)])
self.yDataB = np.roll(self.yDataB, 1)
self.yDataT = np.roll(self.yDataT, 1)
self.yDataM = np.roll(self.yDataM, 1)
self.pointsB.set_data(self.xData, self.yDataB)
self.pointsT.set_data(self.xData, self.yDataT)
self.pointsM.set_data(self.xData, self.yDataM)
self.canvas.restore_region(self.backgroundB)
self.canvas.restore_region(self.backgroundT)
self.canvas.restore_region(self.backgroundM)
self.bottom.draw_artist(self.pointsB)
self.middle.draw_artist(self.pointsM)
self.top.draw_artist(self.pointsT)
self.canvas.blit(self.bottom.bbox)
self.canvas.blit(self.top.bbox)
self.canvas.blit(self.middle.bbox)
self.showCanvas = self.canvas.get_tk_widget()
self.showCanvas.grid()
