class Window(QtGui.QDialog):
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.toolbar.hide()
# Just some button
self.button = QtGui.QPushButton('Plot')
self.button.clicked.connect(self.plot)
self.button1 = QtGui.QPushButton('Zoom')
self.button1.clicked.connect(self.zoom)
self.button2 = QtGui.QPushButton('Pan')
self.button2.clicked.connect(self.pan)
self.button3 = QtGui.QPushButton('Home')
self.button3.clicked.connect(self.home)
# set the layout
layout = QtGui.QVBoxLayout()
layout.addWidget(self.toolbar)
layout.addWidget(self.canvas)
layout.addWidget(self.button)
layout.addWidget(self.button1)
layout.addWidget(self.button2)
layout.addWidget(self.button3)
self.setLayout(layout)
def home(self):
self.toolbar.home()
def zoom(self):
self.toolbar.zoom()
def pan(self):
self.toolbar.pan()
def plot(self):
''' plot some random stuff '''
data = [random.random() for i in range(25)]
ax = self.figure.add_subplot(111)
ax.hold(False)
ax.plot(data, '*-')
self.canvas.draw()
class PlotManager(QtGui.QWidget):
def __init__(self, parent=None):
super(PlotManager, self).__init__(parent)
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.toolbar.hide()
self.zoombut = QtGui.QPushButton("Збільшити")
self.zoombut.clicked.connect(self.zoom)
self.panbut = QtGui.QPushButton("Перемістити")
self.panbut.clicked.connect(self.pan)
self.homebut = QtGui.QPushButton("Повністю")
self.homebut.clicked.connect(self.home)
self.savebut = QtGui.QPushButton("Зберегти")
self.savebut.clicked.connect(self.save)
layout = QtGui.QVBoxLayout()
buttonbox = QtGui.QHBoxLayout()
buttonbox.addWidget(self.zoombut)
buttonbox.addWidget(self.panbut)
buttonbox.addWidget(self.homebut)
buttonbox.addWidget(self.savebut)
layout.addLayout(buttonbox)
layout.addWidget(self.toolbar)
layout.addWidget(self.canvas)
self.setLayout(layout)
self.ax = self.figure.add_subplot(111)
def home(self):
self.toolbar.home()
def zoom(self):
self.toolbar.zoom()
def pan(self):
self.toolbar.pan()
def save(self):
timestr = time.strftime("%Y%m%d_%H%M%S", time.gmtime())
self.figure.savefig(f'{timestr}.png')
class MainWindow(QtGui.QMainWindow, mw.Ui_MainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
self.datalst = []
self.modellst = []
self.lstdatamodel = QtGui.QStandardItemModel(self.listView)
self.listView.setModel(self.lstdatamodel)
self.current_lst_index = -1
self.addButton.clicked.connect(self.add)
self.removeButton.clicked.connect(self.remove)
self.actionCalcLSSParameter.triggered.connect(self.calculatelss)
self.actionAutomaticElutionWindowStretching.triggered.connect(self.calcautelwindowstretch)
self.actionSelectivityMap.triggered.connect(self.pltselectivitymap)
self.actionResolutionMap.triggered.connect(self.pltresolutionmap)
self.actionAbout.triggered.connect(self.about)
self.actionQuit.triggered.connect(self.quit)
self.listView.clicked.connect(self.viewmatrix)
self.toolBox.currentChanged.connect(self.viewmatrix)
self.zoomButton.clicked.connect(self.zoom)
self.panButton.clicked.connect(self.pan)
self.rescaleButton.clicked.connect(self.home)
self.modelBox.currentIndexChanged.connect(self.gradientanalyser)
self.doubleSpinBox_1.valueChanged.connect(self.gradientanalyser)
self.doubleSpinBox_2.valueChanged.connect(self.gradientanalyser)
self.doubleSpinBox_3.valueChanged.connect(self.gradientanalyser)
self.doubleSpinBox_4.valueChanged.connect(self.gradientanalyser)
self.doubleSpinBox_5.valueChanged.connect(self.gradientanalyser)
self.ColumnLenghtSpinBox.valueChanged.connect(self.gradientanalyser)
self.CulumnDiameterSpinBox.valueChanged.connect(self.gradientanalyser)
self.ColumnPorositySpinBox.valueChanged.connect(self.gradientanalyser)
# Add plot
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.toolbar.hide()
# set the layout
layout_chormatogram = QtGui.QVBoxLayout()
layout_chormatogram.addWidget(self.canvas)
self.plotterBox.setLayout(layout_chormatogram)
# Add selectivity map plot
#self.figure_smap = plt.figure()
#self.canvas_smap = FigureCanvas(self.figure_smap)
#self.toolbar_smap = NavigationToolbar(self.canvas_smap, self)
#self.toolbar_smap.hide()
#layout_smap = QtGui.QVBoxLayout()
#layout_smap.addWidget(self.canvas_smap)
#self.plotterBox_2.setLayout(layout_smap)
self.tablemodel = TableModel(self)
self.tableView.setModel(self.tablemodel)
self.tableView.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.tableView.customContextMenuRequested.connect(self.openTableMenu)
# constant parameters
self.crit_resolution = 1.8
self.crit_alpha = 1.1
def openTableMenu(self, position):
""" context menu event """
menu = QtGui.QMenu(self)
exportAction = menu.addAction("Export table as CSV")
action = menu.exec_(self.tableView.viewport().mapToGlobal(position))
if action == exportAction:
fname = QtGui.QFileDialog.getSaveFileName(self, "Save File", "CSV (*.csv)");
#fname = QtGui.getSaveFileName.getOpenFileName(self, tr('Save File'), )
self.tablemodel.SaveTable(fname)
else:
return
return
def keyPressEvent(self, e):
if (e.modifiers() & QtCore.Qt.ControlModifier):
if e.key() == QtCore.Qt.Key_C: #copy
if len(self.tableView.selectionModel().selectedIndexes()) > 0:
previous = self.tableView.selectionModel().selectedIndexes()[0]
columns = []
rows = []
for index in self.tableView.selectionModel().selectedIndexes():
if previous.column() != index.column():
columns.append(rows)
rows = []
rows.append(str(index.data().toPyObject()))
previous = index
columns.append(rows)
# add rows and columns to clipboard
clipboard = ""
nrows = len(columns[0])
ncols = len(columns)
for r in xrange(nrows):
for c in xrange(ncols):
clipboard += columns[c][r]
if c != (ncols-1):
clipboard += '\t'
clipboard += '\n'
# copy to the system clipboard
sys_clip = QtGui.QApplication.clipboard()
sys_clip.setText(clipboard)
def home(self):
self.toolbar.home()
def zoom(self):
self.toolbar.zoom()
def pan(self):
self.toolbar.pan()
def plotchromatogram(self):
''' plot some random stuff '''
data = [random.random() for i in range(25)]
ax = self.figure.add_subplot(111)
ax.hold(False)
ax.plot(data, '*-')
self.canvas.draw()
def add(self):
idialog = ImportDialog()
if idialog.exec_() == 1:
[name, molname, trdata, grad, tg, td, t0, flow, c_length, c_diameter, c_particle] = idialog.getdata()
self.datalst.append(Data(name, molname, trdata, grad, tg, td, t0, flow, c_length, c_diameter, c_particle))
self.lstdatamodel.appendRow(QtGui.QStandardItem(name))
def remove(self):
if self.current_lst_index >= 0 and self.current_lst_index < len(self.datalst):
del self.datalst[self.current_lst_index]
self.lstdatamodel.removeRow(self.current_lst_index)
def viewmatrix(self, indx):
if self.toolBox.currentIndex() == 0:
if indx:
self.current_lst_index = indx.row()
del self.tablemodel.arraydata[:]
del self.tablemodel.header[:]
self.tablemodel.clean()
self.tableView.model().layoutChanged.emit()
molname = self.datalst[self.current_lst_index].molname
trdata = self.datalst[self.current_lst_index].trdata
grad = self.datalst[self.current_lst_index].grad
tg = self.datalst[self.current_lst_index].tg
header = ["Molecule"]
for j in range(len(tg)):
header.append(str("%.1f%% %.1f%% %.1f min" % (round(grad[j][0]*100,1), round(grad[j][1]*100,1), tg[j])))
self.tablemodel.setHeader(header)
for i in range(len(trdata)):
row = [molname[i]]
for j in range(len(trdata[i])):
row.append(round(trdata[i][j], 2))
self.tablemodel.addRow(row)
self.tableView.model().layoutChanged.emit()
else:
del self.tablemodel.arraydata[:]
del self.tablemodel.header[:]
self.tablemodel.clean()
self.tableView.model().layoutChanged.emit()
self.gradientanalyser()
def about(self):
adialog = AboutDialog()
adialog.exec_()
def quit(self):
QtGui.QApplication.quit()
def calculatelss(self):
items = []
lstmodel = self.listView.model()
for index in range(lstmodel.rowCount()):
item = lstmodel.item(index)
items.append(item.text())
runlss = ComputeLSS(items)
if runlss.exec_() == 1:
[indx, modelname] = runlss.getdata()
t0 = self.datalst[indx].t0
v_d = self.datalst[indx].vd
flow = self.datalst[indx].flow
lssmol = SSGenerator(None, None, None, t0, v_d, flow)
self.modellst.append(Model())
self.modellst[-1].modname = modelname
self.modellst[-1].molname = self.datalst[indx].molname
self.modellst[-1].flow = self.datalst[indx].flow
self.modellst[-1].c_length = self.datalst[indx].c_length
self.modellst[-1].c_diameter = self.datalst[indx].c_diameter
self.modellst[-1].c_particle = self.datalst[indx].c_particle
self.modelBox.addItem(modelname)
tg = self.datalst[indx].tg
init_B = []
final_B = []
for i in range(len(tg)):
init_B.append(self.datalst[indx].grad[i][0])
final_B.append(self.datalst[indx].grad[i][1])
self.modellst[-1].v_d = v_d
self.modellst[-1].v_m = t0 * flow
for row in self.datalst[indx].trdata:
lss_logkw, lss_s = lssmol.getlssparameters(row, tg, init_B, final_B)
self.modellst[-1].lss.append([lss_logkw, lss_s])
if len(self.modellst) == 1:
self.gradientanalyser()
def calcautelwindowstretch(self):
aws = AutomaticElutionWindowStretching(self.modellst)
aws.exec_()
def pltselectivitymap(self):
smap = PlotMaps(self.modellst, "sel")
smap.exec_()
def pltresolutionmap(self):
rsmap = PlotMaps(self.modellst, "res")
rsmap.exec_()
def gradientanalyser(self):
indx = self.modelBox.currentIndex()
del self.tablemodel.arraydata[:]
del self.tablemodel.header[:]
self.tablemodel.clean()
header = ["Molecule", "log kW", "S", "tR"]
self.tablemodel.setHeader(header)
self.tableView.model().layoutChanged.emit()
if indx >= 0 and indx < len(self.modellst):
#predict the retention time for each compound
molname = [name for name in self.modellst[indx].molname]
lss = self.modellst[indx].lss
flow_sofware = float(self.doubleSpinBox_1.value())
init_B_soft = float(self.doubleSpinBox_2.value())/100.
final_B_soft = float(self.doubleSpinBox_3.value())/100.
tg_soft = float(self.doubleSpinBox_4.value())
c_length = self.ColumnLenghtSpinBox.value()
c_diameter = self.CulumnDiameterSpinBox.value()
c_particle = self.ColumnPorositySpinBox.value()
t0_soft = 0.
td_soft = 0.
v_m = None
v_d = float(self.doubleSpinBox_5.value())
#if c_length > 0 and c_diameter > 0 and c_porosity > 0:
# v_m = ((square(self.c_diameter)*self.c_length*pi*self.c_porosity)/4.)/1000.
#else:
v_m = self.modellst[indx].v_m
t0_soft = float(v_m/flow_sofware)
td_soft = float(v_d/flow_sofware)
A = 1.0
#N = (c_length*10000.)/(3.4*c_particle)
trtab = []
lssmol = SSGenerator(None, None, None, t0_soft, float(self.modellst[indx].v_d), flow_sofware)
i = 0
trlst = []
for row in lss:
lss_logkw = float(row[0])
lss_s = float(row[1])
W = get_lss_peak_width(c_length, c_particle, lss_logkw, lss_s, init_B_soft, final_B_soft, tg_soft, flow_sofware, self.modellst[indx].v_m, self.modellst[indx].v_d, None)
tr = lssmol.rtpred(lss_logkw, lss_s, tg_soft, init_B_soft, final_B_soft, t0_soft, td_soft)
if tr < t0_soft:
trtab.append([t0_soft, A, W])
else:
trtab.append([tr, A, W])
trlst.append([round(trtab[-1][0], 2), W, molname[i]])
row = [molname[i], round(lss_logkw, 3), round(lss_s, 3), round(trtab[-1][0],2)]
self.tablemodel.addRow(row)
self.tableView.model().layoutChanged.emit()
i += 1
# Calculate the critical resolution
trlst = sorted(trlst, key=lambda x:x[0])
# get min and max time
tr_min = tr_max = 0.
if len(trlst) > 0:
tr_min = trlst[0][0]
tr_max = trlst[-1][0]
# calculate resolution and critical couple
# get the peak width at base multiplying by 1.7
self.plainTextEdit.clear()
text = "Critical couples:\n"
self.plainTextEdit.appendPlainText(text)
crit_trtab = []
crit_molname = []
ncc = 0
for i in range(1, len(trlst)):
width1 = trlst[i][1] * 1.7
width2 = trlst[i-1][1] * 1.7
tr1 = trlst[i-1][0]
tr2 = trlst[i][0]
tmp_rs = (2*(tr2-tr1)) / (width1+width2)
if tmp_rs < self.crit_resolution:
molname_a = trlst[i-1][2]
molname_b = trlst[i][2]
text = " - %s %.2f min\n" % (molname_a, round(trlst[i-1][0], 2))
text += " - %s %.2f min\n" % (molname_b, round(trlst[i][0], 2))
text += "Rs: %.2f\n" % round(tmp_rs, 2)
text += "#"*20
text += "\n"
self.plainTextEdit.appendPlainText(text)
ncc += 1
if molname_a not in crit_molname:
# add to critical tr tab
a_indx = molname.index(molname_a)
crit_trtab.append(trtab.pop(a_indx))
crit_molname.append(molname.pop(a_indx))
if molname_b not in crit_molname:
b_indx = molname.index(molname_b)
crit_trtab.append(trtab.pop(b_indx))
crit_molname.append(molname.pop(b_indx))
else:
continue
self.plainTextEdit.appendPlainText("Total critical couples: %d" % (ncc))
#Create a cromatogram
peaks = BuildChromatogram(trtab, tg_soft, 0.01)
peaks = zip(*peaks)
crit_peaks = BuildChromatogram(crit_trtab, tg_soft, 0.01)
crit_peaks = zip(*crit_peaks)
y = []
x = []
for i in range(len(peaks)):
x.append(peaks[i][0])
y.append(0.)
len(peaks[0])
for j in range(1, len(peaks[0])):
y[-1] += peaks[i][j]
crit_y = []
crit_x = []
for i in range(len(crit_peaks)):
crit_x.append(crit_peaks[i][0])
crit_y.append(0.)
len(peaks[0])
for j in range(1, len(crit_peaks[0])):
crit_y[-1] += crit_peaks[i][j]
ax = self.figure.add_subplot(111)
ax.hold(False)
ax.plot(x, y, "b", crit_x, crit_y, "r")
#ax.plot(x, y, '-', color='blue')
#ax.plot(crit_x, crit_y, '-', color='red')
plt.xlabel('Time')
plt.ylabel('Signal')
plt.xlim([tr_min-((tr_min*10.)/100.), tr_max+((tr_max*10.)/100.)])
self.canvas.draw()
class Averager(QMainWindow, Ui_Averager):
def __init__(self):
super(Averager, self).__init__()
self.setupUi(self)
# state variable
self.idle = True
# number of samples to show on the plot
self.size = 8193 # max size
# buffer and offset for the incoming samples
self.buffer = bytearray(4 * self.size)
self.offset = 0
self.data = np.frombuffer(self.buffer, np.int32)
# create figure
figure = Figure()
figure.set_facecolor('none')
self.axes = figure.add_subplot(111)
self.canvas = FigureCanvas(figure)
self.plotLayout.addWidget(self.canvas)
# create navigation toolbar
self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False)
# remove subplots action
actions = self.toolbar.actions()
self.toolbar.removeAction(actions[7])
self.plotLayout.addWidget(self.toolbar)
# create TCP socket
self.socket = QTcpSocket(self)
self.socket.connected.connect(self.connected)
self.socket.readyRead.connect(self.read_data)
self.socket.error.connect(self.display_error)
self.cbShowComp.clear()
self.cbShowComp.addItems(["Real", "Imaginary", "Absolute", "Phase"])
self.cbShowComp.setCurrentIndex(2);
#connections
self.btnStart.clicked.connect(self.start)
self.txtNOA.valueChanged.connect(self.update_values)
self.txtNOS.valueChanged.connect(self.update_values)
self.chkFFT.stateChanged.connect(self.update_values)
self.chkScale.stateChanged.connect(self.update_values)
self.chkLogScale.stateChanged.connect(self.update_values)
self.cbShowComp.currentIndexChanged.connect(self.update_values)
self.isScaled = True
self.isLogScale = False
self.isFFT = False
self.haveData = False
self.showComp = 0 # Real, Imag, Abs, Phase from combo box
def update_values(self):
self.labNOA.setText(str((1<<int(self.txtNOA.text()))))
self.labNOS.setText(str((1<<int(self.txtNOS.text()))))
self.isScaled = self.chkScale.isChecked()
self.isLogScale = self.chkLogScale.isChecked()
self.isFFT = self.chkFFT.isChecked()
self.showComp = self.cbShowComp.currentIndex()
self.plot()
def start(self):
if self.idle:
print "connecting ..."
self.btnStart.setEnabled(False)
self.socket.connectToHost(self.txtIPA.text(), 1001)
else:
self.idle = True
self.socket.close()
self.offset = 0
self.btnStart.setText('Start')
self.btnStart.setEnabled(True)
print "Disconnected"
def setConfig(self):
# Number of Samples
self.size = (1<<int(self.txtNOS.text()))
self.naverages = (1<<int(self.txtNOA.text()))
#print "number of samples = " + str(self.size)
if self.idle: return
self.socket.write(struct.pack('<I', 1<<28 | int(self.txtTD.text())))
self.socket.write(struct.pack('<I', 2<<28 | int(self.txtNOS.text())))
self.socket.write(struct.pack('<I', 3<<28 | int(self.txtNOA.text())))
#print "Configuration sent"
def connected(self):
print "Connected"
self.idle = False
self.btnStart.setText('Stop')
self.btnStart.setEnabled(True)
self.setConfig()
self.fire()
def read_data(self):
size = self.socket.bytesAvailable()
print "got " + str(size)
if self.offset + size < 4*self.size:
self.buffer[self.offset:self.offset + size] = self.socket.read(size)
self.offset += size
else:
#print "have all data"
self.buffer[self.offset:4*self.size] = self.socket.read(4*self.size - self.offset)
self.offset = 0
self.haveData = True
self.plot()
self.idle = True
self.socket.close()
self.offset = 0
self.btnStart.setText('Start')
self.btnStart.setEnabled(True)
print "Disconnected"
def plot(self):
if self.haveData == False: return
# reset toolbar
self.toolbar.home()
self.toolbar._views.clear()
self.toolbar._positions.clear()
# reset plot
self.axes.clear()
self.axes.grid()
# set data
self.time_step = 1./125 # us
y_data = np.array(self.data[0:self.size], dtype=float)
N = self.size; # number of complex samples
# scale
y_data = y_data/self.naverages
x_data = np.arange(1,N+1)
xlab = "Index"
ylab = "14-bit ADC output"
if self.isScaled == True:
self.gnd = 0*-146.6
self.vcc = 1133.7;
y_data = 4.96*(y_data - self.gnd)/(self.vcc-self.gnd)
x_data = self.time_step*x_data
xlab = 'Time (us)'
ylab = 'Voltage'
if self.isFFT == True:
y_data[-1] = (y_data[0]+y_data[-2])/2
y_data = np.fft.fft(y_data)/N
x_data = np.fft.fftfreq(y_data.size, self.time_step)
x_data = np.fft.fftshift(x_data)
y_data = np.fft.fftshift(y_data)
xlab = 'Frequency (MHz)'
ylab = 'Amplitude'
if self.showComp == 0:
y_data = y_data.real
ylab = "Real " + ylab
elif self.showComp == 1:
y_data = y_data.imag
ylab = "Imag " + ylab
elif self.showComp == 2:
y_data = np.abs(y_data)
ylab = "Abs " + ylab
else:
y_data = np.angle(y_data)
ylab = "Phase " + ylab
if self.isLogScale == True:
y_data = 20*np.log10(y_data)
ylab = ylab + ' (dBV)'
else:
ylab = ylab + ' (V)'
#print str(y_data[N/2-1]) + " " + str(y_data[N/2]) + " " + str(y_data[N/2+1])
self.curve = self.axes.plot(x_data, y_data)
#x1, x2, y1, y2 = self.axes.axis()
# set y axis limits
#self.axes.axis((1, self.size, -1500,500))
self.axes.set_xlim([min(x_data), max(x_data)])
self.axes.set_xlabel(xlab)
self.axes.set_ylabel(ylab)
self.canvas.draw()
def display_error(self, socketError):
if socketError == QAbstractSocket.RemoteHostClosedError:
pass
else:
QMessageBox.information(self, 'Averager', 'Error: %s.' % self.socket.errorString())
self.btnStart.setText('Start')
self.btnStart.setEnabled(True)
def fire(self):
if self.idle: return
self.socket.write(struct.pack('<I', 0<<28))
class Window(QtGui.QWidget):
# G2 = nil
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
# self.toolbar.hide()
# Just some button
self.button = QtGui.QPushButton('Plot')
self.button.clicked.connect(self.plot)
self.button1 = QtGui.QPushButton('Zoom')
self.button1.clicked.connect(self.zoom)
self.button2 = QtGui.QPushButton('Pan')
self.button2.clicked.connect(self.pan)
self.button3 = QtGui.QPushButton('Home')
self.button3.clicked.connect(self.home)
self.button4 = QtGui.QPushButton('Home')
self.button3.clicked.connect(self.home)
# tabs = QtGui.QTabWidget()
# tab1 = QtGui.QWidget()
# tab2 = QtGui.QWidget()
# set the layout
layout = QtGui.QVBoxLayout()
layout.addWidget(self.toolbar)
layout.addWidget(self.canvas)
layout.addWidget(self.button)
layout.addWidget(self.button1)
layout.addWidget(self.button2)
layout.addWidget(self.button3)
self.setLayout(layout)
def home(self):
self.toolbar.home()
def zoom(self):
self.toolbar.zoom()
def pan(self):
self.toolbar.pan()
def addData(self, G=None):
self.G2
def plot(self):
''' plot some random stuff '''
G = nx.balanced_tree(3, 5)
pos = graphviz_layout(G, prog='twopi', args='')
# self.plt2.figure(figsize=(8, 8))
nx.draw(G,
pos,
node_size=100,
alpha=0.5,
node_color="blue",
with_labels=False)
# data = [random.random() for i in range(25)]
# ax = self.figure.add_subplot(111)
# ax.hold(False)
# ax.plot(data, '*-')
self.canvas.draw()
def addData(self, G=None):
G2 = G
print("G2 is ->", G2)
class Window(Qt.QWidget):
def __init__(self):
super(Window, self).__init__()
self.startButton = Qt.QPushButton()
self.startButton.setFixedSize(100, 100)
self.startButton.setIcon(Qt.QIcon('Green_Start.png'))
self.startButton.setIconSize(Qt.QSize(75, 75))
self.stopButton = Qt.QPushButton()
self.stopButton.setFixedSize(100, 100)
self.stopButton.setIcon(Qt.QIcon('Red_Stop.png'))
self.stopButton.setIconSize(Qt.QSize(75, 75))
self.vidThread = Qt.QThread()
self.ardThread = Qt.QThread()
self.vidThread.start()
self.ardThread.start()
self.vidTracking = VideoTracking()
self.vidTracking.moveToThread(self.vidThread)
self.arduino = Arduino()
self.arduino.moveToThread(self.ardThread)
self.stopButton.clicked.connect(lambda: self.arduino.stop())
self.stopButton.clicked.connect(lambda: self.vidTracking.stop())
self.startButton.clicked.connect(self.arduino.Run)
self.startButton.clicked.connect(self.start_pressed)
self.table = Qt.QTableWidget()
self.table_rowCount = 0
self.table.setRowCount(self.table_rowCount)
self.table.setColumnCount(6)
self.table.setHorizontalHeaderLabels([
'Trial #', 'Date', 'Start Time', 'End Time', 'Duration (sec)',
'Comments'
])
#self.table.horizontalHeader().setResizeMode(Qt.QHeaderView.Stretch)
self.table.horizontalHeader().setStretchLastSection(True)
self.table.cellChanged.connect(self.cell_was_clicked)
boldFont = Qt.QFont()
boldFont.setBold(True)
label1 = Qt.QLabel("Python Console Output")
label1.setFont(boldFont)
self.txtEdt1 = Qt.QTextEdit()
self.txtEdt1.setReadOnly(True)
# Install the custom output stream
sys.stdout = EmittingStream(textWritten=self.normalOutputWritten)
self.actButton1 = Qt.QPushButton(self.tr("&actButton1"))
self.actButton1.setCheckable(True)
self.actButton1.toggled.connect(
lambda: self.arduino.actButton1(self.actButton1.isChecked()))
self.actButton2 = Qt.QPushButton(self.tr("&actButton2"))
self.actButton2.setCheckable(True)
self.actButton2.toggled.connect(
lambda: self.arduino.actButton2(self.actButton2.isChecked()))
self.actButton3 = Qt.QPushButton(self.tr("&actButton3"))
self.actButton3.setCheckable(True)
self.actButton3.toggled.connect(
lambda: self.arduino.actButton3(self.actButton3.isChecked()))
self.actButton4 = Qt.QPushButton(self.tr("&actButton4"))
self.actButton4.setCheckable(True)
self.actButton4.toggled.connect(
lambda: self.arduino.actButton4(self.actButton4.isChecked()))
self.actButton5 = Qt.QPushButton(self.tr("&actButton5"))
self.actButton5.setCheckable(True)
self.actButton5.toggled.connect(
lambda: self.arduino.actButton5(self.actButton5.isChecked()))
self.actButton6 = Qt.QPushButton(self.tr("&actButton6"))
self.actButton6.setCheckable(True)
self.actButton6.toggled.connect(
lambda: self.arduino.actButton6(self.actButton6.isChecked()))
self.actButton7 = Qt.QPushButton(self.tr("&actButton7"))
self.actButton7.setCheckable(True)
self.actButton7.toggled.connect(
lambda: self.arduino.actButton7(self.actButton7.isChecked()))
self.actButton8 = Qt.QPushButton(self.tr("&actButton8"))
self.actButton8.setCheckable(True)
self.actButton8.toggled.connect(
lambda: self.arduino.actButton8(self.actButton8.isChecked()))
self.frame4 = Qt.QFrame()
self.frame4.setFrameStyle(1)
self.frame4.setFixedSize(350, 370)
self.arena_setup_new_edit = Qt.QPushButton("New/Edit")
self.arena_setup_new_edit.clicked.connect(self.new_edit_arena_setup)
self.arena_setup_load = Qt.QPushButton("Load")
self.arena_setup_load.clicked.connect(self.load_arena_setup)
self.arena_setup_save = Qt.QPushButton("Save")
self.arena_setup_save.clicked.connect(self.save_arena_setup)
layout6 = Qt.QHBoxLayout()
layout6.addWidget(self.arena_setup_new_edit)
layout6.addWidget(self.arena_setup_load)
layout6.addWidget(self.arena_setup_save)
self.main_frame = Qt.QWidget()
self.main_frame.setFixedSize(325, 325)
self.fig = Figure((5.0, 4.0), dpi=100)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
self.fig.canvas.mpl_connect("motion_notify_event", self.mouse_movement)
self.fig_toolbar = NavigationToolbar(self.canvas, self.main_frame)
self.fig_toolbar.hide()
self.homeBtn = Qt.QPushButton()
self.homeBtn.setFixedSize(25, 25)
self.homeBtn.setIcon(Qt.QIcon('home.png'))
self.homeBtn.setIconSize(Qt.QSize(20, 20))
self.homeBtn.clicked.connect(self.home)
self.panBtn = Qt.QPushButton()
self.panBtn.setCheckable(True)
self.panBtn.setFixedSize(25, 25)
self.panBtn.setIcon(Qt.QIcon('move.png'))
self.panBtn.setIconSize(Qt.QSize(20, 20))
self.panBtn.clicked.connect(self.pan)
self.zoomBtn = Qt.QPushButton()
self.zoomBtn.setCheckable(True)
self.zoomBtn.setFixedSize(25, 25)
self.zoomBtn.setIcon(Qt.QIcon('zoom_to_rect.png'))
self.zoomBtn.setIconSize(Qt.QSize(20, 20))
self.zoomBtn.clicked.connect(self.zoom_to_rect)
self.lblsBtn = Qt.QPushButton()
self.lblsBtn.setCheckable(True)
self.lblsBtn.setFixedSize(25, 25)
self.lblsBtn.setIcon(Qt.QIcon('label_icon.png'))
self.lblsBtn.setIconSize(Qt.QSize(20, 20))
self.lblsBtn.clicked.connect(self.show_hide_labels)
self.drawBtn = Qt.QPushButton()
self.drawBtn.setFixedSize(25, 25)
self.drawBtn.setIcon(Qt.QIcon('refresh_icon.jpeg'))
self.drawBtn.setIconSize(Qt.QSize(20, 20))
self.drawBtn.clicked.connect(self.redraw_arena_setup)
self.coords_label = Qt.QLabel()
self.coords_label.setAlignment(QtCore.Qt.AlignCenter)
self.fig_statusbar = Qt.QStatusBar()
self.fig_statusbar.setSizeGripEnabled(False)
self.fig_statusbar.addWidget(self.homeBtn)
self.fig_statusbar.addWidget(self.panBtn)
self.fig_statusbar.addWidget(self.zoomBtn)
self.fig_statusbar.addWidget(self.lblsBtn)
self.fig_statusbar.addWidget(self.drawBtn)
self.fig_statusbar.addWidget(self.coords_label, 1)
frame_layout4 = Qt.QVBoxLayout()
frame_layout4.addLayout(layout6)
frame_layout4.addWidget(self.main_frame)
frame_layout4.addWidget(self.fig_statusbar)
self.frame4.setLayout(frame_layout4)
self.radBtn1 = Qt.QRadioButton(
self.tr("Connect to Raspberry Pi Camera"))
self.radBtn1.setFont(boldFont)
self.radBtn1.setChecked(False)
self.radBtn1.toggled.connect(self.connect_to_camera)
self.radBtn4 = Qt.QRadioButton(self.tr("Video Record Trial"))
self.radBtn4.setChecked(False)
self.radBtn4.setDisabled(True)
self.radBtn4.toggled.connect(self.video_record_trial)
self.lneEdt1 = Qt.QLineEdit()
self.lneEdt1.setDisabled(True)
self.lneEdt1.setText("example_video_name.mp4")
self.lneEdt1.textChanged.connect(self.video_record_trial)
self.new_edit1 = Qt.QPushButton("New/Edit")
self.new_edit1.clicked.connect(self.new_edit_video_tracking_method)
self.new_edit1.setDisabled(True)
self.load1 = Qt.QPushButton("Load")
self.load1.clicked.connect(self.load_video_tracking_method)
self.load1.setDisabled(True)
self.save1 = Qt.QPushButton("Save")
self.save1.clicked.connect(self.save_video_tracking_method)
self.save1.setDisabled(True)
butLayout1 = Qt.QHBoxLayout()
butLayout1.addWidget(self.new_edit1)
butLayout1.addWidget(self.load1)
butLayout1.addWidget(self.save1)
self.frame1 = Qt.QFrame()
self.frame1.setFrameStyle(1)
self.frame1.setFixedSize(350, 140)
frame_layout1 = Qt.QVBoxLayout()
frame_layout1.addWidget(self.radBtn1)
frame_layout1.addLayout(butLayout1)
frame_layout1.addWidget(self.radBtn4)
frame_layout1.addWidget(self.lneEdt1)
self.frame1.setLayout(frame_layout1)
self.radBtn2 = Qt.QRadioButton(self.tr("Load Video Recording"))
self.radBtn2.setFont(boldFont)
self.radBtn2.setChecked(False)
self.radBtn2.toggled.connect(self.load_video_recording)
self.btnLneEdt1 = ButtonLineEdit()
self.btnLneEdt1.setReadOnly(True)
self.btnLneEdt1.setDisabled(True)
self.btnLneEdt1.buttonClicked.connect(self.find_video_recording)
self.vid_len_label = Qt.QLabel(
"Loaded video length / Trial Runtime (seconds):")
self.vid_len_label.setDisabled(True)
self.vid_len_spnBox = Qt.QSpinBox()
self.vid_len_spnBox.setMaximum(86400)
self.vid_len_spnBox.setDisabled(True)
vidLenLayout = Qt.QFormLayout()
vidLenLayout.addRow(self.vid_len_label, self.vid_len_spnBox)
vidLenLayout.setLabelAlignment(QtCore.Qt.AlignRight)
self.new_edit2 = Qt.QPushButton("New/Edit")
self.new_edit2.clicked.connect(self.new_edit_video_tracking_method)
self.new_edit2.setDisabled(True)
self.load2 = Qt.QPushButton("Load")
self.load2.clicked.connect(self.load_video_tracking_method)
self.load2.setDisabled(True)
self.save2 = Qt.QPushButton("Save")
self.save2.clicked.connect(self.save_video_tracking_method)
self.save2.setDisabled(True)
butLayout2 = Qt.QHBoxLayout()
butLayout2.addWidget(self.new_edit2)
butLayout2.addWidget(self.load2)
butLayout2.addWidget(self.save2)
self.frame2 = Qt.QFrame()
self.frame2.setFrameStyle(1)
self.frame2.setFixedSize(350, 145)
frame_layout2 = Qt.QVBoxLayout()
frame_layout2.addWidget(self.radBtn2)
frame_layout2.addWidget(self.btnLneEdt1)
frame_layout2.addLayout(vidLenLayout)
frame_layout2.addLayout(butLayout2)
self.frame2.setLayout(frame_layout2)
self.radBtn3 = Qt.QRadioButton(self.tr("Connect to Arduino"))
self.radBtn3.setFont(boldFont)
self.radBtn3.setChecked(False)
self.radBtn3.toggled.connect(self.connect_to_arduino)
self.new_edit3 = Qt.QPushButton("New/Edit")
self.new_edit3.clicked.connect(self.new_edit_ard_method)
self.new_edit3.setDisabled(True)
self.load3 = Qt.QPushButton("Load")
self.load3.clicked.connect(self.load_ard_method)
self.load3.setDisabled(True)
self.save3 = Qt.QPushButton("Save")
self.save3.clicked.connect(self.save_ard_method)
self.save3.setDisabled(True)
butLayout3 = Qt.QHBoxLayout()
butLayout3.addWidget(self.new_edit3)
butLayout3.addWidget(self.load3)
butLayout3.addWidget(self.save3)
self.frame3 = Qt.QFrame()
self.frame3.setFrameStyle(1)
self.frame3.setFixedSize(350, 80)
frame_layout3 = Qt.QVBoxLayout()
frame_layout3.addWidget(self.radBtn3)
frame_layout3.addLayout(butLayout3)
self.frame3.setLayout(frame_layout3)
self.group = Qt.QButtonGroup()
self.group.addButton(self.radBtn1)
self.group.addButton(self.radBtn2)
self.group.setExclusive(False)
self.lcd = QtGui.QLCDNumber()
self.lcd.setFixedSize(140, 40)
self.frame6 = Qt.QFrame()
self.frame6.setFrameStyle(1)
frame_layout6 = Qt.QHBoxLayout()
frame_layout6.addWidget(self.lcd)
self.frame6.setLayout(frame_layout6)
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.timer_time)
global s, m, h
s = 0
m = 0
h = 0
layout = Qt.QGridLayout()
layout.addWidget(self.actButton1, 0, 0)
layout.addWidget(self.actButton2, 1, 0)
layout.addWidget(self.actButton3, 0, 1)
layout.addWidget(self.actButton4, 1, 1)
layout.addWidget(self.actButton5, 0, 2)
layout.addWidget(self.actButton6, 1, 2)
layout.addWidget(self.actButton7, 0, 3)
layout.addWidget(self.actButton8, 1, 3)
layout5 = Qt.QHBoxLayout()
layout5.addWidget(self.startButton)
layout5.addWidget(self.stopButton)
self.frame5 = Qt.QFrame()
self.frame5.setFrameStyle(1)
frame_layout5 = Qt.QHBoxLayout()
frame_layout5.addLayout(layout5)
frame_layout5.addLayout(layout)
self.frame5.setLayout(frame_layout5)
layout1 = Qt.QHBoxLayout()
layout1.addWidget(self.frame5)
layout1.addWidget(self.frame6)
layout2 = Qt.QVBoxLayout()
layout2.addLayout(layout1)
layout2.addWidget(self.table)
layout2.addWidget(label1)
layout2.addWidget(self.txtEdt1)
layout5 = Qt.QVBoxLayout()
layout5.addWidget(self.canvas)
layout5.addWidget(self.fig_statusbar)
self.main_frame.setLayout(layout5)
layout3 = Qt.QVBoxLayout()
layout3.addWidget(self.frame4)
layout3.addWidget(self.frame1)
layout3.addWidget(self.frame2)
layout3.addWidget(self.frame3)
layout3.addStretch(True)
layout4 = Qt.QHBoxLayout()
layout4.addLayout(layout3)
layout4.addLayout(layout2)
self.setLayout(layout4)
global global_results, vidTrack_setup_parameters, ard_setup_parameters, arena_setup_parameters, camera, video_name, recording, record_name
global_results = {}
vidTrack_setup_parameters = None
ard_setup_parameters = None
arena_setup_parameters = None
camera = None
video_name = None
recording = False
record_name = None
def __del__(self):
# Restore sys.stdout
sys.stdout = sys.__stdout__
def normalOutputWritten(self, text):
self.txtEdt1.append(text)
def cell_was_clicked(self):
global global_results
try:
current_row = self.table.currentRow()
current_column = self.table.currentColumn()
current_item_text = self.table.currentItem().text()
if current_column == 5:
global_results[str(current_row + 1)]["trial_info"].update(
{"Comments": current_item_text})
except:
pass
def new_edit_arena_setup(self):
global arena_setup_parameters
if arena_setup_parameters == None:
try:
from setup_arena_picture import arena_setup_parameters
except:
pass
self.new_edit_arena = setup_arena_picture.Window(
cam=camera, vid_name=video_name, arena_sp=arena_setup_parameters)
self.new_edit_arena.show()
arena_setup_parameters = None
def load_arena_setup(self):
try:
global arena_setup_parameters
name = Qt.QFileDialog.getOpenFileName(self, 'Load Arena Setup')
with open(name, 'r') as f:
arena_setup_parameters = eval(f.read())
print("loaded arena setup: %s" % (arena_setup_parameters))
except:
pass
def save_arena_setup(self):
global arena_setup_parameters
try:
try:
from setup_arena_picture import arena_setup_parameters
except:
pass
name = Qt.QFileDialog.getSaveFileName(self, 'Save Arena Setup')
with open(name, 'w') as text_file:
text_file.write(str(arena_setup_parameters))
print("arena setup saved %s" % (arena_setup_parameters))
except:
pass
def home(self):
self.fig_toolbar.home()
def pan(self):
self.fig_toolbar.pan()
def zoom_to_rect(self):
self.fig_toolbar.zoom()
def show_hide_labels(self):
global arena_setup_parameters
if self.lblsBtn.isChecked():
# add labels to the grid squares
self.grid_labels = []
for j in range(self.num_height_divs):
y = self.height_div / 2 + j * self.height_div
for i in range(self.num_width_divs):
x = self.width_div / 2. + float(i) * self.width_div
if arena_setup_parameters['arena_pic_name'] != "no picture":
grid_label = self.axes.text(x,
y, ("(%d,%d)" % (i, j)),
fontsize=6,
color='w',
ha='center',
va='center')
else:
grid_label = self.axes.text(x,
y, ("(%d,%d)" % (i, j)),
fontsize=6,
color='b',
ha='center',
va='center')
self.grid_labels.append(grid_label)
self.canvas.draw()
elif not self.lblsBtn.isChecked():
for label in self.grid_labels:
label.remove()
self.canvas.draw()
def redraw_arena_setup(self):
global arena_setup_parameters
if arena_setup_parameters == None:
from setup_arena_picture import arena_setup_parameters
self.lblsBtn.setChecked(False)
self.arena_pic_name = arena_setup_parameters['arena_pic_name']
try:
self.arena_pic = mpimg.imread(self.arena_pic_name)
except:
pass
self.arena_width = arena_setup_parameters['arena_width']
self.arena_height = arena_setup_parameters['arena_height']
self.width_div = arena_setup_parameters['width_div']
self.height_div = arena_setup_parameters['height_div']
self.num_width_divs = int(round(self.arena_width / self.width_div, 0))
self.num_height_divs = int(
round(self.arena_height / self.height_div, 0))
self.fig.clear()
self.axes = self.fig.add_subplot(111)
try:
self.axes.imshow(self.arena_pic,
origin="lower",
extent=(0, self.arena_width, 0,
self.arena_height))
except:
npArray = np.array([[[0, 0, 0, 0]]], dtype="uint8")
self.axes.imshow(npArray,
origin="lower",
extent=(0, self.arena_width, 0,
self.arena_height))
self.axes.set_xticks(
np.arange(0, (self.arena_width + self.width_div), self.width_div))
self.axes.set_yticks(
np.arange(0, (self.arena_height + self.height_div),
self.height_div))
self.axes.tick_params(axis="both", which="major", labelsize="6")
self.axes.grid(which="major", axis="both", linestyle='-', color='r')
self.axes.xaxis.tick_top()
self.axes.invert_yaxis()
self.axes.set_xlabel("Arena Width (cm)", fontsize=8)
self.axes.set_ylabel("Arena Height (cm)", fontsize=8)
self.axes.tick_params(axis="both", which="major", labelsize=6)
self.canvas.draw()
def mouse_movement(self, event):
try:
self.coords_label.setText("x=%.3f, y=%.3f" %
(event.xdata, event.ydata))
except:
if not self.coords_label.text == "":
self.coords_label.setText("")
else:
pass
def connect_to_camera(self):
global camera, vidTrack_setup_parameters
if self.radBtn1.isChecked():
camera = True
self.new_edit1.setDisabled(False)
self.load1.setDisabled(False)
self.save1.setDisabled(False)
self.radBtn4.setDisabled(False)
self.radBtn2.setChecked(False)
#self.load_video_recording()
elif not self.radBtn1.isChecked():
camera = None
vidTrack_setup_parameters = None
self.new_edit1.setDisabled(True)
self.load1.setDisabled(True)
self.save1.setDisabled(True)
self.radBtn4.setDisabled(True)
self.lneEdt1.setDisabled(True)
def new_edit_video_tracking_method(self):
global camera, video_name, vidTrack_setup_parameters
if vidTrack_setup_parameters == None:
try:
from Camera_Wizard_v2 import vidTrack_setup_parameters
except:
pass
self.cwiz = Camera_Wizard_v2.CameraWizard(
cam=camera,
vid_name=video_name,
vidTrack_sp=vidTrack_setup_parameters)
self.cwiz.show()
vidTrack_setup_parameters = None
def load_video_tracking_method(self):
try:
global vidTrack_setup_parameters
name = Qt.QFileDialog.getOpenFileName(self,
'Load Video Tracking Setup')
with open(name, 'r') as f:
vidTrack_setup_parameters = eval(f.read())
print("loaded video tracking setup: %s" %
(vidTrack_setup_parameters))
except:
pass
def save_video_tracking_method(self):
global vidTrack_setup_parameters
try:
if vidTrack_setup_parameters == None:
try:
from Camera_Wizard_v2 import vidTrack_setup_parameters
except:
pass
name = Qt.QFileDialog.getSaveFileName(self,
'Save Video Tracking Setup')
with open(name, 'w') as text_file:
text_file.write(str(vidTrack_setup_parameters))
print("video tracking setup saved %s" %
(vidTrack_setup_parameters))
except:
pass
def video_record_trial(self):
global recording, record_name
if self.radBtn4.isChecked():
self.lneEdt1.setDisabled(False)
recording = True
record_name = self.lneEdt1.text()
elif not self.radBtn4.isChecked():
self.lneEdt1.setDisabled(True)
recording = False
record_name = None
def load_video_recording(self):
global video_name, vidTrack_setup_parameters
if self.radBtn2.isChecked():
self.btnLneEdt1.setDisabled(False)
self.radBtn4.setChecked(False)
self.radBtn4.setDisabled(False)
self.radBtn1.setChecked(False)
#self.connect_to_camera()
elif not self.radBtn2.isChecked():
video_name = None
vidTrack_setup_parameters = None
self.btnLneEdt1.clear()
self.btnLneEdt1.setDisabled(True)
self.vid_len_label.setDisabled(True)
self.vid_len_spnBox.clear()
self.vid_len_spnBox.setDisabled(True)
self.new_edit2.setDisabled(True)
self.load2.setDisabled(True)
self.save2.setDisabled(True)
def find_video_recording(self):
try:
global video_name
video_name = Qt.QFileDialog.getOpenFileName(
self, 'Find Video Recording')
self.btnLneEdt1.setText(video_name)
self.vid_len_label.setDisabled(False)
self.vid_len_spnBox.setDisabled(False)
self.new_edit2.setDisabled(False)
self.load2.setDisabled(False)
self.save2.setDisabled(False)
print("video name: %s" % (video_name))
except:
pass
def connect_to_arduino(self):
global a, ard_setup_parameters
if self.radBtn3.isChecked():
try:
from nanpy import (SerialManager, ArduinoApi)
connection = SerialManager()
a = ArduinoApi(connection=connection)
self.new_edit3.setDisabled(False)
self.load3.setDisabled(False)
self.save3.setDisabled(False)
except:
print("Failed to connect to Arduino")
self.radBtn3.setChecked(False) # change back to False
elif not self.radBtn3.isChecked():
try:
del a
except:
pass
ard_setup_parameters = None
self.new_edit3.setDisabled(True)
self.load3.setDisabled(True)
self.save3.setDisabled(True)
def new_edit_ard_method(self):
global ard_setup_parameters
if ard_setup_parameters == None:
try:
from Arduino_Wizard_v2 import ard_setup_parameters
except:
pass
self.awiz = Arduino_Wizard_v2.ArduinoWizard(
arduino_sp=ard_setup_parameters)
self.awiz.show()
ard_setup_parameters = None
def load_ard_method(self):
global ard_setup_parameters
try:
name = Qt.QFileDialog.getOpenFileName(self, 'Load DAAC setup')
with open(name, 'r') as f:
ard_setup_parameters = eval(f.read())
print("loaded DAAC setup: %s" % (ard_setup_parameters))
except:
pass
def save_ard_method(self):
global ard_setup_parameters
try:
if ard_setup_parameters == None:
try:
from Arduino_Wizard_v2 import ard_setup_parameters
except:
pass
name = Qt.QFileDialog.getSaveFileName(self, 'Save DAAC setup')
with open(name, 'w') as text_file:
text_file.write(str(ard_setup_parameters))
print("DAAC setup saved %s" % (ard_setup_parameters))
except:
pass
def timer_start(self):
global s, m, h
self.timer.start(1000)
def timer_time(self):
global s, m, h
if s < 59:
s += 1
else:
if m < 59:
s = 0
m += 1
elif m == 59 and h < 24:
h += 1
m = 0
s = 0
else:
self.timer.stop()
time = "{0}:{1}:{2}".format(h, m, s)
self.lcd.setDigitCount(len(time))
self.lcd.display(time)
self.activateWindow()
def timer_reset(self):
global s, m, h
self.timer.stop()
s = 0
m = 0
h = 0
time = "{0}:{1}:{2}".format(h, m, s)
self.lcd.setDigitCount(len(time))
self.lcd.display(time)
def start_pressed(self):
global global_results, ard_results, _isRunning2, vidTrack_setup_parameters, ard_setup_parameters
date = strftime("%Y-%m-%d")
start_time = strftime("%H:%M:%S")
self.timer_reset()
self.timer_start()
if (self.radBtn1.isChecked() or self.radBtn2.isChecked()):
trck = self.vidTracking.Run()
while _isRunning2:
Qt.qApp.processEvents()
self.timer.stop()
end_time = strftime("%H:%M:%S")
self.actButton1.setChecked(False)
self.actButton2.setChecked(False)
self.actButton3.setChecked(False)
self.actButton4.setChecked(False)
self.actButton5.setChecked(False)
self.actButton6.setChecked(False)
self.actButton7.setChecked(False)
self.actButton8.setChecked(False)
vidTrack_results = {}
trial_info = {}
try:
if (vidTrack_setup_parameters['video_tracking_algorithm']
== "Frame Differencing") or (
vidTrack_setup_parameters['video_tracking_algorithm']
== "MOG"):
if self.radBtn1.isChecked() or (
self.radBtn2.isChecked() and
(int(self.vid_len_spnBox.value() == 0))):
vidTrack_results['run_time'] = trck[2]
trial_info['Trial_Duration'] = trck[2][-1]
vidTrack_results['vid_pts_time'] = trck[0]
elif self.radBtn2.isChecked() and (int(
self.vid_len_spnBox.value()) != 0):
video_time_calibration_factor = trck[2][-1] / int(
self.vid_len_spnBox.value())
vidTrack_results['run_time'] = []
for time in trck[2]:
mod_time = round(time / video_time_calibration_factor,
2)
vidTrack_results['run_time'].append(mod_time)
trial_info['Trial_Duration'] = vidTrack_results[
'run_time'][-1]
vidTrack_results['vid_pts_time'] = []
for time in trck[0]:
mod_time = round(time / video_time_calibration_factor,
2)
vidTrack_results["vid_pts_time"].append(mod_time)
vidTrack_results['position'] = trck[1]
elif vidTrack_setup_parameters[
'video_tracking_algorithm'] == "None":
if self.radBtn1.isChecked() or (
self.radBtn2.isChecked() and
(int(self.vid_len_spnBox.value()) == 0)):
vidTrack_results['run_time'] = trck
trial_info['Trial_Duration'] = trck[-1]
elif self.radBtn2.isChecked() and (int(
self.vid_len_spnBox.value()) != 0):
video_time_calibration_factor = (
trck[-1] / int(self.vid_len_spnBox.value()))
vidTrack_results['vid_pts_time'] = []
for time in trck[0]:
mod_time = round(time / video_time_calibration_factor,
2)
vidTrack_results['vid_pts_time'].append(mod_time)
trial_info['Trial_Duration'] = vidTrack_results[
'run_time'][-1]
except:
pass
try:
try:
duration = str(trial_info['Trial_Duration'])
except:
duration = str(ard_results['ard_loop_time'][-1])
except:
duration = str(0)
trial_info["Date"] = date
trial_info["Start_Time"] = start_time
trial_info["End_Time"] = end_time
trial_info["Trial_Duration"] = duration
self.table_rowCount += 1
self.table.setRowCount(self.table_rowCount)
global_results[str(self.table_rowCount)] = {}
global_results[str(self.table_rowCount)]["trial_info"] = trial_info
try:
global_results[str(
self.table_rowCount)]["results"] = vidTrack_results
global_results[str(
self.table_rowCount)]["results"].update(ard_results)
try:
ard_results = {}
global_results[str(
self.table_rowCount)]["results"].update(ard_results)
except:
pass
except:
pass
self.table.setItem(self.table_rowCount - 1, 0,
Qt.QTableWidgetItem(str(self.table_rowCount)))
self.table.setItem(self.table_rowCount - 1, 1,
Qt.QTableWidgetItem(date))
self.table.setItem(self.table_rowCount - 1, 2,
Qt.QTableWidgetItem(start_time))
self.table.setItem(self.table_rowCount - 1, 3,
Qt.QTableWidgetItem(end_time))
self.table.setItem(self.table_rowCount - 1, 4,
Qt.QTableWidgetItem(duration))
class Window(QtGui.QDialog):
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.setAcceptDrops(True)
self.figure = plt.figure()
# --- Just for fun lets start with nice picture
img = mpimg.imread('./bq_t4_sys/thor.png')
ax = plt.Axes(self.figure,[0.,0.,1.,1.])
ax.set_axis_off()
self.figure.add_axes(ax)
plt.imshow(img,cmap=cm.get_cmap('gray'))
# ---------------------------------------------
self.canvas = FigureCanvas(self.figure)
# ---------------------------------------------
self.toolbar = NavigationToolbar(self.canvas, self)
# ---------------------------------------------
self.slider = QtGui.QSlider(orientation=Qt.Qt.Horizontal)
self.slider.setTickInterval(1)
self.slider.valueChanged.connect(self.plot)
# ----------------------------------------------
self.view_combo = QtGui.QComboBox(self)
self.view_combo.activated[str].connect(self.changeView)
self.view_combo.addItem('X-Y')
self.view_combo.addItem('X-Z')
self.view_combo.addItem('Y-Z')
self.view = 'X-Y'
self.slide_dimension = 2 # will slide by default though z
self.combo = QtGui.QComboBox(self)
self.combo.activated[str].connect(self.comboActivated)
# -- check box
self.hbox = QtGui.QHBoxLayout()
# self.hbox.addStretch(1)
self.back_button = QtGui.QPushButton('<',self)
self.back_button.clicked.connect(self.goBack)
self.next_button = QtGui.QPushButton('>',self)
self.next_button.clicked.connect(self.goNext)
self.check_abs = QtGui.QCheckBox('Absolute')
# self.check_abs.toggle()
self.check_abs.stateChanged.connect(self.plot)
self.check_bw = QtGui.QCheckBox('B&W')
# self.check_bw.toggle()
self.check_bw.stateChanged.connect(self.plot)
self.check_log = QtGui.QCheckBox('Log')
# self.check_log.toggle()
self.check_log.stateChanged.connect(self.plot)
self.check_si = QtGui.QCheckBox('CGS Units')
self.check_si.toggle()
self.check_si.stateChanged.connect(self.plot)
self.check_aux = QtGui.QCheckBox('No AUX')
self.check_aux.toggle()
self.check_aux.stateChanged.connect(self.reset_bifrost_obj)
self.hbox.addWidget(self.check_si)
self.hbox.addWidget(self.check_abs)
self.hbox.addWidget(self.check_log)
self.hbox.addWidget(self.check_bw)
self.hbox.addWidget(self.check_aux)
self.hbox.addWidget(self.back_button)
self.hbox.addWidget(self.next_button)
self.hbox.addWidget(self.combo)
self.hbox.addWidget(self.view_combo)
# set the layout
layout = QtGui.QVBoxLayout()
layout.addWidget(self.toolbar)
layout.addLayout(self.hbox)
layout.addWidget(self.canvas)
layout.addWidget(self.slider)
self.setLayout(layout)
# actual data stuff
self.fpath = first_file_name
# self.data = np.einsum('ijk->kji', self.data)
self.tag = 'r'
if (first_file_name != "no_file"):
self.param = get_bifrost_param(self.fpath,0)
self.b, self.base_name, self.snap_n = get_bifrost_obj(self.fpath,0, self.check_aux.isChecked())
self.data = self.b.getvar(self.tag)
self.slide_dimension = 2
self.slider.setMinimum(0)
self.slider.setMaximum(self.data.shape[self.slide_dimension]-1)
if (first_slice != -1):
self.slider.setValue(first_slice)
if (first_depth != -1000.0):
self.slider.setValue(np.argmax( self.b.z >= first_depth ))
if self.slider.value() >= self.data.shape[self.slide_dimension]:
self.slider.setValue(self.data.shape[self.slide_dimension]-1)
elif self.slider.value() < 0:
self.slider.setValue(0)
self.setCombo()
self.plot()
else:
print "\t[!] Drag & Drop a snap file to plot its content"
def keyPressEvent(self, event):
key = event.key
if key == Qt.Qt.Key_Right:
self.slider.setValue(self.slider.value() + 1)
elif key == Qt.Qt.Key_Left:
self.slider.setValue(self.slider.value() - 1)
def goBack(self):
self.param = get_bifrost_param(self.fpath,-1)
self.b, self.base_name, self.snap_n = get_bifrost_obj(self.fpath,-1, self.check_aux.isChecked())
self.get_data()
self.plot()
where_str, base_name, snap_n = process_file_name(self.fpath)
snap_n = str(int(snap_n) - 1)
self.fpath = where_str + base_name + '_' + snap_n + '.snap'
pass
def goNext(self):
self.param = get_bifrost_param(self.fpath,1)
self.b, self.base_name, self.snap_n = get_bifrost_obj(self.fpath,1,self.check_aux.isChecked())
self.get_data()
self.plot()
where_str, base_name, snap_n = process_file_name(self.fpath)
snap_n = str(int(snap_n) + 1)
self.fpath = where_str + base_name + '_' + snap_n + '.snap'
pass
def setCombo(self):
self.combo.clear()
for tag in self.b.snapvars:
self.combo.addItem(tag)
if not self.check_aux.isChecked():
for tag in self.b.auxvars:
self.combo.addItem(tag)
def changeView(self, text):
self.view = text
self.get_data()
self.plot()
print 'View changed to: ', self.view
def comboActivated(self, text):
self.tag = text
self.data = self.b.getvar(self.tag)
self.plot()
def reset_bifrost_obj(self):
self.b, self.base_name, self.snap_n = get_bifrost_obj(self.fpath,0,self.check_aux.isChecked())
print self.b.snapvars
self.get_data()
def get_data(self):
self.data = self.b.getvar(self.tag)
if self.view == 'X-Y':
self.slide_dimension = 2
elif self.view == 'X-Z':
self.slide_dimension = 1
elif self.view == 'Y-Z':
self.slide_dimension = 0
self.slider.setMinimum(0)
self.slider.setMaximum(self.data.shape[self.slide_dimension]-1)
if self.slider.value() >= self.data.shape[self.slide_dimension]:
self.slider.setValue(self.data.shape[self.slide_dimension]-1)
elif self.slider.value() < 0:
self.slider.setValue(0)
self.setCombo()
def home(self):
self.toolbar.home()
def zoom(self):
self.toolbar.zoom()
def pan(self):
self.toolbar.pan()
def plot(self):
plt.clf()
ax = self.figure.add_subplot(111)
slice_str = '[?]'
# extension = []
if self.view == 'X-Y':
image = self.data[:,:,self.slider.value()]
slice_str = 'z = %f ' % self.b.z[self.slider.value()]
ax.set_ylabel('y-direction')
ax.set_xlabel('x-direction')
# extension = [0, self.param['mx'], 0, self.param['my']]
elif self.view == 'X-Z':
image = self.data[:,self.slider.value(),:]
slice_str = 'y = %f ' % self.b.y[self.slider.value()]
ax.set_ylabel('z-direction')
ax.set_xlabel('x-direction')
# extension = [0, self.param['mx'], 0, self.param['mz']]
elif self.view == 'Y-Z':
image = self.data[self.slider.value(),:,:]
slice_str = 'x = %f ' % self.b.x[self.slider.value()]
ax.set_ylabel('z-direction')
ax.set_xlabel('y-direction')
# extension = [0, self.param['my'], 0, self.param['mz']]
# image = np.fliplr(image)
# image = np.rot90(image,k=3)
label = "Value"
color = cm.get_cmap('jet')
ax.set_title("[%s] %s (Snap: %s) for %s \n[time: %s]" % (self.tag, self.base_name, self.snap_n, slice_str, str(datetime.timedelta(seconds=self.param['t']*self.param['u_t']))))
# ax.xaxis.set_major_locator(ticker.MultipleLocator(int(64)))
# ax.yaxis.set_major_locator(ticker.MultipleLocator(int(64)))
if self.check_si.isChecked():
if self.tag == 'r':
image = image * self.param['u_r']
unit_label = "[g/cm3]"
label = "Value %s" % unit_label
elif (self.tag == 'bx' or self.tag == 'by' or self.tag == 'bz'):
image = image * self.param['u_b']
unit_label = "[G]"
label = "Value %s" % unit_label
elif (self.tag == 'px' or self.tag == 'py' or self.tag == 'pz'):
image = image * self.param['u_p']
unit_label = "[Ba]"
label = "Value %s" % unit_label
elif self.tag == 'e':
image = image * self.param['u_e']
unit_label = "[erg]"
label = "Value %s" % unit_label
if self.check_abs.isChecked():
image = np.absolute(image)
label = "ABS( %s )" % label
if self.check_log.isChecked():
image = np.log10(image)
label = "Log10( %s )" % label
if self.check_bw.isChecked():
# color = cm.get_cmap('gist_yarg')
color = cm.get_cmap('Greys_r') # Mats favorite color palette
if self.view == 'X-Y':
ax.set_ylabel('y-direction [Mm]')
ax.set_xlabel('x-direction [Mm]')
im = NonUniformImage(ax, interpolation='bilinear', extent=(self.b.x.min(),self.b.x.max(),self.b.y.min(),self.b.y.max()), cmap=color)
im.set_data(self.b.x, self.b.y, np.fliplr(zip(*image[::-1])))
ax.images.append(im)
ax.set_xlim(self.b.x.min(),self.b.x.max())
ax.set_ylim(self.b.y.min(),self.b.y.max())
ax.xaxis.set_major_locator(ticker.MultipleLocator(int(4)))
ax.yaxis.set_major_locator(ticker.MultipleLocator(int(4)))
elif self.view == 'X-Z':
ax.set_ylabel('z-direction [Mm]')
ax.set_xlabel('x-direction [Mm]')
im = NonUniformImage(ax, interpolation='bilinear', extent=(self.b.x.min(),self.b.x.max(),self.b.z.min(),self.b.z.max()), cmap=color)
im.set_data(self.b.x, self.b.z[::-1], np.flipud(np.fliplr(zip(*image[::-1]))))
ax.images.append(im)
ax.set_xlim(self.b.x.min(),self.b.x.max())
ax.set_ylim(self.b.z.max(),self.b.z.min())
ax.xaxis.set_major_locator(ticker.MultipleLocator(int(4)))
ax.yaxis.set_major_locator(ticker.MultipleLocator(int(2)))
elif self.view == 'Y-Z':
ax.set_ylabel('z-direction [Mm]')
ax.set_xlabel('y-direction [Mm]')
im = NonUniformImage(ax, interpolation='bilinear', extent=(self.b.y.min(),self.b.y.max(),self.b.z.min(),self.b.z.max()), cmap=color)
im.set_data(self.b.y, self.b.z[::-1], np.flipud(np.fliplr(zip(*image[::-1]))))
ax.images.append(im)
ax.set_xlim(self.b.y.min(),self.b.y.max())
ax.set_ylim(self.b.z.max(),self.b.z.min())
ax.xaxis.set_major_locator(ticker.MultipleLocator(int(4)))
ax.yaxis.set_major_locator(ticker.MultipleLocator(int(2)))
# im = ax.imshow(image, interpolation='none', origin='lower', cmap=color, extent=extension)
# ax.text(0.025, 0.025, (r'$\langle B_{z} \rangle = %2.2e$'+'\n'+r'$\langle |B_{z}| \rangle = %2.2e$') % (np.average(img),np.average(np.absolute(img))), ha='left', va='bottom', transform=ax.transAxes)
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.05)
plt.colorbar(im, cax=cax,label=label)
self.canvas.draw()
def dragEnterEvent(self, event):
if event.mimeData().hasUrls():
event.accept()
else:
event.ignore()
def dropEvent(self, event):
for url in event.mimeData().urls():
path = url.toLocalFile().toLocal8Bit().data()
if os.path.isfile(path):
self.fpath = path
self.param = get_bifrost_param(self.fpath,0)
self.b, self.base_name, self.snap_n = get_bifrost_obj(self.fpath,0, self.check_aux.isChecked())
self.get_data()
self.plot()
class Window(QtGui.QDialog):
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.toolbar.hide()
# Just some button
self.button = QtGui.QPushButton('Plot')
self.button.clicked.connect(self.plot)
self.button1 = QtGui.QPushButton('Zoom')
self.button1.clicked.connect(self.zoom)
self.button2 = QtGui.QPushButton('Pan')
self.button2.clicked.connect(self.pan)
self.button3 = QtGui.QPushButton('Home')
self.button3.clicked.connect(self.home)
# set the layout
layout = QtGui.QVBoxLayout()
layout.addWidget(self.toolbar)
layout.addWidget(self.canvas)
layout.addWidget(self.button)
layout.addWidget(self.button1)
layout.addWidget(self.button2)
layout.addWidget(self.button3)
self.setLayout(layout)
def home(self):
self.toolbar.home()
def zoom(self):
self.toolbar.zoom()
def pan(self):
self.toolbar.pan()
def plot(self):
''' DO NOT CHANGE. Original sample '''
#data = [random.random() for i in range(25)]
#ax = self.figure.add_subplot(111) # create an axis
#ax.hold(False) # discards the old graph
#ax.plot(data, '*-') # plot data
#self.canvas.draw() # refresh canvas
ra = [45, 40, 90, -75, 80.2,
102.63] # angle --> change to buffer_angle[4000]
ra = [x / 180.0 * 3.141593 for x in ra] # convert angle to radian
dec = [1.01, 6.05, 5.6, 4.02, 9.1,
7.85] # distance --> change to buffer_distance[4000]
ax = self.figure.add_axes([0.1, 0.1, 0.8, 0.8], polar=True)
ax.set_ylim(0, 10.0)
ax.set_yticks(numpy.arange(0, 6, 2))
ax.scatter(ra, dec, c='r') # plot the first microphone
self.canvas.draw()
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.resize(1150, 655)
MainWindow.setMinimumSize(QtCore.QSize(1500, 250))
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
self.gridLayout = QtGui.QGridLayout(self.centralwidget)
self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
self.pushButton_2 = QtGui.QPushButton(self.centralwidget)
self.pushButton_2.setMinimumSize(QtCore.QSize(0, 30))
self.pushButton_2.setMaximumSize(QtCore.QSize(70, 16777215))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.pushButton_2.setFont(font)
self.pushButton_2.setLayoutDirection(QtCore.Qt.RightToLeft)
self.pushButton_2.setObjectName(_fromUtf8("pushButton_2"))
self.pushButton_2.clicked.connect(self.zoom) ########### zoom 함수 연결
self.gridLayout.addWidget(self.pushButton_2, 2, 1, 1, 1)
self.pushButton = QtGui.QPushButton(self.centralwidget)
self.pushButton.setMinimumSize(QtCore.QSize(0, 30))
self.pushButton.setMaximumSize(QtCore.QSize(70, 16777215))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.pushButton.setFont(font)
self.pushButton.setLayoutDirection(QtCore.Qt.RightToLeft)
self.pushButton.setObjectName(_fromUtf8("pushButton"))
self.pushButton.clicked.connect(self.pan) ###########pan 함수 연결
self.gridLayout.addWidget(self.pushButton, 2, 2, 1, 1)
self.pushButton_3 = QtGui.QPushButton(self.centralwidget)
self.pushButton_3.setMinimumSize(QtCore.QSize(0, 30))
self.pushButton_3.setMaximumSize(QtCore.QSize(70, 16777215))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.pushButton_3.setFont(font)
self.pushButton_3.setLayoutDirection(QtCore.Qt.RightToLeft)
self.pushButton_3.setObjectName(_fromUtf8("pushButton_3"))
self.pushButton_3.clicked.connect(self.home) ##########home 함수 연결
self.gridLayout.addWidget(self.pushButton_3, 2, 3, 1, 1)
self.frame_4 = QtGui.QFrame(self.centralwidget)
self.frame_4.setMinimumSize(QtCore.QSize(150, 0))
self.frame_4.setMaximumSize(QtCore.QSize(16777215, 40))
self.frame_4.setFrameShape(QtGui.QFrame.StyledPanel)
self.frame_4.setFrameShadow(QtGui.QFrame.Plain)
self.frame_4.setLineWidth(1)
self.frame_4.setObjectName(_fromUtf8("frame_4"))
self.horizontalLayout = QtGui.QHBoxLayout(self.frame_4)
self.horizontalLayout.setContentsMargins(-1, 0, -1, -1)
self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
self.label = QtGui.QLabel(self.frame_4)
self.label.setMinimumSize(QtCore.QSize(0, 35))
self.label.setMaximumSize(QtCore.QSize(40, 30))
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.label.setFont(font)
self.label.setAlignment(QtCore.Qt.AlignCenter)
self.label.setObjectName(_fromUtf8("label"))
self.horizontalLayout.addWidget(self.label)
self.dateEdit = QtGui.QDateEdit(self.frame_4)
self.dateEdit.setMinimumSize(QtCore.QSize(0, 30))
self.dateEdit.setMaximumSize(QtCore.QSize(121, 20))
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.dateEdit.setFont(font)
self.dateEdit.setAlignment(QtCore.Qt.AlignCenter)
self.dateEdit.setObjectName(_fromUtf8("dateEdit"))
self.dateEdit.setDateTime(
QtCore.QDateTime.currentDateTime()) ########## 현재 날짜로 업데이트
self.dateEdit.setCalendarPopup(True) ########## 캘린더 팝업
self.dateEdit.dateChanged.connect(
self.ShowDate) ########## 선택한 날짜로 데이터 업데이트
self.horizontalLayout.addWidget(self.dateEdit)
self.label_2 = QtGui.QLabel(self.frame_4)
self.label_2.setMinimumSize(QtCore.QSize(0, 35))
self.label_2.setMaximumSize(QtCore.QSize(81, 30))
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.label_2.setFont(font)
self.label_2.setAlignment(QtCore.Qt.AlignCenter)
self.label_2.setObjectName(_fromUtf8("label_2"))
self.horizontalLayout.addWidget(self.label_2)
self.textEdit = QtGui.QTextEdit(self.frame_4)
self.textEdit.setMinimumSize(QtCore.QSize(600, 30))
self.textEdit.setMaximumSize(QtCore.QSize(16777215, 20))
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.textEdit.setFont(font)
self.textEdit.setFrameShape(QtGui.QFrame.StyledPanel)
self.textEdit.setObjectName(_fromUtf8("textEdit"))
self.horizontalLayout.addWidget(self.textEdit)
self.comboBox = QtGui.QComboBox(self.frame_4)
self.comboBox.setMinimumSize(QtCore.QSize(0, 30))
self.comboBox.setMaximumSize(QtCore.QSize(16777215, 20))
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(True)
font.setWeight(75)
self.comboBox.setFont(font)
self.comboBox.setObjectName(_fromUtf8("comboBox"))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.addItem(_fromUtf8(""))
self.comboBox.activated.connect(self.convert_utc)
self.horizontalLayout.addWidget(self.comboBox)
self.gridLayout.addWidget(self.frame_4, 0, 0, 1, 4)
self.verticalLayout = QtGui.QVBoxLayout()
self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
self.fig = plt.figure() ########## figure 만들기
self.canvas = FigureCanvas(self.fig) ########## canvas 만들기
self.verticalLayout.addWidget(self.canvas) ########## figure 삽입
self.toolbar = NavigationToolbar(self.canvas,
MainWindow) ##########툴바 생성
self.toolbar.hide() ##########툴바 숨김
self.gridLayout.addLayout(self.verticalLayout, 1, 0, 1, 4)
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtGui.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 1150, 21))
self.menubar.setObjectName(_fromUtf8("menubar"))
self.menuOpen = QtGui.QMenu(self.menubar)
self.menuOpen.setObjectName(_fromUtf8("menuOpen"))
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtGui.QStatusBar(MainWindow)
self.statusbar.setObjectName(_fromUtf8("statusbar"))
MainWindow.setStatusBar(self.statusbar)
self.actionFile = QtGui.QAction(MainWindow)
self.actionFile.setObjectName(_fromUtf8("actionFile"))
self.actionFile.triggered.connect(
self.OpenFile) ########## OpenFile 연결
self.actionDirectory = QtGui.QAction(MainWindow)
self.actionDirectory.setObjectName(_fromUtf8("actionDirectory"))
self.actionDirectory.triggered.connect(
self.OpenDirectory) ########## OpenDirectory 연결
self.menuOpen.addAction(self.actionFile)
self.menuOpen.addAction(self.actionDirectory)
self.menubar.addAction(self.menuOpen.menuAction())
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow", None))
self.pushButton_2.setText(_translate("MainWindow", "ZOOM", None))
self.pushButton.setText(_translate("MainWindow", "PAN", None))
self.pushButton_3.setText(_translate("MainWindow", "HOME", None))
self.label.setText(_translate("MainWindow", "Date", None))
self.label_2.setText(_translate("MainWindow", "Duration", None))
self.comboBox.setCurrentIndex(14)
self.comboBox.setItemText(0,
_translate("MainWindow", "UTC -12:00", None))
self.comboBox.setItemText(1,
_translate("MainWindow", "UTC -11:00", None))
self.comboBox.setItemText(2,
_translate("MainWindow", "UTC -10:00", None))
self.comboBox.setItemText(3,
_translate("MainWindow", "UTC -09:30", None))
self.comboBox.setItemText(4,
_translate("MainWindow", "UTC -09:00", None))
self.comboBox.setItemText(5,
_translate("MainWindow", "UTC -08:00", None))
self.comboBox.setItemText(6,
_translate("MainWindow", "UTC -07:00", None))
self.comboBox.setItemText(7,
_translate("MainWindow", "UTC -06:00", None))
self.comboBox.setItemText(8,
_translate("MainWindow", "UTC -05:00", None))
self.comboBox.setItemText(9,
_translate("MainWindow", "UTC -04:00", None))
self.comboBox.setItemText(10,
_translate("MainWindow", "UTC -03:30", None))
self.comboBox.setItemText(11,
_translate("MainWindow", "UTC -03:00", None))
self.comboBox.setItemText(12,
_translate("MainWindow", "UTC -02:00", None))
self.comboBox.setItemText(13,
_translate("MainWindow", "UTC -01:00", None))
self.comboBox.setItemText(14,
_translate("MainWindow", "UTC +00:00", None))
self.comboBox.setItemText(15,
_translate("MainWindow", "UTC +01:00", None))
self.comboBox.setItemText(16,
_translate("MainWindow", "UTC +02:00", None))
self.comboBox.setItemText(17,
_translate("MainWindow", "UTC +03:00", None))
self.comboBox.setItemText(18,
_translate("MainWindow", "UTC +03:30", None))
self.comboBox.setItemText(19,
_translate("MainWindow", "UTC +04:00", None))
self.comboBox.setItemText(20,
_translate("MainWindow", "UTC +04:30", None))
self.comboBox.setItemText(21,
_translate("MainWindow", "UTC +05:00", None))
self.comboBox.setItemText(22,
_translate("MainWindow", "UTC +05:30", None))
self.comboBox.setItemText(23,
_translate("MainWindow", "UTC +05:45", None))
self.comboBox.setItemText(24,
_translate("MainWindow", "UTC +06:00", None))
self.comboBox.setItemText(25,
_translate("MainWindow", "UTC +06:30", None))
self.comboBox.setItemText(26,
_translate("MainWindow", "UTC +07:00", None))
self.comboBox.setItemText(27,
_translate("MainWindow", "UTC +08:00", None))
self.comboBox.setItemText(28,
_translate("MainWindow", "UTC +08:30", None))
self.comboBox.setItemText(29,
_translate("MainWindow", "UTC +08:45", None))
self.comboBox.setItemText(30,
_translate("MainWindow", "UTC +09:00", None))
self.comboBox.setItemText(31,
_translate("MainWindow", "UTC +09:30", None))
self.comboBox.setItemText(32,
_translate("MainWindow", "UTC +10:00", None))
self.comboBox.setItemText(33,
_translate("MainWindow", "UTC +10:30", None))
self.comboBox.setItemText(34,
_translate("MainWindow", "UTC +11:00", None))
self.comboBox.setItemText(35,
_translate("MainWindow", "UTC +12:00", None))
self.comboBox.setItemText(36,
_translate("MainWindow", "UTC +12:45", None))
self.comboBox.setItemText(37,
_translate("MainWindow", "UTC +13:00", None))
self.comboBox.setItemText(38,
_translate("MainWindow", "UTC +14:00", None))
self.menuOpen.setTitle(_translate("MainWindow", "Open", None))
self.actionFile.setText(_translate("MainWindow", "File", None))
self.actionDirectory.setText(
_translate("MainWindow", "Directory", None))
def convert_utc(self):
global utc_timezone
temp = self.comboBox.currentText().split(" ")[1]
if temp[0] == '-':
utc_timezone = float(temp[0:3]) - float(temp[4:6]) / 60
else:
utc_timezone = float(temp[0:3]) + float(temp[4:6]) / 60
if time_list is not None:
int_time_list = []
del int_time_list[:]
for i in time_list:
convert_time = self.convert_utc_timezone(i, utc_timezone)
if convert_time.find('-') >= 0:
temp = convert_time.split('-')[0] + convert_time.split(
'-')[1] + convert_time.split('-')[2]
int_time_list.append(temp)
min_time = min(int_time_list)[0:4] + '/' + min(
int_time_list)[4:6] + '/' + min(int_time_list)[6:8]
max_time = max(int_time_list)[0:4] + '/' + max(
int_time_list)[4:6] + '/' + max(int_time_list)[6:8]
self.textEdit.setText(min_time + ' ~ ' + max_time) ###duration 설정
else:
pass
self.View()
def convert_utc_timezone(self, get_time, gap):
get_time = get_time.replace("-", " ")
get_time = get_time.replace(":", " ")
temp = datetime(
int(get_time.split(' ')[0]), int(get_time.split(' ')[1]),
int(get_time.split(' ')[2]), int(get_time.split(' ')[3]),
int(get_time.split(' ')[4]), int(get_time.split(' ')[5]), 0)
convert_time = temp + timedelta(hours=gap)
return str(convert_time)
def zoom(self):
self.toolbar.zoom()
def pan(self):
self.toolbar.pan()
def home(self):
self.toolbar.home()
def ShowDate(self):
date = self.dateEdit.date()
string_date = str(date.toPyDate())
Date["year"] = string_date.split('-')[0]
Date["month"] = string_date.split('-')[1]
Date["day"] = string_date.split('-')[2]
self.View()
def OpenFile(self):
find = ['Onhub', 'Database', 'Amazon Echo']
file_list = []
del file_list[:] #리스트 초기화
del device_list[:]
device_list.append('') # y축 한 줄 띄려고 추가
reload(sys)
sys.setdefaultencoding('utf-8')
FilePath = QtGui.QFileDialog.getOpenFileName()
if FilePath:
if FilePath[-4:] == '.csv': # 확장자로 csv 파일만 필터링
f = open(FilePath, 'r')
first = f.readline().split(',')[0].split('-')[0]
if first.split('(')[0] in find: # 분석 대상 파일 필터링
file_list.append(FilePath)
device_list.append(first)
f.close()
self.Analyze_Data(file_list)
else:
pass
self.init_view()
def OpenDirectory(self):
reload(sys)
sys.setdefaultencoding('utf-8')
DirPath = str(QtGui.QFileDialog.getExistingDirectory())
if DirPath:
self.Directory_Search(DirPath)
else:
pass
self.init_view()
def Directory_Search(self, DirPath):
find = ['Onhub', 'Database', 'Amazon Echo']
file_list = []
del file_list[:] #리스트 초기화
del device_list[:]
device_list.append('') # y축 한 줄 띄려고 추가
for (path, dir, files) in os.walk(
unicode(DirPath)): #unicode(DirPath): 한글 경로 가능하게
for filename in files:
if filename[-4:] == '.csv': #확장자로 csv 파일만 필터링
f = open(os.path.join(path, filename), 'r')
first = f.readline()
if first[0:5] == 'Onhub': #분석 대상 파일 필터링
file_list.append(os.path.join(path, filename))
device_list.append(first.split(',')[0].split('-')[0])
elif first[0:8] == 'Database':
file_list.append(os.path.join(path, filename))
device_list.append(
first.split('_')[0] + '(' +
first.split('(')[1].split('-')[0])
elif first[0:11] == 'Amazon Echo':
file_list.append(os.path.join(path, filename))
device_list.append(first.split(',')[0].split('-')[0])
f.close()
self.Analyze_Data(file_list)
def Analyze_Data(self, file_list):
empty_list = []
out_data["onhub_disconnect"] = empty_list
out_data["onhub_connect"] = empty_list
out_data["amazon_echo"] = empty_list
out_data["Database"] = empty_list
in_data = {} #기기별 모든 데이터가 포함되어 있는 딕셔너리
del time_list[:]
index = 1
for i in range(1, len(device_list)):
data = self.Read_Data(file_list[i - 1], time_list, index) #모든 데이터
if in_data is None:
in_data[device_list[i]] = data
else:
if device_list[i] in in_data:
in_data[device_list[i]] = data
else:
in_data[device_list[i]] = data
index += 1
int_time_list = []
del int_time_list[:]
for i in time_list:
if i.find('-') >= 0:
temp = i.split('-')[0] + i.split('-')[1] + i.split('-')[2]
int_time_list.append(temp)
min_time = min(int_time_list)[0:4] + '/' + min(
int_time_list)[4:6] + '/' + min(int_time_list)[6:8]
max_time = max(int_time_list)[0:4] + '/' + max(
int_time_list)[4:6] + '/' + max(int_time_list)[6:8]
self.textEdit.setText(min_time + ' ~ ' + max_time) ###duration 설정
connect = []
disconnect = []
database = []
echo = []
for key in in_data:
if key[0:5] == 'Onhub':
temp1 = in_data[key] #temp1은 각 기기별 데이터 리스트들
for temp2 in temp1: #temp2는 temp1의 리스트 하나
if temp2[2] == 'Connected':
connect.append(temp2[0] + ' ' + temp2[1] + ' ' +
temp2[3] + ' ' + temp2[4])
elif temp2[2] == 'Disconnected':
disconnect.append(temp2[0] + ' ' + temp2[1] + ' ' +
temp2[3] + ' ' + temp2[4])
else:
continue
out_data["onhub_connect"] = connect
out_data["onhub_disconnect"] = disconnect
elif key[0:11] == 'Amazon Echo':
temp1 = in_data[key] # temp1은 각 기기별 데이터 리스트들
for temp2 in temp1: # temp2는 temp1의 리스트 하나
echo.append(temp2)
out_data["amazon_echo"] = echo
elif key[0:8] == 'Database':
temp1 = in_data[key] # temp1은 각 기기별 데이터 리스트들
for temp2 in temp1: # temp2는 temp1의 리스트 하나
database.append(temp2)
out_data["Database"] = database
###View 함수로 이동
def Read_Data(self, Filepath, time_list, index):
global utc_timezone
f = open(Filepath, 'r')
data_a = csv.reader(f)
count = 0
list = []
device_name = 0
for data in data_a:
if not data:
pass
else:
if count == 0:
if data[0][0:5] == 'Onhub':
device_name = data[0].split('-')[0]
elif data[0][0:11] == 'Amazon Echo':
device_name = data[0].split('-')[0]
elif data[0][0:8] == 'Database':
device_name = data[0].split(
'_')[0] + '(' + data[0].split('(')[1].split('-')[0]
temp = QtCore.QString(data[1].split("UTC")[1])
if temp[0] == '-':
utc_timezone_temp = float(
temp[0:3]) - float(temp[4:6]) / 60
else:
utc_timezone_temp = float(
temp[0:3]) + float(temp[4:6]) / 60
utc_timezone_dic[device_name] = utc_timezone_temp
count = 1
elif data[0].find('Time') >= 0:
count = 2
elif count == 2:
if data[0] == '="None"':
pass
else:
data.append(
device_name) # 기기정보 추가(날짜, 맥주소, 연결/연결해제, 기기정보)
data.append(str(index))
list.append(data)
if utc_timezone_dic[device_name] == utc_timezone:
time_list.append(data[0].split('"')[1].split('"')
[0]) # time_list는 시간정보
else:
time_temp = data[0].split('"')[1].split('"')[0]
time_temp = self.convert_utc_timezone(
time_temp,
utc_timezone - utc_timezone_dic[device_name])
time_list.append(time_temp) # time_list는 시간정보
f.close()
return list
def init_view(self):
plt.clf()
plt.ylim(0, len(device_list)) # y축 최소,최대값 설정
plt.yticks(np.arange(0, len(device_list)), device_list) # y축 눈금
plt.xlim(0, 24) # x축 최소,최대값 설정
plt.xticks(np.arange(0, 25)) # x축 눈금
plt.xlabel('time(hours)')
plt.ylabel('devices')
plt.title('Result')
def View(self):
self.init_view()
global utc_timezone
sc_onhub_connect = []
del sc_onhub_connect[:]
sc_onhub_connect_index = []
del sc_onhub_connect_index[:]
sc_onhub_disconnect = []
del sc_onhub_disconnect[:]
sc_onhub_disconnect_index = []
del sc_onhub_disconnect_index[:]
onhub_disconnect_annot.clear
onhub_connect_annot.clear
sc_Database = []
del sc_Database[:]
sc_Database_index = []
del sc_Database_index[:]
Database_annot.clear
sc_amazon_echo = []
del sc_amazon_echo[:]
sc_amazon_echo_index = []
del sc_amazon_echo_index[:]
echo_annot.clear
if (out_data["onhub_connect"] is ''
) & (out_data["onhub_disconnect"] is '') & (
out_data["Database"] is '') & (out_data["amazon_echo"] is ''):
self.canvas.draw()
self.clear_view()
else:
self.annot = plt.annotate("",
xy=(0, 0),
xytext=(20, 20),
textcoords="offset points",
bbox=dict(boxstyle="round", fc="w"),
arrowprops=dict(arrowstyle="->"))
if out_data["onhub_connect"]:
sc_onhub_connect_temp = out_data["onhub_connect"]
if utc_timezone_dic[sc_onhub_connect_temp[0].split(' ')
[3]] == utc_timezone:
for i in range(len(sc_onhub_connect_temp)):
time = sc_onhub_connect_temp[i].split(' ')[0].split(
'"')[1]
if (Date["year"] == time.split('-')[0]) & (
Date["month"] == time.split('-')[1]) & (
Date["day"] == time.split('-')[2]):
time2 = sc_onhub_connect_temp[i].split(
' ')[1].split('"')[0]
add_data = float(time2.split(":")[0]) + (
float(time2.split(":")[1]) / 60) + (
(float(time2.split(":")[2]) / 60) / 60
) # X축 시간 계산 ##########split 데이터 수정
sc_onhub_connect.append(round(add_data, 4))
index = sc_onhub_connect_temp[i].split(' ')[4]
onhub_connect_annot[round(
add_data, 4
)] = index + '|' + 'MAC address : ' + sc_onhub_connect_temp[
i].split(' ')[2].split('"')[1].split(
'"'
)[0] + '\n' + 'time : ' + sc_onhub_connect_temp[
i].split(' ')[0].split(
'"')[1] + ' ' + sc_onhub_connect_temp[
i].split(' ')[1].split('"')[
0] + '\n' + 'Action: Connected'
sc_onhub_connect_index.append(int(index))
else:
continue
else:
gap = utc_timezone - utc_timezone_dic[
sc_onhub_connect_temp[0].split(' ')[3]]
for i in range(len(sc_onhub_connect_temp)):
time_temp = sc_onhub_connect_temp[i].split(
'"')[1].split('"')[0]
convert_time = self.convert_utc_timezone(
time_temp, gap)
time = convert_time.split(' ')[0]
if (Date["year"] == time.split('-')[0]) & (
Date["month"] == time.split('-')[1]) & (
Date["day"] == time.split('-')[2]):
time2 = convert_time.split(' ')[1]
add_data = float(time2.split(":")[0]) + (
float(time2.split(":")[1]) / 60) + (
(float(time2.split(":")[2]) / 60) / 60
) # X축 시간 계산 ##########split 데이터 수정
sc_onhub_connect.append(round(add_data, 4))
index = sc_onhub_connect_temp[i].split(' ')[4]
onhub_connect_annot[round(
add_data, 4
)] = index + '|' + 'MAC address : ' + sc_onhub_connect_temp[
i].split(' ')[2].split('"')[1].split(
'"'
)[0] + '\n' + 'time : ' + convert_time + '\n' + 'Action: Connected'
sc_onhub_connect_index.append(int(index))
self.onhub_connect = plt.scatter(sc_onhub_connect,
sc_onhub_connect_index,
color='R',
edgecolors='R',
s=50,
label='Connected')
else:
self.onhub_connect = plt.scatter(sc_onhub_connect,
sc_onhub_connect_index,
color='R',
edgecolors='R',
s=50)
if out_data["onhub_disconnect"]:
sc_onhub_disconnect_temp = out_data["onhub_disconnect"]
if utc_timezone_dic[sc_onhub_disconnect_temp[0].split(' ')
[3]] == utc_timezone:
for i in range(len(sc_onhub_disconnect_temp)):
time = sc_onhub_disconnect_temp[i].split(' ')[0].split(
'"')[1]
if (Date["year"] == time.split('-')[0]) & (
Date["month"] == time.split('-')[1]) & (
Date["day"] == time.split('-')[2]):
time2 = sc_onhub_disconnect_temp[i].split(
' ')[1].split('"')[0]
add_data = float(time2.split(":")[0]) + (
float(time2.split(":")[1]) / 60) + (
(float(time2.split(":")[2].split(".")[0]) /
60) / 60) # X축 시간 계산
sc_onhub_disconnect.append(round(add_data, 4))
index = sc_onhub_disconnect_temp[i].split(' ')[4]
sc_onhub_disconnect_index.append(int(index))
onhub_disconnect_annot[round(
add_data, 4
)] = index + '|' + 'MAC address : ' + sc_onhub_disconnect_temp[
i].split(' ')[2].split('"')[1].split(
'"'
)[0] + '\n' + 'time : ' + sc_onhub_disconnect_temp[
i].split(' ')[0].split(
'"'
)[1] + ' ' + sc_onhub_disconnect_temp[
i].split(' ')[1].split('"')[
0] + '\n' + 'Action: Disconnected'
else:
continue
else:
gap = utc_timezone - utc_timezone_dic[
sc_onhub_disconnect_temp[0].split(' ')[3]]
for i in range(len(sc_onhub_disconnect_temp)):
time_temp = sc_onhub_disconnect_temp[i].split(
'"')[1].split('"')[0]
convert_time = self.convert_utc_timezone(
time_temp, gap)
time = convert_time.split(' ')[0]
if (Date["year"] == time.split('-')[0]) & (
Date["month"] == time.split('-')[1]) & (
Date["day"] == time.split('-')[2]):
time2 = convert_time.split(' ')[1]
add_data = float(time2.split(":")[0]) + (
float(time2.split(":")[1]) / 60) + (
(float(time2.split(":")[2].split(".")[0]) /
60) / 60) # X축 시간 계산
sc_onhub_disconnect.append(round(add_data, 4))
index = sc_onhub_disconnect_temp[i].split(' ')[4]
sc_onhub_disconnect_index.append(int(index))
onhub_disconnect_annot[round(
add_data, 4
)] = index + '|' + 'MAC address : ' + sc_onhub_disconnect_temp[
i].split(' ')[2].split('"')[1].split(
'"'
)[0] + '\n' + 'time : ' + convert_time + '\n' + 'Action: Disconnected'
self.onhub_disconnect = plt.scatter(sc_onhub_disconnect,
sc_onhub_disconnect_index,
marker='X',
color='k',
label='Disconnected')
else:
self.onhub_disconnect = plt.scatter(sc_onhub_disconnect,
sc_onhub_disconnect_index,
marker='X',
color='k')
if out_data["amazon_echo"]:
sc_amazon_echo_temp = out_data["amazon_echo"]
if utc_timezone_dic[sc_amazon_echo_temp[0][3]] == utc_timezone:
for i in range(len(sc_amazon_echo_temp)):
time = sc_amazon_echo_temp[i][0].split('"')[1].split(
' ')[0]
if (Date["year"] == time.split('-')[0]) & (
Date["month"] == time.split('-')[1]) & (
Date["day"] == time.split('-')[2]):
time2 = sc_amazon_echo_temp[i][0].split(
' ')[1].split('"')[0]
add_data = float(time2.split(":")[0]) + (
float(time2.split(":")[1]) / 60) + (
(float(time2.split(":")[2].split(".")[0]) /
60) / 60) # X축 시간 계산
sc_amazon_echo.append(round(add_data, 4))
index = sc_amazon_echo_temp[i][4]
sc_amazon_echo_index.append(int(index))
echo_annot[round(
add_data, 4
)] = 'File name : ' + sc_amazon_echo_temp[i][
1] + '\n' + 'time : ' + sc_amazon_echo_temp[i][
0].split('"')[1].split(
'"'
)[0] + '\n' + 'command : ' + sc_amazon_echo_temp[
i][2]
else:
continue
else:
gap = utc_timezone - utc_timezone_dic[
sc_amazon_echo_temp[0][3]]
for i in range(len(sc_amazon_echo_temp)):
time_temp = sc_amazon_echo_temp[i][0].split(
'"')[1].split('"')[0]
convert_time = self.convert_utc_timezone(
time_temp, gap)
time = convert_time.split(' ')[0]
if (Date["year"] == time.split('-')[0]) & (
Date["month"] == time.split('-')[1]) & (
Date["day"] == time.split('-')[2]):
time2 = convert_time.split(' ')[1]
add_data = float(time2.split(":")[0]) + (
float(time2.split(":")[1]) / 60) + (
(float(time2.split(":")[2].split(".")[0]) /
60) / 60) # X축 시간 계산
sc_amazon_echo.append(round(add_data, 4))
index = sc_amazon_echo_temp[i][4]
sc_amazon_echo_index.append(int(index))
echo_annot[round(
add_data, 4
)] = 'File name : ' + sc_amazon_echo_temp[i][
1] + '\n' + 'time : ' + convert_time + '\n' + 'command : ' + sc_amazon_echo_temp[
i][2]
self.amazon_echo = plt.scatter(sc_amazon_echo,
sc_amazon_echo_index,
marker='*',
color='b',
label='Command Event')
else:
self.amazon_echo = plt.scatter(sc_amazon_echo,
sc_amazon_echo_index,
marker='*',
color='b')
if out_data["Database"]:
sc_Database_temp = out_data["Database"]
if utc_timezone_dic[sc_Database_temp[0][2]] == utc_timezone:
for i in range(len(sc_Database_temp)):
time = sc_Database_temp[i][0].split('"')[1].split(
' ')[0]
if (Date["year"] == time.split('-')[0]) & (
Date["month"] == time.split('-')[1]) & (
Date["day"] == time.split('-')[2]):
time2 = sc_Database_temp[i][0].split(' ')[1].split(
'"')[0]
add_data = float(time2.split(":")[0]) + (
float(time2.split(":")[1]) / 60) + (
(float(time2.split(":")[2].split(".")[0]) /
60) / 60) # X축 시간 계산
sc_Database.append(round(add_data, 4))
index = sc_Database_temp[i][3]
sc_Database_index.append(int(index))
Database_annot[round(
add_data,
4)] = 'File name : ' + sc_Database_temp[i][
1] + '\n' + 'time : ' + sc_Database_temp[
i][0].split('"')[1].split('"')[
0] + '\n' + 'Action: File Modified'
else:
continue
else:
gap = utc_timezone - utc_timezone_dic[sc_Database_temp[0]
[2]]
for i in range(len(sc_Database_temp)):
time_temp = sc_Database_temp[i][0].split('"')[1].split(
'"')[0]
convert_time = self.convert_utc_timezone(
time_temp, gap)
time = convert_time.split(' ')[0]
if (Date["year"] == time.split('-')[0]) & (
Date["month"] == time.split('-')[1]) & (
Date["day"] == time.split('-')[2]):
time2 = convert_time.split(' ')[1]
add_data = float(time2.split(":")[0]) + (
float(time2.split(":")[1]) / 60) + (
(float(time2.split(":")[2].split(".")[0]) /
60) / 60) # X축 시간 계산
sc_Database.append(round(add_data, 4))
index = sc_Database_temp[i][3]
sc_Database_index.append(int(index))
Database_annot[round(
add_data, 4
)] = 'File name : ' + sc_Database_temp[i][
1] + '\n' + 'time : ' + convert_time + '\n' + 'Action: File Modified'
self.Database = plt.scatter(sc_Database,
sc_Database_index,
marker='<',
color='g',
label='File Modified')
else:
self.Database = plt.scatter(sc_Database,
sc_Database_index,
marker='<',
color='g')
plt.legend(loc='best')
self.annot.set_visible(False)
self.canvas.draw()
self.canvas.mpl_connect("motion_notify_event", self.event)
def event(self, event):
if event.inaxes is not None:
if self.onhub_connect.contains(event)[0] is True:
onhub_connect_x, onhub_connect_index = self.onhub_connect.contains(
event)
self.update_connect_onhub(onhub_connect_index)
self.annot.set_visible(True)
event.canvas.draw()
elif self.onhub_disconnect.contains(event)[0] is True:
onhub_disconnect_x, onhub_disconnect_index = self.onhub_disconnect.contains(
event)
self.update_disconnect_onhub(onhub_disconnect_index)
self.annot.set_visible(True)
event.canvas.draw()
elif self.amazon_echo.contains(event)[0] is True:
amazon_echo_x, amazon_echo_index = self.amazon_echo.contains(
event)
self.update_amazon_echo(amazon_echo_index)
self.annot.set_visible(True)
event.canvas.draw()
elif self.Database.contains(event)[0] is True:
Database_x, Database_index = self.Database.contains(event)
self.updat_database(Database_index)
self.annot.set_visible(True)
event.canvas.draw()
else:
self.annot.set_visible(False)
self.canvas.draw_idle()
def updat_database(self, ind):
pos = self.Database.get_offsets()[ind["ind"][0]]
self.annot.xy = pos
text = Database_annot[pos[0]]
self.annot.set_text(text)
def update_amazon_echo(self, ind):
pos = self.amazon_echo.get_offsets()[ind["ind"][0]]
self.annot.xy = pos
text = echo_annot[pos[0]]
self.annot.set_text(text)
def update_connect_onhub(self, ind):
pos = self.onhub_connect.get_offsets()[ind["ind"][0]]
self.annot.xy = pos
text = onhub_connect_annot[pos[0]]
if int(text.split('|')[0]) == pos[1]:
self.annot.set_text(text.split('|')[1])
else:
pass
def update_disconnect_onhub(self, ind):
pos = self.onhub_disconnect.get_offsets()[ind["ind"][0]]
self.annot.xy = pos
text = onhub_disconnect_annot[pos[0]]
if int(text.split('|')[0]) == pos[1]:
self.annot.set_text(text.split('|')[1])
else:
pass
class Window(QtGui.QWidget):
# G2 = nil
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
# self.toolbar.hide()
# Just some button
self.button = QtGui.QPushButton('Plot')
self.button.clicked.connect(self.plot)
self.button1 = QtGui.QPushButton('Zoom')
self.button1.clicked.connect(self.zoom)
self.button2 = QtGui.QPushButton('Pan')
self.button2.clicked.connect(self.pan)
self.button3 = QtGui.QPushButton('Home')
self.button3.clicked.connect(self.home)
self.button4 = QtGui.QPushButton('Home')
self.button3.clicked.connect(self.home)
# tabs = QtGui.QTabWidget()
# tab1 = QtGui.QWidget()
# tab2 = QtGui.QWidget()
# set the layout
layout = QtGui.QVBoxLayout()
layout.addWidget(self.toolbar)
layout.addWidget(self.canvas)
layout.addWidget(self.button)
layout.addWidget(self.button1)
layout.addWidget(self.button2)
layout.addWidget(self.button3)
self.setLayout(layout)
def home(self):
self.toolbar.home()
def zoom(self):
self.toolbar.zoom()
def pan(self):
self.toolbar.pan()
def addData(self, G=None):
self.G2
def plot(self):
''' plot some random stuff '''
squarify.plot(sizes=[13, 22, 35, 5],
label=["group A", "group B", "group C", "group D"],
alpha=.7)
# plt.axis('off')
# plt.show()
# data = [random.random() for i in range(25)]
# ax = self.figure.add_subplot(111)
# ax.hold(False)
# ax.plot(data, '*-')
self.canvas.draw()
def addData(self, G=None):
G2 = G
print("G2 is ->", G2)
