class TestDialog( QDialog, Ui_dlgMPLTest ):
def __init__( self, parent = None ):
super( TestDialog, self ).__init__( parent )
self.setupUi( self )
# initialize mpl plot
self.figure = Figure()
#self.figure.set_figsize_inches( ( 4.3, 4.2 ) )
self.axes = self.figure.add_subplot( 111 )
self.figure.suptitle( "Frequency distribution", fontsize = 12 )
self.axes.grid( True )
self.canvas = FigureCanvas( self.figure )
layout = QVBoxLayout()
self.widgetPlot.setLayout(layout)
layout.addWidget(self.canvas)
#self.canvas.setParent( self.widgetPlot )
# draw mpl plot
#self.axes.clear()
#self.axes.grid( True )
#self.figure.suptitle( "Frequency distribution", fontsize = 12 )
self.axes.set_ylabel( "Count", fontsize = 8 )
self.axes.set_xlabel( "Values", fontsize = 8 )
x = [ 4, 1, 5, 3, 3, 2, 3, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1 ]
n, bins, pathes = self.axes.hist( x, 18, alpha=0.5, histtype = "bar" )
self.canvas.draw()
self.setWindowTitle( self.tr( "MPL test" ) )
class MatplotlibWidget(QtGui.QWidget):
"""
Implements a Matplotlib figure inside a QWidget.
Use getFigure() and redraw() to interact with matplotlib.
Example::
mw = MatplotlibWidget()
subplot = mw.getFigure().add_subplot(111)
subplot.plot(x,y)
mw.draw()
"""
def __init__(self, size=(5.0, 4.0), dpi=100):
QtGui.QWidget.__init__(self)
self.fig = Figure(size, dpi=dpi)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self)
self.toolbar = NavigationToolbar(self.canvas, self)
self.vbox = QtGui.QVBoxLayout()
self.vbox.addWidget(self.toolbar)
self.vbox.addWidget(self.canvas)
self.setLayout(self.vbox)
def getFigure(self):
return self.fig
def draw(self):
self.canvas.draw()
def addSkeletonWindow(self):
t_start = 1917 # start frame
t_end = 2130 # end frame
data = pd.read_csv('../inputs/Smart-first_phase_NaN-zeros.csv') # only coordinate data
df = data.loc[t_start:t_end,'Shoulder_left_x':'Ankle_right_z']
data = df.values.tolist()
def chunks(l, n):
return [l[i:i+n] for i in range(0, len(l), n)]
newData = []
for line in data:
newData.append(chunks(line, 3))
figure = render.renderSkeleton(newData)
layout = QtGui.QVBoxLayout()
canvas = FigureCanvas(figure)
toolbar = NavigationToolbar(canvas, self)
self.layout.addWidget(toolbar)
self.layout.addWidget(canvas)
button = QtGui.QPushButton('Plot')
self.layout.addWidget(button)
self.setLayout(self.layout)
canvas.draw()
plt.show()
def __init__(self, parent=None, width=5, height=4, dpi=100):
self.fig = Figure(figsize=(width, height), dpi=dpi)
FigureCanvasQTAgg.__init__(self, self.fig)
self.setParent(parent)
FigureCanvas.setSizePolicy(self, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
def keyPressEvent(self, event):
if self.redetecter:
self.detecter()
key = event.key()
txt = event.text()
modifiers = event.modifiers()
accept = True
debug(u"key: ", key)
if key == Qt.Key_Delete and self.select:
if shift_down(event):
self.executer(u"%s.cacher()" %self.select.nom)
else:
self.executer(u"%s.supprimer()" %self.select.nom)
elif key in (Qt.Key_Return, Qt.Key_Enter) and self.editeur.objet is not self.select:
self.editer(shift_down(event))
elif self.editeur and not self.editeur.key(key, txt, modifiers):
accept = False
if key == Qt.Key_Escape and self.interaction:
print "ESCAPE !"
self.interaction(special="ESC")
accept = True
if not accept:
FigureCanvasQTAgg.keyPressEvent(self, event)
def __init__(self, parent=None, width=5, height=5, dpi=72):
self.fontsize = 10
# fiugrueの生成
# self.fig = plt.figure(figsize=(width, height), dpi=72, facecolor=(1, 1, 1), edgecolor=(0, 0, 0),
# tight_layout=False)
self.fig = plt.figure(figsize=(width, height), dpi=72,tight_layout=False)
# axesハンドルの生成
self.axes = self.fig.add_subplot(111)
# 再描画では上書きしない
self.axes.hold(False)
# コンストラクタ
FigureCanvas.__init__(self, self.fig)
# 親のウィジェットを生成
self.setParent(parent)
# サイズの更新
FigureCanvas.updateGeometry(self)
# シークバーの格納
self.seakbar_handle = None
self.seakbar_xdata = [1, 1]
self.seakbar_ydata = [-1, 1]
# メインラインハンドルの格納
self.mainline_handle = None
# 画像の初期表示
self.compute_initial_fiugre()
def __init__(self, parent=None, width=5, height=4, dpi=72):
# fiugrueの生成
self.fig = Figure(figsize=(width, height), dpi=dpi,
facecolor=[0.5, 0.5, 0.5], edgecolor=None,
linewidth=1.0,
frameon=True, tight_layout=True)
# axesハンドルの生成
self.axes = self.fig.add_subplot(111)
# 再描画では上書きしない
self.axes.hold(False)
# 画像の初期表示
self.compute_initial_fiugre()
# コンストラクタ
FigureCanvas.__init__(self, self.fig)
# 親のウィジェットを生成
self.setParent(parent)
# サイズの設定
# FigureCanvas.setSizePolicy(self,
# QtGui.QSizePolicy.Expanding,
# QtGui.QSizePolicy.Expanding)
# サイズの更新
FigureCanvas.updateGeometry(self)
class PlotWidget(QWidget):
"""
matplotlib plot widget
"""
def __init__(self,parent):
super(PlotWidget,self).__init__(parent)
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.ax = self.figure.add_subplot(111) # create an axis
layout = QVBoxLayout()
layout.addWidget(self.toolbar)
layout.addWidget(self.canvas)
self.setLayout(layout)
def clear(self):
self.ax.cla()
def test(self):
""" plot random data """
df = fakeData()
#self.ax.hold(False) # discard old data
#self.ax.plot(df,'o-')
self.clear()
df.plot(ax=self.ax)
self.canvas.draw()
def __init__(self, parent, ionCatalogArray, ionSwapCatalog):
self.parent = parent
self.fig = Figure()
FigureCanvas.__init__(self, self.fig)
self.ax1 = self.fig.add_subplot(141)
self.ax2 = self.fig.add_subplot(142)
self.ax3 = self.fig.add_subplot(143)
self.ax4 = self.fig.add_subplot(144)
self.setHist(self.ax1, ionCatalogArray[0], label = 'initial')
self.setHist(self.ax2, ionCatalogArray[1], label = 'shine729')
self.setHist(self.ax3, ionCatalogArray[2], label = 'final')
self.ax1.set_xlabel('Number Of Bright Ions')
self.ax2.set_xlabel('Number Of Dark Ions')
self.ax2.text(.35, .75, str((len(np.where(np.array(ionCatalogArray[1]) == 1)[0])/float(len(ionCatalogArray[1])))*100) + ' percent w/ one ion dark', fontsize=12, transform = self.ax2.transAxes)
self.ax2.text(.35, .8, 'Mean: ' + str(np.mean(ionCatalogArray[1])) + ' ions dark', transform = self.ax2.transAxes)
self.ax2.set_ylim(0, 1)
self.ax3.set_xlabel('Number Of Dark Ions')
self.ax3.text(.35, .75, str((len(np.where(np.array(ionCatalogArray[2]) == 1)[0])/float(len(ionCatalogArray[2])))*100) + ' percent w/ one ion dark', fontsize=12, transform = self.ax3.transAxes)
self.ax3.text(.35, .8, 'Mean: ' + str(np.mean(ionCatalogArray[2])) + ' ions dark', transform = self.ax3.transAxes)
self.ax3.set_ylim(0, 1)
self.ax4.hist(ionSwapCatalog, bins=range(self.parent.parent.expectedNumberOfIonsSpinBox.value()), align='left', normed = True, label = 'Ion Swaps' )
self.ax4.legend(loc='best')
self.ax4.set_xlabel('Distance of Ion Movement')
self.ax4.text(.25, .8, 'Number Ion Swaps: ' + str(len(np.where(np.array(ionSwapCatalog) == 1)[0])), transform = self.ax4.transAxes)
self.ax4.text(0.025, .75, '1 ion dark in both shine729 and final: ' + str(len(ionSwapCatalog)/float(len(ionCatalogArray[0]))*100) + ' %', transform = self.ax4.transAxes)
self.ax4.text(0.10, .70, 'Probability of Ion Swap: ' + str(len(np.where(np.array(ionSwapCatalog) == 1)[0])/float(len(ionSwapCatalog))), transform = self.ax4.transAxes)
def __init__(self, parent):
# instantiate figure
self.fig = Figure()
FigureCanvas.__init__(self, self.fig)
#self.parent = parent
self.parent = parent
self.datasetLabelsDict = {}
self.plotParametersDict = {}
self.dataDict = {}
self.plotDict = {}
self.maxDatasetSizeReached = False
self.data = None
self.drawCounter = 0
# create plot
self.ax = self.fig.add_subplot(111)
self.ax.grid()
colormap = pyplot.cm.gist_ncar
# self.ax.set_color_cycle([colormap(i) for i in np.linspace(0, 0.9, 15)])
colors = ['b', 'g', 'r', 'm', 'k']
colors.extend([colormap(i) for i in np.linspace(.2, 0.9, 7)])
colors.pop(8)
self.ax.set_color_cycle(colors)
lines = ["-"]#,"-","-","-","-","-.","-.","-.","-.","-.","--","--","--","--","--",":",":",":",":",":"]
self.linecycler = cycle(lines)
self.background = self.copy_from_bbox(self.ax.bbox)
def __init__(self, spurset, fef, parent):
chart.__init__(self, spurset, fef, parent)
# make the figure blend in with the native application look
bgcol = parent.palette().window().color().toRgb()
bgcol = [bgcol.redF(), bgcol.greenF(), bgcol.blueF()]
self.fig = Figure()
self.fig.set_facecolor(bgcol)
# a FigureCanvas can be added as a QWidget, so we use that
self.plot = FigureCanvas(self.fig)
self.plot.setParent(parent)
self.ax = self.fig.add_subplot(111)
# TODO skip this, just do a redraw() after initialization?
self.ax.set_xlim(self.spurset.RFmin, self.spurset.RFmax)
self.ax.set_ylim(-0.5*self.spurset.dspan, 0.5*self.spurset.dspan)
self.ax.grid(True)
self.fig.tight_layout()
# a second figure to hold the legend
self.legendFig = Figure()
self.legendFig.set_facecolor(bgcol)
self.legendCanvas = FigureCanvas(self.legendFig)
self.legendFig.legend(*self.ax.get_legend_handles_labels(),
loc='upper left')
# connect up the picker watching
self.picked_obj = None
self._pick = self.plot.mpl_connect('pick_event', self.onpick)
self._drag = self.plot.mpl_connect('motion_notify_event', self.ondrag)
self._drop = self.plot.mpl_connect('button_release_event', self.ondrop)
class WireMap(QtGui.QWidget):
def __init__(self, parent=None):
super(WireMap,self).__init__(parent)
self.parent = parent
self.setup_widgets()
self.vbox = QtGui.QVBoxLayout(self)
self.vbox.addWidget(self.canvas)
self.vbox.addWidget(self.toolbar)
def setup_widgets(self):
# setting up dimensions
self.fig = Figure((5.0, 4.0), dpi=100)
#attaching the figure to the canvas
self.canvas = FigureCanvas(self.fig)
#attaching a toolbar to the canvas
self.toolbar = NavigationToolbar(self.canvas, self.parent)
self.axs = [[] for i in range(6)]
self.pts = [[None]*6 for i in range(6)]
sector_grid = gridspec.GridSpec(2,3,wspace=0.3,hspace=0.2)
for sec in range(6):
slyr_grid = gridspec.GridSpecFromSubplotSpec(6,1,
wspace=0.0,hspace=0.1,
subplot_spec=sector_grid[sec])
for slyr in range(6):
self.axs[sec].append(
self.fig.add_subplot(slyr_grid[5-slyr]))
def update_plots(self):
for sec in range(6):
for slyr in range(6):
self.pts[sec][slyr] = \
self.superlayer_plot(self.axs[sec][slyr],sec,slyr)
self.canvas.draw()
def superlayer_plot(self,ax,sec,slyr):
if not hasattr(self,'data'):
self.data = fetchCrateArray(session)
pt = ax.imshow(self.data[sec][slyr],
origin='lower',
aspect='auto',
interpolation='nearest',
extent=[0.5,112.5,-0.5,5.5],
vmin=0,
cmap=cm.ocean)
if slyr == 5:
ax.set_title('Sector '+str(sec+1))
if (sec > 2) and (slyr == 0):
ax.xaxis.set_ticks([1]+list(range(32,113,32)))
ax.xaxis.set_ticklabels([1]+list(range(32,113,32)))
else:
ax.xaxis.set_major_locator(pyplot.NullLocator())
ax.set_ylabel(str(slyr+1))
ax.yaxis.set_major_locator(pyplot.NullLocator())
ax.hold(False)
return pt
class histpanel(QtGui.QWidget):
def __init__(self,app):
super(histpanel,self).__init__()
self.layout =QtGui.QVBoxLayout()
self.setLayout(self.layout )
self.figure=plt.figure()
self.canvas=FigureCanvas(self.figure)
self.layout.addWidget(self.canvas)
self.histdata=[]
self.app=app
def plot(self,datastr):
data=json.loads(unicode(datastr))
if "history" in data["data"]:
self.histdata=np.array(data["data"]["history"])
self.timestep(datastr)
def timestep(self,resultstr):
data=json.loads(unicode(resultstr))
timestamp=data["data"]["stat"]["time"]
if ( self.app.tab.currentIndex()==2 ):
self.figure.clf()
ax=self.figure.add_subplot(111)
self.figure.set_frameon(False)
ax.patch.set_alpha(0)
ax.set_xlabel("Time [s]")
ax.set_ylabel("Image Count")
ppl.hist(ax,self.histdata-np.ceil(timestamp),bins=100,range=(-100,0))
ax.set_xlim((-100,0))
tstr= datetime.datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S')
ax.set_title(tstr +", "+ str(data["data"]["stat"]['images processed'])+" Images Processed")
self.canvas.draw()
def __init__(self, filename):
FigureCanvas.__init__(self, Figure())
self.spike_axes = self.figure.add_subplot(131)
self.spike_axes.set_title('Spike trains')
self.vm_axes = self.figure.add_subplot(132)
self.vm_axes.set_title('Vm')
self.ca_axes = self.figure.add_subplot(133)
self.ca_axes.set_title('[Ca2+]')
self.spike_axes_bg = self.copy_from_bbox(self.spike_axes.bbox)
self.vm_axes_bg = self.copy_from_bbox(self.vm_axes.bbox)
self.ca_axes_bg = self.copy_from_bbox(self.ca_axes.bbox)
self.datafilename = filename
self.spiketrain_dict = {}
self.vm_dict = {}
self.ca_dict = {}
self.spike_matrix = None
self.simtime = None
self.simdt = None
self.plotdt = None
self.timestamp = None
self.frame_count = 0
self.timepoints = []
self.cell_index_map = {}
self.index_cell_map = {}
self._read_data()
self.draw()
class TrimCanvas(QtGui.QWidget):
def __init__(self):
super(TrimCanvas, self).__init__()
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar2QT(self.canvas, self)
self.frames = None
self.data = None
self.handles = None
self.timedata = None
self.interval = None
def replot(self, mode):
data = plots.raw(f_sampling, self.data)
self.timedata = data['x_vector']
data['legend'] = 'Tymczasowe nagranie'
if mode == 'm':
data['sliders'] = (self.timedata[-1]*0.1, self.timedata[-1]*0.1 + self.interval, self.interval)
self.handles = plot_trimmable(self.figure, data)
else:
data['tight'] = True
self.handles = plot_function(self.figure, data)
self.canvas.draw()
def clear_data(self):
self.figure.clear()
self.canvas.draw()
self.frames = None
self.data = None
def data2frames(self):
bytes = self.data.tobytes()
self.frames = [bytes[i:i+2048] for i in range(0, len(bytes), 2048)]
class MatplotlibWidget:
def __init__(self, mainWidget, settingsWidget):
self.settingsWidget = settingsWidget
self.figure = Figure()
self.figureCanvas = FigureCanvas(self.figure)
self.axes = self.figure.add_subplot(111)
font = {'family': 'Courier New'}
self.axes.set_title(u'График веса', font)
self.axes.set_xlabel(u'Дата', font)
self.axes.set_ylabel(u'Вес, кг', font)
self.set_mass_limits()
mainWidget.verticalLayout.insertWidget(0, self.figureCanvas)
def plot(self, x, y):
self.line1 = self.axes.plot(x, y)
self.axes.set_xticklabels([n.strftime('%d:%m:%Y') for i, n in enumerate(x)], rotation=15)
# self.axes.clear()
self.figureCanvas.draw()
def set_mass_limits(self):
self.axes.set_ylim(
(self.settingsWidget.downMassDoubleSpinBox.value(), self.settingsWidget.upMassDoubleSpinBox.value()))
self.figureCanvas.draw()
def __init__(self, parent=None,
size = (7,3.5),
dpi = 100,
logx = False,
logy = False,
legends = True,
bw = False):
self.fig = Figure(figsize=size, dpi=dpi) #in inches
FigureCanvas.__init__(self, self.fig)
FigureCanvas.setSizePolicy(self,
qt.QSizePolicy.Expanding,
qt.QSizePolicy.Expanding)
self.curveTable = None
self.dpi=dpi
ddict = {'logx':logx,
'logy': logy,
'legends':legends,
'bw':bw}
self.ax=None
self.curveList = []
self.curveDict = {}
self.setParameters(ddict)
#self.setBlackAndWhiteEnabled(bw)
#self.setLogXEnabled(logx)
#self.setLogYEnabled(logy)
#self.setLegendsEnabled(legends)
self.xmin = None
self.xmax = None
self.ymin = None
self.ymax = None
self.limitsSet = False
class MathTextLabel(qt.QWidget):
def __init__(self, mathText, parent=None, **kwargs):
qt.QWidget.__init__(self, parent, **kwargs)
l=qt.QVBoxLayout(self)
l.setContentsMargins(0,0,0,0)
r,g,b,a=self.palette().base().color().getRgbF()
self._figure=Figure(edgecolor=(r,g,b), facecolor=(r,g,b))
self._canvas=FigureCanvas(self._figure)
l.addWidget(self._canvas)
self._figure.clear()
text=self._figure.suptitle(
mathText,
x=0.0,
y=1.0,
horizontalalignment='left',
verticalalignment='top',
size=qt.qApp.font().pointSize()*3)
self._canvas.draw()
(x0,y0),(x1,y1)=text.get_window_extent().get_points()
w=x1-x0; h=y1-y0
#self._figure.set_size_inches(w/4, h/4)
self.setFixedSize(w,h)
def _setup_plot(self):
# Image setup
self.fig = Figure()
FigureCanvas.__init__(self, self.fig)
# Create plot, set x and y axes
ax = self.fig.add_subplot(111)
ax.set_ylim(0, 100)
# Build up timestamps
base = datetime.datetime.now()
date_ranges = [base - datetime.timedelta(seconds=x) for x in range(0,self.window_size)]
for pin in range(5):
sensor_values = [0] * self.window_size
s_plot, = ax.plot(date_ranges,sensor_values, label="Analog {}".format(pin))
# Add the ax and plot to our monitor
self.sensor_readings[pin] = sensor_values
plot_dict = {'plot': s_plot, 'ax': ax}
self.sensor_plots[pin] = plot_dict
# Show legend
ax.legend()
# Fix date formatting
self.fig.autofmt_xdate();
# Draw the initial canvas
self.fig.canvas.draw()
def __init__(self, data, parent=None):
super(WaldoProcessPage, self).__init__(parent)
self.data = data
self.waldoProcessCompleted = False
self.setTitle("Running WALDO")
self.image_figure = plt.figure()
self.image_canvas = FigureCanvas(self.image_figure)
self.image_canvas.setMinimumSize(50, 50)
self.image_canvas.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Expanding)
self.ax_image = self.image_figure.add_subplot(111)
self.ax_image.axis('off')
self.report_figure = plt.figure()
self.report_canvas = FigureCanvas(self.report_figure)
self.report_canvas.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Expanding)
self.report_canvas.setMinimumSize(50, 50)
self.ax_report = self.report_figure.add_subplot(111)
self.main_layout = QtGui.QHBoxLayout()
self.showing_status = WaldoProcessPage.SHOWING_NOTHING
layout = QtGui.QVBoxLayout()
layout.addLayout(self.main_layout)
self.setLayout(layout)
def __init__(self, dataGenerator, dtTimer=1000, ylim=None, xlim=None, startsWithZeroZero=False, title=''):
self.fig = Figure()
self.ax = self.fig.add_subplot(111)
FigureCanvas.__init__(self, self.fig)
self.title = title
self.dataGen = dataGenerator
x, t = self.dataGen.next()
self.setTitle(t)
self.counter = 1
self.width = 0.8
self.locs = np.arange(len(x))
self.bars = self.ax.bar(self.locs, x, self.width, color='#6a7ea6')
if not ylim: ylim = []
if not xlim: xlim = []
if (startsWithZeroZero):
if (ylim):
ylim[0] = 0
else:
ylim = [0, max(x * 1.1)]
if (xlim):
xlim[0] = -0.5
else:
xlim = [-0.5, len(x)]
if (ylim): self.ax.set_ylim(ylim[0], ylim[1])
if (xlim): self.ax.set_xlim(xlim[0], xlim[1])
self.fig.canvas.draw()
self.show()
self.timer = self.startTimer(dtTimer)
class Widget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
QVBoxLayout(self)
self.figure = Figure()
self.canvas = FigureCanvas(self.figure)
self.canvas.setParent(self)
codes, verts = zip(*pathdata)
path = mpath.Path(verts, codes)
patch = mpatches.PathPatch(path, facecolor="red", edgecolor="yellow", alpha=0.5)
self.axes = self.figure.add_subplot(111)
self.axes.add_patch(patch)
x, y = zip(*path.vertices)
self.axes.plot(x, y, "go-")
self.axes.grid()
self.axes.set_xlim(-3, 4)
self.axes.set_ylim(-3, 4)
self.axes.set_title("spline paths")
self.layout().addWidget(self.canvas)
self.canvas.draw()
def __init__(self, map_, width, height, parent=None, dpi=100, **matplot_args): # pylint: disable=W0613
# self._widthHint = width
# self._heightHint = height
self._origMap = map_
self._map = map_.resample((width, height))
# Old way (segfaults in some environements)
# self.figure = self._map.plot_simple(**matplot_args)
# FigureCanvas.__init__(self, self.figure)
self.figure = Figure()
self._map.plot(figure=self.figure, basic_plot=True, **matplot_args)
self.axes = self.figure.gca()
FigureCanvas.__init__(self, self.figure)
# How can we get the canvas to preserve its aspect ratio when expanding?
# sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred)
# sizePolicy.setHeightForWidth(True)
# self.setSizePolicy(sizePolicy)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
self.setSizePolicy(sizePolicy)
self.setMinimumSize(QtCore.QSize(width, height))
self.setMaximumSize(QtCore.QSize(width, height))
class MainWidget(QtGui.QWidget):
def __init__(self, parent=None):
super(MainWidget, self).__init__(parent)
# a figure instance to plot on
self.figure = plt.figure()
# this is the Canvas Widget that displays /embpyqt/python/the `figure`
# it takes the `figure` instance as a parameter to __init__
self.canvas = FigureCanvas(self.figure)
# this is the Navigation widget
# it takes the Canvas widget and a parent
self.toolbar = NavigationToolbar(self.canvas, self)
# Just some button connected to `plot` method
self.button = QtGui.QPushButton('Plot')
self.button.clicked.connect(self.plot)
# set the layout
layout = QtGui.QVBoxLayout()
layout.addWidget(self.toolbar)
layout.addWidget(self.canvas)
layout.addWidget(self.button)
self.setLayout(layout)
def plot(self):
''' plot some random stuff '''
# random data
'''data = [random.random() for i in range(2)]
# create an axis
ax = self.figure.add_subplot(111)
# discards the old graph
ax.hold(False)
# plot data
ax.plot(data, '*-')'''
m = Basemap(projection='robin',lon_0=0,resolution='c')#,latlon=True)
m.bluemarble(scale=0.2)
for friend in rpc.bridge.getFriendList():
print ''
pd = rpc.bridge.getPeerDetails(friend)
print pd['name']
print pd['extAddr']
ld = gi.record_by_addr(pd['extAddr'])
print ld
if ld:
print ld['latitude'],ld['longitude']
x, y = m(ld['longitude'],ld['latitude'])
#m.scatter(x, y,30,marker='o',color='k')
plt.plot(x, y,'ro')
plt.text(x,y,pd['name'],fontsize=9,
ha='center',va='top',color='r',
bbox = dict(boxstyle="square",ec='None',fc=(1,1,1,0.5)))
#plt.text(x,y,pd['name'],fontsize=14,fontweight='bold',
# ha='center',va='center',color='r')
# refresh canvas
self.canvas.draw()
class Window(QtGui.QDialog):
def __init__(self, parent=None):
super(Window, self).__init__(parent)
# a figure instance to plot on
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.plot()
# set the layout
layout = QtGui.QVBoxLayout()
layout.addWidget(self.canvas)
self.setLayout(layout)
def plot(self):
''' plot some random stuff '''
# random data
data = [random.random() for i in range(10)]
# create an axis
ax = self.figure.add_subplot(111)
# discards the old graph
ax.hold(False)
# plot data
ax.plot(data, '*-')
# refresh canvas
self.canvas.draw()
class RewardWidget(QtGui.QWidget):
def __init__(self, parent=None):
super(RewardWidget, self).__init__(parent)
self.samples = 0
self.resize(1500, 100)
self.figure = Figure()
self.canvas = FigureCanvasQTAgg(self.figure)
self.axes = self.figure.add_axes([0, 0, 1, 1])
self.layoutVertical = QtGui.QVBoxLayout(self)
self.layoutVertical.addWidget(self.canvas)
def set_time_range(self, time_range):
self.time_range = time_range
range_length = int((time_range[1] - time_range[0]))
self.rewards = [0] * (range_length * 100)
def add_data(self, data_range, data):
begin = int(round((data_range[0] - self.time_range[0]) * 100))
end = int(round((data_range[1] - self.time_range[0]) * 100)) + 1
self.rewards[begin:end] = [data for x in range(end-begin)]
range_length = int((self.time_range[1] - self.time_range[0]))
self.axes.clear()
self.axes.set_xlim([0,range_length*100])
self.axes.set_ylim([-10.0,10.0])
self.axes.plot(self.rewards)
self.canvas.draw()
#print(self.rewards)
def __init__(self, parent):
self.parent = parent
self.fig = Figure()
self.ax = self.fig.add_subplot(111)
FigureCanvas.__init__(self, self.fig)
#self.cidPress = self.mpl_connect('button_press_event', self.onClick)
#self.cidRelease = self.mpl_connect('button_release_event', self.onRelease)
#self.X = np.random.rand(5,5)
#rows,cols,self.slices = self.X.shape
#self.Y = np.random.rand(5,5)
#rows,cols,self.slices = self.X.shape
newdata = np.ones(2*2)
newarray = np.reshape(newdata, (2, 2))
self.data = newarray
#self.im = self.ax.matshow(self.X[:,:])
#self.im = self.ax.matshow(self.data)
self.update()
self.fig.canvas.draw()
self.cnt = 0
self.setupSelector()
def __init__(self,parent=None,width=5,height=4,dpi=100):
figure = Figure(figsize=(width,height),dpi=dpi)
FigureCanvas.__init__(self,figure)
self.setParent(parent)
self.axes = figure.add_subplot(111)
self.axes.hold(False)
self.axeX = [0]
def paintEvent(self, event):
Canvas.paintEvent(self, event)
if not self.limit_mode:
return
# convert to data units
height = self.figure.bbox.height
t = lambda s: np.array(self.axes.transData.transform(s))
qp = QPainter()
qp.begin(self)
qp.setPen(QColor(*self.limit_color))
# Draw polygon
if self.limit_mode and self.limit_type == 1:
for i in range(len(self.limit_data) - 1):
start = t(self.limit_data[i])
end = t(self.limit_data[i + 1])
qp.drawLine(start[0], height - start[1],
end[0], height - end[1])
if self.limit_data:
start = t(self.limit_data[-1])
end = t((self._mouse_move_event.xdata,
self._mouse_move_event.ydata))
qp.drawLine(start[0], height - start[1],
end[0], height - end[1])
# Draw an ellipse
if self.limit_mode and self.limit_type == 2 and self.limit_data:
# convert to display coordinates
startp = t(self.limit_data[0])
mouse = t((self._mouse_move_event.xdata,
self._mouse_move_event.ydata))
center = 0.5 * (startp + mouse)
if len(self.limit_data) == 1: # we've set the center, draw line
eheight = 30
angvec = mouse - center
angle = np.arctan2(angvec[1], angvec[0])
ewidth = np.linalg.norm(angvec)
elif len(self.limit_data) > 1: # we've also fixed the angle
angleline = t(self.limit_data[1])
center = 0.5 * (startp + angleline)
angvec = angleline - center
angle = np.arctan2(angvec[1], angvec[0])
ewidth = np.linalg.norm(angvec)
angvec = angvec / ewidth
mvec = mouse - center
eheight = np.linalg.norm(mvec - np.dot(mvec, angvec) * angvec)
if self.limit_data:
qp.translate(center[0], height - center[1])
qp.rotate(-angle * 180.0 / np.pi)
qp.drawEllipse(QPoint(0, 0), ewidth, eheight)
qp.drawLine(-ewidth, 0, ewidth, 0)
qp.drawLine(0, -eheight, 0, eheight)
qp.end()
def __init__(self):
"""Constructor"""
# Create the figure in the canvas
self.fig = Figure()
self.ax = self.fig.add_subplot(111)
FigureCanvas.__init__(self, self.fig)
# generates first "empty" plot
t = [0.0]
e = [0.0]
self.line, = self.ax.plot(t,
e,
color="black",
linestyle="-",
linewidth=1.0)
# Set some options
self.T = {{L}} / {{U}}
self.Ek = {{E_KIN}}
self.ax.grid()
self.ax.set_xlim(0, 10.0)
self.ax.set_ylim(0.0, 1.1)
self.ax.set_autoscale_on(False)
self.ax.set_xlabel(r"$t U / L$", fontsize=21)
self.ax.set_ylabel(r"$\mathcal{E}_{k}(t) / \mathcal{E}_{k}(0)$", fontsize=21)
# force the figure redraw
self.fig.canvas.draw()
# call the update method (to speed-up visualization)
self.timerEvent(None)
# start timer, trigger event every 1000 millisecs (=1sec)
self.timer = self.startTimer(1000)
class GAUDInspectChartCanvas(QtGui.QWidget):
def __init__(self, parent=None):
super(GAUDInspectChartCanvas, self).__init__(parent)
self.initUI()
def initUI(self):
plt.style.use('fivethirtyeight')
plt.rc('font', size=12)
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.figure.patch.set_alpha(0)
self.ax1 = self.figure.add_subplot(
111, axis_bgcolor='none',
xlim=(0, 20), ylim=(0, 1000),
xlabel='Generations')
self.ax2 = self.ax1.twinx()
self.legend = plt.legend(
*self.ax1.get_legend_handles_labels(),
loc='upper left', fancybox=True, framealpha=0.8)
# set the layout
layout = QtGui.QVBoxLayout()
layout.addWidget(self.canvas)
self.setLayout(layout)
self.figure.tight_layout()
def configure_plot(self, generations, objectives, population):
# Clear eveything
self.legend.remove()
self.ax1.cla()
self.ax2.cla()
self.ax1.set_axis_bgcolor('none')
self.ax1.set_xlabel('Generations')
self.ax1.set_ylabel('Average score')
self.ax1.set_autoscalex_on(False)
self.ax1.set_xlim(1, generations)
self.ax1.set_autoscaley_on(True)
# Create a line plotter for each objective
self.lines = []
for obj in objectives:
line, = self.ax1.plot([], label=obj['name'])
self.lines.append(line)
# Create legend for objectives
self.legend = plt.legend(*self.ax1.get_legend_handles_labels(),
loc='upper left', fancybox=True, framealpha=0.8)
# Get a second Y axis for evaluations
self.ax2.set_ylim(0, population)
self.ax2.set_xlim(1, generations)
self.ax2.set_ylabel('Individuals evaluated')
self.ax2.grid(b=False)
# Fix Z-ordering of axes
self.ax1.set_zorder(self.ax2.get_zorder() + 1)
# Draw evaluations per generation
self.rects = self.ax2.bar(
range(1, generations + 1), [0] * generations,
align='center', color='0.85')
# Move legend to top
self.ax1.add_artist(self.legend)
self.ax2.legend_ = None
self.figure.tight_layout()
self.canvas.draw()
def plot(self, objectives, evals, gen):
self.rects[gen - 1].set_height(evals)
for line, obj in zip(self.lines, objectives):
line.set_data(numpy.append(line.get_xdata(), gen),
numpy.append(line.get_ydata(), obj[0]))
# Update view (yes, all these commands are compulsory)
self.ax1.relim()
self.ax1.autoscale_view()
self.figure.tight_layout()
self.canvas.draw()
class SquidGui(QMainWindow):
defaults = {}
defaults.update(SquidAxon.defaults)
defaults.update(ClampCircuit.defaults)
defaults.update({
'runtime': 50.0,
'simdt': 0.01,
'plotdt': 0.1,
'vclamp.holdingV': 0.0,
'vclamp.holdingT': 10.0,
'vclamp.prepulseV': 0.0,
'vclamp.prepulseT': 0.0,
'vclamp.clampV': 50.0,
'vclamp.clampT': 20.0,
'iclamp.baseI': 0.0,
'iclamp.firstI': 0.1,
'iclamp.firstT': 40.0,
'iclamp.firstD': 5.0,
'iclamp.secondI': 0.0,
'iclamp.secondT': 0.0,
'iclamp.secondD': 0.0
})
def __init__(self, *args):
QMainWindow.__init__(self, *args)
self.squid_setup = SquidSetup()
self._plotdt = SquidGui.defaults['plotdt']
self._plot_dict = defaultdict(list)
self.setWindowTitle('Squid Axon simulation')
self.setDockNestingEnabled(True)
self._createRunControl()
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._runControlDock)
self._runControlDock.setFeatures(QDockWidget.AllDockWidgetFeatures)
self._createChannelControl()
self._channelCtrlBox.setWindowTitle('Channel properties')
self._channelControlDock.setFeatures(QDockWidget.AllDockWidgetFeatures)
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea,
self._channelControlDock)
self._createElectronicsControl()
self._electronicsDock.setFeatures(QDockWidget.AllDockWidgetFeatures)
self._electronicsDock.setWindowTitle('Electronics')
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self._electronicsDock)
self._createPlotWidget()
self.setCentralWidget(self._plotWidget)
self._createStatePlotWidget()
self._createHelpMessage()
self._helpWindow.setVisible(False)
self._statePlotWidget.setWindowFlags(QtCore.Qt.Window)
self._statePlotWidget.setWindowTitle('State plot')
self._initActions()
self._createRunToolBar()
self._createPlotToolBar()
def getFloatInput(self, widget, name):
try:
return float(str(widget.text()))
except ValueError:
QMessageBox.critical(
self, 'Invalid input',
'Please enter a valid number for {}'.format(name))
raise
def _createPlotWidget(self):
self._plotWidget = QWidget()
self._plotFigure = Figure()
self._plotCanvas = FigureCanvas(self._plotFigure)
self._plotCanvas.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self._plotCanvas.updateGeometry()
self._plotCanvas.setParent(self._plotWidget)
self._plotCanvas.mpl_connect('scroll_event', self._onScroll)
self._plotFigure.set_canvas(self._plotCanvas)
# Vm and command voltage go in the same subplot
self._vm_axes = self._plotFigure.add_subplot(
2, 2, 1, title='Membrane potential')
self._vm_axes.set_ylim(-20.0, 120.0)
# Channel conductances go to the same subplot
self._g_axes = self._plotFigure.add_subplot(
2, 2, 2, title='Channel conductance')
self._g_axes.set_ylim(0.0, 0.5)
# Injection current for Vclamp/Iclamp go to the same subplot
self._im_axes = self._plotFigure.add_subplot(2,
2,
3,
title='Injection current')
self._im_axes.set_ylim(-0.5, 0.5)
# Channel currents go to the same subplot
self._i_axes = self._plotFigure.add_subplot(2,
2,
4,
title='Channel current')
self._i_axes.set_ylim(-10, 10)
for axis in self._plotFigure.axes:
axis.set_autoscale_on(False)
layout = QVBoxLayout()
layout.addWidget(self._plotCanvas)
self._plotNavigator = NavigationToolbar(self._plotCanvas,
self._plotWidget)
layout.addWidget(self._plotNavigator)
self._plotWidget.setLayout(layout)
def _createStatePlotWidget(self):
self._statePlotWidget = QWidget()
self._statePlotFigure = Figure()
self._statePlotCanvas = FigureCanvas(self._statePlotFigure)
self._statePlotCanvas.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self._statePlotCanvas.updateGeometry()
self._statePlotCanvas.setParent(self._statePlotWidget)
self._statePlotFigure.set_canvas(self._statePlotCanvas)
self._statePlotFigure.subplots_adjust(hspace=0.5)
self._statePlotAxes = self._statePlotFigure.add_subplot(
2, 1, 1, title='State plot')
self._state_plot, = self._statePlotAxes.plot([], [], label='state')
self._activationParamAxes = self._statePlotFigure.add_subplot(
2, 1, 2, title='H-H activation parameters vs time')
self._activationParamAxes.set_xlabel('Time (ms)')
#for axis in self._plotFigure.axes:
# axis.autoscale(False)
self._stateplot_xvar_label = QLabel('Variable on X-axis')
self._stateplot_xvar_combo = QComboBox()
self._stateplot_xvar_combo.addItems(['V', 'm', 'n', 'h'])
self._stateplot_xvar_combo.setCurrentText('V')
self._stateplot_xvar_combo.setEditable(False)
self._stateplot_xvar_combo.currentIndexChanged[str].connect(
self._statePlotXSlot)
self._stateplot_yvar_label = QLabel('Variable on Y-axis')
self._stateplot_yvar_combo = QComboBox()
self._stateplot_yvar_combo.addItems(['V', 'm', 'n', 'h'])
self._stateplot_yvar_combo.setCurrentIndex(2)
self._stateplot_yvar_combo.setEditable(False)
self._stateplot_yvar_combo.currentIndexChanged[str].connect(
self._statePlotYSlot)
self._statePlotNavigator = NavigationToolbar(self._statePlotCanvas,
self._statePlotWidget)
frame = QFrame()
frame.setFrameStyle(QFrame.StyledPanel + QFrame.Raised)
layout = QHBoxLayout()
layout.addWidget(self._stateplot_xvar_label)
layout.addWidget(self._stateplot_xvar_combo)
layout.addWidget(self._stateplot_yvar_label)
layout.addWidget(self._stateplot_yvar_combo)
frame.setLayout(layout)
self._closeStatePlotAction = QAction('Close', self)
self._closeStatePlotAction.triggered.connect(
self._statePlotWidget.close)
self._closeStatePlotButton = QToolButton()
self._closeStatePlotButton.setDefaultAction(self._closeStatePlotAction)
layout = QVBoxLayout()
layout.addWidget(frame)
layout.addWidget(self._statePlotCanvas)
layout.addWidget(self._statePlotNavigator)
layout.addWidget(self._closeStatePlotButton)
self._statePlotWidget.setLayout(layout)
# Setting the close event so that when the help window is
# closed the ``State plot`` button becomes unchecked
self._statePlotWidget.closeEvent = lambda event: self._showStatePlotAction.setChecked(
False)
def _createRunControl(self):
self._runControlBox = QGroupBox(self)
self._runControlBox.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
self._runTimeLabel = QLabel("Run time (ms)", self._runControlBox)
self._simTimeStepLabel = QLabel("Simulation time step (ms)",
self._runControlBox)
self._runTimeEdit = QLineEdit('%g' % (SquidGui.defaults['runtime']),
self._runControlBox)
set_default_line_edit_size(self._runTimeEdit)
self._simTimeStepEdit = QLineEdit('%g' % (SquidGui.defaults['simdt']),
self._runControlBox)
set_default_line_edit_size(self._simTimeStepEdit)
layout = QGridLayout()
layout.addWidget(self._runTimeLabel, 0, 0)
layout.addWidget(self._runTimeEdit, 0, 1)
layout.addWidget(self._simTimeStepLabel, 1, 0)
layout.addWidget(self._simTimeStepEdit, 1, 1)
layout.setColumnStretch(2, 1.0)
layout.setRowStretch(2, 1.0)
self._runControlBox.setLayout(layout)
self._runControlDock = QDockWidget('Simulation', self)
self._runControlDock.setWidget(self._runControlBox)
def _createChannelControl(self):
self._channelControlDock = QDockWidget('Channels', self)
self._channelCtrlBox = QGroupBox(self)
self._naConductanceToggle = QCheckBox('Block Na+ channel',
self._channelCtrlBox)
self._naConductanceToggle.setToolTip('<html>%s</html>' %
(tooltip_NaChan))
self._kConductanceToggle = QCheckBox('Block K+ channel',
self._channelCtrlBox)
self._kConductanceToggle.setToolTip('<html>%s</html>' %
(tooltip_KChan))
self._kOutLabel = QLabel('[K+]out (mM)', self._channelCtrlBox)
self._kOutEdit = QLineEdit('%g' % (self.squid_setup.axon.K_out),
self._channelCtrlBox)
self._kOutLabel.setToolTip('<html>%s</html>' % (tooltip_Nernst))
self._kOutEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
set_default_line_edit_size(self._kOutEdit)
self._naOutLabel = QLabel('[Na+]out (mM)', self._channelCtrlBox)
self._naOutEdit = QLineEdit('%g' % (self.squid_setup.axon.Na_out),
self._channelCtrlBox)
self._naOutLabel.setToolTip('<html>%s</html>' % (tooltip_Nernst))
self._naOutEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
set_default_line_edit_size(self._naOutEdit)
self._kInLabel = QLabel('[K+]in (mM)', self._channelCtrlBox)
self._kInEdit = QLineEdit('%g' % (self.squid_setup.axon.K_in),
self._channelCtrlBox)
self._kInEdit.setToolTip(tooltip_Nernst)
self._naInLabel = QLabel('[Na+]in (mM)', self._channelCtrlBox)
self._naInEdit = QLineEdit('%g' % (self.squid_setup.axon.Na_in),
self._channelCtrlBox)
self._naInEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
self._temperatureLabel = QLabel('Temperature (C)',
self._channelCtrlBox)
self._temperatureEdit = QLineEdit(
'%g' % (self.defaults['temperature'] - CELSIUS_TO_KELVIN),
self._channelCtrlBox)
self._temperatureEdit.setToolTip('<html>%s</html>' % (tooltip_Nernst))
set_default_line_edit_size(self._temperatureEdit)
for child in self._channelCtrlBox.children():
if isinstance(child, QLineEdit):
set_default_line_edit_size(child)
layout = QGridLayout(self._channelCtrlBox)
layout.addWidget(self._naConductanceToggle, 0, 0)
layout.addWidget(self._kConductanceToggle, 1, 0)
layout.addWidget(self._naOutLabel, 2, 0)
layout.addWidget(self._naOutEdit, 2, 1)
layout.addWidget(self._naInLabel, 3, 0)
layout.addWidget(self._naInEdit, 3, 1)
layout.addWidget(self._kOutLabel, 4, 0)
layout.addWidget(self._kOutEdit, 4, 1)
layout.addWidget(self._kInLabel, 5, 0)
layout.addWidget(self._kInEdit, 5, 1)
layout.addWidget(self._temperatureLabel, 6, 0)
layout.addWidget(self._temperatureEdit, 6, 1)
layout.setRowStretch(7, 1.0)
self._channelCtrlBox.setLayout(layout)
self._channelControlDock.setWidget(self._channelCtrlBox)
return self._channelCtrlBox
def __get_stateplot_data(self, name):
data = []
if name == 'V':
data = self.squid_setup.vm_table.vector
elif name == 'm':
data = self.squid_setup.m_table.vector
elif name == 'h':
data = self.squid_setup.h_table.vector
elif name == 'n':
data = self.squid_setup.n_table.vector
else:
raise ValueError('Unrecognized selection: %s' % name)
return numpy.asarray(data)
def _statePlotYSlot(self, selectedItem):
ydata = self.__get_stateplot_data(str(selectedItem))
self._state_plot.set_ydata(ydata)
self._statePlotAxes.set_ylabel(selectedItem)
if str(selectedItem) == 'V':
self._statePlotAxes.set_ylim(-20, 120)
else:
self._statePlotAxes.set_ylim(0, 1)
self._statePlotCanvas.draw()
def _statePlotXSlot(self, selectedItem):
xdata = self.__get_stateplot_data(str(selectedItem))
self._state_plot.set_xdata(xdata)
self._statePlotAxes.set_xlabel(selectedItem)
if str(selectedItem) == 'V':
self._statePlotAxes.set_xlim(-20, 120)
else:
self._statePlotAxes.set_xlim(0, 1)
self._statePlotCanvas.draw()
def _createElectronicsControl(self):
"""Creates a tabbed widget of voltage clamp and current clamp controls"""
self._electronicsTab = QTabWidget(self)
self._electronicsTab.addTab(self._getIClampCtrlBox(), 'Current clamp')
self._electronicsTab.addTab(self._getVClampCtrlBox(), 'Voltage clamp')
self._electronicsDock = QDockWidget(self)
self._electronicsDock.setWidget(self._electronicsTab)
def _getVClampCtrlBox(self):
vClampPanel = QGroupBox(self)
self._vClampCtrlBox = vClampPanel
self._holdingVLabel = QLabel("Holding Voltage (mV)", vClampPanel)
self._holdingVEdit = QLineEdit(
'%g' % (SquidGui.defaults['vclamp.holdingV']), vClampPanel)
self._holdingTimeLabel = QLabel("Holding Time (ms)", vClampPanel)
self._holdingTimeEdit = QLineEdit(
'%g' % (SquidGui.defaults['vclamp.holdingT']), vClampPanel)
self._prePulseVLabel = QLabel("Pre-pulse Voltage (mV)", vClampPanel)
self._prePulseVEdit = QLineEdit(
'%g' % (SquidGui.defaults['vclamp.prepulseV']), vClampPanel)
self._prePulseTimeLabel = QLabel("Pre-pulse Time (ms)", vClampPanel)
self._prePulseTimeEdit = QLineEdit(
'%g' % (SquidGui.defaults['vclamp.prepulseT']), vClampPanel)
self._clampVLabel = QLabel("Clamp Voltage (mV)", vClampPanel)
self._clampVEdit = QLineEdit(
'%g' % (SquidGui.defaults['vclamp.clampV']), vClampPanel)
self._clampTimeLabel = QLabel("Clamp Time (ms)", vClampPanel)
self._clampTimeEdit = QLineEdit(
'%g' % (SquidGui.defaults['vclamp.clampT']), vClampPanel)
for child in vClampPanel.children():
if isinstance(child, QLineEdit):
set_default_line_edit_size(child)
layout = QGridLayout(vClampPanel)
layout.addWidget(self._holdingVLabel, 0, 0)
layout.addWidget(self._holdingVEdit, 0, 1)
layout.addWidget(self._holdingTimeLabel, 1, 0)
layout.addWidget(self._holdingTimeEdit, 1, 1)
layout.addWidget(self._prePulseVLabel, 2, 0)
layout.addWidget(self._prePulseVEdit, 2, 1)
layout.addWidget(self._prePulseTimeLabel, 3, 0)
layout.addWidget(self._prePulseTimeEdit, 3, 1)
layout.addWidget(self._clampVLabel, 4, 0)
layout.addWidget(self._clampVEdit, 4, 1)
layout.addWidget(self._clampTimeLabel, 5, 0)
layout.addWidget(self._clampTimeEdit, 5, 1)
layout.setRowStretch(6, 1.0)
vClampPanel.setLayout(layout)
return self._vClampCtrlBox
def _getIClampCtrlBox(self):
iClampPanel = QGroupBox(self)
self._iClampCtrlBox = iClampPanel
self._baseCurrentLabel = QLabel("Base Current Level (uA)", iClampPanel)
self._baseCurrentEdit = QLineEdit(
'%g' % (SquidGui.defaults['iclamp.baseI']), iClampPanel)
self._firstPulseLabel = QLabel("First Pulse Current (uA)", iClampPanel)
self._firstPulseEdit = QLineEdit(
'%g' % (SquidGui.defaults['iclamp.firstI']), iClampPanel)
self._firstDelayLabel = QLabel("First Onset Delay (ms)", iClampPanel)
self._firstDelayEdit = QLineEdit(
'%g' % (SquidGui.defaults['iclamp.firstD']), iClampPanel)
self._firstPulseWidthLabel = QLabel("First Pulse Width (ms)",
iClampPanel)
self._firstPulseWidthEdit = QLineEdit(
'%g' % (SquidGui.defaults['iclamp.firstT']), iClampPanel)
self._secondPulseLabel = QLabel("Second Pulse Current (uA)",
iClampPanel)
self._secondPulseEdit = QLineEdit(
'%g' % (SquidGui.defaults['iclamp.secondI']), iClampPanel)
self._secondDelayLabel = QLabel("Second Onset Delay (ms)", iClampPanel)
self._secondDelayEdit = QLineEdit(
'%g' % (SquidGui.defaults['iclamp.secondD']), iClampPanel)
self._secondPulseWidthLabel = QLabel("Second Pulse Width (ms)",
iClampPanel)
self._secondPulseWidthEdit = QLineEdit(
'%g' % (SquidGui.defaults['iclamp.secondT']), iClampPanel)
self._pulseMode = QComboBox(iClampPanel)
self._pulseMode.addItem("Single Pulse")
self._pulseMode.addItem("Pulse Train")
for child in iClampPanel.children():
if isinstance(child, QLineEdit):
set_default_line_edit_size(child)
layout = QGridLayout(iClampPanel)
layout.addWidget(self._baseCurrentLabel, 0, 0)
layout.addWidget(self._baseCurrentEdit, 0, 1)
layout.addWidget(self._firstPulseLabel, 1, 0)
layout.addWidget(self._firstPulseEdit, 1, 1)
layout.addWidget(self._firstDelayLabel, 2, 0)
layout.addWidget(self._firstDelayEdit, 2, 1)
layout.addWidget(self._firstPulseWidthLabel, 3, 0)
layout.addWidget(self._firstPulseWidthEdit, 3, 1)
layout.addWidget(self._secondPulseLabel, 4, 0)
layout.addWidget(self._secondPulseEdit, 4, 1)
layout.addWidget(self._secondDelayLabel, 5, 0)
layout.addWidget(self._secondDelayEdit, 5, 1)
layout.addWidget(self._secondPulseWidthLabel, 6, 0)
layout.addWidget(self._secondPulseWidthEdit, 6, 1)
layout.addWidget(self._pulseMode, 7, 0, 1, 2)
layout.setRowStretch(8, 1.0)
# layout.setSizeConstraint(QLayout.SetFixedSize)
iClampPanel.setLayout(layout)
return self._iClampCtrlBox
def _overlayPlots(self, overlay):
if not overlay:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
title = axis.get_title()
axis.clear()
axis.set_title(title)
suffix = ''
else:
suffix = '_%d' % (len(self._plot_dict['vm']))
self._vm_axes.set_xlim(0.0, self._runtime)
self._g_axes.set_xlim(0.0, self._runtime)
self._im_axes.set_xlim(0.0, self._runtime)
self._i_axes.set_xlim(0.0, self._runtime)
self._vm_plot, = self._vm_axes.plot([], [], label='Vm%s' % (suffix))
self._plot_dict['vm'].append(self._vm_plot)
self._command_plot, = self._vm_axes.plot([], [],
label='command%s' % (suffix))
self._plot_dict['command'].append(self._command_plot)
# Channel conductances go to the same subplot
self._gna_plot, = self._g_axes.plot([], [], label='Na%s' % (suffix))
self._plot_dict['gna'].append(self._gna_plot)
self._gk_plot, = self._g_axes.plot([], [], label='K%s' % (suffix))
self._plot_dict['gk'].append(self._gk_plot)
# Injection current for Vclamp/Iclamp go to the same subplot
self._iclamp_plot, = self._im_axes.plot([], [],
label='Iclamp%s' % (suffix))
self._vclamp_plot, = self._im_axes.plot([], [],
label='Vclamp%s' % (suffix))
self._plot_dict['iclamp'].append(self._iclamp_plot)
self._plot_dict['vclamp'].append(self._vclamp_plot)
# Channel currents go to the same subplot
self._ina_plot, = self._i_axes.plot([], [], label='Na%s' % (suffix))
self._plot_dict['ina'].append(self._ina_plot)
self._ik_plot, = self._i_axes.plot([], [], label='K%s' % (suffix))
self._plot_dict['ik'].append(self._ik_plot)
# self._i_axes.legend()
# State plots
self._state_plot, = self._statePlotAxes.plot([], [],
label='state%s' %
(suffix))
self._plot_dict['state'].append(self._state_plot)
self._m_plot, = self._activationParamAxes.plot([], [],
label='m%s' % (suffix))
self._h_plot, = self._activationParamAxes.plot([], [],
label='h%s' % (suffix))
self._n_plot, = self._activationParamAxes.plot([], [],
label='n%s' % (suffix))
self._plot_dict['m'].append(self._m_plot)
self._plot_dict['h'].append(self._h_plot)
self._plot_dict['n'].append(self._n_plot)
if self._showLegendAction.isChecked():
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.legend()
def _updateAllPlots(self):
self._updatePlots()
self._updateStatePlot()
def _updatePlots(self):
if len(self.squid_setup.vm_table.vector) <= 0:
return
vm = numpy.asarray(self.squid_setup.vm_table.vector)
cmd = numpy.asarray(self.squid_setup.cmd_table.vector)
ik = numpy.asarray(self.squid_setup.ik_table.vector)
# tab = self.squid_setup.ina_table
# print(moose.showmsg(tab))
ina = numpy.asarray(self.squid_setup.ina_table.vector)
iclamp = numpy.asarray(self.squid_setup.iclamp_table.vector)
vclamp = numpy.asarray(self.squid_setup.vclamp_table.vector)
gk = numpy.asarray(self.squid_setup.gk_table.vector)
gna = numpy.asarray(self.squid_setup.gna_table.vector)
time_series = numpy.linspace(0, self._plotdt * len(vm), len(vm))
self._vm_plot.set_data(time_series, vm)
time_series = numpy.linspace(0, self._plotdt * len(cmd), len(cmd))
self._command_plot.set_data(time_series, cmd)
time_series = numpy.linspace(0, self._plotdt * len(ik), len(ik))
self._ik_plot.set_data(time_series, ik)
time_series = numpy.linspace(0, self._plotdt * len(ina), len(ina))
self._ina_plot.set_data(time_series, ina)
time_series = numpy.linspace(0, self._plotdt * len(iclamp),
len(iclamp))
self._iclamp_plot.set_data(time_series, iclamp)
time_series = numpy.linspace(0, self._plotdt * len(vclamp),
len(vclamp))
self._vclamp_plot.set_data(time_series, vclamp)
time_series = numpy.linspace(0, self._plotdt * len(gk), len(gk))
self._gk_plot.set_data(time_series, gk)
time_series = numpy.linspace(0, self._plotdt * len(gna), len(gna))
self._gna_plot.set_data(time_series, gna)
# self._vm_axes.margins(y=0.1)
# self._g_axes.margin(y=0.1)
# self._im_axes.margins(y=0.1)
# self._i_axes.margins(y=0.1)
if self._autoscaleAction.isChecked():
for axis in self._plotFigure.axes:
axis.relim()
axis.margins(0.1, 0.1)
axis.autoscale_view(tight=True)
else:
self._vm_axes.set_ylim(-20.0, 120.0)
self._g_axes.set_ylim(0.0, 0.5)
self._im_axes.set_ylim(-0.5, 0.5)
self._i_axes.set_ylim(-10, 10)
self._vm_axes.set_xlim(0.0, time_series[-1])
self._g_axes.set_xlim(0.0, time_series[-1])
self._im_axes.set_xlim(0.0, time_series[-1])
self._i_axes.set_xlim(0.0, time_series[-1])
self._plotCanvas.draw()
def _updateStatePlot(self):
if len(self.squid_setup.vm_table.vector) <= 0:
return
sx = str(self._stateplot_xvar_combo.currentText())
sy = str(self._stateplot_yvar_combo.currentText())
xdata = self.__get_stateplot_data(sx)
ydata = self.__get_stateplot_data(sy)
minlen = min(len(xdata), len(ydata))
self._state_plot.set_data(xdata[:minlen], ydata[:minlen])
self._statePlotAxes.set_xlabel(sx)
self._statePlotAxes.set_ylabel(sy)
if sx == 'V':
self._statePlotAxes.set_xlim(-20, 120)
else:
self._statePlotAxes.set_xlim(0, 1)
if sy == 'V':
self._statePlotAxes.set_ylim(-20, 120)
else:
self._statePlotAxes.set_ylim(0, 1)
self._activationParamAxes.set_xlim(0, self._runtime)
m = self.__get_stateplot_data('m')
n = self.__get_stateplot_data('n')
h = self.__get_stateplot_data('h')
time_series = numpy.linspace(0, self._plotdt * len(m), len(m))
self._m_plot.set_data(time_series, m)
time_series = numpy.linspace(0, self._plotdt * len(h), len(h))
self._h_plot.set_data(time_series, h)
time_series = numpy.linspace(0, self._plotdt * len(n), len(n))
self._n_plot.set_data(time_series, n)
if self._autoscaleAction.isChecked():
for axis in self._statePlotFigure.axes:
axis.relim()
axis.set_autoscale_on(True)
axis.autoscale_view(True)
self._statePlotCanvas.draw()
def _runSlot(self):
if moose.isRunning():
print('Stopping simulation in progress ...')
moose.stop()
self._runtime = self.getFloatInput(self._runTimeEdit,
self._runTimeLabel.text())
self._overlayPlots(self._overlayAction.isChecked())
self._simdt = self.getFloatInput(self._simTimeStepEdit,
self._simTimeStepLabel.text())
clampMode = None
singlePulse = True
if self._electronicsTab.currentWidget() == self._vClampCtrlBox:
clampMode = 'vclamp'
baseLevel = self.getFloatInput(self._holdingVEdit,
self._holdingVLabel.text())
firstDelay = self.getFloatInput(self._holdingTimeEdit,
self._holdingTimeLabel.text())
firstWidth = self.getFloatInput(self._prePulseTimeEdit,
self._prePulseTimeLabel.text())
firstLevel = self.getFloatInput(self._prePulseVEdit,
self._prePulseVLabel.text())
secondDelay = firstWidth
secondWidth = self.getFloatInput(self._clampTimeEdit,
self._clampTimeLabel.text())
secondLevel = self.getFloatInput(self._clampVEdit,
self._clampVLabel.text())
if not self._autoscaleAction.isChecked():
self._im_axes.set_ylim(-10.0, 10.0)
else:
clampMode = 'iclamp'
baseLevel = self.getFloatInput(self._baseCurrentEdit,
self._baseCurrentLabel.text())
firstDelay = self.getFloatInput(self._firstDelayEdit,
self._firstDelayLabel.text())
firstWidth = self.getFloatInput(self._firstPulseWidthEdit,
self._firstPulseWidthLabel.text())
firstLevel = self.getFloatInput(self._firstPulseEdit,
self._firstPulseLabel.text())
secondDelay = self.getFloatInput(self._secondDelayEdit,
self._secondDelayLabel.text())
secondLevel = self.getFloatInput(self._secondPulseEdit,
self._secondPulseLabel.text())
secondWidth = self.getFloatInput(
self._secondPulseWidthEdit, self._secondPulseWidthLabel.text())
singlePulse = (self._pulseMode.currentIndex() == 0)
if not self._autoscaleAction.isChecked():
self._im_axes.set_ylim(-0.4, 0.4)
self.squid_setup.clamp_ckt.configure_pulses(baseLevel=baseLevel,
firstDelay=firstDelay,
firstWidth=firstWidth,
firstLevel=firstLevel,
secondDelay=secondDelay,
secondWidth=secondWidth,
secondLevel=secondLevel,
singlePulse=singlePulse)
if self._kConductanceToggle.isChecked():
self.squid_setup.axon.specific_gK = 0.0
else:
self.squid_setup.axon.specific_gK = SquidAxon.defaults[
'specific_gK']
if self._naConductanceToggle.isChecked():
self.squid_setup.axon.specific_gNa = 0.0
else:
self.squid_setup.axon.specific_gNa = SquidAxon.defaults[
'specific_gNa']
self.squid_setup.axon.celsius = self.getFloatInput(
self._temperatureEdit, self._temperatureLabel.text())
self.squid_setup.axon.K_out = self.getFloatInput(
self._kOutEdit, self._kOutLabel.text())
self.squid_setup.axon.Na_out = self.getFloatInput(
self._naOutEdit, self._naOutLabel.text())
self.squid_setup.axon.K_in = self.getFloatInput(
self._kInEdit, self._kInLabel.text())
self.squid_setup.axon.Na_in = self.getFloatInput(
self._naInEdit, self._naInLabel.text())
self.squid_setup.axon.updateEk()
self.squid_setup.schedule(self._simdt, self._plotdt, clampMode)
# The following line is for use with Qthread
self.squid_setup.run(self._runtime)
self._updateAllPlots()
def _toggleDocking(self, on):
self._channelControlDock.setFloating(on)
self._electronicsDock.setFloating(on)
self._runControlDock.setFloating(on)
def _restoreDocks(self):
self._channelControlDock.setVisible(True)
self._electronicsDock.setVisible(True)
self._runControlDock.setVisible(True)
def _initActions(self):
self._runAction = QAction(self.tr('Run'), self)
self._runAction.setShortcut(self.tr('F5'))
self._runAction.setToolTip('Run simulation (F5)')
self._runAction.triggered.connect(self._runSlot)
self._resetToDefaultsAction = QAction(self.tr('Restore defaults'),
self)
self._resetToDefaultsAction.setToolTip(
'Reset all settings to their default values')
self._resetToDefaultsAction.triggered.connect(self._useDefaults)
self._showLegendAction = QAction(self.tr('Display legend'), self)
self._showLegendAction.setCheckable(True)
self._showLegendAction.toggled.connect(self._showLegend)
self._showStatePlotAction = QAction(self.tr('State plot'), self)
self._showStatePlotAction.setCheckable(True)
self._showStatePlotAction.setChecked(False)
self._showStatePlotAction.toggled.connect(
self._statePlotWidget.setVisible)
self._autoscaleAction = QAction(self.tr('Auto-scale plots'), self)
self._autoscaleAction.setCheckable(True)
self._autoscaleAction.setChecked(False)
self._autoscaleAction.toggled.connect(self._autoscale)
self._overlayAction = QAction('Overlay plots', self)
self._overlayAction.setCheckable(True)
self._overlayAction.setChecked(False)
self._dockAction = QAction('Undock all', self)
self._dockAction.setCheckable(True)
self._dockAction.setChecked(False)
# self._dockAction.toggle.connect( self._toggleDocking)
self._restoreDocksAction = QAction('Show all', self)
self._restoreDocksAction.triggered.connect(self._restoreDocks)
self._quitAction = QAction(self.tr('&Quit'), self)
self._quitAction.setShortcut(self.tr('Ctrl+Q'))
self._quitAction.triggered.connect(qApp.closeAllWindows)
def _createRunToolBar(self):
self._simToolBar = self.addToolBar(self.tr('Simulation control'))
self._simToolBar.addAction(self._quitAction)
self._simToolBar.addAction(self._runAction)
self._simToolBar.addAction(self._resetToDefaultsAction)
self._simToolBar.addAction(self._dockAction)
self._simToolBar.addAction(self._restoreDocksAction)
def _createPlotToolBar(self):
self._plotToolBar = self.addToolBar(self.tr('Plotting control'))
self._plotToolBar.addAction(self._showLegendAction)
self._plotToolBar.addAction(self._autoscaleAction)
self._plotToolBar.addAction(self._overlayAction)
self._plotToolBar.addAction(self._showStatePlotAction)
self._plotToolBar.addAction(self._helpAction)
self._plotToolBar.addAction(self._helpBiophysicsAction)
def _showLegend(self, on):
if on:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.legend().set_visible(True)
else:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.legend().set_visible(False)
self._plotCanvas.draw()
self._statePlotCanvas.draw()
def _autoscale(self, on):
if on:
for axis in (self._plotFigure.axes + self._statePlotFigure.axes):
axis.relim()
axis.set_autoscale_on(True)
axis.autoscale_view(True)
else:
for axis in self._plotFigure.axes:
axis.set_autoscale_on(False)
self._vm_axes.set_ylim(-20.0, 120.0)
self._g_axes.set_ylim(0.0, 0.5)
self._im_axes.set_ylim(-0.5, 0.5)
self._i_axes.set_ylim(-10, 10)
self._plotCanvas.draw()
self._statePlotCanvas.draw()
def _useDefaults(self):
self._runTimeEdit.setText('%g' % (self.defaults['runtime']))
self._simTimeStepEdit.setText('%g' % (self.defaults['simdt']))
self._overlayAction.setChecked(False)
self._naConductanceToggle.setChecked(False)
self._kConductanceToggle.setChecked(False)
self._kOutEdit.setText('%g' % (SquidGui.defaults['K_out']))
self._naOutEdit.setText('%g' % (SquidGui.defaults['Na_out']))
self._kInEdit.setText('%g' % (SquidGui.defaults['K_in']))
self._naInEdit.setText('%g' % (SquidGui.defaults['Na_in']))
self._temperatureEdit.setText(
'%g' % (SquidGui.defaults['temperature'] - CELSIUS_TO_KELVIN))
self._holdingVEdit.setText('%g' %
(SquidGui.defaults['vclamp.holdingV']))
self._holdingTimeEdit.setText('%g' %
(SquidGui.defaults['vclamp.holdingT']))
self._prePulseVEdit.setText('%g' %
(SquidGui.defaults['vclamp.prepulseV']))
self._prePulseTimeEdit.setText('%g' %
(SquidGui.defaults['vclamp.prepulseT']))
self._clampVEdit.setText('%g' % (SquidGui.defaults['vclamp.clampV']))
self._clampTimeEdit.setText('%g' %
(SquidGui.defaults['vclamp.clampT']))
self._baseCurrentEdit.setText('%g' %
(SquidGui.defaults['iclamp.baseI']))
self._firstPulseEdit.setText('%g' %
(SquidGui.defaults['iclamp.firstI']))
self._firstDelayEdit.setText('%g' %
(SquidGui.defaults['iclamp.firstD']))
self._firstPulseWidthEdit.setText('%g' %
(SquidGui.defaults['iclamp.firstT']))
self._secondPulseEdit.setText('%g' %
(SquidGui.defaults['iclamp.secondI']))
self._secondDelayEdit.setText('%g' %
(SquidGui.defaults['iclamp.secondD']))
self._secondPulseWidthEdit.setText(
'%g' % (SquidGui.defaults['iclamp.secondT']))
self._pulseMode.setCurrentIndex(0)
def _onScroll(self, event):
if event.inaxes is None:
return
axes = event.inaxes
zoom = 0.0
if event.button == 'up':
zoom = -1.0
elif event.button == 'down':
zoom = 1.0
if zoom != 0.0:
self._plotNavigator.push_current()
axes.get_xaxis().zoom(zoom)
axes.get_yaxis().zoom(zoom)
self._plotCanvas.draw()
def closeEvent(self, event):
qApp.closeAllWindows()
def _showBioPhysicsHelp(self):
self._createHelpMessage()
self._helpMessageText.setText(
'<html><p>%s</p><p>%s</p><p>%s</p><p>%s</p><p>%s</p></html>' %
(tooltip_Nernst, tooltip_Erest, tooltip_KChan, tooltip_NaChan,
tooltip_Im))
self._helpWindow.setVisible(True)
def _showRunningHelp(self):
self._createHelpMessage()
self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
self._helpWindow.setVisible(True)
def _createHelpMessage(self):
if hasattr(self, '_helpWindow'):
return
self._helpWindow = QWidget()
self._helpWindow.setWindowFlags(QtCore.Qt.Window)
layout = QVBoxLayout()
self._helpWindow.setLayout(layout)
self._helpMessageArea = QScrollArea()
self._helpMessageText = QTextBrowser()
self._helpMessageText.setOpenExternalLinks(True)
self._helpMessageArea.setWidget(self._helpMessageText)
layout.addWidget(self._helpMessageText)
self._squidGuiPath = os.path.dirname(os.path.abspath(__file__))
self._helpBaseURL = os.path.join(self._squidGuiPath, 'help.html')
self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
self._helpMessageText.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self._helpMessageArea.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self._helpMessageText.setMinimumSize(800, 600)
self._closeHelpAction = QAction('Close', self)
self._closeHelpAction.triggered.connect(self._helpWindow.close)
# Setting the close event so that the ``Help`` button is
# unchecked when the help window is closed
self._helpWindow.closeEvent = lambda event: self._helpAction.setChecked(
False)
self._helpTOCAction = QAction('Help running demo', self)
self._helpTOCAction.triggered.connect(self._jumpToHelpTOC)
# This panel is for putting two buttons using horizontal
# layout
panel = QFrame()
panel.setFrameStyle(QFrame.StyledPanel + QFrame.Raised)
layout.addWidget(panel)
layout = QHBoxLayout()
panel.setLayout(layout)
self._helpAction = QAction('Help running', self)
self._helpAction.triggered.connect(self._showRunningHelp)
self._helpBiophysicsAction = QAction('Help biophysics', self)
self._helpBiophysicsAction.triggered.connect(self._showBioPhysicsHelp)
self._helpTOCButton = QToolButton()
self._helpTOCButton.setDefaultAction(self._helpTOCAction)
self._helpBiophysicsButton = QToolButton()
self._helpBiophysicsButton.setDefaultAction(self._helpBiophysicsAction)
layout.addWidget(self._helpTOCButton)
layout.addWidget(self._helpBiophysicsButton)
self._closeHelpButton = QToolButton()
self._closeHelpButton.setDefaultAction(self._closeHelpAction)
layout.addWidget(self._closeHelpButton)
def _jumpToHelpTOC(self):
self._helpMessageText.setSource(QtCore.QUrl(self._helpBaseURL))
def __init__(self, plotter=None):
if not plotter:
plotter = plotting.Plotter()
self.plotter = plotter
self.canvas = FigureCanvas(self.plotter.f)
self.canvas.mpl_connect('motion_notify_event', self.mouse_moved)
# mcp hitmap type
self.plot_with_cuts_button = QCheckBox()
self.plot_with_cuts = 0
self.plot_with_cuts_button.setCheckState(self.plot_with_cuts)
self.plot_with_cuts_button.clicked.connect(self.plot_with_cuts_clicked)
mcp_hitmap_buttons = QHBoxLayout()
self.mcp_kde_button = QRadioButton('KDE')
self.mcp_hist_button = QRadioButton('Hist')
self.mcp_kde_button.clicked.connect(self.set_use_kde)
self.mcp_hist_button.click()
self.mcp_hist_button.clicked.connect(self.disable_use_kde)
mcp_hitmap_buttons.addWidget(self.mcp_kde_button)
mcp_hitmap_buttons.addWidget(self.mcp_hist_button)
# mcp hitmap histo bin size and kde bandwidth
# mcp_hitmap_settings = QHBoxLayout()
hist_nbins_validator = QIntValidator(0, 10000)
self.mcp_bin_width_entry = QLineEdit(str(self.plotter.mcp_bin_width))
self.mcp_bin_width_entry.setValidator(QDoubleValidator(0., 10000., 10))
self.mcp_bin_width_entry.setMaximumWidth(
PLOTTER_WIDGET_QLINEEDIT_WIDTH)
self.mcp_kde_bw_entry = QLineEdit(str(DEFAULT_KDE_BW))
self.mcp_kde_bw_entry.setValidator(QDoubleValidator(0.0, 10000., 10))
self.mcp_kde_bw_entry.setMaximumWidth(PLOTTER_WIDGET_QLINEEDIT_WIDTH)
# mcp_hitmap_settings.addWidget( self.mcp_hist_bin_size_entry )
# mcp_hitmap_settings.addWidget( self.mcp_kde_bw_entry )
# mcp hitmap bounds inputs
self.mcp_hitmap_left_xbound_entry = QLineEdit(str(-5))
self.mcp_hitmap_right_xbound_entry = QLineEdit(str(5))
self.mcp_hitmap_left_ybound_entry = QLineEdit(str(-5))
self.mcp_hitmap_right_ybound_entry = QLineEdit(str(5))
mcp_hitmap_bounds_validator = QDoubleValidator(-1000, 1000, 10)
self.mcp_hitmap_left_xbound_entry.setValidator(
mcp_hitmap_bounds_validator)
self.mcp_hitmap_right_xbound_entry.setValidator(
mcp_hitmap_bounds_validator)
self.mcp_hitmap_left_ybound_entry.setValidator(
mcp_hitmap_bounds_validator)
self.mcp_hitmap_right_ybound_entry.setValidator(
mcp_hitmap_bounds_validator)
self.mcp_hitmap_left_xbound_entry.setMaximumWidth(
PLOTTER_WIDGET_QLINEEDIT_WIDTH)
self.mcp_hitmap_right_xbound_entry.setMaximumWidth(
PLOTTER_WIDGET_QLINEEDIT_WIDTH)
self.mcp_hitmap_left_ybound_entry.setMaximumWidth(
PLOTTER_WIDGET_QLINEEDIT_WIDTH)
self.mcp_hitmap_right_ybound_entry.setMaximumWidth(
PLOTTER_WIDGET_QLINEEDIT_WIDTH)
mcp_hitmap_xbounds_entry = QHBoxLayout()
mcp_hitmap_ybounds_entry = QHBoxLayout()
mcp_hitmap_xbounds_entry.addWidget(self.mcp_hitmap_left_xbound_entry)
mcp_hitmap_xbounds_entry.addWidget(self.mcp_hitmap_right_xbound_entry)
mcp_hitmap_ybounds_entry.addWidget(self.mcp_hitmap_left_ybound_entry)
mcp_hitmap_ybounds_entry.addWidget(self.mcp_hitmap_right_ybound_entry)
self.tof_hist_nbins_entry = QLineEdit(str(0))
self.tof_hist_nbins_entry.setMaximumWidth(
PLOTTER_WIDGET_QLINEEDIT_WIDTH)
self.tof_hist_nbins_entry.setValidator(hist_nbins_validator)
self.r_hist_nbins_entry = QLineEdit(str(0))
self.r_hist_nbins_entry.setMaximumWidth(PLOTTER_WIDGET_QLINEEDIT_WIDTH)
self.r_hist_nbins_entry.setValidator(hist_nbins_validator)
self.angle_hist_nbins_entry = QLineEdit(str(0))
self.angle_hist_nbins_entry.setMaximumWidth(
PLOTTER_WIDGET_QLINEEDIT_WIDTH)
self.angle_hist_nbins_entry.setValidator(hist_nbins_validator)
# tof cut entry
tof_bounds = QHBoxLayout()
self.tof_lower_cut_entry = QLineEdit(
str(self.plotter.cpt_data.tof_cut_lower))
self.tof_lower_cut_entry.setMaximumWidth(
PLOTTER_WIDGET_QLINEEDIT_WIDTH)
self.tof_lower_cut_entry.setValidator(QDoubleValidator(0., 10000., 10))
self.tof_upper_cut_entry = QLineEdit(
str(self.plotter.cpt_data.tof_cut_upper))
self.tof_upper_cut_entry.setMaximumWidth(
PLOTTER_WIDGET_QLINEEDIT_WIDTH)
self.tof_upper_cut_entry.setValidator(QDoubleValidator(0., 10000., 10))
tof_bounds.addWidget(self.tof_lower_cut_entry)
tof_bounds.addWidget(self.tof_upper_cut_entry)
r_bounds = QHBoxLayout()
self.r_lower_cut_entry = QLineEdit(str(0))
self.r_lower_cut_entry.setMaximumWidth(PLOTTER_WIDGET_QLINEEDIT_WIDTH)
self.r_lower_cut_entry.setValidator(QDoubleValidator(0, 10000, 3))
self.r_upper_cut_entry = QLineEdit(str(0))
self.r_upper_cut_entry.setMaximumWidth(PLOTTER_WIDGET_QLINEEDIT_WIDTH)
self.r_upper_cut_entry.setValidator(QDoubleValidator(0, 10000, 3))
r_bounds.addWidget(self.r_lower_cut_entry)
r_bounds.addWidget(self.r_upper_cut_entry)
layout = QVBoxLayout()
controls_box = QGroupBox('Visualization Controls')
controls_layout = QFormLayout()
# subtitle.setFont( QFont( SUBTITLE_FONT, SUBTITLE_SIZE,
# QFont.Bold ) )
# controls_layout.addRow( subtitle )
controls_layout.addRow('Plot with Cuts', self.plot_with_cuts_button)
controls_layout.addRow('Hitmap Type:', mcp_hitmap_buttons)
# controls_layout.addRow( mcp_hitmap_settings )
controls_layout.addRow('MCP bin width (mm):', self.mcp_bin_width_entry)
controls_layout.addRow('MCP KDE bandwidth:', self.mcp_kde_bw_entry)
controls_layout.addRow('MCP X Bounds:', mcp_hitmap_xbounds_entry)
controls_layout.addRow('MCP Y Bounds:', mcp_hitmap_ybounds_entry)
controls_layout.addRow('TOF hist num bins:', self.tof_hist_nbins_entry)
controls_layout.addRow('Radius hist num bins:',
self.r_hist_nbins_entry)
controls_layout.addRow('Angle hist num bins:',
self.angle_hist_nbins_entry)
reload_button = QPushButton('Reload Parameters')
reload_button.clicked.connect(self.reload_visualization_params)
controls_layout.addRow(reload_button)
controls_box.setLayout(controls_layout)
layout.addWidget(controls_box)
# subtitle = QLabel( 'Data Cuts' )
# subtitle.setFont( QFont( SUBTITLE_FONT, SUBTITLE_SIZE, QFont.Bold ) )
# controls_layout.addRow( subtitle )
cuts_box = QGroupBox('Data Cuts')
cuts_layout = QFormLayout()
cuts_layout.addRow('TOF lower / upper bounds:', tof_bounds)
cuts_layout.addRow('Radius Cut:', r_bounds)
cuts_box.setLayout(cuts_layout)
layout.addWidget(cuts_box)
fits_box = QGroupBox('Gaussian Fitting')
# fits_layout = QVBoxLayout()
# fits_layout.setSpacing(0)
self.fit_widget = FitWidget(self.plotter.all_hists)
# self.tof_fit_widget = FitWidget( 'TOF', self.plotter.tof_hist )
# self.angle_fit_widget = FitWidget( 'Angle', self.plotter.angle_hist )
# self.radius_fit_widget = FitWidget( 'Radius', self.plotter.radius_hist )
# fits_layout.addLayout( self.tof_fit_widget.layout )
# fits_layout.addLayout( self.angle_fit_widget.layout )
# fits_layout.addLayout( self.radius_fit_widget.layout )
fits_box.setLayout(self.fit_widget.layout)
layout.addWidget(fits_box)
self.metadata_widget = MetadataWidget(self.plotter.cpt_data)
layout.addWidget(self.metadata_widget.box)
canvas_layout = QVBoxLayout()
canvas_layout.addWidget(self.canvas)
self.coords_label = QLabel()
canvas_layout.addWidget(self.coords_label)
self.grid_layout = QGridLayout()
self.grid_layout.addLayout(layout, 0, 0, 0, 1, QtCore.Qt.AlignLeft)
self.grid_layout.setColumnStretch(0, 0.5)
self.grid_layout.addLayout(canvas_layout, 0, 1, 1, 1)
self.grid_layout.setColumnStretch(1, 1)
def create_main_frame(self):
self.main_frame = QWidget()
# Create the mpl Figure and FigCanvas objects.
# 5x4 inches, 100 dots-per-inch
#
self.dpi = 100
self.fig = Figure((5.0, 4.0), dpi=self.dpi)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
# Since we have only one plot, we can use add_axes
# instead of add_subplot, but then the subplot
# configuration tool in the navigation toolbar wouldn't
# work.
#
self.axes = self.fig.add_subplot(111)
# Bind the 'pick' event for clicking on one of the bars
#
self.canvas.mpl_connect('pick_event', self.on_pick)
# Create the navigation toolbar, tied to the canvas
#
self.mpl_toolbar = NavigationToolbar(self.canvas, self.main_frame)
# Other GUI controls
#
self.textbox = QLineEdit()
self.textbox.setMinimumWidth(200)
self.connect(self.textbox, SIGNAL('editingFinished ()'), self.on_draw)
self.draw_button = QPushButton("&Draw")
self.connect(self.draw_button, SIGNAL('clicked()'), self.on_draw)
self.grid_cb = QCheckBox("Show &Grid")
self.grid_cb.setChecked(False)
self.connect(self.grid_cb, SIGNAL('stateChanged(int)'), self.on_draw)
slider_label = QLabel('Bar width (%):')
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(1, 100)
self.slider.setValue(20)
self.slider.setTracking(True)
self.slider.setTickPosition(QSlider.TicksBothSides)
self.connect(self.slider, SIGNAL('valueChanged(int)'), self.on_draw)
#
# Layout with box sizers
#
hbox = QHBoxLayout()
for w in [
self.textbox, self.draw_button, self.grid_cb, slider_label,
self.slider
]:
hbox.addWidget(w)
hbox.setAlignment(w, Qt.AlignVCenter)
vbox = QVBoxLayout()
vbox.addWidget(self.canvas)
vbox.addWidget(self.mpl_toolbar)
vbox.addLayout(hbox)
self.main_frame.setLayout(vbox)
self.setCentralWidget(self.main_frame)
class AppForm(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setWindowTitle('Demo: PyQt with matplotlib')
self.create_menu()
self.create_main_frame()
self.create_status_bar()
self.textbox.setText('1 2 3 4')
self.on_draw()
def save_plot(self):
file_choices = "PNG (*.png)|*.png"
path = unicode(
QFileDialog.getSaveFileName(self, 'Save file', '', file_choices))
if path:
self.canvas.print_figure(path, dpi=self.dpi)
self.statusBar().showMessage('Saved to %s' % path, 2000)
def on_about(self):
msg = """ A demo of using PyQt with matplotlib:
* Use the matplotlib navigation bar
* Add values to the text box and press Enter (or click "Draw")
* Show or hide the grid
* Drag the slider to modify the width of the bars
* Save the plot to a file using the File menu
* Click on a bar to receive an informative message
"""
QMessageBox.about(self, "About the demo", msg.strip())
def on_pick(self, event):
# The event received here is of the type
# matplotlib.backend_bases.PickEvent
#
# It carries lots of information, of which we're using
# only a small amount here.
#
box_points = event.artist.get_bbox().get_points()
msg = "You've clicked on a bar with coords:\n %s" % box_points
QMessageBox.information(self, "Click!", msg)
def on_draw(self):
""" Redraws the figure
"""
str = unicode(self.textbox.text())
self.data = map(int, str.split())
x = range(len(self.data))
# clear the axes and redraw the plot anew
#
self.axes.clear()
self.axes.grid(self.grid_cb.isChecked())
self.axes.bar(left=x,
height=self.data,
width=self.slider.value() / 100.0,
align='center',
alpha=0.44,
picker=5)
self.canvas.draw()
def create_main_frame(self):
self.main_frame = QWidget()
# Create the mpl Figure and FigCanvas objects.
# 5x4 inches, 100 dots-per-inch
#
self.dpi = 100
self.fig = Figure((5.0, 4.0), dpi=self.dpi)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
# Since we have only one plot, we can use add_axes
# instead of add_subplot, but then the subplot
# configuration tool in the navigation toolbar wouldn't
# work.
#
self.axes = self.fig.add_subplot(111)
# Bind the 'pick' event for clicking on one of the bars
#
self.canvas.mpl_connect('pick_event', self.on_pick)
# Create the navigation toolbar, tied to the canvas
#
self.mpl_toolbar = NavigationToolbar(self.canvas, self.main_frame)
# Other GUI controls
#
self.textbox = QLineEdit()
self.textbox.setMinimumWidth(200)
self.connect(self.textbox, SIGNAL('editingFinished ()'), self.on_draw)
self.draw_button = QPushButton("&Draw")
self.connect(self.draw_button, SIGNAL('clicked()'), self.on_draw)
self.grid_cb = QCheckBox("Show &Grid")
self.grid_cb.setChecked(False)
self.connect(self.grid_cb, SIGNAL('stateChanged(int)'), self.on_draw)
slider_label = QLabel('Bar width (%):')
self.slider = QSlider(Qt.Horizontal)
self.slider.setRange(1, 100)
self.slider.setValue(20)
self.slider.setTracking(True)
self.slider.setTickPosition(QSlider.TicksBothSides)
self.connect(self.slider, SIGNAL('valueChanged(int)'), self.on_draw)
#
# Layout with box sizers
#
hbox = QHBoxLayout()
for w in [
self.textbox, self.draw_button, self.grid_cb, slider_label,
self.slider
]:
hbox.addWidget(w)
hbox.setAlignment(w, Qt.AlignVCenter)
vbox = QVBoxLayout()
vbox.addWidget(self.canvas)
vbox.addWidget(self.mpl_toolbar)
vbox.addLayout(hbox)
self.main_frame.setLayout(vbox)
self.setCentralWidget(self.main_frame)
def create_status_bar(self):
self.status_text = QLabel("This is a demo")
self.statusBar().addWidget(self.status_text, 1)
def create_menu(self):
self.file_menu = self.menuBar().addMenu("&File")
load_file_action = self.create_action("&Save plot",
shortcut="Ctrl+S",
slot=self.save_plot,
tip="Save the plot")
quit_action = self.create_action("&Quit",
slot=self.close,
shortcut="Ctrl+Q",
tip="Close the application")
self.add_actions(self.file_menu, (load_file_action, None, quit_action))
self.help_menu = self.menuBar().addMenu("&Help")
about_action = self.create_action("&About",
shortcut='F1',
slot=self.on_about,
tip='About the demo')
self.add_actions(self.help_menu, (about_action, ))
def add_actions(self, target, actions):
for action in actions:
if action is None:
target.addSeparator()
else:
target.addAction(action)
def create_action(self,
text,
slot=None,
shortcut=None,
icon=None,
tip=None,
checkable=False,
signal="triggered()"):
action = QAction(text, self)
if icon is not None:
action.setIcon(QIcon(":/%s.png" % icon))
if shortcut is not None:
action.setShortcut(shortcut)
if tip is not None:
action.setToolTip(tip)
action.setStatusTip(tip)
if slot is not None:
self.connect(action, SIGNAL(signal), slot)
if checkable:
action.setCheckable(True)
return action
class TSPlot(QFrame):
def __init__(self,
E,
T,
cell_flag,
feat_flag,
tSeek1,
DInt,
EDInt,
t_span=80,
t=1):
super(TSPlot, self).__init__()
self.E = E
self.T = T
self.E_norm = deepcopy(E)
self.T_norm = deepcopy(T)
self.t = t
self.t_span = t_span
self.tSeek1 = tSeek1
self.DInt = DInt
self.EDInt = EDInt
self.cell_flag = cell_flag
self.feat_flag = feat_flag
#self.normalize_data()
self.create_main_frame()
def normalize_data(self):
E_num = len(self.E.keys())
T_num = len(self.T.keys())
#only the speed and Death Marker needs to be normalized
#First, Normalize E
#The speed
Max_speed_E = 0
Max_DM_E = 0
for i in range(1, E_num + 1):
if max(self.E['E' + str(i)][3]) > Max_speed_E:
Max_speed_E = max(self.E['E' + str(i)][3])
if max(self.E['E' + str(i)][4]) > Max_DM_E:
Max_DM_E = max(self.E['E' + str(i)][4])
for i in range(1, E_num + 1):
for t in range(0, self.t_span):
self.E_norm['E' +
str(i)][3][t] = self.E['E' + str(i)][3][t] / (
Max_speed_E + 0.001)
self.E_norm['E' +
str(i)][4][t] = self.E['E' + str(i)][4][t] / (
Max_DM_E + 0.001)
#First, Normalize T
#The speed
Max_speed_T = 0
Max_DM_T = 0
for i in range(1, T_num + 1):
if max(self.T['T' + str(i)][3]) > Max_speed_T:
Max_speed_T = max(self.T['T' + str(i)][3])
if max(self.T['T' + str(i)][4]) > Max_DM_T:
Max_DM_T = max(self.T['T' + str(i)][4])
for i in range(1, T_num + 1):
for t in range(0, self.t_span):
self.T_norm['T' +
str(i)][3][t] = self.T['T' + str(i)][3][t] / (
Max_speed_T + 0.001)
self.T_norm['T' +
str(i)][4][t] = self.T['T' + str(i)][4][t] / (
Max_DM_T + 0.001)
def create_main_frame(self):
self.main_frame = QWidget()
self.refresh()
self.Box = QHBoxLayout()
self.Box.addWidget(self.main_frame)
self.setLayout(self.Box)
self.setFixedSize(800, 500)
self.setObjectName("myObject3")
self.setStyleSheet("#myObject3 {border: 5px solid white}")
self.show()
def refresh(self):
Thresh = 0
tSeek1 = self.tSeek1
mini = 0
maxi = 200
self.fig = plt.figure(figsize=(8, 5))
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
ax = self.fig.add_subplot(1, 1, 1)
cell_index = self.cell_flag.index(1)
feat_index = self.feat_flag.index(1)
if cell_index == 0:
cell_key = 'E1'
plot_title = 'Effector Cell 1 Feature Time Series'
Thresh = self.EDInt
try:
feat_data = self.E[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell E1 or No given features"
if cell_index == 1:
cell_key = 'E2'
plot_title = 'Effector Cell 2 Feature Time Series'
Thresh = self.EDInt
try:
feat_data = self.E[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell E2 or No given features"
if cell_index == 2:
cell_key = 'E3'
plot_title = 'Effector Cell 3 Feature Time Series'
Thresh = self.EDInt
try:
feat_data = self.E[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell E3 or No given features"
if cell_index == 3:
cell_key = 'E4'
plot_title = 'Effector Cell 4 Feature Time Series'
Thresh = self.EDInt
try:
feat_data = self.E[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell E4 or No given features"
if cell_index == 4:
cell_key = 'T1'
plot_title = 'Target Cell 1 Feature Time Series'
Thresh = self.DInt
try:
feat_data = self.T[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell T1 or No given features"
if cell_index == 5:
cell_key = 'T2'
plot_title = 'Target Cell 2 Feature Time Series'
Thresh = self.DInt
try:
feat_data = self.T[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell T2 or No given features"
if cell_index == 6:
cell_key = 'T3'
plot_title = 'Target Cell 3 Feature Time Series'
Thresh = self.DInt
try:
feat_data = self.T[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell T3 or No given features"
if cell_index == 7:
cell_key = 'T4'
plot_title = 'Target Cell 4 Feature Time Series'
Thresh = self.DInt
try:
feat_data = self.T[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell T4 or No given features"
if feat_index == 0:
y_label = 'Position X'
if feat_index == 1:
y_label = 'Position Y'
if feat_index == 2:
y_label = 'Aspect Ratio'
if feat_index == 3:
y_label = 'Speed'
if feat_index == 4:
y_label = 'Death Marker'
if feat_index == 5:
y_label = 'Contact Ratio'
try:
plt.plot(feat_data)
plt.plot(feat_data, 'ro')
# plot contact line
if tSeek1 > 0 and tSeek1 < self.t_span:
plt.plot((tSeek1, tSeek1),
(int(mini * 0.95), int(maxi * 1.05)), 'r-')
# plot deathmarker threshold
if feat_index == 4:
plt.plot((0, 80), (Thresh, Thresh), 'r-')
plt.xlabel('Time')
plt.ylabel(y_label)
plt.title(plot_title)
except:
print "Can't Plot Time Series Left!"
def update_main_frame(self):
plt.close(self.fig)
self.Box.removeWidget(self.main_frame)
self.main_frame.deleteLater()
self.main_frame = None
self.main_frame = QWidget()
self.refresh()
self.Box.addWidget(self.main_frame)
self.show()
def refresh(self):
Thresh = 0
tSeek1 = self.tSeek1
mini = 0
maxi = 200
self.fig = plt.figure(figsize=(8, 5))
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
ax = self.fig.add_subplot(1, 1, 1)
cell_index = self.cell_flag.index(1)
feat_index = self.feat_flag.index(1)
if cell_index == 0:
cell_key = 'E1'
plot_title = 'Effector Cell 1 Feature Time Series'
Thresh = self.EDInt
try:
feat_data = self.E[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell E1 or No given features"
if cell_index == 1:
cell_key = 'E2'
plot_title = 'Effector Cell 2 Feature Time Series'
Thresh = self.EDInt
try:
feat_data = self.E[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell E2 or No given features"
if cell_index == 2:
cell_key = 'E3'
plot_title = 'Effector Cell 3 Feature Time Series'
Thresh = self.EDInt
try:
feat_data = self.E[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell E3 or No given features"
if cell_index == 3:
cell_key = 'E4'
plot_title = 'Effector Cell 4 Feature Time Series'
Thresh = self.EDInt
try:
feat_data = self.E[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell E4 or No given features"
if cell_index == 4:
cell_key = 'T1'
plot_title = 'Target Cell 1 Feature Time Series'
Thresh = self.DInt
try:
feat_data = self.T[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell T1 or No given features"
if cell_index == 5:
cell_key = 'T2'
plot_title = 'Target Cell 2 Feature Time Series'
Thresh = self.DInt
try:
feat_data = self.T[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell T2 or No given features"
if cell_index == 6:
cell_key = 'T3'
plot_title = 'Target Cell 3 Feature Time Series'
Thresh = self.DInt
try:
feat_data = self.T[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell T3 or No given features"
if cell_index == 7:
cell_key = 'T4'
plot_title = 'Target Cell 4 Feature Time Series'
Thresh = self.DInt
try:
feat_data = self.T[cell_key][feat_index]
mini = min(feat_data)
maxi = max(feat_data)
except:
print "No cell T4 or No given features"
if feat_index == 0:
y_label = 'Position X'
if feat_index == 1:
y_label = 'Position Y'
if feat_index == 2:
y_label = 'Aspect Ratio'
if feat_index == 3:
y_label = 'Speed'
if feat_index == 4:
y_label = 'Death Marker'
if feat_index == 5:
y_label = 'Contact Ratio'
try:
plt.plot(feat_data)
plt.plot(feat_data, 'ro')
# plot contact line
if tSeek1 > 0 and tSeek1 < self.t_span:
plt.plot((tSeek1, tSeek1),
(int(mini * 0.95), int(maxi * 1.05)), 'r-')
# plot deathmarker threshold
if feat_index == 4:
plt.plot((0, 80), (Thresh, Thresh), 'r-')
plt.xlabel('Time')
plt.ylabel(y_label)
plt.title(plot_title)
except:
print "Can't Plot Time Series Left!"
class line_tracker(QtGui.QWidget):
def __init__(self, reactor, clipboard=None, cxn=None, parent=None):
QtGui.QWidget.__init__(self, parent)
self.reactor = reactor
self.clipboard = clipboard
self.cxn = cxn
self.subscribed = False
#see if favoirtes are provided in the configuration. if not, use an empty dictionary
try:
self.favorites = c.favorites
except AttributeError:
self.favorites = {}
self.number_of_channel = 4
self.create_layout()
self.connect_labrad()
updater = LoopingCall(self.update_lines)
updater.start(c.update_rate)
def create_layout(self):
layout = QtGui.QGridLayout()
plot_layout = self.create_drift_layout()
layout.addLayout(plot_layout, 0, 0)
widget_layout = self.create_widget_layout()
# spectrum_layout = self.create_spectrum_layout()
# layout.addLayout(plot_layout, 0, 0, 1, 2)
layout.addLayout(widget_layout, 1, 0)
# layout.addLayout(spectrum_layout, 1, 1, 1, 1)
self.setLayout(layout)
def create_drift_layout(self):
layout = QtGui.QVBoxLayout()
self.fig = Figure()
self.plot_canvas = FigureCanvas(self.fig)
self.plot_canvas.setParent(self)
#gs = gridspec.GridSpec(1, 2, wspace=0.15, left = 0.05, right = 0.95)
line_drift = self.fig.add_subplot(1, 1, 1)
line_drift.ticklabel_format(useOffset=False)
line_drift.set_xlabel('Time (min)')
line_drift.set_ylabel('kHz')
line_drift.set_title("Line Drift")
self.line_drift = line_drift
self.line_drift_lines = []
self.line_drift_fit_line = []
self.line_all_line = []
self.mpl_toolbar = NavigationToolbar2QT(self.plot_canvas, self)
layout.addWidget(self.mpl_toolbar)
layout.addWidget(self.plot_canvas)
return layout
def create_widget_layout(self):
layout = QtGui.QGridLayout()
self.submit_button = []
self.freq_enter_box = []
self.freq_label_id = []
self.freq_label_current = []
self.remove_button = []
self.track_duration_box = []
for i in range(self.number_of_channel):
self.submit_button.append(QtGui.QPushButton("Submit"))
spin_box = QtGui.QDoubleSpinBox()
spin_box.setSuffix(' kHz')
spin_box.setRange(-50000.0, 50000.0)
spin_box.setDecimals(5)
self.freq_enter_box.append(spin_box)
label = QtGui.QLabel(str(i + 1))
self.freq_label_id.append(label)
freq_value = 0.000
freq_value_label = QtGui.QLabel("%.5f kHz" % freq_value)
self.freq_label_current.append(freq_value_label)
self.remove_button.append(QtGui.QPushButton("Remove"))
track_duration_spin_box = QtGui.QDoubleSpinBox()
track_duration_spin_box.setSuffix(' min')
track_duration_spin_box.setDecimals(1)
self.track_duration_box.append(track_duration_spin_box)
layout.addWidget(self.freq_label_id[i], i, 0)
layout.addWidget(self.freq_enter_box[i], i, 1)
layout.addWidget(self.submit_button[i], i, 2)
layout.addWidget(self.freq_label_current[i], i, 3)
layout.addWidget(self.remove_button[i], i, 4)
layout.addWidget(self.track_duration_box[i], i, 5)
return layout
def connect_layout(self):
for i in range(self.number_of_channel):
#self.submit_button[i].clicked.connect(lambda i=i: self.on_entry(i))
self.track_duration_box[i].valueChanged.connect(
partial(self.on_duration_change, i, 9))
self.submit_button[i].clicked.connect(partial(self.on_entry, i))
self.remove_button[i].clicked.connect(partial(self.on_remove, i))
@inlineCallbacks
def initialize_layout(self):
server = yield self.cxn.get_server('Line Tracker')
# transitions = yield server.get_transition_names()
# self.entry_table.fill_out(transitions)
for i in range(self.number_of_channel):
duration = yield server.history_duration(i + 1)
self.track_duration_box[i].setValue(duration['min'])
yield self.on_new_fit(None, None)
@inlineCallbacks
def on_entry(self, i, j):
server = yield self.cxn.get_server('Line Tracker')
freq = self.freq_enter_box[i].value()
print freq
print "submit button", i
freq_with_units = self.WithUnit(freq, 'kHz')
try:
yield server.set_measurement(freq_with_units, i + 1)
except self.Error as e:
self.displayError(e.msg)
@inlineCallbacks
def on_duration_change(self, i, j, value):
#print i, j, value
server = yield self.cxn.get_server('Line Tracker')
rate_line = self.WithUnit(value, 'min')
print rate_line
yield server.history_duration(i + 1, rate_line)
@inlineCallbacks
def on_remove(self, i, j):
server = yield self.cxn.get_server('Line Tracker')
try:
yield server.remove_measurement(i + 1)
except self.Error as e:
self.displayError(e.msg)
@inlineCallbacks
def connect_labrad(self):
from labrad.units import WithUnit
from labrad.types import Error
self.WithUnit = WithUnit
self.Error = Error
if self.cxn is None:
from clients.connection import connection
self.cxn = connection()
yield self.cxn.connect()
self.context = yield self.cxn.context()
try:
yield self.subscribe_tracker()
# print "yes"
except Exception as e:
# print e
# print 'no'
self.setDisabled(True)
self.cxn.add_on_connect('Line Tracker', self.reinitialize_tracker)
self.cxn.add_on_disconnect('Line Tracker', self.disable)
self.connect_layout()
@inlineCallbacks
def subscribe_tracker(self):
server = yield self.cxn.get_server('Line Tracker')
#print c.ID
yield server.signal__new_fit(c.ID, context=self.context)
yield server.addListener(listener=self.on_new_fit,
source=None,
ID=c.ID,
context=self.context)
yield self.initialize_layout()
self.subscribed = True
@inlineCallbacks
def reinitialize_tracker(self):
self.setDisabled(False)
server = yield self.cxn.get_server('Line Tracker')
yield server.signal__new_fit(c.ID, context=self.context)
if not self.subscribed:
yield server.addListener(listener=self.on_new_fit,
source=None,
ID=c.ID,
context=self.context)
yield self.initialize_layout()
self.subscribed = True
@inlineCallbacks
def on_new_fit(self, x, y):
yield self.update_lines()
#print x, y
yield self.update_fit()
@inlineCallbacks
def update_fit(self):
try:
server = yield self.cxn.get_server('Line Tracker')
#number = yield server.get_tracker_number()
except Exception as e:
#no fit available
print e
pass
else:
## clear all curves
self.clear_plot_canvas(self.line_drift_lines)
self.clear_plot_canvas(self.line_drift_fit_line)
self.line_drift.set_color_cycle(
None
) # reset the color rotation such that line 1 is always the same color
for i in range(self.number_of_channel):
j = i + 1
## get all lines
history_line = yield server.get_fit_history(j)
all_history_line = yield server.get_all_history(j)
## plot if lines are not empty
if len(history_line) > 0:
fit_param = yield server.get_fit_parameters(j)
inunits_f = [(t['min'], freq['kHz'])
for (t, freq) in history_line]
self.update_track(inunits_f, self.line_drift,
self.line_drift_lines)
self.plot_fit_f(
fit_param, inunits_f[0][0], inunits_f[-1]
[0]) ## send fit parameter and range to line fitter
if len(all_history_line) > 0:
history_inunits_f = [(t['min'], freq['kHz'])
for (t, freq) in all_history_line]
self.update_history_track(history_inunits_f,
self.line_drift,
self.line_drift_lines)
#
def plot_fit_f(self, p, xmin, xmax):
points = 1000
x = numpy.linspace(xmin, xmax, points)
y = numpy.polyval(p, 60 * x)
l = self.line_drift.plot(x, y, '-r')[0]
#label = self.line_drift.annotate('Slope {0:.1f} Hz/sec'.format(10**6 * p[-2]), xy = (0.5, 0.8), xycoords = 'axes fraction', fontsize = 13.0)
self.line_drift_fit_line.append(l)
#self.line_drift_fit_line.append(label)
self.plot_canvas.draw()
@inlineCallbacks
def update_lines(self):
try:
server = yield self.cxn.get_server('Line Tracker')
for i in range(self.number_of_channel):
freq = yield server.get_current_line(i + 1)
self.freq_label_current[i].setText("%.5f kHz" % freq['kHz'])
except Exception as e:
print e
#no lines available
returnValue(None)
else:
pass
#self.update_spectrum(lines)
#self.update_listing(lines)
#returnValue(lines)
#
def clear_plot_canvas(self, lines):
#clear all current lines
for i in range(len(lines)):
line = lines.pop()
line.remove()
def update_history_track(self, meas, axes, lines):
x = numpy.array([m[0] for m in meas])
y = [m[1] for m in meas]
#annotate the last point
try:
last = y[-1]
except IndexError:
pass
# else:
# label = axes.annotate('Last: {0:.2f} {1}'.format(last, axes.get_ylabel()), xy = (0.5, 0.9), xycoords = 'axes fraction', fontsize = 13.0)
# lines.append(label)
#line = axes.plot(x,y, 'b*')[0]
line = axes.plot(x, y, 'b.')[0]
lines.append(line)
self.plot_canvas.draw()
def update_track(self, meas, axes, lines):
x = numpy.array([m[0] for m in meas])
y = [m[1] for m in meas]
#annotate the last point
try:
last = y[-1]
except IndexError:
pass
# else:
# label = axes.annotate('Last: {0:.2f} {1}'.format(last, axes.get_ylabel()), xy = (0.5, 0.9), xycoords = 'axes fraction', fontsize = 13.0)
# lines.append(label)
#line = axes.plot(x,y, 'b*')[0]
line = axes.plot(x, y, '*')[0]
lines.append(line)
self.plot_canvas.draw()
#
@inlineCallbacks
def disable(self):
self.setDisabled(True)
yield None
def displayError(self, text):
#runs the message box in a non-blocking method
message = QtGui.QMessageBox(self)
message.setText(text)
message.open()
message.show()
message.raise_()
def closeEvent(self, x):
self.reactor.stop()
class Form(QMainWindow):
def __init__(self, parent=None):
super(Form, self).__init__(parent)
self.setWindowTitle('SHOGUN interactive demo')
self.data = DataHolder()
self.series_list_model = QStandardItemModel()
self.create_menu()
self.create_main_frame()
self.create_status_bar()
self.on_show()
def load_file(self, filename=None):
filename = QFileDialog.getOpenFileName(self,
'Open a data file', '.', 'CSV files (*.csv);;All Files (*.*)')
if filename:
self.data.load_from_file(filename)
self.fill_series_list(self.data.series_names())
self.status_text.setText("Loaded " + filename)
def on_show(self):
self.axes.clear()
self.axes.grid(True)
self.axes.plot(self.data.x1, self.data.x2, 'bo')
self.axes.set_xlim((-5,5))
self.axes.set_ylim((-5,5))
self.canvas.draw()
self.fill_series_list(self.data.get_stats())
def on_about(self):
msg = __doc__
QMessageBox.about(self, "About the demo", msg.strip())
def fill_series_list(self, names):
self.series_list_model.clear()
for name in names:
item = QStandardItem(name)
item.setCheckState(Qt.Unchecked)
item.setCheckable(False)
self.series_list_model.appendRow(item)
def onclick(self, event):
print 'button=%d, x=%d, y=%d, xdata=%f, ydata=%f'%(event.button, event.x, event.y, event.xdata, event.ydata)
self.data.add_example(event.xdata, event.ydata)
self.on_show()
def clear(self):
self.data.clear()
self.on_show()
def enable_widgets(self):
kernel_name = self.kernel_combo.currentText()
if kernel_name == "LinearKernel":
self.sigma.setDisabled(True)
self.degree.setDisabled(True)
elif kernel_name == "PolynomialKernel":
self.sigma.setDisabled(True)
self.degree.setEnabled(True)
elif kernel_name == "GaussianKernel":
self.sigma.setEnabled(True)
self.degree.setDisabled(True)
def train_svm(self):
width = float(self.sigma.text())
degree = int(self.degree.text())
self.axes.clear()
self.axes.grid(True)
self.axes.plot(self.data.x1, self.data.x2, 'bo')
# train svm
labels = self.data.get_labels()
print type(labels)
lab = RegressionLabels(labels)
features = self.data.get_examples()
train = RealFeatures(features)
kernel_name = self.kernel_combo.currentText()
print "current kernel is %s" % (kernel_name)
if kernel_name == "LinearKernel":
gk = LinearKernel(train, train)
gk.set_normalizer(IdentityKernelNormalizer())
elif kernel_name == "PolynomialKernel":
gk = PolyKernel(train, train, degree, True)
gk.set_normalizer(IdentityKernelNormalizer())
elif kernel_name == "GaussianKernel":
gk = GaussianKernel(train, train, width)
cost = float(self.cost.text())
tubeeps = float(self.tubeeps.text())
print "cost", cost
svm = LibSVR(cost, tubeeps, gk, lab)
svm.train()
svm.set_epsilon(1e-2)
x=numpy.linspace(-5.0,5.0,100)
y=svm.apply(RealFeatures(numpy.array([x]))).get_labels()
self.axes.plot(x,y,'r-')
self.axes.set_xlim((-5,5))
self.axes.set_ylim((-5,5))
self.canvas.draw()
def create_main_frame(self):
self.main_frame = QWidget()
plot_frame = QWidget()
self.dpi = 100
self.fig = Figure((6.0, 6.0), dpi=self.dpi)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
cid = self.canvas.mpl_connect('button_press_event', self.onclick)
self.axes = self.fig.add_subplot(111)
self.cax = None
#self.mpl_toolbar = NavigationToolbar(self.canvas, self.main_frame)
log_label = QLabel("Number of examples:")
self.series_list_view = QListView()
self.series_list_view.setModel(self.series_list_model)
cost_label = QLabel('C')
#self.cost = QSpinBox()#QLineEdit()
self.cost = QLineEdit()
self.cost.setText("1.0")
#self.cost.setMinimum(1)
spin_label2 = QLabel('tube')
self.tubeeps = QLineEdit()
self.tubeeps.setText("0.1")
spin_label3 = QLabel('sigma')
self.sigma = QLineEdit()
self.sigma.setText("1.2")
#self.sigma.setMinimum(1)
spin_label4 = QLabel('d')
self.degree = QLineEdit()
self.degree.setText("2")
#self.sigma.setMinimum(1)
spins_hbox = QHBoxLayout()
spins_hbox.addWidget(cost_label)
spins_hbox.addWidget(self.cost)
spins_hbox.addWidget(spin_label2)
spins_hbox.addWidget(self.tubeeps)
spins_hbox.addWidget(spin_label3)
spins_hbox.addWidget(self.sigma)
spins_hbox.addWidget(spin_label4)
spins_hbox.addWidget(self.degree)
spins_hbox.addStretch(1)
self.legend_cb = QCheckBox("Show Support Vectors")
self.legend_cb.setChecked(False)
self.show_button = QPushButton("&Train SVR")
self.connect(self.show_button, SIGNAL('clicked()'), self.train_svm)
self.clear_button = QPushButton("&Clear")
self.connect(self.clear_button, SIGNAL('clicked()'), self.clear)
self.kernel_combo = QComboBox()
self.kernel_combo.insertItem(-1, "GaussianKernel")
self.kernel_combo.insertItem(-1, "PolynomialKernel")
self.kernel_combo.insertItem(-1, "LinearKernel")
self.kernel_combo.maximumSize = QSize(300, 50)
self.connect(self.kernel_combo, SIGNAL("currentIndexChanged(QString)"), self.enable_widgets)
left_vbox = QVBoxLayout()
left_vbox.addWidget(self.canvas)
#left_vbox.addWidget(self.mpl_toolbar)
right0_vbox = QVBoxLayout()
right0_vbox.addWidget(log_label)
right0_vbox.addWidget(self.series_list_view)
#right0_vbox.addWidget(self.legend_cb)
right0_vbox.addStretch(1)
right2_vbox = QVBoxLayout()
right2_label = QLabel("Settings")
right2_vbox.addWidget(right2_label)
right2_vbox.addWidget(self.show_button)
right2_vbox.addWidget(self.kernel_combo)
right2_vbox.addLayout(spins_hbox)
right2_clearlabel = QLabel("Remove Data")
right2_vbox.addWidget(right2_clearlabel)
right2_vbox.addWidget(self.clear_button)
right2_vbox.addStretch(1)
right_vbox = QHBoxLayout()
right_vbox.addLayout(right0_vbox)
right_vbox.addLayout(right2_vbox)
hbox = QVBoxLayout()
hbox.addLayout(left_vbox)
hbox.addLayout(right_vbox)
self.main_frame.setLayout(hbox)
self.setCentralWidget(self.main_frame)
self.enable_widgets()
def create_status_bar(self):
self.status_text = QLabel("")
self.statusBar().addWidget(self.status_text, 1)
def create_menu(self):
self.file_menu = self.menuBar().addMenu("&File")
load_action = self.create_action("&Load file",
shortcut="Ctrl+L", slot=self.load_file, tip="Load a file")
quit_action = self.create_action("&Quit", slot=self.close,
shortcut="Ctrl+Q", tip="Close the application")
self.add_actions(self.file_menu,
(load_action, None, quit_action))
self.help_menu = self.menuBar().addMenu("&Help")
about_action = self.create_action("&About",
shortcut='F1', slot=self.on_about,
tip='About the demo')
self.add_actions(self.help_menu, (about_action,))
def add_actions(self, target, actions):
for action in actions:
if action is None:
target.addSeparator()
else:
target.addAction(action)
def create_action( self, text, slot=None, shortcut=None,
icon=None, tip=None, checkable=False,
signal="triggered()"):
action = QAction(text, self)
if icon is not None:
action.setIcon(QIcon(":/%s.png" % icon))
if shortcut is not None:
action.setShortcut(shortcut)
if tip is not None:
action.setToolTip(tip)
action.setStatusTip(tip)
if slot is not None:
self.connect(action, SIGNAL(signal), slot)
if checkable:
action.setCheckable(True)
return action
def changePlotWidget(self, library, frame_for_plot):
if library == "Qwt5" and has_qwt:
plotWdg = QwtPlot(frame_for_plot)
sizePolicy = QSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
plotWdg.sizePolicy().hasHeightForWidth())
plotWdg.setSizePolicy(sizePolicy)
plotWdg.setMinimumSize(QSize(0, 0))
plotWdg.setAutoFillBackground(False)
#Decoration
plotWdg.setCanvasBackground(Qt.white)
plotWdg.plotLayout().setAlignCanvasToScales(True)
zoomer = QwtPlotZoomer(QwtPlot.xBottom, QwtPlot.yLeft,
QwtPicker.DragSelection,
QwtPicker.AlwaysOff, plotWdg.canvas())
zoomer.setRubberBandPen(QPen(Qt.blue))
if platform.system() != "Windows":
# disable picker in Windows due to crashes
picker = QwtPlotPicker(QwtPlot.xBottom, QwtPlot.yLeft,
QwtPicker.NoSelection,
QwtPlotPicker.CrossRubberBand,
QwtPicker.AlwaysOn, plotWdg.canvas())
picker.setTrackerPen(QPen(Qt.green))
#self.dockwidget.qwtPlot.insertLegend(QwtLegend(), QwtPlot.BottomLegend);
grid = Qwt.QwtPlotGrid()
grid.setPen(QPen(QColor('grey'), 0, Qt.DotLine))
grid.attach(plotWdg)
return plotWdg
elif library == "Matplotlib" and has_mpl:
from matplotlib.figure import Figure
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg
fig = Figure((1.0, 1.0),
linewidth=0.0,
subplotpars=matplotlib.figure.SubplotParams(left=0,
bottom=0,
right=1,
top=1,
wspace=0,
hspace=0))
font = {'family': 'arial', 'weight': 'normal', 'size': 12}
matplotlib.rc('font', **font)
rect = fig.patch
rect.set_facecolor((0.9, 0.9, 0.9))
self.subplot = fig.add_axes((0.07, 0.15, 0.92, 0.82))
self.subplot.set_xbound(0, 1000)
self.subplot.set_ybound(0, 1000)
self.manageMatplotlibAxe(self.subplot)
canvas = FigureCanvasQTAgg(fig)
sizePolicy = QSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
canvas.setSizePolicy(sizePolicy)
return canvas
def create_main_window(self):
"""
This function creates the main window of the program.
"""
self.main_frame = QWidget()
self.main_frame.setMinimumSize(QSize(700, 700))
self.dpi = 100
self.fig = plt.Figure((6, 6),
dpi=self.dpi,
facecolor='w',
edgecolor='w')
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
# Stuff for the preview map >>>>>>>>>>>>>>>>>>>>>>>>>
self.preview_frame = QWidget()
self.preview_fig = plt.Figure((3, 1.6),
dpi=self.dpi,
facecolor='w',
edgecolor='w')
self.preview = FigureCanvas(self.preview_fig)
self.preview.setParent(self.preview_frame)
self.preview_axes = self.preview_fig.add_subplot(111)
self.preview_fig.canvas.mpl_connect('button_press_event', self.onclick)
self.preview_fig.subplots_adjust(top=1, bottom=0, left=0, right=1)
# Stuff for the preview map <<<<<<<<<<<<<<<<<<<<<<<<<
# Stuff for the colorbar >>>>>>>>>>>>>>>>>>>>>>>>>
self.colorbar_frame = QWidget()
self.colorbar_fig = plt.Figure((3, 0.4),
dpi=self.dpi,
facecolor='w',
edgecolor='w')
self.colorbar = FigureCanvas(self.colorbar_fig)
self.colorbar.setParent(self.colorbar_frame)
self.colorbar_axes = self.colorbar_fig.add_subplot(111)
self.colorbar_fig.subplots_adjust(
top=1.0, bottom=0.35, left=0.02,
right=0.97) #Tightening the area around the subplot
self.colorbar_fig.patch.set_facecolor(
'none') # Making the figure background transparent
self.colorbar_axes.get_xaxis().set_visible(False)
self.colorbar_axes.get_yaxis().set_visible(False)
# Stuff for the colorbar <<<<<<<<<<<<<<<<<<<<<<<<<
# Since we have only one plot, we can use add_axes
# instead of add_subplot, but then the subplot
# configuration tool in the navigation toolbar wouldn't
# work.
#
self.axes = self.fig.add_subplot(111)
# Turning off the axes ticks to maximize space. Also the labels were meaningless
# anyway because they were not representing the actual lat/lons.
self.axes.get_xaxis().set_visible(False)
self.axes.get_yaxis().set_visible(False)
# Other GUI controls
# Information section
font = QFont("SansSerif", 14)
# STATISTICS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
self.statdisplay = QLabel("Statistics:")
self.statgrid = QGridLayout()
self.statgrid.setSpacing(5)
w = QLabel("View")
w.setFont(font)
self.statgrid.addWidget(w, 1, 1, Qt.AlignCenter)
w = QLabel("Global")
w.setFont(font)
self.statgrid.addWidget(w, 1, 2, Qt.AlignCenter)
for i, name in enumerate(["Minimum", "Maximum", "Mean"]):
w = QLabel(name)
w.setFont(font)
self.statgrid.addWidget(w, i + 2, 0, Qt.AlignLeft)
self.statsarray = []
for i in range(6):
self.statsarray.append(QLabel(''))
self.statsarray[3].setText("{0:3d}".format(int(self.dc.data.min())))
self.statsarray[4].setText("{0:3d}".format(int(self.dc.data.max())))
self.statsarray[5].setText("{0:3d}".format(int(self.dc.data.mean())))
for i in range(3):
self.statgrid.addWidget(self.statsarray[i], i + 2, 1,
Qt.AlignCenter)
self.statgrid.addWidget(self.statsarray[i + 3], i + 2, 2,
Qt.AlignCenter)
self.statsarray[i].setFont(font)
self.statsarray[i + 3].setFont(font)
# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
# PIXEL INFO >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
self.infodisplay = QLabel("Pixel Information:")
self.infogrid = QGridLayout()
self.infogrid.setSpacing(5)
for i, name in enumerate(["Lat", "Lon", "KMT", "I, J"]):
w = QLabel(name)
w.setFont(font)
# w.setLineWidth(1)
# w.setFrameShape(QFrame.Box)
self.infogrid.addWidget(w, i + 2, 0, Qt.AlignLeft)
self.latdisplay = QLabel("")
self.londisplay = QLabel("")
self.valdisplay = QLabel("")
self.idxdisplay = QLabel("")
for i, w in enumerate([
self.latdisplay, self.londisplay, self.valdisplay,
self.idxdisplay
]):
self.infogrid.addWidget(w, i + 2, 1, Qt.AlignLeft)
w.setFont(font)
# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
# Colorscheme selector
cmap_label = QLabel('Colorscheme:')
self.colormaps = QComboBox(self)
self.colormaps.addItems(self.maps)
self.colormaps.setCurrentIndex(self.maps.index('Set1'))
self.colormaps.currentIndexChanged.connect(self.render_view)
# New value editor
valhbox = QHBoxLayout()
w = QLabel("Enter new value: ")
w.setFont(font)
valhbox.addWidget(w)
self.inputbox = QLineEdit()
self.inputbox.returnPressed.connect(self.update_value)
valhbox.addWidget(self.inputbox)
for item in [
self.statdisplay, self.infodisplay, self.latdisplay,
self.londisplay, self.valdisplay, self.idxdisplay, cmap_label
]:
item.setFont(font)
vbox = QVBoxLayout()
vbox.addWidget(self.canvas)
vbox2 = QVBoxLayout()
vbox2.addWidget(self.preview) # Adding preview window
# Horizontal line
fr = QFrame()
fr.setLineWidth(0.5)
fr.setFrameShape(QFrame.HLine)
vbox2.addWidget(fr)
vbox2.setAlignment(fr, Qt.AlignTop)
# databox is a horizontal box for the displayed "information"
databox = QHBoxLayout()
statvbox = QVBoxLayout() # This is the sub-box for the statistics
statvbox.addWidget(self.statdisplay)
statvbox.setAlignment(self.statdisplay, Qt.AlignTop)
statvbox.addLayout(self.statgrid)
databox.addLayout(statvbox)
fr = QFrame()
fr.setLineWidth(0.5)
fr.setFrameShape(QFrame.VLine)
databox.addWidget(fr)
pixelvbox = QVBoxLayout(
) # This is another sub-box of databox for the pixel info
pixelvbox.addWidget(self.infodisplay)
pixelvbox.setAlignment(self.infodisplay, Qt.AlignTop)
pixelvbox.addLayout(self.infogrid)
databox.addLayout(pixelvbox)
vbox2.addLayout(databox)
# Horizontal line
fr = QFrame()
fr.setLineWidth(0.5)
fr.setFrameShape(QFrame.HLine)
vbox2.addWidget(fr)
vbox2.setAlignment(fr, Qt.AlignTop)
vbox2.addLayout(valhbox, Qt.AlignTop)
vbox2.addStretch(1)
vbox2.addWidget(cmap_label) # Adding the colormap label
vbox2.addWidget(self.colormaps) # Adidng the colormap selector
vbox2.addWidget(self.colorbar)
vbox2.setAlignment(self.colorbar, Qt.AlignCenter)
vbox2.addStretch(1)
helpbox = QVBoxLayout()
help_title = QLabel("Help")
font = QFont("SansSerif", 14)
font.setBold(True)
help_title.setFont(font)
helpbox.addWidget(help_title)
helpbox.setAlignment(help_title, Qt.AlignTop)
helpgrid = QGridLayout()
helpgrid.setSpacing(5)
helpgrid.addWidget(QLabel("Key"), 0, 0, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("Action"), 0, 1, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("up, down,left,right"), 1, 0, 1, 1,
Qt.AlignLeft)
helpgrid.addWidget(QLabel("move cursor"), 1, 1, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("h,j,k,l"), 2, 0, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("move view"), 2, 1, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("a"), 3, 0, 1, 1, Qt.AlignLeft)
# helpgrid.addWidget(QLabel("replace cell value with 9 point average"), 3, 1, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("replace cell value with 9\npoint average"),
3, 1, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("="), 4, 0, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("enter new value for cell"), 4, 1, 1, 1,
Qt.AlignLeft)
helpgrid.addWidget(QLabel("c"), 5, 0, 1, 1, Qt.AlignLeft)
# helpgrid.addWidget(QLabel("copy value under cursor into buffer"), 5, 1, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("copy value under cursor\ninto buffer"), 5,
1, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("v"), 6, 0, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("paste value in buffer"), 6, 1, 1, 1,
Qt.AlignLeft)
helpgrid.addWidget(QLabel("m"), 7, 0, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("move focus to color selector"), 7, 1, 1, 1,
Qt.AlignLeft)
helpgrid.addWidget(QLabel("Escape"), 8, 0, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("move focus to main view"), 8, 1, 1, 1,
Qt.AlignLeft)
helpbox.addLayout(helpgrid)
helpbox.setAlignment(helpgrid, Qt.AlignTop)
vbox2.addLayout(helpbox)
vbox2.setAlignment(helpbox, Qt.AlignBottom)
hbox = QHBoxLayout()
hbox.addLayout(vbox)
hbox.addLayout(vbox2)
self.main_frame.setLayout(hbox)
self.setCentralWidget(self.main_frame)
self.main_frame.setFocus()
def create_main_frame(self):
self.main_frame = QWidget()
plot_frame = QWidget()
self.dpi = 100
self.fig = Figure((6.0, 6.0), dpi=self.dpi)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
cid = self.canvas.mpl_connect('button_press_event', self.onclick)
self.axes = self.fig.add_subplot(111)
self.cax = None
#self.mpl_toolbar = NavigationToolbar(self.canvas, self.main_frame)
log_label = QLabel("Number of examples:")
self.series_list_view = QListView()
self.series_list_view.setModel(self.series_list_model)
cost_label = QLabel('C')
#self.cost = QSpinBox()#QLineEdit()
self.cost = QLineEdit()
self.cost.setText("1.0")
#self.cost.setMinimum(1)
spin_label2 = QLabel('tube')
self.tubeeps = QLineEdit()
self.tubeeps.setText("0.1")
spin_label3 = QLabel('sigma')
self.sigma = QLineEdit()
self.sigma.setText("1.2")
#self.sigma.setMinimum(1)
spin_label4 = QLabel('d')
self.degree = QLineEdit()
self.degree.setText("2")
#self.sigma.setMinimum(1)
spins_hbox = QHBoxLayout()
spins_hbox.addWidget(cost_label)
spins_hbox.addWidget(self.cost)
spins_hbox.addWidget(spin_label2)
spins_hbox.addWidget(self.tubeeps)
spins_hbox.addWidget(spin_label3)
spins_hbox.addWidget(self.sigma)
spins_hbox.addWidget(spin_label4)
spins_hbox.addWidget(self.degree)
spins_hbox.addStretch(1)
self.legend_cb = QCheckBox("Show Support Vectors")
self.legend_cb.setChecked(False)
self.show_button = QPushButton("&Train SVR")
self.connect(self.show_button, SIGNAL('clicked()'), self.train_svm)
self.clear_button = QPushButton("&Clear")
self.connect(self.clear_button, SIGNAL('clicked()'), self.clear)
self.kernel_combo = QComboBox()
self.kernel_combo.insertItem(-1, "GaussianKernel")
self.kernel_combo.insertItem(-1, "PolynomialKernel")
self.kernel_combo.insertItem(-1, "LinearKernel")
self.kernel_combo.maximumSize = QSize(300, 50)
self.connect(self.kernel_combo, SIGNAL("currentIndexChanged(QString)"), self.enable_widgets)
left_vbox = QVBoxLayout()
left_vbox.addWidget(self.canvas)
#left_vbox.addWidget(self.mpl_toolbar)
right0_vbox = QVBoxLayout()
right0_vbox.addWidget(log_label)
right0_vbox.addWidget(self.series_list_view)
#right0_vbox.addWidget(self.legend_cb)
right0_vbox.addStretch(1)
right2_vbox = QVBoxLayout()
right2_label = QLabel("Settings")
right2_vbox.addWidget(right2_label)
right2_vbox.addWidget(self.show_button)
right2_vbox.addWidget(self.kernel_combo)
right2_vbox.addLayout(spins_hbox)
right2_clearlabel = QLabel("Remove Data")
right2_vbox.addWidget(right2_clearlabel)
right2_vbox.addWidget(self.clear_button)
right2_vbox.addStretch(1)
right_vbox = QHBoxLayout()
right_vbox.addLayout(right0_vbox)
right_vbox.addLayout(right2_vbox)
hbox = QVBoxLayout()
hbox.addLayout(left_vbox)
hbox.addLayout(right_vbox)
self.main_frame.setLayout(hbox)
self.setCentralWidget(self.main_frame)
self.enable_widgets()
class LFGui(QtGui.QMainWindow):
proc = QtCore.Signal(int, infra.SplineCurve)
open_file_sig = QtCore.Signal(backends.FilePath, dict)
kill_thread = QtCore.Signal()
redraw_sig = QtCore.Signal(bool, bool)
draw_done_sig = QtCore.Signal()
spinner_lst = [
{
'name': 's_width',
'min': 0,
'max': 99,
'step': .5,
'prec': 1,
'type': np.float,
'default': 10,
'togglable': False
},
{
'name': 's_num',
'min': 1,
'max': 9999,
'step': 1,
'type': np.int,
'default': 100,
'togglable': False
},
{
'name': 'search_range',
'min': .001,
'max': 2 * np.pi,
'step': .005,
'prec': 3,
'type': np.float,
'default': .01,
'togglable': False
},
{
'name': 'memory',
'min': 0,
'max': 999,
'step': 1,
'type': np.int,
'default': 0,
'togglable': False
},
{
'name': 'pix_err',
'min': 0,
'max': 9,
'step': .1,
'prec': 1,
'type': np.float,
'default': 0.5,
'togglable': False
},
{
'name': 'mix_in_count',
'min': 0,
'max': 100,
'step': 1,
'type': np.int,
'default': 0,
'togglable': False
},
{
'name': 'min_tlen',
'min': 0,
'max': 999999,
'step': 1,
'type': np.int,
'default': 15,
'togglable': True,
'default_state': True
},
{
'name': 'fft_filter',
'min': 0,
'max': 999,
'step': 1,
'type': np.int,
'default': 10,
'togglable': True,
'default_state': True
},
{
'name': 'min_extent',
'min': 0,
'max': 999,
'step': 1,
'type': np.int,
'default': 10,
'togglable': True,
'default_state': False,
'tooltip': 'The minimum extent in q[pixel] of a track to be valid'
},
{
'name':
'max_gap',
'min':
0,
'max':
np.pi,
'step':
np.pi / 100,
'type':
np.float,
'default':
np.pi / 6,
'prec':
3,
'togglable':
True,
'default_state':
True,
'tooltip':
'The maximum gap (in rad) before the' +
' alternate gap handling is used'
},
{
'name':
'max_circ_change',
'min':
0,
'max':
1,
'step':
.0005,
'prec':
4,
'type':
np.float,
'default':
.002,
'togglable':
True,
'default_state':
True,
'tooltip':
"""The maximum fractional change in the circumference of
successive rims. If exceeded, the previous seed-curve is re-used"""
},
{
'name': 'end_frame',
'min': -1,
'max': 2**31 - 1,
'step': 1,
'type': np.int,
'default': -1,
'togglable': True,
'default_state': False,
'tooltip': """The last frame to process to"""
},
]
toggle_lst = [{
'name':
'straddle',
'default':
True,
'tooltip':
'If checked, then tracks must cross' + ' the seed line to be valid'
}]
cap_lst = ['cine base path']
@QtCore.Slot()
def unlock_gui(self):
"""
Forcable un-locks the gui
"""
self.prog_bar.hide()
self.diag.setEnabled(True)
def __init__(self, parent=None):
QtGui.QMainWindow.__init__(self, parent)
self.setWindowTitle('Fringe Finder')
self.cine_fname = None
self.cur_frame = 0
self.draw_fringes = False
default_params = dict(
(d['name'], d['default']) for d in self.spinner_lst
if ('default_state' not in d or d['default_state']))
for tog in self.toggle_lst:
default_params[tog['name']] = tog['default']
self.thread = QtCore.QThread(parent=self)
self.worker = LFWorker(parent=None)
self.worker.moveToThread(self.thread)
self.cur_curve = None
self.next_curve = None
self.fringe_lines = []
self.all_fringes_flg = False
self.paths_dict = defaultdict(lambda: None)
self.directory_actions = {}
self.param_spin_dict = {}
self.param_checkbox_dict = {}
self.create_actions()
self.create_main_frame()
self.create_menu_bar()
self.create_diag()
self.create_status_bar()
self.on_draw(True, True)
self.worker.frame_proced.connect(self.on_draw)
self.worker.file_loaded.connect(self.redraw)
self.proc.connect(self.worker.proc_frame)
self.open_file_sig.connect(self.worker.set_new_fname)
self.redraw_sig.connect(self.on_draw)
self.kill_thread.connect(self.thread.quit)
self.draw_done_sig.connect(self._play)
self.draw_done_sig.connect(self.unlock_gui)
self.show()
self.thread.start()
QtGui.qApp.exec_()
def grab_sf_curve(self):
try:
self.cur_curve = self.sf.return_SplineCurve()
if self.cur_curve is not None:
self.proc_this_frame_acc.setEnabled(True)
self.start_comp_acc.setEnabled(True)
else:
print('no spline!?')
except:
print('spline fitter not ready')
self.cur_curve = None
# def update_param(self, key, val):
# self.worker.update_param(key, val)
def _proc_this_frame(self):
print('entered _proc_this_frame')
self.prog_bar.show()
self.diag.setEnabled(False)
self.draw_fringes = True
self.proc_next_frame_acc.setEnabled(True)
self.iterate_button.setEnabled(True)
self.proc.emit(self.cur_frame, self.cur_curve)
def _proc_next_frame(self):
self.frame_spinner.setValue(self.cur_frame + 1)
self.diag.setEnabled(False)
#self._proc_this_frame()
def set_fringes_visible(self, i):
self.draw_fringes = bool(i)
self.redraw_sig.emit(True, False)
def set_all_friges(self, i):
self.all_fringes_flg = bool(i)
self.redraw_sig.emit(True, False)
@QtCore.Slot(bool, bool)
def on_draw(self, refresh_lines=True, refresh_img=True):
""" Redraws the figure
"""
self.fringe_grp_bx.setChecked(self.draw_fringes)
# update the image
if refresh_img and self.im is not None:
img = self.worker.get_frame(self.cur_frame)
if img is not None:
self.im.set_data(img)
# if we need to update the lines
if refresh_lines:
# clear the lines we have
for ln in self.fringe_lines:
ln.remove()
# nuke all those objects
self.fringe_lines = []
if self.draw_fringes:
# if we should draw new ones, do so
# grab new mbe from thread object
mbe = self.worker.get_mbe()
# grab new next curve
self.next_curve = self.worker.get_next_curve()
if self.draw_fringes and mbe is not None:
self.fringe_lines.extend(
mbe.ax_plot_tracks(self.axes,
min_len=0,
all_tracks=self.all_fringes_flg))
self.fringe_lines.extend(
mbe.ax_draw_center_curves(self.axes))
self.canvas.draw()
self.status_text.setNum(self.cur_frame)
self.draw_done_sig.emit()
def clear_mbe(self):
self.cur_curve = None
self.next_curve = None
self.proc_this_frame_acc.setEnabled(False)
self.proc_next_frame_acc.setEnabled(False)
self.start_comp_acc.setEnabled(False)
self.iterate_button.setEnabled(False)
self.fringe_grp_bx.setChecked(False)
def set_spline_fitter(self, i):
if i:
self.sf.connect_sf()
# if we can screw with it, make it visible
self.sf_show.setChecked(True)
else:
self.sf.disconnect_sf()
self.redraw_sig.emit(False, False)
def set_spline_fitter_visible(self, i):
self.sf.set_visible(i)
# if we can't see it, don't let is screw with it
if not bool(i):
self.sf_check.setChecked(False)
self.redraw_sig.emit(False, False)
def set_cur_frame(self, i):
old_frame, self.cur_frame = self.cur_frame, i
if old_frame == self.cur_frame - 1:
self.cur_curve = self.next_curve
if self.draw_fringes:
self._proc_this_frame()
else:
self.redraw_sig.emit(False, True)
else:
self.draw_fringes = False
self.worker.clear()
self.redraw_sig.emit(True, True)
def iterate_frame(self):
self.cur_curve = self.next_curve
self._proc_this_frame()
def clear_spline(self):
self.sf.clear()
def show_cntrls(self):
self.diag.show()
def start_comp(self):
self.worker.start_comp(self.cur_curve,
self.output_template.path_template,
self.cur_frame, self.i_disk_dict)
def open_file(self):
fname, _ = QtGui.QFileDialog.getOpenFileName(
self,
caption='Select cine',
dir=self.paths_dict['cine base path'],
filter="cine (*.cine)")
if len(fname) == 0:
return
self.fringe_grp_bx.setChecked(False)
while (self.paths_dict['cine base path'] is None
or (not (self.paths_dict['cine base path']
== fname[:len(self.paths_dict['cine base path'])]))):
print('please set base_dir')
self.directory_actions['cine base path'].trigger()
self.prog_bar.show()
tmp_params = self._get_cur_parametrs()
self.diag.setEnabled(False)
path_, fname_ = os.path.split(
fname[(len(self.paths_dict['cine base path']) + 1):])
new_cine_fname = backends.FilePath(self.paths_dict['cine base path'],
path_, fname_)
self.fname_text.setText('/'.join(new_cine_fname[1:]))
self.clear_mbe()
# reset spinners to default values
# for p in self.spinner_lst:
# self.param_spin_dict[p['name']].setValue(p['default'])
self.fname_text.setText(new_cine_fname[-1])
self.open_file_sig.emit(new_cine_fname, tmp_params)
def _get_cur_parametrs(self):
tmp_dict = {}
# get parameters out of spin boxes
for key, sb in self.param_spin_dict.items():
if sb.isEnabled():
tmp_dict[key] = sb.value()
# get toggle switch values
for key, cb in self.param_checkbox_dict.items():
tmp_dict[key] = bool(cb.checkState())
return tmp_dict
def update_all_params(self):
tmp_dict = self._get_cur_parametrs()
# shove them into the worker
self.worker.update_all_params(tmp_dict)
# re-draw
if self.draw_fringes:
self._proc_this_frame()
def create_diag(self):
# make top level stuff
self.diag = QtGui.QDockWidget('controls', parent=self)
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, self.diag)
diag_widget = QtGui.QWidget(self.diag)
self.diag.setWidget(diag_widget)
diag_layout = QtGui.QVBoxLayout()
diag_widget.setLayout(diag_layout)
# frame number lives on top
self.frame_spinner = QtGui.QSpinBox()
self.frame_spinner.setRange(0, len(self.worker) - 1)
self.frame_spinner.valueChanged.connect(self.set_cur_frame)
frame_selector_group = QtGui.QVBoxLayout()
fs_form = QtGui.QHBoxLayout()
fs_form.addWidget(QtGui.QLabel('frame #'))
fs_form.addWidget(self.frame_spinner)
fs_form.addWidget(QtGui.QLabel(' of '))
self.max_cine_label = QtGui.QLabel(str(len(self.worker) - 1))
fs_form.addWidget(self.max_cine_label)
fs_stepbox = QtGui.QGroupBox("Frame step")
fs_sb_rb = QtGui.QHBoxLayout()
for j in [1, 10, 100, 1000, 10000]:
tmp_rdo = QtGui.QRadioButton(str(j))
tmp_rdo.toggled.connect(lambda x, j=j: self.frame_spinner.
setSingleStep(j) if x else None)
fs_sb_rb.addWidget(tmp_rdo)
if j == 1:
tmp_rdo.toggle()
pass
fs_stepbox.setLayout(fs_sb_rb)
frame_selector_group.addLayout(fs_form)
frame_selector_group.addWidget(fs_stepbox)
diag_layout.addLayout(frame_selector_group)
# play button
play_button = QtGui.QPushButton('Play')
self.play_button = play_button
play_button.setCheckable(True)
play_button.setChecked(False)
self.play_button.pressed.connect(self.frame_spinner.stepUp)
diag_layout.addWidget(play_button)
meta_data_group = QtGui.QVBoxLayout()
useful_button = QtGui.QPushButton('useful')
useful_button.clicked.connect(self.worker.set_useful)
useless_button = QtGui.QPushButton('useless')
useless_button.clicked.connect(self.worker.set_useless)
use_level = QtGui.QHBoxLayout()
use_level.addWidget(useful_button)
use_level.addWidget(useless_button)
meta_data_group.addLayout(use_level)
md_dict_disp = dict_display('cine md')
self.worker.md_loadad.connect(md_dict_disp.update)
meta_data_group.addWidget(md_dict_disp)
diag_layout.addLayout(meta_data_group)
# tool box for all the controls
diag_tool_box = QtGui.QToolBox()
diag_layout.addWidget(diag_tool_box)
# section for dealing with fringe finding
# the widget to shove into the toolbox
fringe_cntrls_w = QtGui.QWidget()
# vbox layout for this panel
fc_vboxes = QtGui.QVBoxLayout()
# set the widget layout
fringe_cntrls_w.setLayout(fc_vboxes)
# add to the tool box
diag_tool_box.addItem(fringe_cntrls_w, "Fringe Finding Settings")
# form layout to hold the spinners
fringe_cntrls_spins = QtGui.QFormLayout()
# add spinner layout
fc_vboxes.addLayout(fringe_cntrls_spins)
# fill the spinners
for spin_prams in LFGui.spinner_lst:
s_type = np.dtype(spin_prams['type']).kind
if s_type == 'i':
spin_box = QtGui.QSpinBox(parent=self)
elif s_type == 'f':
spin_box = QtGui.QDoubleSpinBox(parent=self)
spin_box.setDecimals(spin_prams['prec'])
else:
print(s_type)
continue
# properties of spin box
spin_box.setRange(spin_prams['min'], spin_prams['max'])
spin_box.setSingleStep(spin_prams['step'])
spin_box.setValue(spin_prams['default'])
name = spin_prams['name']
spin_box.setKeyboardTracking(False)
# connect it to an action
spin_box.valueChanged.connect(self.update_params_acc.trigger)
l_label = QtGui.QLabel(spin_prams['name'])
if 'tooltip' in spin_prams:
l_label.setToolTip(spin_prams['tooltip'])
# if it can be turned on or off
if spin_prams['togglable']:
l_checkbox = QtGui.QCheckBox('enable')
l_checkbox.stateChanged.connect(spin_box.setEnabled)
l_checkbox.setChecked(spin_prams['default_state'])
spin_box.setEnabled(spin_prams['default_state'])
l_checkbox.stateChanged.connect(self.update_params_acc.trigger)
l_h_layout = QtGui.QHBoxLayout()
l_h_layout.addWidget(spin_box)
l_h_layout.addWidget(l_checkbox)
fringe_cntrls_spins.addRow(l_label, l_h_layout)
# if it can't
else:
fringe_cntrls_spins.addRow(l_label, spin_box)
# add the spin box
self.param_spin_dict[name] = spin_box
for cb_param in self.toggle_lst:
l_label = QtGui.QLabel(cb_param['name'])
if 'tooltip' in cb_param:
l_label.setToolTip(cb_param['tooltip'])
l_checkbox = QtGui.QCheckBox('enable')
l_checkbox.setChecked(cb_param['default'])
self.param_checkbox_dict[cb_param['name']] = l_checkbox
l_checkbox.stateChanged.connect(self.update_params_acc.trigger)
fringe_cntrls_spins.addRow(l_label, l_checkbox)
# button to grab initial spline
grab_button = QtGui.QPushButton('Grab Spline')
grab_button.clicked.connect(self.grab_sf_curve)
fc_vboxes.addWidget(grab_button)
# button to process this frame
ptf_button = QtGui.QPushButton('Process This Frame')
ptf_button.clicked.connect(self.proc_this_frame_acc.trigger)
ptf_button.setEnabled(self.proc_this_frame_acc.isEnabled())
self.proc_this_frame_acc.changed.connect(lambda: ptf_button.setEnabled(
self.proc_this_frame_acc.isEnabled()))
fc_vboxes.addWidget(ptf_button)
# button to process next frame
pnf_button = QtGui.QPushButton('Process Next Frame')
pnf_button.clicked.connect(self.proc_next_frame_acc.trigger)
pnf_button.setEnabled(self.proc_next_frame_acc.isEnabled())
self.proc_next_frame_acc.changed.connect(lambda: pnf_button.setEnabled(
self.proc_next_frame_acc.isEnabled()))
fc_vboxes.addWidget(pnf_button)
# nuke tracking data
clear_mbe_button = QtGui.QPushButton('Clear fringes')
clear_mbe_button.clicked.connect(self.clear_mbe)
fc_vboxes.addWidget(clear_mbe_button)
self.fringe_grp_bx = QtGui.QGroupBox("Draw Fringes")
self.fringe_grp_bx.setCheckable(True)
self.fringe_grp_bx.setChecked(False)
self.fringe_grp_bx.toggled.connect(self.set_fringes_visible)
# self.proc_this_frame_acc.triggered.connect(
# lambda:self.fringe_grp_bx.setChecked(True))
all_fringe_rb = QtGui.QRadioButton('All Fringes')
valid_fringes_rb = QtGui.QRadioButton('Valid Fringes')
rb_vbox = QtGui.QVBoxLayout()
rb_vbox.addWidget(valid_fringes_rb)
rb_vbox.addWidget(all_fringe_rb)
self.fringe_grp_bx.setLayout(rb_vbox)
all_fringe_rb.toggled.connect(self.set_all_friges)
all_fringe_rb.setChecked(False)
valid_fringes_rb.setChecked(True)
fc_vboxes.addWidget(self.fringe_grp_bx)
iterate_button = QtGui.QPushButton('Iterate fringes')
iterate_button.clicked.connect(self.iterate_frame)
iterate_button.setEnabled(False)
fc_vboxes.addWidget(iterate_button)
self.iterate_button = iterate_button
start_comp_bttn = QtGui.QPushButton('Start Computation')
start_comp_bttn.clicked.connect(self.start_comp_acc.trigger)
start_comp_bttn.setEnabled(self.start_comp_acc.isEnabled())
self.start_comp_acc.changed.connect(lambda: start_comp_bttn.setEnabled(
self.start_comp_acc.isEnabled()))
fc_vboxes.addWidget(start_comp_bttn)
fc_vboxes.addStretch()
# section for making spline fitting panel
spline_cntrls = QtGui.QVBoxLayout()
spline_cntrls_w = QtGui.QWidget()
spline_cntrls_w.setLayout(spline_cntrls)
self.sf_check = QtGui.QCheckBox('enabled input')
self.sf_check.stateChanged.connect(self.set_spline_fitter)
spline_cntrls.addWidget(self.sf_check)
self.sf_show = QtGui.QCheckBox('display fitter')
self.sf_show.stateChanged.connect(self.set_spline_fitter_visible)
spline_cntrls.addWidget(self.sf_show)
clear_spline_button = QtGui.QPushButton('Clear Spline')
clear_spline_button.clicked.connect(self.clear_spline)
spline_cntrls.addWidget(clear_spline_button)
spline_cntrls.addStretch()
diag_tool_box.addItem(spline_cntrls_w, "Manual Spline Fitting")
# section for making spline fitting panel
paths_layout = QtGui.QVBoxLayout()
path_w = QtGui.QWidget()
path_w.setLayout(paths_layout)
for c in self.cap_lst:
ds = directory_selector(caption=c)
paths_layout.addWidget(ds)
self.directory_actions[c].triggered.connect(ds.select_path)
ds.selected.connect(
lambda x, c=c: self.paths_dict.__setitem__(c, x))
self.disk_widget = numbered_paths(2, self)
paths_layout.addWidget(self.disk_widget)
self.output_template = base_path_path_selector('output template')
paths_layout.addWidget(self.output_template)
paths_layout.addStretch()
diag_tool_box.addItem(path_w, "Paths")
def create_main_frame(self):
self.main_frame = QtGui.QWidget()
# create the mpl Figure and FigCanvas objects.
# 5x4 inches, 100 dots-per-inch
#
self.fig = Figure((24, 24), tight_layout=True)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
self.axes = self.fig.add_subplot(111,
adjustable='datalim',
aspect='equal')
# self.fig.tight_layout(.3, None, None, None)
# Since we have only one plot, we can use add_axes
# instead of add_subplot, but then the subplot
# configuration tool in the navigation toolbar wouldn't
# work.
#
self.im = None
# tmp = self.worker.get_frame(self.cur_frame)
#self.im = self.axes.imshow(tmp, cmap='gray', interpolation='nearest')
# self.axes.set_aspect('equal')
# self.im.set_clim([.5, 1.5])
self.sf = infra.spline_fitter(self.axes)
self.sf.disconnect_sf()
# self.axes.set_xlim(left=0)
#self.axes.set_ylim(top=0)
# this is because images are plotted upside down
# Create the navigation toolbar, tied to the canvas
#
self.mpl_toolbar = NavigationToolbar(self.canvas, self.main_frame)
# Other GUI controls
#
# lay out main panel
vbox = QtGui.QVBoxLayout()
vbox.addWidget(self.mpl_toolbar)
vbox.addWidget(self.canvas)
self.main_frame.setLayout(vbox)
self.setCentralWidget(self.main_frame)
@QtCore.Slot(bool, bool)
def redraw(self, draw_img, draw_tracks):
if self.im is not None:
self.im.remove()
self.im = None
print('entered redraw')
# clear the lines we have
for ln in self.fringe_lines:
ln.remove()
self.fringe_lines = []
mbe = self.worker.get_mbe()
img = self.worker.get_frame(0)
if img is None:
img = 1.5 * np.ones((1, 1))
extent = [0, img.shape[1], 0, img.shape[0]]
self.im = self.axes.imshow(img,
cmap='gray',
extent=extent,
origin='lower',
interpolation='nearest')
self.im.set_clim([.5, 1.5])
self.axes.set_aspect('equal')
if self.draw_fringes and mbe is not None:
# if we should draw new ones, do so
# grab new mbe from thread object
# grab new next curve
if self.draw_fringes and mbe is not None:
self.fringe_lines.extend(
mbe.ax_plot_tracks(self.axes,
min_len=0,
all_tracks=self.all_fringes_flg))
#self.status_text.setText(label)
self.frame_spinner.setRange(0, len(self.worker) - 1)
self.max_cine_label.setText(str(len(self.worker) - 1))
self.frame_spinner.setValue(0)
self.redraw_sig.emit(False, False)
def create_status_bar(self):
self.status_text = QtGui.QLabel(str(self.cur_frame))
self.fname_text = QtGui.QLabel('')
self.fname_text.setTextInteractionFlags(
QtCore.Qt.TextSelectableByMouse)
self.statusBar().addWidget(self.status_text)
self.prog_bar = QtGui.QProgressBar()
self.prog_bar.setRange(0, 0)
self.prog_bar.hide()
self.statusBar().addWidget(self.prog_bar, 1)
self.statusBar().addPermanentWidget(self.fname_text)
def closeEvent(self, ce):
self.kill_thread.emit()
# QtGui.qApp.quit()
# self.thread.quit()
self.diag.close()
QtGui.QMainWindow.closeEvent(self, ce)
def create_actions(self):
self.show_cntrl_acc = QtGui.QAction(u'show controls', self)
self.show_cntrl_acc.triggered.connect(self.show_cntrls)
self.start_comp_acc = QtGui.QAction(u'Save Parameters', self)
self.start_comp_acc.setEnabled(False)
self.start_comp_acc.triggered.connect(self.start_comp)
self.open_file_acc = QtGui.QAction(u'Open &File', self)
self.open_file_acc.triggered.connect(self.open_file)
self.proc_this_frame_acc = QtGui.QAction('Process this Frame', self)
self.proc_this_frame_acc.setEnabled(False)
self.proc_this_frame_acc.triggered.connect(self._proc_this_frame)
self.proc_next_frame_acc = QtGui.QAction('Process next Frame', self)
self.proc_next_frame_acc.setEnabled(False)
self.proc_next_frame_acc.triggered.connect(self._proc_next_frame)
self.directory_actions = {}
cta_lst = ['Select ' + x for x in self.cap_lst]
for cap, cta in zip(self.cap_lst, cta_lst):
tmp_acc = QtGui.QAction(cta, self)
self.directory_actions[cap] = tmp_acc
self.update_params_acc = QtGui.QAction('Update Parameters', self)
self.update_params_acc.triggered.connect(self.update_all_params)
def create_menu_bar(self):
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(self.show_cntrl_acc)
fileMenu.addAction(self.start_comp_acc)
fileMenu.addAction(self.open_file_acc)
pathMenu = menubar.addMenu('&Path')
for ac in self.directory_actions:
pathMenu.addAction(ac)
procMenu = menubar.addMenu('&Process')
procMenu.addAction(self.proc_this_frame_acc)
procMenu.addAction(self.proc_next_frame_acc)
@QtCore.Slot()
def _play(self):
QtGui.qApp.processEvents() # make sure all pending
# events are cleaned up if we
# don't do this, this gets
# hit before the button is
# marked as checked
if self.play_button.isChecked():
QtCore.QTimer.singleShot(30, self.frame_spinner.stepUp)
@property
def disk_dict(self):
return self.disk_widget.path_dict
@property
def i_disk_dict(self):
return {v: k for k, v in self.disk_widget.path_dict.items()}
class KMTEditor(QMainWindow):
KMT_MIN_VAL = 0
KMT_MAX_VAL = 60
def __init__(self, fname, datavar, dwx=60, dwy=60):
"""
ARGUMENTS:
fname - Name of the netcdf4 file
datavar - Name of the data variable in the file for which to plot
dwx, dwy - size of the DataContainer in number of array elements
scale - A float that will be multiplied with the data to scale the data
"""
super(KMTEditor, self).__init__(None)
self.setWindowTitle('KMTEditor - {0}'.format(fname))
# Creating a variable that contains all the data
self.dc = DataContainer(dwy, dwx, fname, datavar)
self.cursor = self.dc.getCursor() # Defining a cursor on the data
# This is the Rectangle boundary drawn on the world map that bounds the region
# under the view. At the start of the program it's value is None
self.prvrect = None
# This stores the matplotlib text objects used in the rendering of the colorbar
# This is used by the function draw_colorbar()
self.colorbarlabels = []
# self.colorbar_gradient is used by the function draw_colorbar()
self.colorbar_gradient = np.vstack(
(np.linspace(0, 1, 256), np.linspace(0, 1, 256)))
# The previously updated value
self.buffer_value = None
# Stuff for saving data
self.ofile = None # Name of output file
self.asked_about_overwrite_permission = False
self.unsaved_changes_exist = False
self.maps = mpl.cm.datad.keys() # The names of colormaps available
self.maps.sort() # Sorting them alphabetically for ease of use
self.create_menu()
self.create_main_window()
self.set_stats_info(self.dc.updateView(
0, 0)) # Set the initial view for the data container class
self.draw_preview_worldmap()
self.render_view()
self.statusBar().showMessage('KMTEditor 2015')
def keyPressEvent(self, e):
if e.key() == Qt.Key_Equal:
# Pressing = for edit
self.inputbox.setFocus()
elif e.key() == Qt.Key_V:
self.update_value(self.buffer_value)
elif e.key() == Qt.Key_C:
self.buffer_value = self.dc.getValueUnderCursor()
self.statusBar().showMessage(
'Value copied: {0}'.format(self.buffer_value), 2000)
elif e.key() == Qt.Key_A:
# Get the 5-point average and update the value
self.update_value_with_average(self.dc.getAverage())
elif e.key() == Qt.Key_M:
self.colormaps.setFocus()
elif e.key() == Qt.Key_Escape:
# Pressing escape to refocus back to the main frame
self.main_frame.setFocus()
elif e.key() in [Qt.Key_H, Qt.Key_J, Qt.Key_K, Qt.Key_L]:
self.set_stats_info(self.dc.moveView(e.key()))
self.render_view()
self.render_edited_cells()
else:
self.dc.updateCursorPosition(e)
self.draw_cursor()
def create_main_window(self):
"""
This function creates the main window of the program.
"""
self.main_frame = QWidget()
self.main_frame.setMinimumSize(QSize(700, 700))
self.dpi = 100
self.fig = plt.Figure((6, 6),
dpi=self.dpi,
facecolor='w',
edgecolor='w')
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
# Stuff for the preview map >>>>>>>>>>>>>>>>>>>>>>>>>
self.preview_frame = QWidget()
self.preview_fig = plt.Figure((3, 1.6),
dpi=self.dpi,
facecolor='w',
edgecolor='w')
self.preview = FigureCanvas(self.preview_fig)
self.preview.setParent(self.preview_frame)
self.preview_axes = self.preview_fig.add_subplot(111)
self.preview_fig.canvas.mpl_connect('button_press_event', self.onclick)
self.preview_fig.subplots_adjust(top=1, bottom=0, left=0, right=1)
# Stuff for the preview map <<<<<<<<<<<<<<<<<<<<<<<<<
# Stuff for the colorbar >>>>>>>>>>>>>>>>>>>>>>>>>
self.colorbar_frame = QWidget()
self.colorbar_fig = plt.Figure((3, 0.4),
dpi=self.dpi,
facecolor='w',
edgecolor='w')
self.colorbar = FigureCanvas(self.colorbar_fig)
self.colorbar.setParent(self.colorbar_frame)
self.colorbar_axes = self.colorbar_fig.add_subplot(111)
self.colorbar_fig.subplots_adjust(
top=1.0, bottom=0.35, left=0.02,
right=0.97) #Tightening the area around the subplot
self.colorbar_fig.patch.set_facecolor(
'none') # Making the figure background transparent
self.colorbar_axes.get_xaxis().set_visible(False)
self.colorbar_axes.get_yaxis().set_visible(False)
# Stuff for the colorbar <<<<<<<<<<<<<<<<<<<<<<<<<
# Since we have only one plot, we can use add_axes
# instead of add_subplot, but then the subplot
# configuration tool in the navigation toolbar wouldn't
# work.
#
self.axes = self.fig.add_subplot(111)
# Turning off the axes ticks to maximize space. Also the labels were meaningless
# anyway because they were not representing the actual lat/lons.
self.axes.get_xaxis().set_visible(False)
self.axes.get_yaxis().set_visible(False)
# Other GUI controls
# Information section
font = QFont("SansSerif", 14)
# STATISTICS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
self.statdisplay = QLabel("Statistics:")
self.statgrid = QGridLayout()
self.statgrid.setSpacing(5)
w = QLabel("View")
w.setFont(font)
self.statgrid.addWidget(w, 1, 1, Qt.AlignCenter)
w = QLabel("Global")
w.setFont(font)
self.statgrid.addWidget(w, 1, 2, Qt.AlignCenter)
for i, name in enumerate(["Minimum", "Maximum", "Mean"]):
w = QLabel(name)
w.setFont(font)
self.statgrid.addWidget(w, i + 2, 0, Qt.AlignLeft)
self.statsarray = []
for i in range(6):
self.statsarray.append(QLabel(''))
self.statsarray[3].setText("{0:3d}".format(int(self.dc.data.min())))
self.statsarray[4].setText("{0:3d}".format(int(self.dc.data.max())))
self.statsarray[5].setText("{0:3d}".format(int(self.dc.data.mean())))
for i in range(3):
self.statgrid.addWidget(self.statsarray[i], i + 2, 1,
Qt.AlignCenter)
self.statgrid.addWidget(self.statsarray[i + 3], i + 2, 2,
Qt.AlignCenter)
self.statsarray[i].setFont(font)
self.statsarray[i + 3].setFont(font)
# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
# PIXEL INFO >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
self.infodisplay = QLabel("Pixel Information:")
self.infogrid = QGridLayout()
self.infogrid.setSpacing(5)
for i, name in enumerate(["Lat", "Lon", "KMT", "I, J"]):
w = QLabel(name)
w.setFont(font)
# w.setLineWidth(1)
# w.setFrameShape(QFrame.Box)
self.infogrid.addWidget(w, i + 2, 0, Qt.AlignLeft)
self.latdisplay = QLabel("")
self.londisplay = QLabel("")
self.valdisplay = QLabel("")
self.idxdisplay = QLabel("")
for i, w in enumerate([
self.latdisplay, self.londisplay, self.valdisplay,
self.idxdisplay
]):
self.infogrid.addWidget(w, i + 2, 1, Qt.AlignLeft)
w.setFont(font)
# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
# Colorscheme selector
cmap_label = QLabel('Colorscheme:')
self.colormaps = QComboBox(self)
self.colormaps.addItems(self.maps)
self.colormaps.setCurrentIndex(self.maps.index('Set1'))
self.colormaps.currentIndexChanged.connect(self.render_view)
# New value editor
valhbox = QHBoxLayout()
w = QLabel("Enter new value: ")
w.setFont(font)
valhbox.addWidget(w)
self.inputbox = QLineEdit()
self.inputbox.returnPressed.connect(self.update_value)
valhbox.addWidget(self.inputbox)
for item in [
self.statdisplay, self.infodisplay, self.latdisplay,
self.londisplay, self.valdisplay, self.idxdisplay, cmap_label
]:
item.setFont(font)
vbox = QVBoxLayout()
vbox.addWidget(self.canvas)
vbox2 = QVBoxLayout()
vbox2.addWidget(self.preview) # Adding preview window
# Horizontal line
fr = QFrame()
fr.setLineWidth(0.5)
fr.setFrameShape(QFrame.HLine)
vbox2.addWidget(fr)
vbox2.setAlignment(fr, Qt.AlignTop)
# databox is a horizontal box for the displayed "information"
databox = QHBoxLayout()
statvbox = QVBoxLayout() # This is the sub-box for the statistics
statvbox.addWidget(self.statdisplay)
statvbox.setAlignment(self.statdisplay, Qt.AlignTop)
statvbox.addLayout(self.statgrid)
databox.addLayout(statvbox)
fr = QFrame()
fr.setLineWidth(0.5)
fr.setFrameShape(QFrame.VLine)
databox.addWidget(fr)
pixelvbox = QVBoxLayout(
) # This is another sub-box of databox for the pixel info
pixelvbox.addWidget(self.infodisplay)
pixelvbox.setAlignment(self.infodisplay, Qt.AlignTop)
pixelvbox.addLayout(self.infogrid)
databox.addLayout(pixelvbox)
vbox2.addLayout(databox)
# Horizontal line
fr = QFrame()
fr.setLineWidth(0.5)
fr.setFrameShape(QFrame.HLine)
vbox2.addWidget(fr)
vbox2.setAlignment(fr, Qt.AlignTop)
vbox2.addLayout(valhbox, Qt.AlignTop)
vbox2.addStretch(1)
vbox2.addWidget(cmap_label) # Adding the colormap label
vbox2.addWidget(self.colormaps) # Adidng the colormap selector
vbox2.addWidget(self.colorbar)
vbox2.setAlignment(self.colorbar, Qt.AlignCenter)
vbox2.addStretch(1)
helpbox = QVBoxLayout()
help_title = QLabel("Help")
font = QFont("SansSerif", 14)
font.setBold(True)
help_title.setFont(font)
helpbox.addWidget(help_title)
helpbox.setAlignment(help_title, Qt.AlignTop)
helpgrid = QGridLayout()
helpgrid.setSpacing(5)
helpgrid.addWidget(QLabel("Key"), 0, 0, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("Action"), 0, 1, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("up, down,left,right"), 1, 0, 1, 1,
Qt.AlignLeft)
helpgrid.addWidget(QLabel("move cursor"), 1, 1, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("h,j,k,l"), 2, 0, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("move view"), 2, 1, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("a"), 3, 0, 1, 1, Qt.AlignLeft)
# helpgrid.addWidget(QLabel("replace cell value with 9 point average"), 3, 1, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("replace cell value with 9\npoint average"),
3, 1, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("="), 4, 0, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("enter new value for cell"), 4, 1, 1, 1,
Qt.AlignLeft)
helpgrid.addWidget(QLabel("c"), 5, 0, 1, 1, Qt.AlignLeft)
# helpgrid.addWidget(QLabel("copy value under cursor into buffer"), 5, 1, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("copy value under cursor\ninto buffer"), 5,
1, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("v"), 6, 0, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("paste value in buffer"), 6, 1, 1, 1,
Qt.AlignLeft)
helpgrid.addWidget(QLabel("m"), 7, 0, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("move focus to color selector"), 7, 1, 1, 1,
Qt.AlignLeft)
helpgrid.addWidget(QLabel("Escape"), 8, 0, 1, 1, Qt.AlignLeft)
helpgrid.addWidget(QLabel("move focus to main view"), 8, 1, 1, 1,
Qt.AlignLeft)
helpbox.addLayout(helpgrid)
helpbox.setAlignment(helpgrid, Qt.AlignTop)
vbox2.addLayout(helpbox)
vbox2.setAlignment(helpbox, Qt.AlignBottom)
hbox = QHBoxLayout()
hbox.addLayout(vbox)
hbox.addLayout(vbox2)
self.main_frame.setLayout(hbox)
self.setCentralWidget(self.main_frame)
self.main_frame.setFocus()
def draw_preview_worldmap(self):
"""
This function draws the world map in the preview window on the top right hand corner
of the application.
"""
m = Basemap(projection='cyl', lon_0=180, llcrnrlat=-90,urcrnrlat=90,\
llcrnrlon=0,urcrnrlon=360,resolution='c', ax=self.preview_axes)
self.preview_axes.set_xlim([0, 360])
m.drawcoastlines(linewidth=0.5)
m.fillcontinents()
self.preview_axes.set_ylim([-90, 90])
def draw_colorbar(self):
"""
This function draws the colorbar and the labels for the colorbar.
"""
# First clear the colorbar axes
self.colorbar_axes.cla()
# Get the current selected colormap
cmap = mpl.cm.get_cmap(self.maps[self.colormaps.currentIndex()])
# Plot the colormap
self.colorbar_axes.imshow(self.colorbar_gradient,
aspect='auto',
cmap=cmap)
pos = list(self.colorbar_axes.get_position().bounds)
dx = (pos[2]) / 6. # The spacing between the labels
if self.colorbarlabels != []:
# Delete and clear the text labels
while self.colorbarlabels:
self.colorbarlabels.pop().remove()
for i, l in enumerate([1, 10, 20, 30, 40, 50, 60]):
self.colorbarlabels.append(
self.colorbar_fig.text(pos[0] + (i * dx),
0.01,
str(l),
va='bottom',
ha='center',
fontsize=10))
self.colorbar.draw()
def draw_cursor(self, noremove=False):
if self.cursor.marker and (not noremove): self.cursor.marker.remove()
# The increment by 0.5 below is done so that the center of the marker is shifted
# so that the top left corner of the square marker conicides with the top right corner
# of each pixel. The value of 0.5 comes simply because each pixel are offset by 1 in each dimension.
_cx, _cy = self.cursor.x + 0.5, self.cursor.y + 0.5
self.cursor.marker = self.axes.scatter(_cx,
_cy,
s=55,
marker='s',
edgecolor="k",
facecolor='none',
linewidth=2)
self.set_information(self.cursor.y, self.cursor.x)
self.canvas.draw()
def render_edited_cells(self):
"""
This function draws a box around cells that have been edited, thereby highlighting
them from the other cells.
"""
changes_row_idx = self.dc.changes_row_idx
# We only need to go ahead if a change has been made, i.e. changes_row_idx is larger than 0
if changes_row_idx > 0:
# We are creating simple views to make the code for this function simpler
change_rows = self.dc.changes[:self.dc.changes_row_idx, 0].view(
) # A view on rows indices that have been changed
change_cols = self.dc.changes[:self.dc.changes_row_idx, 1].view(
) # A view on column indices that have been changed
# Retrieving some class variables and storing for speed
si = self.dc.si
sj = self.dc.sj
nrows = self.dc.nrows
ncols = self.dc.ncols
# We select the indices that lie within the view box
indices_of_interest = np.logical_and(
np.logical_and(change_rows >= si, change_rows <= (si + nrows)),
np.logical_and(change_cols >= sj, change_cols <= (sj + ncols)))
_i = change_rows[indices_of_interest] + 0.5 - si
_j = change_cols[indices_of_interest] + 0.5 - sj
self.axes.scatter(_j,
_i,
s=38,
marker='s',
edgecolor="k",
facecolor='none',
linewidth=1)
self.canvas.draw()
def render_view(self):
self.draw_colorbar()
self.axes.clear()
# Either select the colormap through the combo box or specify a custom colormap
cmap = mpl.cm.get_cmap(self.maps[self.colormaps.currentIndex()])
self.axes.pcolor(self.dc.view_masked,
cmap=cmap,
edgecolors='w',
linewidths=0.5,
vmin=KMTEditor.KMT_MIN_VAL,
vmax=KMTEditor.KMT_MAX_VAL)
tmp1 = self.dc.nrows
tmp2 = self.dc.ncols
# This is for drawing the black contour line for the continents
self.axes.contour(self.dc.view,
levels=[0],
colors='k',
linewidth=1.5,
interpolation="nearest",
origin="lower",
extents=[0.5, tmp2 + 0.5, 0.5, tmp1 + 0.5])
# Setting the axes limits. This helps in setting the right orientation of the plot
# and in clontrolling how much extra space we want around the scatter plot.
# I am putting 4% space around the scatter plot
self.axes.set_ylim([int(tmp1 * 1.02), 0 - int(tmp1 * 0.02)])
self.axes.set_xlim([0 - int(tmp2 * 0.02), int(tmp2 * 1.02)])
self.canvas.draw()
self.fig.tight_layout()
self.draw_cursor(noremove=True)
def update_value(self, inp=None):
if inp == None:
inp = self.inputbox.text() # Get the value in the text box
if self.InputValueIsAcceptable(inp):
self.dc.modifyValue(inp) # Modify the data array
self.unsaved_changes_exist = True
self.buffer_value = inp
self.statusBar().showMessage('Value changed: {0}'.format(inp),
2000)
self.set_stats_info(self.dc.getViewStatistics())
self.inputbox.clear() # Now clear the input box
self.render_view(
) # Render the new view (which now contains the updated value)
self.render_edited_cells()
self.main_frame.setFocus() # Bring focus back to the view
def update_value_with_average(self, val):
"""
Updates the value at the current cursor position using the input val.
"""
self.dc.modifyValue(val) # Modify the data array
self.unsaved_changes_exist = True
self.statusBar().showMessage('Value changed: {0}'.format(val), 2000)
self.set_stats_info(self.dc.getViewStatistics())
self.render_view(
) # Render the new view (which now contains the updated value)
self.render_edited_cells()
def InputValueIsAcceptable(self, inp):
""" This functions checks to see if the user has entered a valid
vlaue kmt value. Returns true if the input value is acceptable. """
tt = float(inp)
if (tt != int(tt)):
msg = "KMT level must be an integer value\nYou entered {0}".format(
inp)
QMessageBox.critical(self, "Invalid Value", msg.strip())
return False
if ((tt < 0) or (tt > 60)):
msg = "KMT level values must be between 0 and 60.\nYou entered {0}".format(
inp)
QMessageBox.critical(self, "Invalid Value", msg.strip())
return False
return True
def set_information(self, i, j):
""" Sets the displayed information about the pixel in the right sidebar.
ARGUMENTS
i, j : the local (i.e. DataContainer) 0-based indices for the element
"""
i_global, j_global = self.dc.viewIndex2GlobalIndex(
i, j) # Convert local indices to global indices
self.latdisplay.setText("{0:7.3f}".format(self.dc.kmt_lats[i_global,
j_global]))
self.londisplay.setText("{0:7.3f}".format(self.dc.kmt_lons[i_global,
j_global]))
self.valdisplay.setText("{0:3d}".format(
int(self.dc.data[i_global, j_global])))
self.idxdisplay.setText("{0:3d},{1:3d}".format(int(i_global),
int(j_global)))
def set_stats_info(self, s):
"""
Updates the statistics display panel with the stats for the view.
ARGUMENTS
s - a tuple with the min, max and mean of the view
"""
self.statsarray[0].setText("{0:3d}".format(int(s[0])))
self.statsarray[1].setText("{0:3d}".format(int(s[1])))
self.statsarray[2].setText("{0:3d}".format(int(s[2])))
def onclick(self, event):
QMessageBox.information(
self, "",
"KMTEditor does not presently support mouse selection over the preview plot"
)
def on_about(self):
msg = """ Edit KMT levels for the POP ocean model. """
QMessageBox.about(self, "About", msg.strip())
def save_data(self):
"""
Saves the data to a netCDF4 file. The program tries to construct a default format of
output filename, but if it exists, it asks the user whether to overwrite it. If the
user does not want to overwrite, she is asked to enter a new filename.
"""
# We construct a standard output name of the form: inputname_fixed.nc
if self.ofile is None:
self.ofile = self.dc.fname.split(".")[0] + "_fixed.nc"
# Now we check if the file exists. Then we must ask the user if she wants to overwrite the file
if not self.asked_about_overwrite_permission:
clobber = False
if os.path.exists(self.ofile):
reply = QMessageBox.question(
self, 'Saving file...',
"The output file {0} exists. Overwrite?".format(
self.ofile), QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if reply == QMessageBox.Yes: clobber = True
if not clobber:
# The use has responded to not overwrite, we must now ask for a new filename
ok = False
erromsg = ""
# This loop continues until an acceptable filename is entered, or the user presses cancel
while not ok:
_inp, ok = QInputDialog.getText(
self,
"Saving file...",
"{0}Enter name of a different output file:".format(
erromsg),
)
if ok:
try:
self.ofile = str(_inp)
except:
ok = False
erromsg = "File name not acceptable. "
if os.path.exists(self.ofile):
ok = False
erromsg = "File exists. "
else:
self.ofile = None
self.statusBar().showMessage(
'Save cancelled', 2000)
return
# To simplify creation of the output filename, i first duplicate the original file, then overwrite
# the kmt array.
nccopy(self.dc.fname,
self.ofile,
quiet=True,
clobber=clobber,
zlib=False,
shuffle=False,
classic=1)
# now we set this to True, so that next time we save, we are not prompted about existing file
self.asked_about_overwrite_permission = True
ncfile = Dataset(self.ofile, "a", format="NETCDF4")
alldimensions = ncfile.dimensions
allvariables = ncfile.variables
if not "changes" in alldimensions:
ncfile.createDimension("changes", None)
if not "i" in alldimensions: ncfile.createDimension("i", 3)
if not "original_kmt" in allvariables:
okmt = ncfile.createVariable("original_kmt", "f4",
("latitude", "longitude"))
okmt.description = "Original KMT data from which this file was created by KMTEditor.py"
okmt[:, :] = np.flipud(self.dc.orig_data)
if not "changes" in allvariables:
cngvar = ncfile.createVariable("changes", "f8", ("changes", "i"))
cngvar.description = "changes to original data leading to present data. (i,j,val)"
cngvar[:, :] = self.dc.changes[0:self.dc.changes_row_idx, :]
else:
cngvar = allvariables["changes"]
# s = cngvar.shape[0]
cngvar[:, :] = self.dc.changes[0:self.dc.changes_row_idx, :]
kmtvar = ncfile.variables["kmt"]
kmtvar[:, :] = np.flipud(self.dc.data)
kmtvar.description = "Created by KMTEditor.py"
ncfile.history = "Created by KMTEditor.py"
ncfile.input_file = self.dc.fname
ncfile.created = time.ctime()
ncfile.close()
self.unsaved_changes_exist = False
self.statusBar().showMessage('Saved to file: %s' % self.ofile, 2000)
def create_action(self,
text,
slot=None,
shortcut=None,
icon=None,
tip=None,
checkable=False,
signal="triggered()"):
action = QAction(text, self)
if icon is not None:
action.setIcon(QIcon(":/%s.png" % icon))
if shortcut is not None:
action.setShortcut(shortcut)
if tip is not None:
action.setToolTip(tip)
action.setStatusTip(tip)
if slot is not None:
self.connect(action, SIGNAL(signal), slot)
if checkable:
action.setCheckable(True)
return action
def add_actions(self, target, actions):
for action in actions:
if action is None:
target.addSeparator()
else:
target.addAction(action)
def create_menu(self):
self.file_menu = self.menuBar().addMenu("&File")
load_file_action = self.create_action("&Save Data",
shortcut="Ctrl+S",
slot=self.save_data,
tip="Save the data array")
self.add_actions(self.file_menu, (load_file_action, ))
self.help_menu = self.menuBar().addMenu("&Help")
about_action = self.create_action("&About",
shortcut='F1',
slot=self.on_about,
tip='About KMTEditor')
self.add_actions(self.help_menu, (about_action, ))
def closeEvent(self, event):
if self.unsaved_changes_exist:
reply = QMessageBox.question(
self, 'Message',
"There are unsaved changes. Are you sure you want to quit?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
event.accept()
else:
event.ignore()
class RdfWindow(QtGui.QDialog):
def __init__(self):
super(RdfWindow, self).__init__()
self.bft = []
self.k = []
self.kpow = 0
# self.rdf_r = []
# self.rdf = []
self.params = []
self.amp_orig = [[], []] #0 - k, 1 - amp or pha
self.pha_orig = [[], []]
self.rdf_exafs = []
self.rdf_exafs_k = []
self.initUI()
@QtCore.pyqtSlot(str)
def on_myStream_message(self, message):
self.textEdit.moveCursor(QtGui.QTextCursor.End)
self.textEdit.insertPlainText(message)
def initUI(self):
self.fig = plt.figure(5, figsize=(18, 6))
self.ax_bft = plt.subplot2grid((1, 3), (0, 0))
self.ax_bftft = plt.subplot2grid((1, 3), (0, 1))
self.ax_rdf = plt.subplot2grid((1, 3), (0, 2))
self.ax_bft.set_xlabel('Wavevector k, $\AA^{-1}$')
self.ax_bft.set_ylabel('EXAFS, $\AA^{-2}$')
self.ax_bftft.set_xlabel('Distance R, $\AA$')
self.ax_bftft.set_ylabel('Fourier transform, $\AA^{-3}$')
self.ax_rdf.set_xlabel('Distance R, $\AA$')
self.ax_rdf.set_ylabel('RDF G(R)')
self.line1_bft, = self.ax_bft.plot([], [], label='BFT')
self.line2_bft, = self.ax_bft.plot([], [], label='fit')
self.line1_bft.set_color('b')
self.line2_bft.set_color('g')
self.ax_bft.legend(handles=[self.line1_bft, self.line2_bft])
self.line1_bftft, self.line2_bftft = self.ax_bftft.plot([], [], [], [])
self.line1_bftft.set_color('b')
self.line2_bftft.set_color('b')
self.line2_bftft.set_linestyle('dotted')
self.line3_bftft, self.line4_bftft = self.ax_bftft.plot([], [], [], [])
self.line3_bftft.set_color('g')
self.line4_bftft.set_color('g')
self.line4_bftft.set_linestyle('dotted')
self.line1_rdf, = self.ax_rdf.plot([], [], marker='o')
self.line2_rdf, = self.ax_rdf.plot([], [])
self.fig.tight_layout()
self.canv = FigureCanvas(self.fig)
self.tbar = NavigationToolbar(self.canv, self)
self.rdf_r = np.arange(0.8, 2.5, 0.01)
self.rdf = np.zeros(len(self.rdf_r))
# self.lblNrShells = QtGui.QLabel("Number of shells")
# self.edtNrShells = QtGui.QLineEdit("1")
self.lblkmin = QtGui.QLabel("K min")
self.lblkmax = QtGui.QLabel("K max")
self.lbldk = QtGui.QLabel("dK")
self.lblrmin = QtGui.QLabel("Rmin")
self.lblrmax = QtGui.QLabel("Rmax")
self.lbldr = QtGui.QLabel("dR")
self.edtkmin = QtGui.QLineEdit("0.5")
self.edtkmax = QtGui.QLineEdit("15")
self.edtdk = QtGui.QLineEdit("0.05")
self.edtrmin = QtGui.QLineEdit("0.5")
self.edtrmax = QtGui.QLineEdit("2.8")
self.edtdr = QtGui.QLineEdit("0.01")
self.edtrmin.editingFinished.connect(self.resetFit)
self.edtrmax.editingFinished.connect(self.resetFit)
self.edtdr.editingFinished.connect(self.resetFit)
# self.lblCentralDist = QtGui.QLabel("Central distance")
# self.edtCentralDist = QtGui.QLineEdit("1.8")
# self.lblWidth = QtGui.QLabel("Width")
# self.edtWidth = QtGui.QLineEdit("0.001")
# self.lblAmplitude = QtGui.QLabel("Amplitude")
# self.edtAmplitude = QtGui.QLineEdit("50")
self.lblIterations = QtGui.QLabel("Max. number of iterations")
self.edtIterations = QtGui.QLineEdit("20")
self.chkFirstFit = QtGui.QCheckBox(
"Start new fit (checked) / continue fit (unchecked)")
self.chkFirstFit.setChecked(True)
self.Amp = QtGui.QComboBox()
self.Pha = QtGui.QComboBox()
lblAmp = QtGui.QLabel("Amplitude")
lblPha = QtGui.QLabel("Phase")
self.Amp.addItem("")
self.Amp.addItem("E:/work/development/xaslib/fit/amp0001.dat")
self.Pha.addItem("")
self.Pha.addItem("E:/work/development/xaslib/fit/pha0001.dat")
self.lblFuncEval = QtGui.QLabel("Number of function evaluations done")
self.edtFuncEval = QtGui.QLineEdit()
self.lblFitMessage = QtGui.QLabel("Iterations done")
self.edtFitMessage = QtGui.QLineEdit()
self.lblOptimality = QtGui.QLabel("Residual")
self.edtOptimality = QtGui.QLineEdit()
lfit = QtGui.QGridLayout()
lfit.addWidget(self.lblFitMessage, 0, 0)
lfit.addWidget(self.edtFitMessage, 0, 1)
lfit.addWidget(self.lblFuncEval, 1, 0)
lfit.addWidget(self.edtFuncEval, 1, 1)
lfit.addWidget(self.lblOptimality, 2, 0)
lfit.addWidget(self.edtOptimality, 2, 1)
self.btnFit = QtGui.QPushButton('Fit')
self.btnFit.clicked.connect(self.Fit_rdf)
self.btnSaveRdf = QtGui.QPushButton('Save RDF')
self.btnSaveRdf.clicked.connect(self.saveRDF)
self.btnApply = QtGui.QPushButton('Apply')
self.btnApply.clicked.connect(self.apply)
self.btnCancel = QtGui.QPushButton('Cancel')
self.btnCancel.clicked.connect(self.cancel)
self.btnOpenAmp = QtGui.QPushButton('Open amplitude file(s) ...')
self.btnOpenAmp.clicked.connect(self.openamp)
self.btnOpenPha = QtGui.QPushButton('Open phase file(s) ...')
self.btnOpenPha.clicked.connect(self.openpha)
self.btnOpenFeff = QtGui.QPushButton('Open feff file(s) ...')
self.btnOpenFeff.clicked.connect(self.openfeff)
# self.textEdit = QtGui.QTextEdit(self)
# lb.addWidget(self.textEdit, 1, 0)
lfig = QtGui.QGridLayout()
lfig.addWidget(self.tbar, 0, 0, 1, 2)
lfig.addWidget(self.canv, 1, 0, 1, 2)
lfig.addLayout(lfit, 2, 0)
lfig.addWidget(self.btnFit, 3, 0)
lfig.addWidget(self.btnSaveRdf, 4, 0)
lfig.addWidget(self.btnApply, 5, 0)
lfig.addWidget(self.btnCancel, 6, 0)
lp = QtGui.QGridLayout()
lp.addWidget(self.lblkmin, 0, 0)
lp.addWidget(self.edtkmin, 0, 1)
lp.addWidget(self.lblkmax, 0, 2)
lp.addWidget(self.edtkmax, 0, 3)
lp.addWidget(self.lbldk, 0, 4)
lp.addWidget(self.edtdk, 0, 5)
lp.addWidget(self.lblrmin, 1, 0)
lp.addWidget(self.edtrmin, 1, 1)
lp.addWidget(self.lblrmax, 1, 2)
lp.addWidget(self.edtrmax, 1, 3)
lp.addWidget(self.lbldr, 1, 4)
lp.addWidget(self.edtdr, 1, 5)
# lfig.addWidget(self.lblAmplitude, 2,1)
# lfig.addWidget(self.edtAmplitude, 2,2)
# lfig.addWidget(self.lblCentralDist, 2,3)
# lfig.addWidget(self.edtCentralDist, 2,4)
# lfig.addWidget(self.lblWidth, 2,5)
# lfig.addWidget(self.edtWidth, 2,6)
lp.addWidget(self.lblIterations, 2, 0, 1, 3)
lp.addWidget(self.edtIterations, 2, 3, 1, 3)
lp.addWidget(self.chkFirstFit, 3, 0, 1, 6)
lp.addWidget(lblAmp, 4, 0)
lp.addWidget(self.Amp, 4, 1, 1, 4)
lp.addWidget(lblPha, 5, 0)
lp.addWidget(self.Pha, 5, 1, 1, 4)
lp.addWidget(self.btnOpenAmp, 4, 5)
lp.addWidget(self.btnOpenPha, 5, 5)
lp.addWidget(self.btnOpenFeff, 6, 0)
lfig.addLayout(lp, 2, 1, 5, 1)
self.setLayout(lfig)
self.canv.draw()
def Fit_rdf(self):
self.kstart = float(self.edtkmin.text())
self.kend = float(self.edtkmax.text())
self.dk = float(self.edtdk.text())
self.common_k = np.arange(self.kstart, self.kend, self.dk)
self.rstart = float(self.edtrmin.text())
self.rend = float(self.edtrmax.text())
self.dr = float(self.edtdr.text())
self.rdf_r = np.arange(self.rstart, self.rend, self.dr)
if self.chkFirstFit.isChecked():
self.rdf = np.zeros(len(self.rdf_r))
#prepare variable and parameter array
splbft = InterpolatedUnivariateSpline(self.k, self.bft)
self.common_bft = splbft(self.common_k)
varbounds = [[], []]
varbounds1 = []
for i in range(len(self.rdf_r)):
varbounds[0].append(0)
varbounds[1].append(1E6)
varbounds1.append((0, 1E6))
varbounds[0] = tuple(varbounds[0])
varbounds[1] = tuple(varbounds[1])
par = []
var_par = []
edtVarBoxes = []
if self.amp_orig[0] == [] or self.pha_orig[0] == []:
kamp, amp_orig = np.genfromtxt(self.Amp.currentText(),
usecols=(0, 1),
unpack=True)
kpha, pha_orig = np.genfromtxt(self.Pha.currentText(),
usecols=(0, 1),
unpack=True)
self.amp_orig[0] = kamp
self.pha_orig[0] = kpha
self.amp_orig[1] = amp_orig
self.pha_orig[1] = pha_orig
else:
kamp = self.amp_orig[0]
amp_orig = self.amp_orig[1]
kpha = self.pha_orig[0]
pha_orig = self.pha_orig[1]
print(kamp, amp_orig)
splamp = InterpolatedUnivariateSpline(kamp, amp_orig)
splpha = InterpolatedUnivariateSpline(kpha, pha_orig)
amp = splamp(self.common_k)
pha = splpha(self.common_k)
pha_component = np.sin(2 * np.transpose(np.array([self.rdf_r])).dot(
np.array([self.common_k])) + pha)
rdf_r2 = self.rdf_r * self.rdf_r
amp_component = amp * (1 / np.transpose(np.array([rdf_r2])).dot(
np.array([self.common_k])))
self.amptimespha = amp_component * pha_component
options1 = {
'disp': False,
'maxls': 20,
'iprint': -1,
'gtol': 1e-05,
'eps': 1e-08,
'maxiter': int(self.edtIterations.text()),
'ftol': 2.220446049250313e-09,
'maxcor': 10,
'maxfun': 15000
}
args = (self.common_k, self.common_bft, self.amptimespha, self.dr,
self.kpow)
self.rdffnd = RDFinder()
self.rdffnd.args = args
self.rdffnd.options1 = options1
self.rdffnd.varbounds1 = varbounds1
self.rdffnd.rdf = self.rdf
self.wthread = QtCore.QThread(self)
self.rdffnd.moveToThread(self.wthread)
self.wthread.started.connect(self.rdffnd.calculate)
self.rdffnd.finished.connect(self.RDFinished)
self.rdffnd.updateProgress.connect(self.updateProgress)
self.rdffnd.finished.connect(self.wthread.quit)
print("Starting optimisation...")
self.wthread.start()
print("optimisation started...")
def updateProgress(self, Xi):
fresidual = exafsrdf_difeval(Xi, self.common_k, self.common_bft,
self.amptimespha, self.dr, self.kpow)
print("Step residual: ", fresidual)
self.edtOptimality.setText("{:e}".format(fresidual))
self.window = Window_Gauss10(self.common_k, self.kstart, self.kend)
self.bftw = self.common_bft * self.window
self.r, self.fr, self.fi = FT(self.common_k, self.bftw, 0, 4, 0.02)
self.efr = np.sqrt(self.fr * self.fr + self.fi * self.fi)
self.efi = self.fi * (-1)
fit_result = exafsrdf(Xi, self.common_k, self.common_bft,
self.amptimespha, self.dr,
self.kpow) + self.common_bft
fit_result_w = fit_result * self.window
res_r, res_fr, res_fi = FT(self.common_k, fit_result_w, 0, 4, 0.02)
res_efr = np.sqrt(res_fr * res_fr + res_fi * res_fi)
res_efi = res_fi * (-1)
self.line1_bft.set_xdata(self.k)
self.line1_bft.set_ydata(self.bft)
self.line2_bft.set_xdata(self.common_k)
self.line2_bft.set_ydata(fit_result)
self.line1_bftft.set_xdata(self.r)
self.line1_bftft.set_ydata(self.efr)
self.line2_bftft.set_xdata(self.r)
self.line2_bftft.set_ydata(self.efi)
self.line3_bftft.set_xdata(res_r)
self.line3_bftft.set_ydata(res_efr)
self.line4_bftft.set_xdata(res_r)
self.line4_bftft.set_ydata(res_efi)
self.line1_rdf.set_xdata(self.rdf_r)
self.line1_rdf.set_ydata(Xi)
self.ax_bft.relim()
self.ax_bft.autoscale()
self.ax_bftft.relim()
self.ax_bftft.autoscale()
self.ax_rdf.relim()
self.ax_rdf.autoscale()
self.canv.draw()
def RDFinished(self, lsq_result):
print("RDF finnished")
optim = exafsrdf_difeval(lsq_result.x, self.common_k, self.common_bft,
self.amptimespha, self.dr, self.kpow)
self.edtFuncEval.setText("{:d}".format(lsq_result.nfev))
self.edtOptimality.setText("{:e}".format(optim))
self.edtFitMessage.setText("{:d}".format(lsq_result.nit))
self.window = Window_Gauss10(self.common_k, self.kstart, self.kend)
self.bftw = self.common_bft * self.window
self.r, self.fr, self.fi = FT(self.common_k, self.bftw, 0, 4, 0.02)
self.efr = np.sqrt(self.fr * self.fr + self.fi * self.fi)
self.efi = self.fi * (-1)
self.fit_result = exafsrdf(lsq_result.x, self.common_k,
self.common_bft, self.amptimespha, self.dr,
self.kpow) + self.common_bft
fit_result_w = self.fit_result * self.window
res_r, res_fr, res_fi = FT(self.common_k, fit_result_w, 0, 4, 0.02)
res_efr = np.sqrt(res_fr * res_fr + res_fi * res_fi)
res_efi = res_fi * (-1)
self.rdf_exafs = self.fit_result
self.rdf_exafs_k = self.common_k
self.line1_bft.set_xdata(self.k)
self.line1_bft.set_ydata(self.bft)
self.line2_bft.set_xdata(self.common_k)
self.line2_bft.set_ydata(self.fit_result)
self.line1_bftft.set_xdata(self.r)
self.line1_bftft.set_ydata(self.efr)
self.line2_bftft.set_xdata(self.r)
self.line2_bftft.set_ydata(self.efi)
self.line3_bftft.set_xdata(res_r)
self.line3_bftft.set_ydata(res_efr)
self.line4_bftft.set_xdata(res_r)
self.line4_bftft.set_ydata(res_efi)
self.line1_rdf.set_xdata(self.rdf_r)
self.line1_rdf.set_ydata(lsq_result.x)
self.line2_rdf.set_xdata(self.rdf_r)
self.line2_rdf.set_ydata(self.rdf)
self.ax_bft.relim()
self.ax_bft.autoscale()
self.ax_bftft.relim()
self.ax_bftft.autoscale()
self.ax_rdf.relim()
self.ax_rdf.autoscale()
self.canv.draw()
self.rdf = lsq_result.x
self.chkFirstFit.setChecked(False)
def saveRDF(self):
fn = self.savefiledialog_qtgui()
if fn == "":
return
column_captions = "#r rdf k"
save_array = []
save_array.append(self.rdf_r)
save_array.append(self.rdf)
np.savetxt(fn + ".rdf",
np.transpose(save_array),
header=column_captions)
column_captions = "#k exafs_rdf"
save_array = []
save_array.append(self.common_k)
save_array.append(self.fit_result)
np.savetxt(fn + ".rdfexafs",
np.transpose(save_array),
header=column_captions)
column_captions = "#r ft_real ft_im"
save_array = []
save_array.append(self.r)
save_array.append(self.efr)
save_array.append(self.efi)
np.savetxt(fn + ".rdfft",
np.transpose(save_array),
header=column_captions)
def apply(self):
self.params = []
self.params.append(float(self.edtkmin.text()))
self.params.append(float(self.edtkmax.text()))
self.params.append(float(self.edtdk.text()))
self.params.append(float(self.edtrmin.text()))
self.params.append(float(self.edtrmax.text()))
self.params.append(float(self.edtdr.text()))
self.params.append(float(self.edtIterations.text()))
self.accept()
def cancel(self):
self.close()
def bftft(self):
self.window = Window_Gauss10(self.k, self.k[0],
self.k[len(self.k) - 1])
self.bftw = self.bft * self.window
self.r, self.fr, self.fi = FT(self.k, self.bftw, 0, 4, 0.02)
self.efr = np.sqrt(self.fr * self.fr + self.fi * self.fi)
self.efi = self.fi * (-1)
def plot(self):
self.line1_bft.set_xdata(self.k)
self.line1_bft.set_ydata(self.bft)
self.line2_bft.set_xdata(self.rdf_exafs_k)
self.line2_bft.set_ydata(self.rdf_exafs)
self.line1_bftft.set_xdata(self.r)
self.line1_bftft.set_ydata(self.efr)
self.line2_bftft.set_xdata(self.r)
self.line2_bftft.set_ydata(self.efi)
self.line1_rdf.set_xdata(self.rdf_r)
self.line1_rdf.set_ydata(self.rdf)
print(len(self.rdf_exafs_k))
print(len(self.rdf_exafs))
self.ax_bft.relim()
self.ax_bft.autoscale()
self.ax_bftft.relim()
self.ax_bftft.autoscale()
self.ax_rdf.relim()
self.ax_rdf.autoscale()
self.canv.draw()
def openamp(self):
dlg = QtGui.QFileDialog()
dlg.setFileMode(QtGui.QFileDialog.ExistingFiles)
dlg.setAcceptMode(0) # open dialog
dlg.setNameFilters(["All files (*.*)", "Amplitude files (*.amp)"])
dlg.setDirectory(os.getcwd())
if dlg.exec_():
self.fnamp = dlg.selectedFiles()
else:
return
self.fnamp.sort()
self.Amp.clear()
self.Amp.addItems(self.fnamp)
def openpha(self):
dlg = QtGui.QFileDialog()
dlg.setFileMode(QtGui.QFileDialog.ExistingFiles)
dlg.setAcceptMode(0) # open dialog
dlg.setNameFilters(["All files (*.*)", "Amplitude files (*.pha)"])
dlg.setDirectory(os.getcwd())
if dlg.exec_():
self.fnpha = dlg.selectedFiles()
else:
return
self.fnpha.sort()
self.Pha.clear()
self.Pha.addItems(self.fnpha)
def openfeff(self):
dlg = QtGui.QFileDialog()
dlg.setFileMode(QtGui.QFileDialog.ExistingFiles)
dlg.setAcceptMode(0) # open dialog
dlg.setNameFilters(["All files (*.*)"])
dlg.setDirectory(os.getcwd())
if dlg.exec_():
self.fnfeff = dlg.selectedFiles()
else:
return
self.fnfeff.sort()
#Extract amplitude and phase from feff files and save to disk
for i in range(len(self.fnfeff)):
state = 0
data = []
f = open(self.fnfeff[i])
for line in f:
cols = line.split()
if cols[0] == '-----------------------------------------------------------------------':
state = 1
continue
if cols[0] == 'k':
state = 2
continue
if state == 1:
r = float(cols[2])
state = 0
continue
if state == 2:
data.append(cols)
new_data_amp = []
new_data_pha = []
for j in range(len(data)):
k = float(data[j][0])
pha = float(data[j][1]) + float(data[j][3])
amp = float(data[j][2]) * np.exp(
-2 * r / float(data[j][5])) * float(data[j][4])
new_data_amp.append([k, amp])
new_data_pha.append([k, pha])
# print(new_data_amp)
# print(new_data_pha)
np.savetxt(self.fnfeff[i] + '.amp', new_data_amp)
np.savetxt(self.fnfeff[i] + '.pha', new_data_pha)
self.Amp.clear()
self.Amp.addItem(self.fnfeff[i] + '.amp')
self.Pha.clear()
self.Pha.addItem(self.fnfeff[i] + '.pha')
def addshell(self):
self.tabs.append(QtGui.QFrame())
caption = "Shell" + str(self.shellnr + 1)
self.tabShells.addTab(self.tabs[self.shellnr], caption)
lblN = QtGui.QLabel("N")
lblR = QtGui.QLabel("R")
lblSigma = QtGui.QLabel("Sigma")
lblC3 = QtGui.QLabel("C3")
lblC4 = QtGui.QLabel("C4")
lblC5 = QtGui.QLabel("C5")
lblC6 = QtGui.QLabel("C6")
lblE0 = QtGui.QLabel("E0")
lblAmp = QtGui.QLabel("Amplitude")
lblPha = QtGui.QLabel("Phase")
self.ltShell.append(QtGui.QGridLayout())
self.shellN.append([
QtGui.QLineEdit("4"),
QtGui.QLineEdit("0"),
QtGui.QLineEdit("8"),
QtGui.QLineEdit("0.00001"),
QtGui.QCheckBox()
])
self.shellR.append([
QtGui.QLineEdit("2"),
QtGui.QLineEdit("0"),
QtGui.QLineEdit("4"),
QtGui.QLineEdit("0.0000001"),
QtGui.QCheckBox()
])
self.shellSigma.append([
QtGui.QLineEdit("0"),
QtGui.QLineEdit("0"),
QtGui.QLineEdit("1"),
QtGui.QLineEdit("0.00000001"),
QtGui.QCheckBox()
])
self.shellC3.append([
QtGui.QLineEdit("0"),
QtGui.QLineEdit("0"),
QtGui.QLineEdit("0.0001"),
QtGui.QLineEdit("0.0001"),
QtGui.QCheckBox()
])
self.shellC4.append([
QtGui.QLineEdit("0"),
QtGui.QLineEdit("0"),
QtGui.QLineEdit("0.0001"),
QtGui.QLineEdit("0.0001"),
QtGui.QCheckBox()
])
self.shellC5.append([
QtGui.QLineEdit("0"),
QtGui.QLineEdit("0"),
QtGui.QLineEdit("0.0001"),
QtGui.QLineEdit("0.0001"),
QtGui.QCheckBox()
])
self.shellC6.append([
QtGui.QLineEdit("0"),
QtGui.QLineEdit("0"),
QtGui.QLineEdit("0.0001"),
QtGui.QLineEdit("0.0001"),
QtGui.QCheckBox()
])
self.shellE0.append([
QtGui.QLineEdit("0"),
QtGui.QLineEdit("0"),
QtGui.QLineEdit("0"),
QtGui.QLineEdit("0.0001"),
QtGui.QCheckBox()
])
self.shellAmp.append(QtGui.QComboBox())
self.shellPha.append(QtGui.QComboBox())
self.shellAmp[len(self.shellAmp) -
1].addItem("E:/work/development/xaslib/fit/amp0001.dat")
self.shellPha[len(self.shellPha) -
1].addItem("E:/work/development/xaslib/fit/pha0001.dat")
self.ltShell[self.shellnr].addWidget(lblN, 0, 0)
self.ltShell[self.shellnr].addWidget(lblR, 1, 0)
self.ltShell[self.shellnr].addWidget(lblSigma, 2, 0)
self.ltShell[self.shellnr].addWidget(lblC3, 3, 0)
self.ltShell[self.shellnr].addWidget(lblC4, 4, 0)
self.ltShell[self.shellnr].addWidget(lblC5, 5, 0)
self.ltShell[self.shellnr].addWidget(lblC6, 6, 0)
self.ltShell[self.shellnr].addWidget(lblE0, 7, 0)
self.ltShell[self.shellnr].addWidget(lblAmp, 8, 0)
self.ltShell[self.shellnr].addWidget(lblPha, 9, 0)
for i in range(5):
self.ltShell[self.shellnr].addWidget(self.shellN[self.shellnr][i],
0, 2 * i + 1)
self.ltShell[self.shellnr].addWidget(self.shellR[self.shellnr][i],
1, 2 * i + 1)
self.ltShell[self.shellnr].addWidget(
self.shellSigma[self.shellnr][i], 2, 2 * i + 1)
self.ltShell[self.shellnr].addWidget(self.shellC3[self.shellnr][i],
3, 2 * i + 1)
self.ltShell[self.shellnr].addWidget(self.shellC4[self.shellnr][i],
4, 2 * i + 1)
self.ltShell[self.shellnr].addWidget(self.shellC5[self.shellnr][i],
5, 2 * i + 1)
self.ltShell[self.shellnr].addWidget(self.shellC6[self.shellnr][i],
6, 2 * i + 1)
self.ltShell[self.shellnr].addWidget(self.shellE0[self.shellnr][i],
7, 2 * i + 1)
self.ltShell[self.shellnr].addWidget(self.shellAmp[self.shellnr], 8, 1,
1, 8)
self.ltShell[self.shellnr].addWidget(self.shellPha[self.shellnr], 9, 1,
1, 8)
for j in range(7):
self.ltShell[self.shellnr].addWidget(QtGui.QLabel("Min. limit"), j,
2)
self.ltShell[self.shellnr].addWidget(QtGui.QLabel("Max. limit"), j,
4)
self.ltShell[self.shellnr].addWidget(QtGui.QLabel("Accuracy"), j,
6)
self.tabs[self.shellnr].setLayout(self.ltShell[self.shellnr])
self.shellnr = self.shellnr + 1
def resetFit(self):
self.chkFirstFit.setChecked(True)
def savefiledialog_qtgui(self):
dlg = QtGui.QFileDialog()
dlg.setFileMode(QtGui.QFileDialog.AnyFile)
dlg.setAcceptMode(1) # save dialog
dlg.setNameFilters(["All files (*.*)"])
# dlg.setDirectory(self.currentdir)
if dlg.exec_():
flist = dlg.selectedFiles()
return flist[0]
else:
return ""
def initUI(self):
self.fig = plt.figure(5, figsize=(18, 6))
self.ax_bft = plt.subplot2grid((1, 3), (0, 0))
self.ax_bftft = plt.subplot2grid((1, 3), (0, 1))
self.ax_rdf = plt.subplot2grid((1, 3), (0, 2))
self.ax_bft.set_xlabel('Wavevector k, $\AA^{-1}$')
self.ax_bft.set_ylabel('EXAFS, $\AA^{-2}$')
self.ax_bftft.set_xlabel('Distance R, $\AA$')
self.ax_bftft.set_ylabel('Fourier transform, $\AA^{-3}$')
self.ax_rdf.set_xlabel('Distance R, $\AA$')
self.ax_rdf.set_ylabel('RDF G(R)')
self.line1_bft, = self.ax_bft.plot([], [], label='BFT')
self.line2_bft, = self.ax_bft.plot([], [], label='fit')
self.line1_bft.set_color('b')
self.line2_bft.set_color('g')
self.ax_bft.legend(handles=[self.line1_bft, self.line2_bft])
self.line1_bftft, self.line2_bftft = self.ax_bftft.plot([], [], [], [])
self.line1_bftft.set_color('b')
self.line2_bftft.set_color('b')
self.line2_bftft.set_linestyle('dotted')
self.line3_bftft, self.line4_bftft = self.ax_bftft.plot([], [], [], [])
self.line3_bftft.set_color('g')
self.line4_bftft.set_color('g')
self.line4_bftft.set_linestyle('dotted')
self.line1_rdf, = self.ax_rdf.plot([], [], marker='o')
self.line2_rdf, = self.ax_rdf.plot([], [])
self.fig.tight_layout()
self.canv = FigureCanvas(self.fig)
self.tbar = NavigationToolbar(self.canv, self)
self.rdf_r = np.arange(0.8, 2.5, 0.01)
self.rdf = np.zeros(len(self.rdf_r))
# self.lblNrShells = QtGui.QLabel("Number of shells")
# self.edtNrShells = QtGui.QLineEdit("1")
self.lblkmin = QtGui.QLabel("K min")
self.lblkmax = QtGui.QLabel("K max")
self.lbldk = QtGui.QLabel("dK")
self.lblrmin = QtGui.QLabel("Rmin")
self.lblrmax = QtGui.QLabel("Rmax")
self.lbldr = QtGui.QLabel("dR")
self.edtkmin = QtGui.QLineEdit("0.5")
self.edtkmax = QtGui.QLineEdit("15")
self.edtdk = QtGui.QLineEdit("0.05")
self.edtrmin = QtGui.QLineEdit("0.5")
self.edtrmax = QtGui.QLineEdit("2.8")
self.edtdr = QtGui.QLineEdit("0.01")
self.edtrmin.editingFinished.connect(self.resetFit)
self.edtrmax.editingFinished.connect(self.resetFit)
self.edtdr.editingFinished.connect(self.resetFit)
# self.lblCentralDist = QtGui.QLabel("Central distance")
# self.edtCentralDist = QtGui.QLineEdit("1.8")
# self.lblWidth = QtGui.QLabel("Width")
# self.edtWidth = QtGui.QLineEdit("0.001")
# self.lblAmplitude = QtGui.QLabel("Amplitude")
# self.edtAmplitude = QtGui.QLineEdit("50")
self.lblIterations = QtGui.QLabel("Max. number of iterations")
self.edtIterations = QtGui.QLineEdit("20")
self.chkFirstFit = QtGui.QCheckBox(
"Start new fit (checked) / continue fit (unchecked)")
self.chkFirstFit.setChecked(True)
self.Amp = QtGui.QComboBox()
self.Pha = QtGui.QComboBox()
lblAmp = QtGui.QLabel("Amplitude")
lblPha = QtGui.QLabel("Phase")
self.Amp.addItem("")
self.Amp.addItem("E:/work/development/xaslib/fit/amp0001.dat")
self.Pha.addItem("")
self.Pha.addItem("E:/work/development/xaslib/fit/pha0001.dat")
self.lblFuncEval = QtGui.QLabel("Number of function evaluations done")
self.edtFuncEval = QtGui.QLineEdit()
self.lblFitMessage = QtGui.QLabel("Iterations done")
self.edtFitMessage = QtGui.QLineEdit()
self.lblOptimality = QtGui.QLabel("Residual")
self.edtOptimality = QtGui.QLineEdit()
lfit = QtGui.QGridLayout()
lfit.addWidget(self.lblFitMessage, 0, 0)
lfit.addWidget(self.edtFitMessage, 0, 1)
lfit.addWidget(self.lblFuncEval, 1, 0)
lfit.addWidget(self.edtFuncEval, 1, 1)
lfit.addWidget(self.lblOptimality, 2, 0)
lfit.addWidget(self.edtOptimality, 2, 1)
self.btnFit = QtGui.QPushButton('Fit')
self.btnFit.clicked.connect(self.Fit_rdf)
self.btnSaveRdf = QtGui.QPushButton('Save RDF')
self.btnSaveRdf.clicked.connect(self.saveRDF)
self.btnApply = QtGui.QPushButton('Apply')
self.btnApply.clicked.connect(self.apply)
self.btnCancel = QtGui.QPushButton('Cancel')
self.btnCancel.clicked.connect(self.cancel)
self.btnOpenAmp = QtGui.QPushButton('Open amplitude file(s) ...')
self.btnOpenAmp.clicked.connect(self.openamp)
self.btnOpenPha = QtGui.QPushButton('Open phase file(s) ...')
self.btnOpenPha.clicked.connect(self.openpha)
self.btnOpenFeff = QtGui.QPushButton('Open feff file(s) ...')
self.btnOpenFeff.clicked.connect(self.openfeff)
# self.textEdit = QtGui.QTextEdit(self)
# lb.addWidget(self.textEdit, 1, 0)
lfig = QtGui.QGridLayout()
lfig.addWidget(self.tbar, 0, 0, 1, 2)
lfig.addWidget(self.canv, 1, 0, 1, 2)
lfig.addLayout(lfit, 2, 0)
lfig.addWidget(self.btnFit, 3, 0)
lfig.addWidget(self.btnSaveRdf, 4, 0)
lfig.addWidget(self.btnApply, 5, 0)
lfig.addWidget(self.btnCancel, 6, 0)
lp = QtGui.QGridLayout()
lp.addWidget(self.lblkmin, 0, 0)
lp.addWidget(self.edtkmin, 0, 1)
lp.addWidget(self.lblkmax, 0, 2)
lp.addWidget(self.edtkmax, 0, 3)
lp.addWidget(self.lbldk, 0, 4)
lp.addWidget(self.edtdk, 0, 5)
lp.addWidget(self.lblrmin, 1, 0)
lp.addWidget(self.edtrmin, 1, 1)
lp.addWidget(self.lblrmax, 1, 2)
lp.addWidget(self.edtrmax, 1, 3)
lp.addWidget(self.lbldr, 1, 4)
lp.addWidget(self.edtdr, 1, 5)
# lfig.addWidget(self.lblAmplitude, 2,1)
# lfig.addWidget(self.edtAmplitude, 2,2)
# lfig.addWidget(self.lblCentralDist, 2,3)
# lfig.addWidget(self.edtCentralDist, 2,4)
# lfig.addWidget(self.lblWidth, 2,5)
# lfig.addWidget(self.edtWidth, 2,6)
lp.addWidget(self.lblIterations, 2, 0, 1, 3)
lp.addWidget(self.edtIterations, 2, 3, 1, 3)
lp.addWidget(self.chkFirstFit, 3, 0, 1, 6)
lp.addWidget(lblAmp, 4, 0)
lp.addWidget(self.Amp, 4, 1, 1, 4)
lp.addWidget(lblPha, 5, 0)
lp.addWidget(self.Pha, 5, 1, 1, 4)
lp.addWidget(self.btnOpenAmp, 4, 5)
lp.addWidget(self.btnOpenPha, 5, 5)
lp.addWidget(self.btnOpenFeff, 6, 0)
lfig.addLayout(lp, 2, 1, 5, 1)
self.setLayout(lfig)
self.canv.draw()
class MyTableWidget(QWidget):
def __init__(self, parent):
super(QWidget, self).__init__(parent)
self.layout = QVBoxLayout(self)
# The dataframe
self.df = pd.DataFrame()
self.gs = pd.DataFrame()
self.gs1 = pd.DataFrame()
self.gs2 = pd.DataFrame()
# Initialize the labels for the first tab
self.productLabel = QLabel("Product", self)
self.countryLabel = QLabel("Country", self)
self.stateLabel = QLabel("State", self)
self.cityLabel = QLabel("City", self)
# Initialise the textbox for all the labels along with the tooltips
self.productTextBox = QLineEdit(self)
self.productTextBox.setToolTip("Enter the product here")
self.countryTextBox = QComboBox(self)
self.countryTextBox.setToolTip("Enter the country here")
self.stateTextBox = QComboBox(self)
self.stateTextBox.setToolTip("Enter the state here")
self.cityTextBox = QComboBox(self)
self.cityTextBox.setToolTip("Enter the city here")
# Canvas and Toolbar
# a figure instance to plot on
self.figure = Figure()
self.figure3 = Figure()
self.figure4 = Figure()
# this is the Canvas Widget that displays the `figure`
# it takes the `figure` instance as a parameter to __init__
self.canvas = FigureCanvas(self.figure)
self.canvas3 = FigureCanvas(self.figure3)
self.canvas4 = FigureCanvas(self.figure4)
self.submitButton = QPushButton("Submit")
self.submitButton.setToolTip("To submit and get results")
self.submitButton.resize(self.submitButton.sizeHint())
self.submitButton.clicked.connect(self.on_click)
self.show()
#print(self.on_click)
# Buttons to be added to the first tab
self.clearAllButton = QPushButton("Clear All")
self.clearAllButton.resize(self.clearAllButton.sizeHint())
self.clearAllButton.setToolTip("To clear all the fields")
self.clearAllButton.clicked.connect(self.clear_on_click)
# Initialize tab screen
self.tabs = QTabWidget()
self.tab1 = QWidget()
self.tab2 = QWidget()
self.tab3 = QWidget()
self.tab4 = QWidget()
self.tabs.resize(480, 320)
# Add tabs
self.tabs.addTab(self.tab1, "The Input Tab")
self.tabs.addTab(self.tab2, "The Graphs")
self.tabs.addTab(self.tab3, "The Data")
self.tabs.addTab(self.tab4, "The Recommendation")
# Create first tab
self.tab1.layout = QVBoxLayout(self)
self.tab1.layout.addWidget(self.productLabel)
self.tab1.layout.addWidget(self.productTextBox)
self.tab1.layout.addWidget(self.submitButton)
self.tab1.layout.addWidget(self.clearAllButton)
self.tab1.layout.addWidget(self.countryLabel)
self.tab1.layout.addWidget(self.countryTextBox)
self.tab1.layout.addWidget(self.stateLabel)
self.tab1.layout.addWidget(self.stateTextBox)
self.tab1.layout.addWidget(self.cityLabel)
self.tab1.layout.addWidget(self.cityTextBox)
self.tab1.setLayout(self.tab1.layout)
# Add tabs to widget
self.layout.addWidget(self.tabs)
self.setLayout(self.layout)
# Canvas and Toolbar
# a figure instance to plot on
self.figure = Figure()
# this is the Canvas Widget that displays the `figure`
# it takes the `figure` instance as a parameter to __init__
self.canvas = FigureCanvas(self.figure)
# this is the Navigation widget
# it takes the Canvas widget and a parent
self.toolbar = NavigationToolbar(self.canvas, self)
# set the layout
tab2layout = QVBoxLayout()
tab2layout.addWidget(self.toolbar)
tab2layout.addWidget(self.canvas)
self.tab2.setLayout(tab2layout)
# Tab 3 The Data
self.tab3Table = QFormLayout()
self.tableWidget = QTableWidget()
self.tab3Table.addWidget(self.tableWidget)
self.tab3.setLayout(self.tab3Table)
self.tab3Table.addRow(self.tableWidget)
# Buttons to be added to the first tab
self.exportCSVButton = QPushButton("Export Data to CSV")
self.exportCSVButton.resize(self.clearAllButton.sizeHint())
self.exportCSVButton.setToolTip("To export the above data to a CSV")
self.exportCSVButton.clicked.connect(self.export_csv_connect)
self.tab3Table.addRow(self.exportCSVButton)
self.tab3.setLayout(self.tab3Table)
#self.tab3.layout.addWidget(self.exportCSVButton)
# Tab 4 The Recommendation
self.tab4Form = QFormLayout()
self.recommendationText = QTextEdit()
self.recommendationText.setMinimumSize(480, 320)
self.recommendationText.setToolTip(
"This tab shows the recommendation ")
self.tab4Form.addRow(self.recommendationText)
self.tab4.setLayout(self.tab4Form)
# call the function to get the recommendation and then load it into the textbox
def onActivated(self, text):
print(text + ' Is selected')
#print(ScorceCode.forCountry(text,self.productName))
CountrySelected = text
print('breakpoint')
ls1 = ScorceCode.forCountry(CountrySelected, self.productName)
#ls1.to_csv('C:/Users/lakshay/Desktop/udemy/PRI_Exported_CSV_files/finlistState.csv')
#print(ls1)
finlistState = ls1.index.tolist()
self.gs1 = ls1
#print(finlistState)
#self.textEdit3.setText(ls1.to_string())
tableFor = "country"
self.createTable(tableFor)
print('breakpoint 1')
self.stateTextBox.clear()
self.cityTextBox.clear()
self.stateTextBox.addItems(finlistState)
print(self.stateTextBox.activated[str].connect(self.onActivated1))
self.plot(ls1)
# have to pass the state value to this method !!!!!!!!!!!!!!!!!!
def onActivated1(self, StateSelected):
try:
self.cityTextBox.clear()
print("state selected is ")
print(StateSelected)
print('value in state box :')
print(self.stateTextBox.currentText())
print(self.countryTextBox.currentText())
StateSelected = self.stateTextBox.currentText()
CountrySelected = self.countryTextBox.currentText()
ls2 = ScorceCode.forState(CountrySelected, StateSelected,
self.productName)
#ls2.to_csv('C:/Users/lakshay/Desktop/udemy/PRI_Exported_CSV_files/finlistCity.csv')
self.gs2 = ls2
finlistCity = ls2.index.tolist()
#self.textEdit3.setText(ls2.to_string())
tableFor = "state"
self.createTable(tableFor)
print('list of city')
#print(finlistCity)
self.cityTextBox.clear()
self.cityTextBox.addItems(finlistCity)
self.cityTextBox.activated[str].connect(self.onActivated2)
self.plot(ls2)
except:
print(
'An error occured while retrieving the cities of the states.')
# have to pass the state value and city to this method !!!!!!!!!!
def onActivated2(self, CitySelected):
try:
StateSelected = self.stateTextBox.currentText()
CountrySelected = self.countryTextBox.currentText()
print('final country selected')
print(CountrySelected)
print('final state selected')
print(StateSelected)
print("final city selected is ")
print(CitySelected)
print('Number of total internet users in ' + CitySelected + ' is:')
print(ScorceCode.forTotalUsers(CountrySelected, CitySelected))
ls2 = ScorceCode.forState(CountrySelected, StateSelected,
self.productName)
UserPercentage = int(ls2.loc[CitySelected, :])
print(UserPercentage)
totalUsers = ScorceCode.forTotalUsers(CountrySelected,
CitySelected)
print(totalUsers)
finalUsers = int((totalUsers * UserPercentage) / 100)
totalPopulation = ScorceCode.forTotalPop(CitySelected)
totalPenitration = ScorceCode.forTotalPenitration(CountrySelected)
ratio = int((finalUsers / totalPopulation) * 100)
self.recommendationText.setText(
"There are total of " + str(finalUsers) +
" people searching for the keyword out of " +
str(totalPopulation) + " people in the city of " +
CitySelected + " which gives us the ratio of " + str(ratio) +
"% of users searching for this keyword and the percentage of internet penetration is "
+ str(totalPenitration) + "%")
print('end')
except:
print(
'An error occured while retrieving the population data of the city: '
+ CitySelected)
self.recommendationText.setText(
'No recommendation found due to lack of precise data for city: '
+ CitySelected)
def createTable(self, tableFor):
# Create table
# print("Table data " + self.tableDf)PROGRAM RUNNING?????????
# find the table length
if (tableFor == "world"):
self.lsTest = self.gs
if (tableFor == "country"):
self.lsTest = self.gs1
if (tableFor == "state"):
self.lsTest = self.gs2
# print(self.lsTest)
rows = self.lsTest.count()
columns = 2
# rows=10
#print(rows)
#print(columns)
# set the rows and columns of the table
self.tableWidget.setRowCount(rows)
self.tableWidget.setColumnCount(columns)
i = 0
for index, value in self.lsTest.iterrows():
#print(value[0])
if i < int(rows):
self.tableWidget.setItem(i, 0, QTableWidgetItem(index))
self.tableWidget.setItem(i, 1, QTableWidgetItem(str(value[0])))
i = i + 1
## self.tableWidget.setItem(index, 2, QTableWidgetItem(row['']))
# for x in rows:
# for y in columns:
# if(y==0)
# self.tableWidget.setItem(x, y, QTableWidgetItem(self.tableDf[x][y]))
# self.tableWidget.setItem(0, 1, QTableWidgetItem("Cell (1,2)"))
def show_model(self):
font = QtGui.QFont()
font.setFamily('Lucida')
font.setFixedPitch(True)
font.setPointSize(10)
self.textEdit3.setCurrentFont(font)
# selmodel = self.creSelectModel[str(self.comboBox.currentText())]
self.textEdit3.setText("1234566465464")
def export_csv_connect(self):
print('Export data to CSV operation: ')
self.gs.to_csv(
'C:/Users/lakshay/Desktop/udemy/PRI_Exported_CSV_files/finlistWorld.csv'
)
self.gs1.to_csv(
'C:/Users/lakshay/Desktop/udemy/PRI_Exported_CSV_files/finlistState.csv'
)
self.gs2.to_csv(
'C:/Users/lakshay/Desktop/udemy/PRI_Exported_CSV_files/finlistCity.csv'
)
QMessageBox.about(self, "Export to CSV", "Files Exported Successfully")
def on_click(self):
print("\n")
self.stateTextBox.clear()
self.cityTextBox.clear()
print(self.productTextBox.text())
self.productName = self.productTextBox.text()
self.countryTextBox.activated[str].connect(self.onActivated)
ls = ScorceCode.forWorld(self.productName)
#print(ls)
#ls.to_csv('C:/Users/lakshay/Desktop/udemy/PRI_Exported_CSV_files/finlistWorld.csv')
self.gs = ls
finlist = ls.index.tolist()
#print(finlist)
print('someht')
self.countryTextBox.clear()
self.countryTextBox.addItems(finlist)
self.countryTextBox.activated[str].connect(self.onActivated)
#makeitastring = ''.join(map(str, finlist))
#print('the string is')
#print(makeitastring)
tableFor = "world"
#self.textEdit3.setText(ls.to_string())
self.createTable(tableFor)
self.plot(ls)
def clear_on_click(self):
self.countryTextBox.clear()
self.stateTextBox.clear()
self.cityTextBox.clear()
self.productTextBox.clear()
print('all clear')
def plot(self, data):
# hit only if we have values on all the four components
if (self.productTextBox.text()):
print("Inside the plot method")
# Call the api #TODO
#statisticsPerCountry = SourceCode.forCountry(self.selectedCountry,self.productTextBox.text())
#statisticsPerState
#statisticsPerUsers
print('plotBreak')
# create an axis
ax = self.figure.add_subplot(111)
# discards the old graph
ax.clear()
# plot data
ax.plot(data, '*-')
# refresh canvas
self.canvas.draw()
else:
QMessageBox.about(self, "Inputs", "Please check your inputs")
def __init__(self, parent):
super(QWidget, self).__init__(parent)
self.layout = QVBoxLayout(self)
# The dataframe
self.df = pd.DataFrame()
self.gs = pd.DataFrame()
self.gs1 = pd.DataFrame()
self.gs2 = pd.DataFrame()
# Initialize the labels for the first tab
self.productLabel = QLabel("Product", self)
self.countryLabel = QLabel("Country", self)
self.stateLabel = QLabel("State", self)
self.cityLabel = QLabel("City", self)
# Initialise the textbox for all the labels along with the tooltips
self.productTextBox = QLineEdit(self)
self.productTextBox.setToolTip("Enter the product here")
self.countryTextBox = QComboBox(self)
self.countryTextBox.setToolTip("Enter the country here")
self.stateTextBox = QComboBox(self)
self.stateTextBox.setToolTip("Enter the state here")
self.cityTextBox = QComboBox(self)
self.cityTextBox.setToolTip("Enter the city here")
# Canvas and Toolbar
# a figure instance to plot on
self.figure = Figure()
self.figure3 = Figure()
self.figure4 = Figure()
# this is the Canvas Widget that displays the `figure`
# it takes the `figure` instance as a parameter to __init__
self.canvas = FigureCanvas(self.figure)
self.canvas3 = FigureCanvas(self.figure3)
self.canvas4 = FigureCanvas(self.figure4)
self.submitButton = QPushButton("Submit")
self.submitButton.setToolTip("To submit and get results")
self.submitButton.resize(self.submitButton.sizeHint())
self.submitButton.clicked.connect(self.on_click)
self.show()
#print(self.on_click)
# Buttons to be added to the first tab
self.clearAllButton = QPushButton("Clear All")
self.clearAllButton.resize(self.clearAllButton.sizeHint())
self.clearAllButton.setToolTip("To clear all the fields")
self.clearAllButton.clicked.connect(self.clear_on_click)
# Initialize tab screen
self.tabs = QTabWidget()
self.tab1 = QWidget()
self.tab2 = QWidget()
self.tab3 = QWidget()
self.tab4 = QWidget()
self.tabs.resize(480, 320)
# Add tabs
self.tabs.addTab(self.tab1, "The Input Tab")
self.tabs.addTab(self.tab2, "The Graphs")
self.tabs.addTab(self.tab3, "The Data")
self.tabs.addTab(self.tab4, "The Recommendation")
# Create first tab
self.tab1.layout = QVBoxLayout(self)
self.tab1.layout.addWidget(self.productLabel)
self.tab1.layout.addWidget(self.productTextBox)
self.tab1.layout.addWidget(self.submitButton)
self.tab1.layout.addWidget(self.clearAllButton)
self.tab1.layout.addWidget(self.countryLabel)
self.tab1.layout.addWidget(self.countryTextBox)
self.tab1.layout.addWidget(self.stateLabel)
self.tab1.layout.addWidget(self.stateTextBox)
self.tab1.layout.addWidget(self.cityLabel)
self.tab1.layout.addWidget(self.cityTextBox)
self.tab1.setLayout(self.tab1.layout)
# Add tabs to widget
self.layout.addWidget(self.tabs)
self.setLayout(self.layout)
# Canvas and Toolbar
# a figure instance to plot on
self.figure = Figure()
# this is the Canvas Widget that displays the `figure`
# it takes the `figure` instance as a parameter to __init__
self.canvas = FigureCanvas(self.figure)
# this is the Navigation widget
# it takes the Canvas widget and a parent
self.toolbar = NavigationToolbar(self.canvas, self)
# set the layout
tab2layout = QVBoxLayout()
tab2layout.addWidget(self.toolbar)
tab2layout.addWidget(self.canvas)
self.tab2.setLayout(tab2layout)
# Tab 3 The Data
self.tab3Table = QFormLayout()
self.tableWidget = QTableWidget()
self.tab3Table.addWidget(self.tableWidget)
self.tab3.setLayout(self.tab3Table)
self.tab3Table.addRow(self.tableWidget)
# Buttons to be added to the first tab
self.exportCSVButton = QPushButton("Export Data to CSV")
self.exportCSVButton.resize(self.clearAllButton.sizeHint())
self.exportCSVButton.setToolTip("To export the above data to a CSV")
self.exportCSVButton.clicked.connect(self.export_csv_connect)
self.tab3Table.addRow(self.exportCSVButton)
self.tab3.setLayout(self.tab3Table)
#self.tab3.layout.addWidget(self.exportCSVButton)
# Tab 4 The Recommendation
self.tab4Form = QFormLayout()
self.recommendationText = QTextEdit()
self.recommendationText.setMinimumSize(480, 320)
self.recommendationText.setToolTip(
"This tab shows the recommendation ")
self.tab4Form.addRow(self.recommendationText)
self.tab4.setLayout(self.tab4Form)
class AppForm(QtGui.QMainWindow):
def __init__(self,
parent=None,
specterCenter=0,
columnNumber=0,
windowLength=0):
QtGui.QMainWindow.__init__(self, parent)
#self.x, self.y = self.get_data()
self.create_main_frame()
self.specter = []
self.currentSpecter = 0
self.abelData = []
self.specterCenter = specterCenter
self.columnNumber = columnNumber
self.windowLength = windowLength
exitAction = QtGui.QAction(QtGui.QIcon('icons/svg/power.svg'), '&Exit',
self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(QtGui.qApp.quit)
openAction = QtGui.QAction(QtGui.QIcon('icons/svg/folder-open.svg'),
'&Open', self)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open file sequence')
openAction.triggered.connect(self.loadSpecterFromFiles)
#plotAction = QtGui.QAction(QtGui.QIcon('icons/svg/chart-line-outline.svg'), '&Plot', self)
#plotAction.setShortcut('Ctrl+P')
#plotAction.setStatusTip('Plot')
#plotAction.triggered.connect(self.on_draw)
nextSpecterAction = QtGui.QAction(
QtGui.QIcon('icons/svg/chevron-right-outline.svg'),
'&Next specter', self)
nextSpecterAction.setStatusTip('Next specter')
nextSpecterAction.triggered.connect(self.nextSpecter)
self.currentSpecterInput = QtGui.QLabel()
#self.currentSpecterInput.setMaxLength(150)
#self.currentSpecterInput.setValidator(QtGui.QIntValidator())
self.currentSpecterInput.setFixedWidth(500)
self.totalSpecterLabel = QtGui.QLabel()
self.totalSpecterLabel.setFixedWidth(40)
prevSpecterAction = QtGui.QAction(
QtGui.QIcon('icons/svg/chevron-left-outline.svg'), '&Next specter',
self)
prevSpecterAction.setStatusTip('Prev specter')
prevSpecterAction.triggered.connect(self.prevSpecter)
self.statusBar().showMessage('Ready')
self.setWindowTitle('Abel transform and temperature calculation')
menubar = self.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(openAction)
#fileMenu.addAction(plotAction)
fileMenu.addAction(exitAction)
self.toolbar = self.addToolBar('Main')
self.toolbar.addAction(openAction)
self.toolbar.addAction(prevSpecterAction)
self.toolbar.addAction(nextSpecterAction)
self.toolbar.addWidget(self.currentSpecterInput)
self.toolbar.addWidget(self.totalSpecterLabel)
#self.toolbar.addAction(plotAction)
#self.toolbar.addAction(exitAction)
def create_main_frame(self):
self.main_frame = QtGui.QWidget()
self.fig = Figure((10.0, 8.0), dpi=72)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
#self.canvas.setFocusPolicy(Qt.StrongFocus)
self.canvas.setFocus()
self.mpl_toolbar = NavigationToolbar(self.canvas, self.main_frame)
self.canvas.mpl_connect('key_press_event', self.on_key_press)
self.canvas.mpl_connect('motion_notify_event', self.mouse_moved)
self.table = QtGui.QTableWidget()
self.table.setColumnCount(6)
self.table.setHorizontalHeaderLabels(
['L1', "L2", "LNIST", "Aki", "Ek", "g"])
header = self.table.horizontalHeader()
header.setResizeMode(QtGui.QHeaderView.Stretch)
self.table.itemChanged.connect(self.setLine)
self.buttonAddLine = QtGui.QPushButton("Add a line")
self.buttonAddLine.clicked.connect(self.addLine)
self.buttonComputeTemp = QtGui.QPushButton("Compute temperature")
self.buttonComputeTemp.clicked.connect(self.computeTemp)
self.lines = []
vbox = QtGui.QGridLayout()
vbox.addWidget(self.table, 0, 0, 1, 1)
vbox.addWidget(self.buttonAddLine, 1, 0, 1, 1)
vbox.addWidget(self.buttonComputeTemp, 2, 0, 1, 1)
vbox.addWidget(self.canvas, 0, 1, 1, 4) # the matplotlib canvas
vbox.addWidget(self.mpl_toolbar, 1, 1, 1, 4)
vbox.setColumnStretch(1, 5)
self.main_frame.setLayout(vbox)
self.setCentralWidget(self.main_frame)
def on_draw(self):
self.fig.clear()
gs = gridspec.GridSpec(2,
2,
width_ratios=[5, 1],
height_ratios=[4, 1],
wspace=0.12,
hspace=0.12,
left=0.05,
bottom=0.05,
right=0.95,
top=0.95)
self.axes1 = self.fig.add_subplot(gs[0])
self.axes2 = self.fig.add_subplot(gs[1])
self.axes3 = self.fig.add_subplot(gs[2])
self.drawSpecter()
self.drawPlots()
def drawSpecter(self):
abelData = self.abelData[self.currentSpecter]
self.axes1.imshow(np.transpose(abelData),
interpolation='nearest',
aspect='auto')
self.axes11 = self.axes1.twiny()
self.axes11.set_xticklabels(
self.specter[self.currentSpecter].wavelength)
majorLocator = FixedLocator(5)
#majorFormatter = FormatStrFormatter('%d')
minorLocator = MultipleLocator(5)
#self.axes11.get_xaxis().set_major_locator(majorLocator)
#self.axes11.get_xaxis().set_major_formatter(majorFormatter)
self.canvas.draw()
def drawPlots(self, x=0, y=0):
abelData = self.abelData[self.currentSpecter]
vertPixels = len(abelData[x])
self.axes2.cla()
self.axes2.set_ylim([vertPixels, 0])
self.axes2.grid()
self.axes2.plot(abelData[x], np.arange(0, vertPixels, 1))
transp = np.transpose(abelData)[y]
self.axes3.cla()
self.axes3.set_xlim([0, len(transp)])
self.axes3.grid()
self.axes3.plot(transp)
for line in self.lines:
self.axes3.axvline(x=int(line[0]), color='r', linestyle='-')
self.axes3.axvline(x=int(line[1]), color='r', linestyle='-')
self.canvas.draw()
def on_key_press(self, event):
print('you pressed', event.key)
def mouse_moved(self, mouse_event):
if mouse_event.inaxes:
x, y = int(round(mouse_event.xdata)), int(round(mouse_event.ydata))
self.drawPlots(x, y)
def loadSpecterFromFiles(self):
self.dirPath = QtGui.QFileDialog.getExistingDirectory(
self.main_frame, "Open Directory", "D:")
fileList = glob.glob(self.dirPath + '\*.asc')
for fileName in fileList:
self.specter.append(
Specter(np.loadtxt(fileName), fileName, self.specterCenter,
self.windowLength))
if len(self.specter) > 0:
self.currentSpecter = 0
self.updateSpecterInput()
for specNum in range(0, len(self.specter)):
self.statusBar().showMessage('Busy...')
self.computeAbelTransform(specNum)
self.statusBar().showMessage('Ready')
self.on_draw()
def nextSpecter(self):
if self.currentSpecter < (len(self.specter) - 1):
self.currentSpecter += 1
self.updateSpecterInput()
self.on_draw()
def prevSpecter(self):
if self.currentSpecter > 1:
self.currentSpecter -= 1
self.updateSpecterInput()
self.on_draw()
def updateSpecterInput(self):
self.currentSpecterInput.setText(
str(self.currentSpecter + 1) + ' / ' + str(len(self.specter)) +
' (' + self.specter[self.currentSpecter].name + ')')
def computeAbelTransform(self, specterNum):
abelData = []
for column in self.specter[specterNum].dataCombinedHalf:
abelData.append(Abel.transform(column))
self.abelData.append(np.array(abelData))
def addLine(self):
#self.lines.append((0,0,0,0,0,0))
#test case
self.lines.append((244, 265, 250, 10, 3000, 2))
self.lines.append((305, 343, 325, 10, 2000, 2))
self.updateTable()
def setLine(self, item):
lineNum = item.row()
self.lines[lineNum] = (int(self.table.item(lineNum, 0).text()),
int(self.table.item(lineNum, 1).text()),
float(self.table.item(lineNum, 2).text()),
float(self.table.item(lineNum, 3).text()),
float(self.table.item(lineNum, 4).text()),
float(self.table.item(lineNum, 5).text()))
def computeTemp(self):
abelData = self.abelData[self.currentSpecter]
Tempereture.compute(abelData, self.lines)
def updateTable(self):
self.table.setRowCount(0)
for line in self.lines:
currentRowCount = self.table.rowCount()
self.table.insertRow(currentRowCount)
for col, value in enumerate(line):
self.table.setItem(currentRowCount, col,
QtGui.QTableWidgetItem(str(value)))
def saveDataToFile(self, data, fileName):
np.savetxt(fileName, data, fmt='%10.5f')
class SliceWidget(QtGui.QWidget):
"""
Main widget holding the slice matplotlib Figure wrapped in FigureCanvasQTAgg.
"""
index_changed = QtCore.pyqtSignal(int)
def __init__(self, slices, indexes, dataset_title=None, default_cmap='seismic',
x_axis_indexes=None, y_axis_indexes=None,
show_h_indicator=False, show_v_indicator=False, v_min_max=None):
super(SliceWidget, self).__init__()
self.slices = slices
self.indexes = indexes
self.x_axis_name, self.x_axis_indexes = x_axis_indexes or (None, None)
self.y_axis_name, self.y_axis_indexes = y_axis_indexes or (None, None)
self.default_cmap = default_cmap
self.show_h_indicator = show_h_indicator
self.show_v_indicator = show_v_indicator
self.palette().setColor(self.backgroundRole(), QtCore.Qt.white)
self.current_index = 0
# setting up the figure and canvas
self.figure = Figure(figsize=(800, 200), dpi=20, facecolor='white')
self.axes = self.figure.add_subplot(111)
self.segy_plot = SegyPlot(self.slices,
self.indexes,
self.axes,
self.default_cmap,
x_axis_indexes=x_axis_indexes,
y_axis_indexes=y_axis_indexes,
display_horizontal_indicator=self.show_h_indicator,
display_vertical_indicator=self.show_v_indicator,
v_min_max=v_min_max)
self.figure_canvas = FigureCanvas(self.figure)
self.figure_canvas.setParent(self)
# connect to mouse click events
self.figure_canvas.mpl_connect('button_press_event', self._mouse_clicked)
# widget layout
self.layout = QtGui.QVBoxLayout(self)
self.layout.addWidget(self.figure_canvas)
def _mouse_clicked(self, evt):
if evt.inaxes is not None:
self.current_index = int(evt.xdata)
self._signal_index_change(self.current_index)
def _signal_index_change(self, x):
if self.x_axis_indexes is not None:
self.index_changed.emit(self.x_axis_indexes[x])
def update_image(self, index):
self.segy_plot.update_image(index)
self.figure_canvas.draw()
def set_cmap(self, action):
self.segy_plot.set_colormap(str(action))
self.figure_canvas.draw()
def set_vertical_line_indicator(self, line):
self.segy_plot.set_vertical_line_indicator(line)
self.figure_canvas.draw()
def set_horizontal_line_indicator(self, line):
self.segy_plot.set_horizontal_line_indicator(line)
self.figure_canvas.draw()
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.dirname = "E:/KaggleData/clips/Volumes/Seagate/seizure_detection/competition_data/clips"
#tk = tkinter.Tk()
#tk.withdraw()
#self.dirname = askdirectory()
self.dirname += "/"
self.patient = "Dog_1"
self.typ = "ictal"
self.rang = "500"
self.channel = "1"
self.start = "0"
self.end = "60"
self.data = None
self.graph = plt.figure()
self.canvas = FigureCanvas(self.graph)
layout = QtGui.QGridLayout()
layout.setColumnMinimumWidth(0, 1200)
layout.setRowMinimumHeight(0, 30)
layout.setRowMinimumHeight(1, 400)
layout.addWidget(self.canvas, 1, 0)
# Directory text box
dir_box = QtGui.QLineEdit()
dir_box.setFixedWidth(200)
layout.addWidget(dir_box)
dir_box.move(5, 5)
dir_box.textChanged[str].connect(self.dir_changed)
dir_box.setText(self.dirname)
# Patient combo box
patient_box = QtGui.QComboBox()
patient_box.setFixedWidth(100)
layout.addWidget(patient_box)
patient_box.move(215, 5)
patient_box.addItem("Dog_1")
patient_box.addItem("Dog_2")
patient_box.addItem("Dog_3")
patient_box.addItem("Dog_4")
patient_box.addItem("Patient_1")
patient_box.addItem("Patient_2")
patient_box.addItem("Patient_3")
patient_box.addItem("Patient_4")
patient_box.addItem("Patient_5")
patient_box.addItem("Patient_6")
patient_box.addItem("Patient_7")
patient_box.addItem("Patient_8")
patient_box.activated[str].connect(self.patient_changed)
# Type combo box
type_box = QtGui.QComboBox()
type_box.setFixedWidth(100)
layout.addWidget(type_box)
type_box.move(325, 5)
type_box.addItem("ictal")
type_box.addItem("interictal")
type_box.addItem("test")
type_box.activated[str].connect(self.type_changed)
# Load button
load_button = QtGui.QPushButton('Load')
load_button.clicked.connect(self.load)
load_button.setFixedWidth(70)
layout.addWidget(load_button)
load_button.move(435, 5)
# Channel combo box
channel_box = QtGui.QComboBox()
channel_box.setFixedWidth(40)
layout.addWidget(channel_box)
channel_box.move(5, 5)
channel_box.addItem("1")
channel_box.addItem("2")
channel_box.addItem("3")
channel_box.addItem("4")
channel_box.addItem("5")
channel_box.addItem("6")
channel_box.addItem("7")
channel_box.addItem("8")
channel_box.addItem("9")
channel_box.addItem("10")
channel_box.addItem("11")
channel_box.addItem("12")
channel_box.addItem("13")
channel_box.addItem("14")
channel_box.addItem("15")
channel_box.addItem("16")
channel_box.activated[str].connect(self.channel_changed)
# Range combo box
range_box = QtGui.QComboBox()
range_box.setFixedWidth(50)
layout.addWidget(range_box)
range_box.move(5, 25)
range_box.addItem("500")
range_box.addItem("400")
range_box.addItem("300")
range_box.addItem("200")
range_box.addItem("100")
range_box.activated[str].connect(self.range_changed)
# Start text box
start_box = QtGui.QLineEdit()
start_box.setFixedWidth(40)
layout.addWidget(start_box)
start_box.move(5, 5)
start_box.textChanged[str].connect(self.start_changed)
start_box.setText(self.start)
# End text box
end_box = QtGui.QLineEdit()
end_box.setFixedWidth(40)
layout.addWidget(end_box)
end_box.move(1000, 1000)
end_box.textChanged[str].connect(self.end_changed)
end_box.setText(self.end)
# Set layout
self.setGeometry(8, 32, 100, 100)
self.setLayout(layout)
def __init__(self):
self.fig = Figure()
FigureCanvas.__init__(self, self.fig)
FigureCanvas.setSizePolicy(self, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
def changePlotWidget(self, library, frame_for_plot):
if library == "PyQtGraph":
plotWdg = pg.PlotWidget()
plotWdg.showGrid(True, True, 0.5)
datavline = pg.InfiniteLine(0,
angle=90,
pen=pg.mkPen('r', width=1),
name='cross_vertical')
datahline = pg.InfiniteLine(0,
angle=0,
pen=pg.mkPen('r', width=1),
name='cross_horizontal')
plotWdg.addItem(datavline)
plotWdg.addItem(datahline)
#cursor
xtextitem = pg.TextItem('X : /',
color=(0, 0, 0),
border=pg.mkPen(color=(0, 0, 0), width=1),
fill=pg.mkBrush('w'),
anchor=(0, 1))
ytextitem = pg.TextItem('Y : / ',
color=(0, 0, 0),
border=pg.mkPen(color=(0, 0, 0), width=1),
fill=pg.mkBrush('w'),
anchor=(0, 0))
plotWdg.addItem(xtextitem)
plotWdg.addItem(ytextitem)
plotWdg.getViewBox().autoRange(items=[])
plotWdg.getViewBox().disableAutoRange()
plotWdg.getViewBox().border = pg.mkPen(color=(0, 0, 0), width=1)
return plotWdg
elif library == "Qwt5" and has_qwt:
plotWdg = QwtPlot(frame_for_plot)
sizePolicy = QSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
plotWdg.sizePolicy().hasHeightForWidth())
plotWdg.setSizePolicy(sizePolicy)
plotWdg.setMinimumSize(QSize(0, 0))
plotWdg.setAutoFillBackground(False)
#Decoration
plotWdg.setCanvasBackground(Qt.white)
plotWdg.plotLayout().setAlignCanvasToScales(True)
zoomer = QwtPlotZoomer(QwtPlot.xBottom, QwtPlot.yLeft,
QwtPicker.DragSelection,
QwtPicker.AlwaysOff, plotWdg.canvas())
zoomer.setRubberBandPen(QPen(Qt.blue))
if platform.system() != "Windows":
# disable picker in Windows due to crashes
picker = QwtPlotPicker(QwtPlot.xBottom, QwtPlot.yLeft,
QwtPicker.NoSelection,
QwtPlotPicker.CrossRubberBand,
QwtPicker.AlwaysOn, plotWdg.canvas())
picker.setTrackerPen(QPen(Qt.green))
#self.dockwidget.qwtPlot.insertLegend(QwtLegend(), QwtPlot.BottomLegend);
grid = Qwt.QwtPlotGrid()
grid.setPen(QPen(QColor('grey'), 0, Qt.DotLine))
grid.attach(plotWdg)
return plotWdg
elif library == "Matplotlib" and has_mpl:
from matplotlib.figure import Figure
if int(qgis.PyQt.QtCore.QT_VERSION_STR[0]) == 4:
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg
elif int(qgis.PyQt.QtCore.QT_VERSION_STR[0]) == 5:
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg
fig = Figure((1.0, 1.0),
linewidth=0.0,
subplotpars=matplotlib.figure.SubplotParams(left=0,
bottom=0,
right=1,
top=1,
wspace=0,
hspace=0))
font = {'family': 'arial', 'weight': 'normal', 'size': 12}
rc('font', **font)
rect = fig.patch
rect.set_facecolor((0.9, 0.9, 0.9))
self.subplot = fig.add_axes((0.05, 0.15, 0.92, 0.82))
self.subplot.set_xbound(0, 1000)
self.subplot.set_ybound(0, 1000)
self.manageMatplotlibAxe(self.subplot)
canvas = FigureCanvasQTAgg(fig)
sizePolicy = QSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
canvas.setSizePolicy(sizePolicy)
return canvas
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
class Statpage(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.parent = parent
self.parent.statsInfo.connect(self.processStatsInfos)
self.globalname = None
self.globalforevername = None
self.tabs = QTabWidget(self)
self.setCentralWidget(self.tabs)
self.setWindowTitle('Player statistics')
self.mu, self.sigma = 1500, 500
self.playermu, self.playersigma = 1500, 500
self.name = "none"
self.create_menu()
self.create_global_frame()
self.create_global_evolution_frame()
self.create_global_evolution_forever_frame()
#self.create_status_bar()
self.tabs.currentChanged.connect(self.tabChanged)
self.on_draw()
def tabChanged(self, tab):
if tab == 1:
if self.name != "unknown" and self.globalname != self.name:
self.parent.statsServer.send(
dict(command="stats",
player=self.name,
type="global_90_days"))
#self.parent.send()
self.evoaxes.clear()
self.globalname = self.name
if tab == 2:
if self.name != "unknown" and self.globalforevername != self.name:
self.parent.statsServer.send(
dict(command="stats",
player=self.name,
type="global_90_days"))
self.evoaxesforever.clear()
self.globalforevername = self.name
def processStatsInfos(self, message):
type = message['type']
if not type == "global_forever" and not type == "global_90_days":
return
name = message['player']
values = message['values']
if name == self.name:
if type == "global_forever":
xaxis = []
ymeanaxis = []
ydevminaxis = []
ydevmaxaxis = []
for val in values:
ymeanaxis.append(val["mean"])
date = val["date"].split('.')
timing = val["time"].split(':')
ydevminaxis.append(val["mean"] - val["dev"])
ydevmaxaxis.append(val["mean"] + val["dev"])
date = datetime.datetime(int(date[2]), int(date[1]),
int(date[0]), int(timing[0]),
int(timing[1]))
xaxis.append(date)
self.evoaxesforever.clear()
self.evoaxesforever.set_ylabel("Skill")
self.evoaxesforever.set_xlabel("Time")
self.evoaxesforever.xaxis.set_major_formatter(
mdates.DateFormatter('%d/%m/%y'))
self.evoaxesforever.plot(xaxis,
ymeanaxis,
'-,',
linewidth=.5,
color='black')
self.evoaxesforever.fill_between(xaxis,
ymeanaxis,
ydevminaxis,
interpolate=True,
linewidth=0,
alpha=.5,
facecolor='red')
self.evoaxesforever.fill_between(xaxis,
ymeanaxis,
ydevmaxaxis,
interpolate=True,
linewidth=0,
alpha=.5,
facecolor='red')
#plt.fill(xaxis, ydevminaxis, 'r')
self.evocanvasforever.draw()
if type == "global_90_days":
xaxis = []
ymeanaxis = []
ydevminaxis = []
ydevmaxaxis = []
for val in values:
ymeanaxis.append(val["mean"])
date = val["date"].split('.')
timing = val["time"].split(':')
ydevminaxis.append(val["mean"] - val["dev"])
ydevmaxaxis.append(val["mean"] + val["dev"])
date = datetime.datetime(int(date[2]), int(date[1]),
int(date[0]), int(timing[0]),
int(timing[1]))
xaxis.append(date)
self.evoaxes.clear()
self.evoaxes.set_ylabel("Skill")
self.evoaxes.set_xlabel("Time")
self.evoaxes.xaxis.set_major_formatter(
mdates.DateFormatter('%d %b'))
self.evoaxes.plot(xaxis,
ymeanaxis,
'-,',
linewidth=.5,
color='black')
self.evoaxes.fill_between(xaxis,
ymeanaxis,
ydevminaxis,
interpolate=True,
linewidth=0,
alpha=.5,
facecolor='red')
self.evoaxes.fill_between(xaxis,
ymeanaxis,
ydevmaxaxis,
interpolate=True,
linewidth=0,
alpha=.5,
facecolor='red')
#plt.fill(xaxis, ydevminaxis, 'r')
self.evocanvas.draw()
def setplayer(self, name):
if name in self.parent.players:
self.evoaxes.clear()
self.evoaxesforever.clear()
self.setWindowTitle('Rating analysis of %s' % name)
self.name = name
self.mu = self.parent.players[name]["rating_mean"]
self.sigma = self.parent.players[name]["rating_deviation"]
self.playermu = self.parent.players[
self.parent.login]["rating_mean"]
self.playersigma = self.parent.players[
self.parent.login]["rating_deviation"]
self.on_draw()
if self.tabs.currentIndex() == 1:
self.parent.send(
dict(command="stats",
player=self.name,
type="global_90_days"))
if self.tabs.currentIndex() == 2:
self.parent.send(
dict(command="stats",
player=self.name,
type="global_forever"))
else:
self.name = "unknown"
self.mu = 0
self.sigma = 0
def save_plot(self):
file_choices = "PNG (*.png)|*.png"
path = unicode(
QFileDialog.getSaveFileName(self, 'Save file', '', file_choices))
if path:
self.canvas.print_figure(path, dpi=self.dpi)
self.statusBar().showMessage('Saved to %s' % path, 2000)
def on_pick(self, event):
box_points = event.artist.get_bbox().get_points()
msg = "You've clicked on a bar with coords:\n %s" % box_points
QMessageBox.information(self, "Click!", msg)
def on_draw(self):
""" Redraws the figure
"""
str = unicode(self.textbox.text())
x = self.mu + self.sigma * np(50000)
self.axes.clear()
self.axes.grid(self.grid_cb.isChecked())
self.axes.set_xlabel("Skill")
self.axes.set_ylabel("Probability %")
#self.ylabel('')
self.axes.set_title("performance graph of %s" % self.name)
#
## the histogram of the data
n, bins, patches = self.axes.hist(x,
100,
normed=1,
facecolor='green',
alpha=0.55)
y = normpdf(bins, self.mu, self.sigma) * 100
text = "This is the potential rating of %s.\n66 percent chances to be between %i and %i." % (
self.name, int(self.mu - self.sigma), int(self.mu + self.sigma))
self.textbox.setText(text + "\n%.2f percent chances to be %i" %
(round((max(y) * 100), 2), int(self.mu)))
self.textbox.setText(
self.textbox.text() +
"\nThe worst rating possible is the one in the leaderboard : %i" %
int(self.mu - 3 * self.sigma))
self.axes.axis([
self.mu - 4 * self.sigma, self.mu + 4 * self.sigma, 0,
(100 + (max(y) * 100) * 1.5) / 2
])
#self.axes.hist(x, bins, normed=1, facecolor='green',)
self.axes.plot(bins,
y * 100,
linewidth=.5,
linestyle='None',
color='red',
alpha=1.0)
self.axes.fill(bins,
y * 100,
'r--',
linewidth=0,
alpha=.5,
facecolor='red')
self.axes.annotate(('%s maximum rating (%i)' % (self.name, self.mu)),
xy=(self.mu, max(y) * 100),
xycoords='data',
xytext=(-50, 30),
textcoords='offset points',
arrowprops=dict(arrowstyle="wedge",
facecolor='red',
linewidth=0),
size=7,
alpha=0.5,
backgroundcolor='lightgrey')
if not self.compare_cb.isChecked():
self.axes.fill_between(bins,
y * 100,
0,
where=bins > self.mu + self.sigma,
facecolor='darkred',
interpolate=True)
self.axes.fill_between(bins,
y * 100,
0,
where=bins < self.mu - self.sigma,
facecolor='darkred',
interpolate=True)
if self.compare_cb.isChecked():
self.axes.set_title("performance graph of %s VS you " % self.name)
x = self.playermu + self.playersigma * np(50000)
n, bins, patches = self.axes.hist(x,
100,
normed=1,
facecolor='green',
alpha=0.55)
y2 = normpdf(bins, self.playermu, self.playersigma) * 100
self.axes.axis([
min(self.mu - 4 * self.sigma,
self.playermu - 4 * self.playersigma),
max(self.mu + 4 * self.sigma,
self.playermu + 4 * self.playersigma), 0,
max((100 + (max(y) * 100) * 1.5) / 2,
(100 + (max(y2) * 100) * 1.5) / 2)
])
self.axes.plot(bins,
y2 * 100,
linewidth=.5,
linestyle='None',
color='blue',
alpha=1.0)
self.axes.fill(bins,
y2 * 100,
'r--',
linewidth=0,
alpha=.5,
facecolor='blue')
#self.axes.fill_between(bins, y2*100 ,0, where=bins>self.playermu+self.playersigma, facecolor='darkblue', interpolate=True)
#self.axes.fill_between(bins, y2*100 ,0, where=bins<self.playermu-self.playersigma, facecolor='darkblue', interpolate=True )
self.axes.annotate('Your most probable rating (%i)' %
int(self.playermu),
xy=(self.playermu, max(y2) * 100),
xycoords='data',
xytext=(-50, 30),
textcoords='offset points',
arrowprops=dict(arrowstyle="wedge",
facecolor='blue',
linewidth=0),
size=7,
alpha=0.5,
backgroundcolor='lightgrey')
text = "This is the potential rating of %s.\n66 percent chances to be between %i and %i. (you : between %i and %i)" % (
self.name,
int(self.mu - self.sigma), int(self.mu + self.sigma),
int(self.playermu - self.playersigma),
int(self.playermu + self.playersigma))
self.textbox.setText(
text +
"\n%.2f percent chances to be %i (You : \n%.2f percent chances to be %i)"
% (round((max(y) * 100), 2), int(self.mu),
round((max(y2) * 100), 2), int(self.playermu)))
self.textbox.setText(
self.textbox.text() +
"\nThe worst rating possible is the one in the leaderboard : %i (you : %i)"
% (int(self.mu - 3 * self.sigma),
int(self.playermu - 3 * self.playersigma)))
teamsTrueskill = []
Team1 = Team()
Team1.addPlayer("1", Rating(self.mu, self.sigma))
Team2 = Team()
Team2.addPlayer("2", Rating(self.playermu, self.playersigma))
teamsTrueskill.append(Team1)
teamsTrueskill.append(Team2)
gameInfo = GameInfo()
calculator = FactorGraphTrueSkillCalculator()
gamequality = calculator.calculateMatchQuality(
gameInfo, teamsTrueskill) * 100
self.textbox.setText(
self.textbox.text() +
"\nProbabilites of having a even match : %.2f percent" %
gamequality)
self.canvas.draw()
def create_global_evolution_forever_frame(self):
self.global_evolution_forever = QWidget()
self.evoforeverfig = Figure((5.0, 4.0), dpi=self.dpi)
self.evocanvasforever = FigureCanvas(self.evoforeverfig)
self.evocanvasforever.setParent(self.global_evolution_forever)
self.evoaxesforever = self.evoforeverfig.add_subplot(111)
self.evotoolbarf = NavigationToolbar(self.evocanvasforever,
self.global_evolution_forever)
hbox = QHBoxLayout()
vbox = QVBoxLayout()
vbox.addWidget(self.evocanvasforever)
vbox.addWidget(self.evotoolbarf)
vbox.addLayout(hbox)
self.global_evolution_forever.setLayout(vbox)
self.tabs.addTab(self.global_evolution_forever,
"Global Rating Evolution for a year")
def create_global_evolution_frame(self):
self.global_evolution = QWidget()
self.evofig = Figure((5.0, 4.0), dpi=self.dpi)
self.evocanvas = FigureCanvas(self.evofig)
self.evocanvas.setParent(self.global_evolution)
self.evoaxes = self.evofig.add_subplot(111)
self.evotoolbar = NavigationToolbar(self.evocanvas,
self.global_evolution)
hbox = QHBoxLayout()
# hbox.addWidget(self.textbox)
# hbox.addWidget(self.grid_cb)
vbox = QVBoxLayout()
vbox.addWidget(self.evocanvas)
vbox.addWidget(self.evotoolbar)
vbox.addLayout(hbox)
self.global_evolution.setLayout(vbox)
self.tabs.addTab(self.global_evolution,
"Global Rating Evolution for the last 90 days")
def create_global_frame(self):
self.global_frame = QWidget()
# Create the mpl Figure and FigCanvas objects.
# 5x4 inches, 100 dots-per-inch
#
self.dpi = 100
self.fig = Figure((5.0, 4.0), dpi=self.dpi)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.global_frame)
# Since we have only one plot, we can use add_axes
# instead of add_subplot, but then the subplot
# configuration tool in the navigation toolbar wouldn't
# work.
#
self.axes = self.fig.add_subplot(111)
#self.fig.add_subplot(xlabel='Smarts')
# Bind the 'pick' event for clicking on one of the bars
#
self.canvas.mpl_connect('pick_event', self.on_pick)
# Create the navigation toolbar, tied to the canvas
#
self.mpl_toolbar = NavigationToolbar(self.canvas, self.global_frame)
# Other GUI controls
#
text = "This is the potential rating of %s.\n66 percent chances to be between %i and %i." % (
self.name, int(self.mu - self.sigma), int(self.mu + self.sigma))
self.textbox = QLabel(text)
self.grid_cb = QCheckBox("Show &Grid")
self.grid_cb.setChecked(True)
self.connect(self.grid_cb, SIGNAL('stateChanged(int)'), self.on_draw)
#
self.compare_cb = QCheckBox("&Compare to you")
self.connect(self.compare_cb, SIGNAL('stateChanged(int)'),
self.on_draw)
hbox = QHBoxLayout()
hbox.addWidget(self.textbox)
hbox.addWidget(self.grid_cb)
hbox.addWidget(self.compare_cb)
hbox.setAlignment(self.grid_cb, Qt.AlignVCenter)
hbox.setAlignment(self.grid_cb, Qt.AlignRight)
vbox = QVBoxLayout()
vbox.addWidget(self.canvas)
vbox.addWidget(self.mpl_toolbar)
vbox.addLayout(hbox)
self.global_frame.setLayout(vbox)
self.tabs.addTab(self.global_frame, "Global rating")
def create_menu(self):
self.file_menu = self.menuBar().addMenu("&File")
load_file_action = self.create_action("&Save plot",
shortcut="Ctrl+S",
slot=self.save_plot,
tip="Save the plot")
quit_action = self.create_action("&Quit",
slot=self.close,
shortcut="Ctrl+Q",
tip="Close the application")
self.add_actions(self.file_menu, (load_file_action, None, quit_action))
def add_actions(self, target, actions):
for action in actions:
if action is None:
target.addSeparator()
else:
target.addAction(action)
def create_action(self,
text,
slot=None,
shortcut=None,
icon=None,
tip=None,
checkable=False,
signal="triggered()"):
action = QAction(text, self)
if icon is not None:
action.setIcon(QIcon(":/%s.png" % icon))
if shortcut is not None:
action.setShortcut(shortcut)
if tip is not None:
action.setToolTip(tip)
action.setStatusTip(tip)
if slot is not None:
self.connect(action, SIGNAL(signal), slot)
if checkable:
action.setCheckable(True)
return action
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(1127, 665)
self.centralwidget = QtWidgets.QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.QuitButton = QtWidgets.QPushButton(self.centralwidget)
self.QuitButton.setGeometry(QtCore.QRect(10, 550, 161, 61))
self.QuitButton.setObjectName("QuitButton")
self.UpButton = QtWidgets.QPushButton(self.centralwidget)
self.UpButton.setGeometry(QtCore.QRect(160, 20, 161, 61))
self.UpButton.setObjectName("UpButton")
self.RightButton = QtWidgets.QPushButton(self.centralwidget)
self.RightButton.setGeometry(QtCore.QRect(310, 100, 161, 61))
self.RightButton.setObjectName("RightButton")
self.DownButton = QtWidgets.QPushButton(self.centralwidget)
self.DownButton.setGeometry(QtCore.QRect(160, 180, 161, 61))
self.DownButton.setObjectName("DownButton")
self.LeftButton = QtWidgets.QPushButton(self.centralwidget)
self.LeftButton.setGeometry(QtCore.QRect(10, 100, 161, 61))
self.LeftButton.setObjectName("LeftButton")
self.Control = QtWidgets.QPushButton(self.centralwidget)
self.Control.setGeometry(QtCore.QRect(160, 310, 161, 61))
self.Control.setObjectName("Control")
self.RecordButton = QtWidgets.QPushButton(self.centralwidget)
self.RecordButton.setGeometry(QtCore.QRect(160, 390, 161, 61))
self.RecordButton.setObjectName("RecordButton")
self.ReplayButton = QtWidgets.QPushButton(self.centralwidget)
self.ReplayButton.setGeometry(QtCore.QRect(160, 470, 161, 61))
self.ReplayButton.setObjectName("ReplayButton")
self.GraphGui = QtWidgets.QWidget(self.centralwidget)
self.GraphGui.setGeometry(QtCore.QRect(490, 10, 621, 601))
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.GraphGui.sizePolicy().hasHeightForWidth())
self.GraphGui.setSizePolicy(sizePolicy)
self.GraphGui.setObjectName("GraphGui")
self.mplvl = QtWidgets.QVBoxLayout(self.GraphGui)
self.mplvl.setContentsMargins(0, 0, 0, 0)
self.mplvl.setObjectName("mplvl")
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 1127, 21))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
MainWindow.setStatusBar(self.statusbar)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
#setting up functions for buttons
self.UpButton.clicked.connect(self.Up)
self.DownButton.clicked.connect(self.Down)
self.LeftButton.clicked.connect(self.Left)
self.RightButton.clicked.connect(self.Right)
self.QuitButton.clicked.connect(self.quit)
self.RecordButton.clicked.connect(self.updateGraph)
self.Control.clicked.connect(self.controlSwitch)
def Up(self):
if(self.Control.text == "Arm Control"): #arm up
ser.write(0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
elif(self.Control.text == "Head Control"): #tilt up
ser.write(0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
def Down(self):
if(self.Control.text == "Arm Control"): #arm down
ser.write(0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
elif(self.Control.text == "Head Control"): #tilt down
ser.write(0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
def Left(self):
if(self.Control.text == "Arm Control"): #arm left
ser.write(0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
elif(self.Control.text == "Head Control"): #pan left
ser.write(0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
def Right(self):
if(self.Control.text == "Arm Control"): #arm right
ser.write(0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
elif(self.Control.text == "Head Control"): #pan right
ser.write(0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
def Out(self):
if(self.Control.text == "Arm Control"): #arm out
ser.write(0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
elif(self.Control.text == "Head Control"): #roll left
ser.write(0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
def In(self):
if(self.Control.text == "Arm Control"): #arm in
ser.write(0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
elif(self.Control.text == "Head Control"): #roll right
ser.write(0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
def quit(self):
ser.close()
QtWidgets.QApplication.exit()
MainWindow.close()
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
self.QuitButton.setText(_translate("MainWindow", "Quit"))
self.UpButton.setText(_translate("MainWindow", "Up"))
self.RightButton.setText(_translate("MainWindow", "Right"))
self.DownButton.setText(_translate("MainWindow", "Down"))
self.LeftButton.setText(_translate("MainWindow", "Left"))
self.Control.setText(_translate("MainWindow", "Arm Control"))
self.RecordButton.setText(_translate("MainWindow", "Record"))
self.ReplayButton.setText(_translate("MainWindow", "Replay"))
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
def updateGraph(self):
global zline
global xline
global yline
print(ser.write(0x0C))
for x in range (0,13):
print(ser.write(0x00))
newzline = np.append(zline, np.array([random.randint(0,100)]), 0)
newxline = np.append(xline, np.array([random.randint(0,100)]), 0)
newyline = np.append(yline, np.array([random.randint(0,100)]), 0)
zline = newzline
xline = newxline
yline = newyline
fig1.clf()
fig1.add_subplot(111, projection='3d').plot3D(xline, yline, zline, 'red')
self.addmpl(fig1)
def controlSwitch(self):
_translate = QtCore.QCoreApplication.translate
if self.Control.text() == "Arm Control":
self.Control.setText(_translate("Arm Control", "Head Control"))
self.UpButton.setText(_translate("Up", "Tilt Up"))
self.DownButton.setText(_translate("Down", "Tilt Down"))
self.LeftButton.setText(_translate("Left", "Pan Left"))
self.RightButton.setText(_translate("Right", "Pan Right"))
elif self.Control.text() == "Head Control":
self.Control.setText(_translate("Head Control", "Arm Control"))
self.UpButton.setText(_translate("Tilt Up", "Up"))
self.DownButton.setText(_translate("Tilt Down", "Down"))
self.LeftButton.setText(_translate("Pan Left", "Left"))
self.RightButton.setText(_translate("Pan Right", "Right"))
def __init__(self, spectrum_collec, gen_heatmap, map, path, parent=None):
super(PlotDisplay, self).__init__(parent)
# Set spectrum collection instance variable/member
self.my_collec = spectrum_collec
# a figure instance to plot on
self.figure = plt.figure()
# callback to gen heatmap
self.gen_heatmap = gen_heatmap
# callback to map images
self.map = map
#self.lin_reg = lin_reg
# initializations for image stack creation
self.path = path
self.stack = ImageStack(self.my_collec, self.path)
self.stack.setWindowTitle('TIFF Image Stack')
self.ax = self.figure.add_subplot(111)
# this is the Canvas Widget that displays the `figure`
# it takes the `figure` instance as a parameter to __init__
self.canvas = FigureCanvas(self.figure)
# this is the Navigation widget
# it takes the Canvas widget and a parent
self.toolbar = NavigationToolbar(self.canvas, self)
# a button connected to `plot` method
self.button = QtGui.QPushButton('Plot Spectrum')
self.button.clicked.connect(self.plot)
# add a combobox for all X values
self.drop_down_x = QtGui.QComboBox()
x_list = list(self.my_collec.x_to_y.keys())
x_list = [str(each) for each in x_list]
self.drop_down_x.addItems(x_list)
# add a combobox for Y's corresponding to first X
self.drop_down_y = QtGui.QComboBox()
y_list = list(self.my_collec.x_to_y.values())
y_list = [str(each) for each in y_list[0]]
self.drop_down_y.addItems(y_list)
self.drop_down_x.currentIndexChanged.connect(self.selection_change)
# create label
self.label_x = QtGui.QLabel("Select X:")
self.label_y = QtGui.QLabel("Select Y:")
# create split layout for displaying combo boxes side by side
splitter = QtGui.QSplitter(QtCore.Qt.Horizontal)
splitter.addWidget(self.label_x)
splitter.addWidget(self.drop_down_x)
splitter.addWidget(self.label_y)
splitter.addWidget(self.drop_down_y)
# add left vertical line slider for peak selection
self.sld = QtGui.QSlider(QtCore.Qt.Horizontal)
self.sld.setMinimum(0)
self.wavenums = self.get_wavenums()
self.sld.setMaximum(len(self.wavenums) - 1)
self.sld.setTickInterval(1)
self.curr_sld = self.sld.sliderPosition()
self.sld.valueChanged.connect(self.sld_change)
# add right vertical line slider for peak selection
self.sld_2 = QtGui.QSlider(QtCore.Qt.Horizontal)
self.sld_2.setMinimum(0)
self.wavenums = self.get_wavenums()
self.sld_2.setMaximum(len(self.wavenums) - 1)
self.sld_2.setTickInterval(1)
self.curr_sld_2 = self.sld_2.sliderPosition()
self.sld_2.valueChanged.connect(self.sld_change)
# initialize left and right lines to start at None
self.vert_line = None
self.vert_line_2 = None
# text edit to display wavenumber for left slider
self.textedit = QtGui.QLabel()
self.textedit.setStyleSheet('background-color: white')
# text edit to display wavenumber for right slider
self.textedit_2 = QtGui.QLabel()
self.textedit_2.setStyleSheet('background-color: white')
# horizontal layout to hold slider and text edit box
hslider_text = QtGui.QHBoxLayout()
hslider_text.addWidget(self.sld, 2)
hslider_text.addWidget(self.textedit, 1)
# group box to group left slider and text elements together
gbox = QtGui.QGroupBox("Left")
gbox.setLayout(hslider_text)
qpalette = QtGui.QPalette()
qpalette.setColor(QtGui.QPalette.Dark, QtCore.Qt.white)
gbox.setPalette(qpalette)
# set layout of left slider group box
hslider_text_2 = QtGui.QHBoxLayout()
hslider_text_2.addWidget(self.sld_2, 2)
hslider_text_2.addWidget(self.textedit_2, 1)
# group box to group right slider and text elements together
gbox_2 = QtGui.QGroupBox("Right")
gbox_2.setLayout(hslider_text_2)
qpalette = QtGui.QPalette()
qpalette.setColor(QtGui.QPalette.Dark, QtCore.Qt.white)
gbox.setPalette(qpalette)
# set layout of right slider group box
slider_layout = QtGui.QVBoxLayout()
slider_layout.addWidget(gbox)
slider_layout.addWidget(gbox_2)
slider_group = QtGui.QGroupBox("Peak Selection")
slider_group.setLayout(slider_layout)
# add button for heat map generation
self.hm_button = QtGui.QPushButton('Generate Heatmap')
self.hm_button.clicked.connect(self.hm_make)
# add button for image stack pop out window
self.map_img = QtGui.QPushButton('View Image Stack')
self.map_img.clicked.connect(self.img_stack)
# add baseline correction button
self.bg_test = QtGui.QPushButton('Baseline Correction')
self.bg_test.clicked.connect(self.rb_test)
# set the layout of main window, adding all widgets
layout = QtGui.QVBoxLayout()
layout.addWidget(self.toolbar)
layout.addWidget(self.canvas)
layout.addWidget(self.button)
layout.addWidget(splitter)
layout.addWidget(slider_group)
layout.addWidget(self.hm_button)
layout.addWidget(self.map_img)
layout.addWidget(self.bg_test)
self.setLayout(layout)
class PlotWidget(QWidget):
def __init__(self, parent=None, image=None, toolbar=True):
QWidget.__init__(self, parent)
self.data = image
self.dpi = 100
self.cmap = 'gray'
self.toolbar = toolbar
self.create_main_widget()
if self.data is not None:
self.on_draw()
def create_main_widget(self):
print self.data
self.fig = Figure((10.0, 8.0), dpi=self.dpi)
self.canvas = FigureCanvas(self.fig)
self.canvas.setFocusPolicy(Qt.StrongFocus)
self.canvas.setFocus()
vbox = QVBoxLayout()
vbox.addWidget(self.canvas) # the matplotlib canvas
if self.toolbar:
self.mpl_toolbar = NavigationToolbar(self.canvas, self)
vbox.addWidget(self.mpl_toolbar)
self.canvas.mpl_connect('key_press_event', self.on_key_press)
self.setLayout(vbox)
def set_image(self, image):
self.data = image
self.on_draw()
def on_key_press(self, event):
if event.key == 'i':
print('* image infos:')
print('shape is (%dx%d)' %
(np.shape(self.data)[0], np.shape(self.data)[1]))
print('min in image= %d, max in image=%d' %
(np.min(self.data), np.max(self.data)))
elif event.key == 'right':
# load next image
self.parent().parent().on_next_image()
elif event.key == 'left':
# load previous image
self.parent().parent().on_prev_image()
elif event.key == 'h':
# plot the image histogram
hist(self.data,
data_range=(np.min(self.data), np.max(self.data)),
show=True)
# implement the default mpl key press events described at
# http://matplotlib.org/users/navigation_toolbar.html#navigation-keyboard-shortcuts
key_press_handler(event, self.canvas, self.mpl_toolbar)
def on_draw(self):
if not hasattr(self.fig, 'subplot'):
self.axes = self.fig.add_subplot(111)
self.axes.imshow(self.data,
cmap=self.cmap,
origin='upper',
interpolation='nearest',
clim=[np.min(self.data),
np.max(self.data)])
self.canvas.draw()
class Window(QtGui.QDialog):
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.dirname = "E:/KaggleData/clips/Volumes/Seagate/seizure_detection/competition_data/clips"
#tk = tkinter.Tk()
#tk.withdraw()
#self.dirname = askdirectory()
self.dirname += "/"
self.patient = "Dog_1"
self.typ = "ictal"
self.rang = "500"
self.channel = "1"
self.start = "0"
self.end = "60"
self.data = None
self.graph = plt.figure()
self.canvas = FigureCanvas(self.graph)
layout = QtGui.QGridLayout()
layout.setColumnMinimumWidth(0, 1200)
layout.setRowMinimumHeight(0, 30)
layout.setRowMinimumHeight(1, 400)
layout.addWidget(self.canvas, 1, 0)
# Directory text box
dir_box = QtGui.QLineEdit()
dir_box.setFixedWidth(200)
layout.addWidget(dir_box)
dir_box.move(5, 5)
dir_box.textChanged[str].connect(self.dir_changed)
dir_box.setText(self.dirname)
# Patient combo box
patient_box = QtGui.QComboBox()
patient_box.setFixedWidth(100)
layout.addWidget(patient_box)
patient_box.move(215, 5)
patient_box.addItem("Dog_1")
patient_box.addItem("Dog_2")
patient_box.addItem("Dog_3")
patient_box.addItem("Dog_4")
patient_box.addItem("Patient_1")
patient_box.addItem("Patient_2")
patient_box.addItem("Patient_3")
patient_box.addItem("Patient_4")
patient_box.addItem("Patient_5")
patient_box.addItem("Patient_6")
patient_box.addItem("Patient_7")
patient_box.addItem("Patient_8")
patient_box.activated[str].connect(self.patient_changed)
# Type combo box
type_box = QtGui.QComboBox()
type_box.setFixedWidth(100)
layout.addWidget(type_box)
type_box.move(325, 5)
type_box.addItem("ictal")
type_box.addItem("interictal")
type_box.addItem("test")
type_box.activated[str].connect(self.type_changed)
# Load button
load_button = QtGui.QPushButton('Load')
load_button.clicked.connect(self.load)
load_button.setFixedWidth(70)
layout.addWidget(load_button)
load_button.move(435, 5)
# Channel combo box
channel_box = QtGui.QComboBox()
channel_box.setFixedWidth(40)
layout.addWidget(channel_box)
channel_box.move(5, 5)
channel_box.addItem("1")
channel_box.addItem("2")
channel_box.addItem("3")
channel_box.addItem("4")
channel_box.addItem("5")
channel_box.addItem("6")
channel_box.addItem("7")
channel_box.addItem("8")
channel_box.addItem("9")
channel_box.addItem("10")
channel_box.addItem("11")
channel_box.addItem("12")
channel_box.addItem("13")
channel_box.addItem("14")
channel_box.addItem("15")
channel_box.addItem("16")
channel_box.activated[str].connect(self.channel_changed)
# Range combo box
range_box = QtGui.QComboBox()
range_box.setFixedWidth(50)
layout.addWidget(range_box)
range_box.move(5, 25)
range_box.addItem("500")
range_box.addItem("400")
range_box.addItem("300")
range_box.addItem("200")
range_box.addItem("100")
range_box.activated[str].connect(self.range_changed)
# Start text box
start_box = QtGui.QLineEdit()
start_box.setFixedWidth(40)
layout.addWidget(start_box)
start_box.move(5, 5)
start_box.textChanged[str].connect(self.start_changed)
start_box.setText(self.start)
# End text box
end_box = QtGui.QLineEdit()
end_box.setFixedWidth(40)
layout.addWidget(end_box)
end_box.move(1000, 1000)
end_box.textChanged[str].connect(self.end_changed)
end_box.setText(self.end)
# Set layout
self.setGeometry(8, 32, 100, 100)
self.setLayout(layout)
def load(self):
print("loading files...")
filestub = self.dirname + self.patient + "/" + self.patient + "_" + self.typ + "_segment_"
cont = 1
i = 2
print("file", i)
self.data = scipy.io.loadmat(filestub + "1.mat")['data']
lats = [-1]
while cont:
try:
f = scipy.io.loadmat(filestub + str(i) + ".mat")
dat = f['data']
lat = f['latency']
self.data = concatenate((self.data, dat), 1)
lats.append(int(lat[0]))
print(filestub + str(i) + ".mat")
except:
cont = 0
i += 1
self.lens = []
i = 0
j = 0
for i in range(0, len(lats)):
if lats[i] == 0:
self.lens.append(j)
j = 0
else:
j += 1
self.lens.append(j)
if self.typ == 'interictal':
self.lens = [len(self.data[0]) / 400]
print(self.lens)
self.display()
print("load complete")
def display(self):
if self.data != None:
print("generating display")
axis = self.graph.add_subplot(1, 1, 1)
axis.cla()
axis.hold(True)
length = len(self.data[int(self.channel) - 1])
if int(self.end) > length:
self.end = str(length / 400)
s = int(self.start)
e = int(self.end)
c = int(self.channel) - 1
xrange = np.arange(s, e * 400, 1 / 400)
i = 0
color = 0
for j in range(0, len(self.lens)):
end = i + self.lens[j]
if end > e:
end = e - s
tempx = xrange[i * 400:end * 400]
tempy = self.data[c][i * 400:end * 400]
axis.plot(tempx, tempy, colors[color])
i += self.lens[j]
if color % 8 == 7:
color = 0
else:
color += 1
axis.set_ylim([-1 * int(self.rang), int(self.rang)])
self.canvas.draw()
axis.hold(False)
def dir_changed(self, dirname):
self.dirname = dirname
print("New directory:", self.dirname)
def patient_changed(self, patient):
self.patient = patient
print("New patient:", self.patient)
def type_changed(self, typ):
self.typ = typ
print("New data type:", self.typ)
def channel_changed(self, channel):
self.channel = channel
print("Channel:", self.channel)
self.display()
def range_changed(self, rang):
self.rang = rang
print("Vertical range changed to +/-", self.rang)
self.display()
def start_changed(self, start):
if start != "":
self.start = start
print("Start value:", self.start)
self.display()
def end_changed(self, end):
if end != "":
self.end = end
print("End value:", self.end)
self.display()
class PlotDisplay(QtGui.QDialog):
"""Creates the main application window"""
def __init__(self, spectrum_collec, gen_heatmap, map, path, parent=None):
super(PlotDisplay, self).__init__(parent)
# Set spectrum collection instance variable/member
self.my_collec = spectrum_collec
# a figure instance to plot on
self.figure = plt.figure()
# callback to gen heatmap
self.gen_heatmap = gen_heatmap
# callback to map images
self.map = map
#self.lin_reg = lin_reg
# initializations for image stack creation
self.path = path
self.stack = ImageStack(self.my_collec, self.path)
self.stack.setWindowTitle('TIFF Image Stack')
self.ax = self.figure.add_subplot(111)
# this is the Canvas Widget that displays the `figure`
# it takes the `figure` instance as a parameter to __init__
self.canvas = FigureCanvas(self.figure)
# this is the Navigation widget
# it takes the Canvas widget and a parent
self.toolbar = NavigationToolbar(self.canvas, self)
# a button connected to `plot` method
self.button = QtGui.QPushButton('Plot Spectrum')
self.button.clicked.connect(self.plot)
# add a combobox for all X values
self.drop_down_x = QtGui.QComboBox()
x_list = list(self.my_collec.x_to_y.keys())
x_list = [str(each) for each in x_list]
self.drop_down_x.addItems(x_list)
# add a combobox for Y's corresponding to first X
self.drop_down_y = QtGui.QComboBox()
y_list = list(self.my_collec.x_to_y.values())
y_list = [str(each) for each in y_list[0]]
self.drop_down_y.addItems(y_list)
self.drop_down_x.currentIndexChanged.connect(self.selection_change)
# create label
self.label_x = QtGui.QLabel("Select X:")
self.label_y = QtGui.QLabel("Select Y:")
# create split layout for displaying combo boxes side by side
splitter = QtGui.QSplitter(QtCore.Qt.Horizontal)
splitter.addWidget(self.label_x)
splitter.addWidget(self.drop_down_x)
splitter.addWidget(self.label_y)
splitter.addWidget(self.drop_down_y)
# add left vertical line slider for peak selection
self.sld = QtGui.QSlider(QtCore.Qt.Horizontal)
self.sld.setMinimum(0)
self.wavenums = self.get_wavenums()
self.sld.setMaximum(len(self.wavenums) - 1)
self.sld.setTickInterval(1)
self.curr_sld = self.sld.sliderPosition()
self.sld.valueChanged.connect(self.sld_change)
# add right vertical line slider for peak selection
self.sld_2 = QtGui.QSlider(QtCore.Qt.Horizontal)
self.sld_2.setMinimum(0)
self.wavenums = self.get_wavenums()
self.sld_2.setMaximum(len(self.wavenums) - 1)
self.sld_2.setTickInterval(1)
self.curr_sld_2 = self.sld_2.sliderPosition()
self.sld_2.valueChanged.connect(self.sld_change)
# initialize left and right lines to start at None
self.vert_line = None
self.vert_line_2 = None
# text edit to display wavenumber for left slider
self.textedit = QtGui.QLabel()
self.textedit.setStyleSheet('background-color: white')
# text edit to display wavenumber for right slider
self.textedit_2 = QtGui.QLabel()
self.textedit_2.setStyleSheet('background-color: white')
# horizontal layout to hold slider and text edit box
hslider_text = QtGui.QHBoxLayout()
hslider_text.addWidget(self.sld, 2)
hslider_text.addWidget(self.textedit, 1)
# group box to group left slider and text elements together
gbox = QtGui.QGroupBox("Left")
gbox.setLayout(hslider_text)
qpalette = QtGui.QPalette()
qpalette.setColor(QtGui.QPalette.Dark, QtCore.Qt.white)
gbox.setPalette(qpalette)
# set layout of left slider group box
hslider_text_2 = QtGui.QHBoxLayout()
hslider_text_2.addWidget(self.sld_2, 2)
hslider_text_2.addWidget(self.textedit_2, 1)
# group box to group right slider and text elements together
gbox_2 = QtGui.QGroupBox("Right")
gbox_2.setLayout(hslider_text_2)
qpalette = QtGui.QPalette()
qpalette.setColor(QtGui.QPalette.Dark, QtCore.Qt.white)
gbox.setPalette(qpalette)
# set layout of right slider group box
slider_layout = QtGui.QVBoxLayout()
slider_layout.addWidget(gbox)
slider_layout.addWidget(gbox_2)
slider_group = QtGui.QGroupBox("Peak Selection")
slider_group.setLayout(slider_layout)
# add button for heat map generation
self.hm_button = QtGui.QPushButton('Generate Heatmap')
self.hm_button.clicked.connect(self.hm_make)
# add button for image stack pop out window
self.map_img = QtGui.QPushButton('View Image Stack')
self.map_img.clicked.connect(self.img_stack)
# add baseline correction button
self.bg_test = QtGui.QPushButton('Baseline Correction')
self.bg_test.clicked.connect(self.rb_test)
# set the layout of main window, adding all widgets
layout = QtGui.QVBoxLayout()
layout.addWidget(self.toolbar)
layout.addWidget(self.canvas)
layout.addWidget(self.button)
layout.addWidget(splitter)
layout.addWidget(slider_group)
layout.addWidget(self.hm_button)
layout.addWidget(self.map_img)
layout.addWidget(self.bg_test)
self.setLayout(layout)
def plot(self):
""""Create matplotlib plot for specific X and Y contained in my_collec"""
# discards the old graph
self.ax.hold(False)
# get data from combo box
curr_x = self.drop_down_x.itemText(self.drop_down_x.currentIndex())
curr_y = self.drop_down_y.itemText(self.drop_down_y.currentIndex())
# plot data
spectra_list = self.my_collec.spectra
for i, spectrum in enumerate(spectra_list):
if (spectrum.x == float(curr_x)) and (spectrum.y == float(curr_y)):
self.ax.scatter(*zip(*self.my_collec.spectra[i].info_flipped))
self.ax.grid('on')
# add left vert line
self.vert_line = self.ax.axvline(x=0)
# add right vert line
self.vert_line_2 = self.ax.axvline(x=0)
# refresh canvas
self.canvas.draw()
def selection_change(self):
"""If the X drop down value changes, get the matching Y's corresponding to the new X"""
curr_x = self.drop_down_x.itemText(self.drop_down_x.currentIndex())
curr_ys = list(self.my_collec.x_to_y.get(float(curr_x)))
curr_ys = [str(each) for each in curr_ys]
self.drop_down_y.clear()
self.drop_down_y.addItems(curr_ys)
def get_wavenums(self):
""""Makes a list of all wavenums in spectra"""
wavenums = []
for spectrum in self.my_collec.spectra:
wavenums = spectrum.info[1]
wavenums.sort()
return wavenums
def sld_change(self):
"""If left and/or right slider changes, set respective text to correct wavenumber, move line
vertical line to correct position"""
self.vert_line.remove()
self.vert_line_2.remove()
curr_pos = self.sld.sliderPosition()
curr_wavenum = self.wavenums[curr_pos]
curr_pos_2 = self.sld_2.sliderPosition()
curr_wavenum_2 = self.wavenums[curr_pos_2]
self.textedit.setText(str(curr_wavenum))
self.textedit_2.setText(str(curr_wavenum_2))
self.vert_line = self.ax.axvline(x=curr_wavenum)
self.vert_line_2 = self.ax.axvline(x=curr_wavenum_2)
self.canvas.draw()
def hm_make(self):
"""
Generate heatmap using values selected from left and right sliders
"""
curr_pos = self.sld.sliderPosition()
curr_wavenum = self.wavenums[curr_pos]
curr_pos_2 = self.sld_2.sliderPosition()
curr_wavenum_2 = self.wavenums[curr_pos_2]
self.ax.grid('off')
self.gen_heatmap(curr_wavenum, curr_wavenum_2)
def img_stack(self):
"""
Show scrollable set of TIFF images
"""
file_names = [
f for f in sorted(os.listdir(self.path)) if f.endswith(".tiff")
]
if len(file_names) == 0:
self.map()
self.stack.show()
def bg_sub_test(self):
"""
Background subtraction using linear regression method
"""
curr_pos = self.sld.sliderPosition()
curr_wavenum = self.wavenums[curr_pos]
curr_pos_2 = self.sld_2.sliderPosition()
curr_wavenum_2 = self.wavenums[curr_pos_2]
curr_x = self.drop_down_x.itemText(self.drop_down_x.currentIndex())
curr_y = self.drop_down_y.itemText(self.drop_down_y.currentIndex())
spectra_list = self.my_collec.spectra
for i, spectrum in enumerate(spectra_list):
if (spectrum.x == float(curr_x)) and (spectrum.y == float(curr_y)):
intens = self.my_collec.spectra[i].info[0]
wavenums = self.my_collec.spectra[i].info[1]
btwn_wavenums = []
btwn_intens = []
for i, wavenum in enumerate(wavenums):
if wavenum <= curr_wavenum_2 and wavenum >= curr_wavenum:
btwn_wavenums.append(wavenum)
btwn_intens.append(intens[i])
new_y_list = []
slope, intercept = self.lin_reg(btwn_wavenums, btwn_intens)
for i, y in enumerate(intens):
fit_y = slope * wavenums[i] + intercept
y -= fit_y
if y < 0:
y = 0
new_y_list.append(y)
print(len(wavenums), len(new_y_list))
new_plot = np.column_stack((wavenums, new_y_list))
self.ax.scatter(*zip(*new_plot))
self.canvas.draw()
def rb_test(self):
"""
Background/baseline subtraction using 'rubberband correction' method
"""
# get data from combo box
curr_x = self.drop_down_x.itemText(self.drop_down_x.currentIndex())
curr_y = self.drop_down_y.itemText(self.drop_down_y.currentIndex())
# get vertex points
curr_spec = None
curr_spec_plt = None
spectra_list = self.my_collec.spectra
for i, spectrum in enumerate(spectra_list):
if (spectrum.x == float(curr_x)) and (spectrum.y == float(curr_y)):
curr_spec = self.my_collec.spectra[i]
# Separate x and y values into two separate lists
x = curr_spec.info[1]
y = curr_spec.info[0]
# Zip to create np array of (x, y) tuples
zipped = np.column_stack((x, y))
# Find the convex hull, where array v contains the indices of the convex hull
# vertex points arranged in a counter clockwise direction
v = ConvexHull(zipped).vertices
# Rotate convex hull vertices until v starts from the lowest one
v = np.roll(v, -v.argmin())
# Leave only the ascending part
v = v[:v.argmax()]
# Create baseline using linear interpolation between vertices
bsln = np.interp(x, x[v], y[v])
# Find new y values using baseline
new_y = []
for i, point in enumerate(y):
point -= bsln[i]
new_y.append(point)
# convert list of x and new y's into an np array of tuples
x_y = np.column_stack((x, new_y))
# plot the new spectrum
self.ax.scatter(*zip(*x_y))
self.ax.grid(which='both')
# add left vert line
self.vert_line = self.ax.axvline(x=0)
# add right vert line
self.vert_line_2 = self.ax.axvline(x=0)
self.canvas.draw()
