def __init__(self, parent=None):
super(Window, self).__init__(parent)
#Variables Init
self.figure = plt.figure()
self.ax = self.figure.add_subplot(111)
canvas = FigureCanvas(self.figure)
self.mat = self.ax.matshow(np.zeros((num_rows,num_cols)))
#global ax, mat, ser, Array, data
toolbar = NavigationToolbar(canvas, self)
toolbar.hide()
# Start Button
self.button = QtGui.QPushButton('Start')
self.button.clicked.connect(plot)
#self.button1 = QtGui.QPushButton('Record')
#self.button.clicked.connect(self.plot)
# set the layout
layout = QtGui.QVBoxLayout()
layout.addWidget(canvas)
layout.addWidget(self.button)
self.setLayout(layout)
self.figure.canvas.draw()
self.timer = self.startTimer(3)
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 matplotlibWidget(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.canvas = MplCanvas()
self.vbl = QtGui.QVBoxLayout()
# print self.width(), self.height()
# self.canvas.setMinimumSize(self.canvas.size())
self.vbl.addWidget(self.canvas)
#--
self.mpl_toolbar = NavigationToolbar(self.canvas, self)
self.mpl_toolbar.hide()
# self.vbl.addWidget(self.mpl_toolbar)
#--
self.setLayout(self.vbl)
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 mGraph(QtGui.QWidget):
def __init__(self, device, parent=None):
QtGui.QWidget.__init__(self, parent)
# Create a matplotlib figure.
self.figure = plt.figure()
self.figure.set_facecolor('r')
# Create a QFrame to house the plot. This is not necessary,
# just makes it look nice.
self.matframe = QtGui.QFrame()
self.matLayout = QtGui.QVBoxLayout()
self.matLayout.setSpacing(0)
self.matframe.setLayout(self.matLayout)
self.matframe.setFrameShape(QtGui.QFrame.Panel)
self.matframe.setFrameShadow(QtGui.QFrame.Plain)
self.matframe.setStyleSheet(
"background-color: rgb(70,80,88); "
"margin:0px; border:2px solid rgb(0, 0, 0); ")
self.canvas = FigureCanvas(self.figure)
self.canvas.setSizePolicy(QtGui.QSizePolicy.Preferred,
QtGui.QSizePolicy.Preferred)
# This is the device we want to use.
self.device = device
# This sets up axis on which to plot.
color = (189. / 255, 195. / 255, 199. / 255)
self.ax = self.figure.add_subplot(111, axisbg=color)
ax = self.ax
# Add the matplotlib canvas to the QFrame.
self.matLayout.addWidget(self.canvas)
# The following lines set up all the colors, makes it look nice.
# The code to do it is far from pretty and I am planning
# on cleaning this up a bit.
self.figure.patch.set_color((70. / 255, 80. / 255, 88. / 255))
self.figure.patch.set_edgecolor((70. / 255, 80. / 255, 88. / 255))
ax.spines['bottom'].set_color(color)
ax.spines['top'].set_color(color)
ax.spines['right'].set_color(color)
ax.spines['left'].set_color(color)
ax.tick_params(axis='x', colors=color)
ax.tick_params(axis='y', colors=color)
ax.title.set_color(color)
ax.yaxis.label.set_color(color)
ax.xaxis.label.set_color(color)
ax.xaxis.get_offset_text().set_color(color)
ax.yaxis.get_offset_text().set_color(color)
# This is an array of all the lines on the plot. A line for
# every parameter.
self.line = []
self.mins = 0
self.maxes = 1
# Each element of line holds a plot, to be combined onto
# the same graph.
self.line.append(ax.plot(1, 1, label="Getting Data...")[0])
# In order to handle interactivity, I had to do some odd stuff
# with the toolbar buttons: self.home holds the original
# function called when the home button on the toolbar
# is clicked.
self.home = NavigationToolbar.home
# We now change the function that is called when the toolbar is
# clicked.
NavigationToolbar.home = self.enableAutoScaling
self.toolbar = NavigationToolbar(self.canvas, self)
self.cid = self.canvas.mpl_connect('button_press_event',
self.disableAutoScaling)
self.setStyleSheet("QPushButton{\
color:rgb(189,195, 199); \
background:rgb(70, 80, 88)};")
self.fullGraphBtn = QtGui.QPushButton("Show Interactive Graph")
self.fullGraphBtn.clicked.connect(self.openFullGraphGui)
self.toolbarFrame = QtGui.QFrame()
toolbarFrameLayout = QtGui.QVBoxLayout()
toolbarFrameLayout.addWidget(self.toolbar)
self.toolbar.setParent(None)
self.toolbarFrame.setLayout(toolbarFrameLayout)
self.toolbarFrame.setStyleSheet("\
border:2px solid rgb(0,0,0);\
color:rgb(189,195,199); \
background:rgb(70, 80, 88);")
self.toolbar.setStyleSheet("\
border:0px solid rgb(0,0,0);\
QDialog{background:rgb(70, 80, 88)}")
self.matPlotInfo = QtGui.QLabel()
self.alertFont = QtGui.QFont()
self.alertFont.setPointSize(12)
self.matPlotInfo.setStyleSheet("color:rgb(200, 69, 50);")
self.matPlotInfo.setText("Auto refresh disabled, "
"click HOME button to enable.")
self.matPlotInfo.setFont(self.alertFont)
#self.refreshRateSec = device.getFrame().getPlotRefreshRate()
self.refreshRateSec = device.getFrame().getPlotRefreshRate()
self.timer = QtCore.QTimer(self)
self.hidden = True
self.home = True
self.initialized = False
self.currTimeRange = 120
self.lineSelect = MCheckableComboBox()
self.lineSelect.setSizeAdjustPolicy(0)
self.lineSelect.setStyleSheet("\
background-color:rgb(70, 80, 88);\
color:rgb(189,195, 199);")
self.plot(self.currTimeRange)
self.timer.timeout.connect(partial(self.plot, self.currTimeRange))
self.timer.start(self.refreshRateSec * 1000)
# Did it store data?
self.dataOk = True
self.hideButton = QtGui.QPushButton("Show Plot")
self.hideButton.clicked.connect(self.togglePlot)
self.oneMinButton = QtGui.QPushButton("1 min")
self.oneMinButton.clicked.connect(partial(self.plot, 60))
self.tenMinButton = QtGui.QPushButton("10 min")
self.tenMinButton.clicked.connect(partial(self.plot, 600))
self.twoHrButton = QtGui.QPushButton("2 hr")
self.twoHrButton.clicked.connect(partial(self.plot, 7200))
self.twelveHrButton = QtGui.QPushButton("12 hr")
self.twelveHrButton.clicked.connect(partial(self.plot, 43200))
self.threeDayButton = QtGui.QPushButton("3 day")
self.threeDayButton.clicked.connect(partial(self.plot, 259200))
self.oneWkButton = QtGui.QPushButton("1 week")
self.oneWkButton.clicked.connect(partial(self.plot, 604800))
self.allButton = QtGui.QPushButton("All Time")
self.allButton.clicked.connect(partial(self.plot, None))
self.canvas.hide()
self.toolbar.hide()
# Set the layout.
buttonLayout1 = QtGui.QHBoxLayout()
buttonLayout1.addWidget(self.hideButton)
buttonLayout1.addWidget(self.fullGraphBtn)
buttonLayout1.addStretch(0)
buttonLayout2 = QtGui.QHBoxLayout()
settingsbuttons1 = QtGui.QHBoxLayout()
buttonLayout2.addWidget(self.oneMinButton)
buttonLayout2.addWidget(self.tenMinButton)
buttonLayout2.addWidget(self.twoHrButton)
buttonLayout2.addWidget(self.twelveHrButton)
buttonLayout2.addWidget(self.threeDayButton)
buttonLayout2.addWidget(self.oneWkButton)
buttonLayout2.addWidget(self.allButton)
buttonLayout2.addStretch(0)
self.oneMinButton.hide()
self.tenMinButton.hide()
self.twoHrButton.hide()
self.twelveHrButton.hide()
self.threeDayButton.hide()
self.oneWkButton.hide()
self.allButton.hide()
self.lineSelect.hide()
self.matframe.hide()
self.matPlotInfo.hide()
self.toolbarFrame.hide()
settingsbuttons1.addWidget(self.lineSelect)
layout = QtGui.QVBoxLayout()
allButtonsLayout = QtGui.QHBoxLayout()
timeButtonsLayout = QtGui.QVBoxLayout()
allButtonsLayout.addLayout(timeButtonsLayout)
layout.addLayout(allButtonsLayout)
allButtonsLayout.addLayout(settingsbuttons1)
timeButtonsLayout.addLayout(buttonLayout1)
timeButtonsLayout.addLayout(buttonLayout2)
timeButtonsLayout.addWidget(self.matPlotInfo)
layout.addWidget(self.matframe)
layout.addWidget(self.toolbarFrame)
self.setLayout(layout)
def enableAutoScaling(self):
self.timer.start(self.refreshRateSec * 1000)
self.home = True
self.matPlotInfo.hide()
self.plot(self.currTimeRange)
def disableAutoScaling(self, event):
self.home = False
self.matPlotInfo.show()
self.canvas.update()
self.timer.stop()
def togglePlot(self):
if not self.hidden:
self.canvas.hide()
self.toolbar.hide()
self.oneMinButton.hide()
self.tenMinButton.hide()
self.twoHrButton.hide()
self.twelveHrButton.hide()
self.threeDayButton.hide()
self.oneWkButton.hide()
self.allButton.hide()
self.matPlotInfo.hide()
self.matframe.hide()
self.lineSelect.hide()
self.toolbarFrame.hide()
self.timer.stop()
self.hideButton.setText("Show Plot")
self.hidden = True
elif self.hidden:
self.canvas.show()
self.toolbar.show()
self.oneMinButton.show()
self.tenMinButton.show()
self.twoHrButton.show()
self.twelveHrButton.show()
self.threeDayButton.show()
self.oneWkButton.show()
self.allButton.show()
self.plot(self.currTimeRange)
self.matframe.show()
self.lineSelect.show()
self.toolbarFrame.show()
self.timer.start(self.refreshRateSec * 1000)
self.hideButton.setText("Hide Plot")
self.enableAutoScaling()
self.hidden = False
def initializePlot(self, dataSet):
if dataSet:
varNames = dataSet.getVariables()
varNames = [varNames[1][i][0] for i in range(len(varNames[1]))]
self.dropdownFont = QtGui.QFont()
self.dropdownFont.setPointSize(12)
if dataSet is not None:
self.initialized = True
self.line[0].remove()
self.line = []
for i in range(len(varNames)):
self.line.append(self.ax.plot(1, 1, label=varNames[i])[0])
text = QtCore.QString(varNames[i])
self.lineSelect.addItem(text)
self.lineSelect.setFont(self.dropdownFont)
self.lineSelect.setChecked(i, True)
def changeIndependenVarRange(self, timeRange):
if not self.hidden:
if timeRange != self.currTimeRange:
self.timer.stop()
self.timer.timeout.disconnect()
self.currTimeRange = timeRange
self.timer.timeout.connect(
lambda: self.plot(self.currTimeRange))
self.timer.start(self.refreshRateSec * 1000)
plotRefreshRate = self.device.getFrame().getPlotRefreshRate()
if self.refreshRateSec != plotRefreshRate:
self.refreshRateSec = plotRefreshRate
self.timer.stop()
self.timer.timeout.disconnect()
self.currTimeRange = timeRange
self.timer.timeout.connect(
lambda: self.plot(self.currTimeRange))
self.timer.start(self.refreshRateSec * 1000)
def getDataRangeFromDataSet(self, dataSet, time):
if dataSet:
data = dataSet.getData()
i = len(data) - 1
if time:
while data[i][0] > (data[-1][0] - time):
i -= 1
if -1 * i > len(data):
return data
data = data[i:-1]
return data
else:
return None
def openFullGraphGui(self):
# print "opening full graph gui."
dataSet = self.device.getFrame().getDataSet().getData()
# print dataSet
times = [dt.datetime.fromtimestamp(elem[0]) for elem in dataSet]
vars = self.device.getFrame().getDataSet().getVariables()
self.fullgraphcont = fullGraphContainer(times, vars, dataSet)
self.fullgraphcont.show()
def plot(self, time):
times = None
self.changeIndependenVarRange(time)
dataSet = self.device.getFrame().getDataSet()
if not self.initialized:
self.initializePlot(dataSet)
self.legend = self.ax.legend(loc='upper left')
# This is the ONLY time canvas.draw is called. It should
# NOT be called anywhere else if the graphing speed is
# to be fast.
self.canvas.draw()
else:
data = self.getDataRangeFromDataSet(dataSet, time)
for i in range(len(data[0]) - 1):
if self.lineSelect.isChecked(i):
times = [dt.datetime.fromtimestamp(row[0]) for row in data]
column = [row[i + 1] for row in data]
if not self.line[i].get_visible():
self.line[i].set_visible(True)
self.line[i].set_data(times, column)
self.legend = self.ax.legend(loc='upper left')
self.ax.grid(True)
self.ax.hold(True)
else:
self.line[i].set_visible(False)
pass
self.ax.set_title(self.device.getFrame().getTitle(),
color=(189. / 255, 195. / 255, 199. / 255))
if self.home and times:
self.ax.set_xlim(times[0], times[-1])
self.ax.relim(visible_only=True)
self.ax.autoscale(axis='y')
frame = self.device.getFrame()
yLabel = frame.getYLabel()
if yLabel is not None:
if frame.getCustomUnits():
self.ax.set_ylabel("%s (%s)" %
(yLabel, frame.getCustomUnits()))
elif frame.getUnits()[i - 1]:
self.ax.set_ylabel("%s (%s)" %
(yLabel, frame.getUnits()[i - 1]))
locator = AutoDateLocator()
self.ax.xaxis.set_major_locator(locator)
self.ax.xaxis.set_major_formatter(DateFormatter('%m/%d %H:%M:%S'))
self.figure.autofmt_xdate()
self.ax.draw_artist(self.figure)
self.ax.draw_artist(self.ax.patch)
self.ax.draw_artist(self.ax.yaxis)
self.ax.draw_artist(self.ax.xaxis)
for i, line in enumerate(self.line):
self.ax.draw_artist(line)
self.ax.set_xlabel("Time")
self.ax.draw_artist(self.legend)
self.canvas.update()
self.canvas.flush_events()
class MplGraphWidget(QtGui.QWidget):
def __init__(self, parent=None, width=3, height=3, dpi=100):
super(MplGraphWidget, self).__init__(parent)
self._dataY = np.array([])
self._dataX = np.array([])
self._spCols = 1
self._spRows = 1
self.all_sp_axes = []
self.fig = Figure(figsize=(width,height), dpi=dpi)
self.all_sp_axes.append(self.fig.add_subplot(self._spCols, self._spRows, 1))
self.fig.set_frameon(False)
self.fig.set_tight_layout(True)
self.canvas = Canvas(self.fig)
self._navBarOn = True
self.mpl_toolbar = NavigationToolbar(self.canvas, parent)
self.canvas.mpl_connect('key_press_event', self.on_key_press)
self.canvas.mpl_connect('button_press_event', self.on_button_press)
self.canvas.mpl_connect('motion_notify_event', self.on_mouse_move)
self.canvas.setFocusPolicy(QtCore.Qt.ClickFocus)
self.canvas.setFocus()
self.canvas.setParent(parent)
self.canvas.clearMask()
self.canvas.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
self.canvas.updateGeometry()
vbox = QtGui.QVBoxLayout()
vbox.addWidget(self.canvas)
if self._navBarOn:
vbox.addWidget(self.mpl_toolbar)
self.setLayout(vbox)
key_pressed = QtCore.pyqtSignal(object, name='keyPressed')
def on_key_press(self, event):
self.key_pressed.emit(event)
key_press_handler(event, self.canvas, self.mpl_toolbar)
button_pressed = QtCore.pyqtSignal(object, name='buttonPressed')
def on_button_press(self, event):
self.button_pressed.emit(event)
key_press_handler(event, self.canvas, self.mpl_toolbar)
mouse_move = QtCore.pyqtSignal(object, name='mouseMoved')
def on_mouse_move(self, event):
self.mouse_move.emit(event)
key_press_handler(event, self.canvas, self.mpl_toolbar)
def get_icon(name):
"""Return Matplotlib icon *name*"""
return QtGui.QIcon(osp.join(rcParams['datapath'], 'images', name))
def generateNewAxes(self):
for ax in self.all_sp_axes:
self.fig.delaxes(ax)
self.all_sp_axes = []
numOfAxes = (self._spRows*self._spCols)+1
for i in np.arange(1,numOfAxes):
self.all_sp_axes.append(self.fig.add_subplot(self._spRows, self._spCols, i))
self.canvas.setGeometry(100, 100, 300, 300) #Used to update the new number of axes
self.canvas.updateGeometry() #This will bring the size of the canvas back to the original (defined by the vbox)
spRowsChanged = QtCore.pyqtSignal(int)
def getspRows(self):
return self._spRows
@QtCore.pyqtSlot(int)
def setspRows(self, spRows):
self._spRows = spRows
self.generateNewAxes()
self.spRowsChanged.emit(spRows)
def resetspRows(self):
self.setspRows(1)
spRows = QtCore.pyqtProperty(int, getspRows, setspRows, resetspRows)
spColsChanged = QtCore.pyqtSignal(int)
def getspCols(self):
return self._spCols
@QtCore.pyqtSlot(int)
def setspCols(self, spCols):
self._spCols = spCols
self.generateNewAxes()
self.spRowsChanged.emit(spCols)
def resetspCols(self):
self.setspCols(1)
spCols = QtCore.pyqtProperty(int, getspCols, setspCols, resetspCols)
dataChanged = QtCore.pyqtSignal(bool)
def get_Y_data(self):
return self._dataY
@QtCore.pyqtSlot(int)
def set_Y_data(self, y_data):
self._dataY = y_data
self.dataChanged.emit(True)
def plot(self, on_axes=0):
if np.size(self._dataX) == 0:
self.all_sp_axes[on_axes].plot(self._dataY)
else:
self.all_sp_axes[on_axes].plot(self._dataX, self._dataY)
def getNavBarOn(self):
return self._navBarOn
def setNavBarOn(self, navBarOn):
self._navBarOn = navBarOn
if not navBarOn:
self.mpl_toolbar.hide()
else:
self.mpl_toolbar.show()
def resetNavBarOn(self):
self._navBarOn = True
navBarOn = QtCore.pyqtProperty(bool, getNavBarOn, setNavBarOn, resetNavBarOn)
# def getautoscale(self):
# return self._autoscale
#
# def setautoscale(self, autoscale):
# self._autoscale = autoscale
# for axis in self.all_sp_axes:
# axis.set_autoscale(autoscale)
#
# def resetautoscale(self):
# self._autoscale = False
#
# autoscale = QtCore.pyqtProperty(bool, getautoscale, setautoscale, resetautoscale)
@QtCore.pyqtSlot(bool)
def set_autoscale(self, autoscale):
for axis in self.all_sp_axes:
axis.set_autoscale(autoscale)
class mGraph(QtGui.QWidget):
def __init__(self, device, parent=None):
QtGui.QWidget.__init__(self, parent)
# Create a matplotlib figure
self.figure = plt.figure()
self.figure.set_facecolor("r")
# Create a QFrame to house the plot. This is not necessary, just makes it look nice
self.matframe = QtGui.QFrame()
self.matLayout = QtGui.QVBoxLayout()
self.matLayout.setSpacing(0)
self.matframe.setLayout(self.matLayout)
self.matframe.setFrameShape(QtGui.QFrame.Panel)
self.matframe.setFrameShadow(QtGui.QFrame.Plain)
self.matframe.setStyleSheet("background-color: rgb(70,80,88); margin:0px; border:2px solid rgb(0, 0, 0); ")
self.canvas = FigureCanvas(self.figure)
self.canvas.setSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred)
# This is the device we want to use
self.device = device
# This sets up axis on which to plot
self.ax = self.figure.add_subplot(111, axisbg=(189.0 / 255, 195.0 / 255, 199.0 / 255))
# Add the matplotlib canvas to the QFrame
self.matLayout.addWidget(self.canvas)
# The following lines set up all the colors, makes it look nice. The code to do it is
# far from pretty and I am planning on cleaning this up a bit.
self.figure.patch.set_color((70.0 / 255, 80.0 / 255, 88.0 / 255))
self.figure.patch.set_edgecolor((70.0 / 255, 80.0 / 255, 88.0 / 255))
self.ax.spines["bottom"].set_color((189.0 / 255, 195.0 / 255, 199.0 / 255))
self.ax.spines["top"].set_color((189.0 / 255, 195.0 / 255, 199.0 / 255))
self.ax.spines["right"].set_color((189.0 / 255, 195.0 / 255, 199.0 / 255))
self.ax.spines["left"].set_color((189.0 / 255, 195.0 / 255, 199.0 / 255))
self.ax.tick_params(axis="x", colors=(189.0 / 255, 195.0 / 255, 199.0 / 255))
self.ax.tick_params(axis="y", colors=(189.0 / 255, 195.0 / 255, 199.0 / 255))
self.ax.title.set_color((189.0 / 255, 195.0 / 255, 199.0 / 255))
self.ax.yaxis.label.set_color((189.0 / 255, 195.0 / 255, 199.0 / 255))
self.ax.xaxis.label.set_color((189.0 / 255, 195.0 / 255, 199.0 / 255))
self.ax.xaxis.get_offset_text().set_color((189.0 / 255, 195.0 / 255, 199.0 / 255))
self.ax.yaxis.get_offset_text().set_color((189.0 / 255, 195.0 / 255, 199.0 / 255))
# This is an array of all the lines on the plot. A line for every parameter
self.line = []
# Each element of line holds a plot, to be combined onto the same graph
self.line.append(self.ax.plot(1, 1, label="Getting Data...")[0])
# This is the ONLY time canvas.draw is called. It should NOT be called anywhere else if
# the graphing speed is to be fast.
self.canvas.draw()
# In order to handle interactivity, I had to do some odd stuff with the
# toolbar buttons. Self.home holds the original function called when the home button on the toolbar
# is clicked.
self.home = NavigationToolbar.home
# We now change the function that is called when the toolbar is clicked.
NavigationToolbar.home = self.enableAutoScaling
self.toolbar = NavigationToolbar(self.canvas, self)
# print [item for item in dir(self.toolbar) if type(item) == QtGui.QDialog]
self.cid = self.canvas.mpl_connect("button_press_event", self.disableAutoScaling)
self.setStyleSheet(
"QPushButton{\
color:rgb(189,195, 199); \
background:rgb(70, 80, 88)}"
)
self.toolbarFrame = QtGui.QFrame()
toolbarFrameLayout = QtGui.QVBoxLayout()
toolbarFrameLayout.addWidget(self.toolbar)
self.toolbar.setParent(None)
self.toolbarFrame.setLayout(toolbarFrameLayout)
self.toolbarFrame.setStyleSheet(
"\
border:2px solid rgb(0,0,0);\
color:rgb(189,195,199); \
background:rgb(70, 80, 88);\
"
)
self.toolbar.setStyleSheet(
"\
border:0px solid rgb(0,0,0);\
QDialog{background:rgb(250, 80, 88)}\
"
)
# print dir(self.toolbar)
# print self.toolbar.children()
# print self.toolbar.setPalette
self.matPlotInfo = QtGui.QLabel()
self.alertFont = QtGui.QFont()
self.alertFont.setPointSize(12)
self.matPlotInfo.setStyleSheet("color:rgb(200, 69, 50);")
self.matPlotInfo.setText("Auto refresh disabled, click HOME button to enable.")
self.matPlotInfo.setFont(self.alertFont)
self.refreshRateSec = device.getFrame().getPlotRefreshRate()
self.timer = QtCore.QTimer(self)
self.hidden = True
self.home = True
self.currTimeRange = 120
self.plot(self.currTimeRange)
self.timer.timeout.connect(partial(self.plot, self.currTimeRange))
self.timer.start(self.refreshRateSec * 1000)
# did it store data?
self.dataOk = True
self.hideButton = QtGui.QPushButton("Show Plot")
self.hideButton.clicked.connect(self.togglePlot)
self.thrtysecButton = QtGui.QPushButton("30 Sec")
self.thrtysecButton.clicked.connect(partial(self.plot, 30))
self.twoMinButton = QtGui.QPushButton("2 Min")
self.twoMinButton.clicked.connect(partial(self.plot, 120))
self.fiveMinButton = QtGui.QPushButton("5 Min")
self.fiveMinButton.clicked.connect(partial(self.plot, 300))
self.thrtyMinButton = QtGui.QPushButton("30 Min")
self.thrtyMinButton.clicked.connect(partial(self.plot, 1800))
self.twoHrButton = QtGui.QPushButton("2 Hr")
self.twoHrButton.clicked.connect(partial(self.plot, 7200))
self.tenHrButton = QtGui.QPushButton("10 Hr")
self.tenHrButton.clicked.connect(partial(self.plot, 36000))
self.oneDayButton = QtGui.QPushButton("24 Hr")
self.oneDayButton.clicked.connect(partial(self.plot, 86400))
self.oneWkButton = QtGui.QPushButton("1 Wk")
self.oneWkButton.clicked.connect(partial(self.plot, 604800))
self.twoWkButton = QtGui.QPushButton("2 Wk")
self.twoWkButton.clicked.connect(partial(self.plot, 1209600))
self.allButton = QtGui.QPushButton("All Time")
self.allButton.clicked.connect(partial(self.plot, None))
self.canvas.hide()
self.toolbar.hide()
# set the layout
buttonLayout = QtGui.QHBoxLayout()
buttonLayout.addWidget(self.hideButton)
buttonLayout.addStretch(0)
buttonLayout2 = QtGui.QHBoxLayout()
buttonLayout3 = QtGui.QHBoxLayout()
buttonLayout2.addWidget(self.thrtysecButton)
buttonLayout2.addWidget(self.twoMinButton)
buttonLayout2.addWidget(self.fiveMinButton)
buttonLayout2.addWidget(self.thrtyMinButton)
buttonLayout2.addWidget(self.twoHrButton)
buttonLayout2.addStretch(0)
buttonLayout3.addWidget(self.tenHrButton)
buttonLayout3.addWidget(self.oneDayButton)
buttonLayout3.addWidget(self.oneWkButton)
buttonLayout3.addWidget(self.twoWkButton)
buttonLayout3.addWidget(self.allButton)
buttonLayout3.addStretch(0)
self.thrtysecButton.hide()
self.twoMinButton.hide()
self.fiveMinButton.hide()
self.thrtyMinButton.hide()
self.twoHrButton.hide()
self.tenHrButton.hide()
self.oneDayButton.hide()
self.oneWkButton.hide()
self.twoWkButton.hide()
self.allButton.hide()
self.matframe.hide()
self.matPlotInfo.hide()
self.toolbarFrame.hide()
layout = QtGui.QVBoxLayout()
layout.addLayout(buttonLayout)
layout.addLayout(buttonLayout2)
layout.addLayout(buttonLayout3)
layout.addWidget(self.matPlotInfo)
layout.addWidget(self.matframe)
layout.addWidget(self.toolbarFrame)
self.setLayout(layout)
def enableAutoScaling(self):
self.timer.start(self.refreshRateSec * 1000)
# self.canvas.mpl_disconnect(self.cid)
# self.cid = self.canvas.mpl_connect('button_press_event', self.disableAutoScaling)
self.home = True
self.matPlotInfo.hide()
# self.deviceThread = threading.Thread(target =
# self.plot, args=[self.currTimeRange])
# If the main thread stops, stop the child thread
# self.deviceThread.daemon = True
# Start the thread
# self.deviceThread.start()
self.plot(self.currTimeRange)
def disableAutoScaling(self, event):
self.home = False
self.matPlotInfo.show()
self.canvas.update()
# plt.show()
# print event.name
# self.canvas.mpl_disconnect(self.cid)
# self.cid = self.canvas.mpl_connect('button_press_event', self.enableAutoScaling)
self.timer.stop()
# self.zoom(self.toolbar)
def togglePlot(self):
if not self.hidden:
self.canvas.hide()
self.toolbar.hide()
self.thrtysecButton.hide()
self.twoMinButton.hide()
self.fiveMinButton.hide()
self.thrtyMinButton.hide()
self.twoHrButton.hide()
self.tenHrButton.hide()
self.oneDayButton.hide()
self.oneWkButton.hide()
self.twoWkButton.hide()
self.allButton.hide()
self.matPlotInfo.hide()
self.matframe.hide()
self.toolbarFrame.hide()
self.timer.stop()
self.hideButton.setText("Show Plot")
self.hidden = True
elif self.hidden:
self.canvas.show()
self.toolbar.show()
self.thrtysecButton.show()
self.twoMinButton.show()
self.fiveMinButton.show()
self.thrtyMinButton.show()
self.twoHrButton.show()
self.tenHrButton.show()
self.oneDayButton.show()
self.oneWkButton.show()
self.twoWkButton.show()
self.allButton.show()
self.plot(self.currTimeRange)
self.matframe.show()
self.toolbarFrame.show()
self.timer.start(self.refreshRateSec * 1000)
self.hideButton.setText("Hide Plot")
self.enableAutoScaling()
self.hidden = False
def plot(self, timeRange):
if not self.hidden:
if timeRange != self.currTimeRange:
self.timer.stop()
self.timer.timeout.disconnect()
self.currTimeRange = timeRange
self.timer.timeout.connect(lambda: self.plot(self.currTimeRange))
self.timer.start(self.refreshRateSec * 1000)
if self.refreshRateSec != self.device.getFrame().getPlotRefreshRate():
# print "New plot refresh rate: ", self.device.getFrame().getPlotRefreshRate()
self.refreshRateSec = self.device.getFrame().getPlotRefreshRate()
self.timer.stop()
self.timer.timeout.disconnect()
self.currTimeRange = timeRange
self.timer.timeout.connect(lambda: self.plot(self.currTimeRange))
self.timer.start(self.refreshRateSec * 1000)
dataSet = self.device.getFrame().getDataSet()
# If the dataset exists
if dataSet is not None:
# Get all data from the dataset
data = dataSet.getData()
self.ax.hold(False)
try:
# for each entry in the dataset [[time], [[data], [data], [data...]]]
# print data
# Get the corresponding times that the values were recorded
for i in range(1, len(data[-1])):
# Get colum. aka all values from parameter i over time
column = [row[i] for row in data]
# print times
# If the there is no defined a time range
if self.currTimeRange is None:
times = [datetime.datetime.fromtimestamp(row[0]) for row in data]
# Plot all of the data (columns) vs time
# self.ax.plot_date(times, column, label =
# dataSet.getVariables()[1][i-1][0])
pass
else:
# Otherwise, if the user PREVIOUSLY defined a time range,
# we need to look for the beginning of it.
# Start by getting the current time
dstamp = dateStamp()
# The dataset should be from now to -timerange
# time(now)-time(range)
startTime = dstamp.utcNowFloat() - self.currTimeRange
# If timeRange is not None, then we know we need
# to display only a certain range of values
# However, if the starttime defined is less than the lowest time, we
# do not have enough data to display the whole thing, so we must
# display all that we have instead. We do this by setting
# currTimeRange = 0.
if timeRange is not None and startTime < float(data[0][0]):
self.currTimeRange = None
# For all entries in data
for y in range(len(data)):
# We are searching backwards through the dataset to find a time
# just before the time range specified
if data[len(data) - y - 1][0] < startTime:
# once we find it, we know the beginning index of the data to be
# displayed
index = y
# Get the times and datafrom the index and columns to the end of the dataset
times = [datetime.datetime.fromtimestamp(row[0]) for row in data[-index:]]
# print times[0]
column = [row[i] for row in data[-index:]]
# Exit the loop
break
try:
while len(self.line) <= i:
self.line.append(self.ax.plot(1, 1, label=dataSet.getVariables()[1][i - 1][0])[0])
self.line[i].set_data(times, column)
self.ax.legend(loc="upper left", shadow=True, fancybox=True)
# maxi = max(column)
# mini = min(column)
# newMax = max(column)
# newMini = min(column)
# if(newMax>maxi)
# maxi=newMax
# self.ax.set_ylim(mini-mini/2, maxi+maxi/2)
# if(newMini<mini)
# self.ax.set_ylim(mini-mini/2, maxi+maxi/2)
# maxi = max(column)
# mini = min(column)
# self.ax.set_ylim(mini-mini/2, maxi+maxi/2)
# self.ax.set_xlim(min(times), max(times))
# self.ax.draw_artist(self.line[i])
except:
traceback.print_exc()
# print "Failed to log data"
# Add a legend
legend = self.ax.legend(loc="upper left")
self.ax.set_title(
self.device.getFrame().getTitle(), color=(189.0 / 255, 195.0 / 255, 199.0 / 255)
)
if (
self.device.getFrame().getYLabel() is not None
and len(self.device.getFrame().getCustomUnits()) is not 0
):
self.ax.set_ylabel(
self.device.getFrame().getYLabel()
+ " ("
+ self.device.getFrame().getCustomUnits()
+ ")"
)
elif (
self.device.getFrame().getYLabel() is not None
and len(self.device.getFrame().getUnits()[i - 1]) is not 0
):
self.ax.set_ylabel(
self.device.getFrame().getYLabel()
+ " ("
+ self.device.getFrame().getUnits()[i - 1]
+ ")"
)
self.ax.set_xlabel("Time")
self.ax.hold(True)
# locator = AutoDateLocator()
# self.ax.fmt_xdata = AutoDateFormatter()
# self.ax.xaxis.set_major_locator(locator)
# self.ax.xaxis.set_major_locator(locator)
# self.ax.xaxis.set_major_formatter(DateFormatter('%m/%d'))
# self.ax.fmt_xdata = mdates.DateFormatter('%m/%d %H:%M:%S')
# print "type: ", type(times[-1])
# print "time[-1]: ",times[-1]
# self.ax.set_ylim(bottom = 733681, top = 733682)
# self.figure.tight_layout()
self.ax.grid(True)
except Exception as e:
print "Error"
try:
self.ax.grid(True)
# self.ax.clear(self.ax.yaxis)
# self.ax.cla()
if self.home:
self.ax.set_xlim(times[0], times[-1])
self.ax.relim()
self.ax.autoscale()
# print self.ax.get_data_interval()
self.ax.draw_artist(self.figure)
self.ax.draw_artist(self.ax.patch)
locator = AutoDateLocator()
self.ax.xaxis.set_major_locator(locator)
self.ax.xaxis.set_major_formatter(DateFormatter("%m/%d %H:%M:%S"))
self.figure.autofmt_xdate()
# print [time.toordinal() for time in times]
self.ax.draw_artist(self.ax.yaxis)
self.ax.draw_artist(self.ax.xaxis)
for line in self.line:
self.ax.draw_artist(line)
# self.ax.axis('off')
self.ax.draw_artist(legend)
self.canvas.update()
self.canvas.flush_events()
except:
times = [datetime.datetime.fromtimestamp(row[0]) for row in data]
traceback.print_exc()
self.ax.set_xlim(times[0], times[-1])
self.ax.relim()
self.ax.autoscale()
# print self.ax.get_data_interval()
pass
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):
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.setWindowTitle('OpenWave-2KE V%s'%__version__)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap("openwave.ico"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.setWindowIcon(icon)
#Waveform area.
self.figure = plt.figure()
self.figure.set_facecolor('white')
self.canvas = FigureCanvas(self.figure)
self.canvas.setMinimumSize(800, 400)
self.toolbar = NavigationToolbar(self.canvas, self)
self.toolbar.hide()
#Zoom In/out and Capture Buttons
self.zoomBtn = QtGui.QPushButton('Zoom')
self.zoomBtn.setFixedSize(100, 30)
self.zoomBtn.clicked.connect(self.toolbar.zoom)
self.panBtn = QtGui.QPushButton('Pan')
self.panBtn.setFixedSize(100, 30)
self.panBtn.clicked.connect(self.toolbar.pan)
self.homeBtn = QtGui.QPushButton('Home')
self.homeBtn.setFixedSize(100, 30)
self.homeBtn.clicked.connect(self.toolbar.home)
self.captureBtn = QtGui.QPushButton('Capture')
self.captureBtn.setFixedSize(100, 50)
self.captureBtn.clicked.connect(self.manualCapture)
if(dso.connection_status==0):
self.captureBtn.setEnabled(False)
self.continuousBtn = QtGui.QRadioButton('Continuous')
self.continuousBtn.setEnabled(True)
self.continuousBtn.clicked.connect(self.setContinuous)
#Continuous capture selection
self.captureLayout = QtGui.QHBoxLayout()
self.captureLayout.addWidget(self.captureBtn)
self.captureLayout.addWidget(self.continuousBtn)
#Type: Raw Data/Image
self.typeBtn = QtGui.QPushButton('Raw Data')
self.typeBtn.setToolTip("Switch to get raw data or image from DSO.")
self.typeBtn.setFixedSize(120, 50)
self.typeFlag=True #Initial state -> Get raw data
self.typeBtn.setCheckable(True)
self.typeBtn.setChecked(True)
self.typeBtn.clicked.connect(self.typeAction)
#Channel Selection.
self.ch1checkBox = QtGui.QCheckBox('CH1')
self.ch1checkBox.setFixedSize(60, 30)
self.ch1checkBox.setChecked(True)
self.ch2checkBox = QtGui.QCheckBox('CH2')
self.ch2checkBox.setFixedSize(60, 30)
if(dso.chnum==4):
self.ch3checkBox = QtGui.QCheckBox('CH3')
self.ch3checkBox.setFixedSize(60, 30)
self.ch4checkBox = QtGui.QCheckBox('CH4')
self.ch4checkBox.setFixedSize(60, 30)
#Set channel selection layout.
self.selectLayout = QtGui.QHBoxLayout()
self.selectLayout.addWidget(self.ch1checkBox)
self.selectLayout.addWidget(self.ch2checkBox)
if(dso.chnum==4):
self.selectLayout2 = QtGui.QHBoxLayout()
self.selectLayout2.addWidget(self.ch3checkBox)
self.selectLayout2.addWidget(self.ch4checkBox)
self.typeLayout = QtGui.QHBoxLayout()
self.typeLayout.addWidget(self.typeBtn)
self.typeLayout.addLayout(self.selectLayout)
if(dso.chnum==4):
self.typeLayout.addLayout(self.selectLayout2)
self.zoominoutLayout = QtGui.QHBoxLayout()
self.zoominoutLayout.addWidget(self.zoomBtn)
self.zoominoutLayout.addWidget(self.panBtn)
self.zoominoutLayout.addWidget(self.homeBtn)
#Save/Load/Quit button
self.saveBtn = QtGui.QPushButton('Save')
self.saveBtn.setFixedSize(100, 50)
self.saveMenu = QtGui.QMenu(self)
self.csvAction = self.saveMenu.addAction("&As CSV File")
self.pictAction = self.saveMenu.addAction("&As PNG File")
self.saveBtn.setMenu(self.saveMenu)
self.saveBtn.setToolTip("Save waveform to CSV file or PNG file.")
self.connect(self.csvAction, QtCore.SIGNAL("triggered()"), self.saveCsvAction)
self.connect(self.pictAction, QtCore.SIGNAL("triggered()"), self.savePngAction)
self.loadBtn = QtGui.QPushButton('Load')
self.loadBtn.setToolTip("Load CHx's raw data from file(*.csv, *.lsf).")
self.loadBtn.setFixedSize(100, 50)
self.loadBtn.clicked.connect(self.loadAction)
self.quitBtn = QtGui.QPushButton('Quit')
self.quitBtn.setFixedSize(100, 50)
self.quitBtn.clicked.connect(self.quitAction)
# set the layout
self.waveLayout = QtGui.QHBoxLayout()
self.waveLayout.addWidget(self.canvas)
self.wave_box=QtGui.QVBoxLayout()
self.wave_box.addLayout(self.waveLayout)
self.wavectrlLayout = QtGui.QHBoxLayout()
self.wavectrlLayout.addStretch(1)
self.wavectrlLayout.addLayout(self.zoominoutLayout)
self.wavectrlLayout.addStretch(1)
self.wavectrlLayout.addLayout(self.captureLayout)
self.wavectrlLayout.addStretch(1)
self.saveloadLayout = QtGui.QHBoxLayout()
self.saveloadLayout.addWidget(self.saveBtn)
self.saveloadLayout.addWidget(self.loadBtn)
self.saveloadLayout.addWidget(self.quitBtn)
self.ctrl_box=QtGui.QHBoxLayout()
self.ctrl_box.addLayout(self.typeLayout)
self.ctrl_box.addLayout(self.saveloadLayout)
main_box=QtGui.QVBoxLayout()
main_box.addLayout(self.wave_box) #Waveform area.
main_box.addLayout(self.wavectrlLayout) #Zoom In/Out...
main_box.addLayout(self.ctrl_box) #Save/Load/Quit
self.setLayout(main_box)
self.captured_flag=0
self.timer=QtCore.QTimer()
self.timer.timeout.connect(self.timerCapture)
def typeAction(self):
if(self.typeFlag==True):
self.typeFlag=False
self.typeBtn.setText("Image")
self.csvAction.setEnabled(False)
else:
self.typeFlag=True
self.typeBtn.setText("Raw Data")
self.csvAction.setEnabled(True)
self.typeBtn.setChecked(self.typeFlag)
self.ch1checkBox.setEnabled(self.typeFlag)
self.ch2checkBox.setEnabled(self.typeFlag)
if(dso.chnum==4):
self.ch3checkBox.setEnabled(self.typeFlag)
self.ch4checkBox.setEnabled(self.typeFlag)
def saveCsvAction(self):
if(self.typeFlag==True): #Save raw data to csv file.
file_name=QtGui.QFileDialog.getSaveFileName(self, "Save as", 'DS0001', "Fast CSV File(*.csv)")[0]
num=len(dso.ch_list)
#print num
for ch in xrange(num):
if(dso.info[ch]==[]):
print('Failed to save data, raw data information is required!')
return
f = open(file_name, 'wb')
item=len(dso.info[0])
#Write file header.
f.write('%s,\r\n' % dso.info[0][0])
for x in xrange(1, 24):
str=''
for ch in xrange(num):
str+=('%s,' % dso.info[ch][x])
str+='\r\n'
f.write(str)
#Write Fast CSV mode only.
str=''
for ch in xrange(num):
str+='Mode,Fast,'
str+='\r\n'
f.write(str)
str=''
if(num==1):
str+=('%s,' % dso.info[0][25])
else:
for ch in xrange(num):
str+=('%s,,' % dso.info[ch][25])
str+='\r\n'
f.write(str)
#Write raw data.
item=len(dso.iWave[0])
#print item
tenth=int(item/10)
n_tenth=tenth-1
percent=10
for x in xrange(item):
str=''
if(num==1):
str+=('%s,' % dso.iWave[0][x])
else:
for ch in xrange(num):
str+=('%s, ,' % dso.iWave[ch][x])
str+='\r\n'
f.write(str)
if(x==n_tenth):
n_tenth+=tenth
print('%3d %% Saved\r'%percent),
percent+=10
f.close()
def savePngAction(self):
#Save figure to png file.
file_name=QtGui.QFileDialog.getSaveFileName(self, "Save as", 'DS0001', "PNG File(*.png)")[0]
if(file_name==''):
return
if(self.typeFlag==True): #Save raw data waveform as png file.
main.figure.savefig(file_name)
else: #Save figure to png file.
if(dso.osname=='pi'): #For raspberry pi only.
img=dso.im.transpose(Image.FLIP_TOP_BOTTOM)
img.save(file_name)
else:
dso.im.save(file_name)
print('Saved image to %s.'%file_name)
def loadAction(self):
dso.ch_list=[]
full_path_name=QtGui.QFileDialog.getOpenFileName(self,self.tr("Open File"),".","CSV/LSF files (*.csv *.lsf);;All files (*.*)")
sFileName=unicode(full_path_name).split(',')[0][3:-1] #For PySide
print sFileName
if(len(sFileName)<=0):
return
if os.path.exists(sFileName):
print 'Reading file...'
count=dso.readRawDataFile(sFileName)
#Draw waveform.
if(count>0):
total_chnum=len(dso.ch_list)
if(total_chnum==0):
return
self.drawWaveform(0)
else:
print('File not found!')
def quitAction(self):
if(dso.connection_status==1):
dso.closeIO()
self.close()
def timerCapture(self):
self.captureAction()
if(self.continuousBtn.isChecked()==True):
self.timer.start(10) #Automatic capturing.
def manualCapture(self):
if(self.continuousBtn.isChecked()==True):
if(self.captured_flag ==0):
self.captured_flag = 1 #Continuous capture started.
self.captureBtn.setText("Click to Stop")
self.loadBtn.setEnabled(False)
self.timer.start()
else:
self.captured_flag = 0 #Continuous capture stopped.
self.captureBtn.setText("Capture")
self.loadBtn.setEnabled(True)
self.timer.stop()
self.captureAction()
def captureAction(self):
dso.iWave=[[], [], [], []]
dso.ch_list=[]
if(self.typeFlag==True): #Get raw data.
draw_flag=False
#Turn on the selected channels.
if((self.ch1checkBox.isChecked()==True) and (dso.isChannelOn(1)==False)):
dso.write(":CHAN1:DISP ON\n") #Set CH1 on.
if((self.ch2checkBox.isChecked()==True) and (dso.isChannelOn(2)==False)):
dso.write(":CHAN2:DISP ON\n") #Set CH2 on.
if(dso.chnum==4):
if((self.ch3checkBox.isChecked()==True) and (dso.isChannelOn(3)==False)):
dso.write(":CHAN3:DISP ON\n") #Set CH3 on.
if((self.ch4checkBox.isChecked()==True) and (dso.isChannelOn(4)==False)):
dso.write(":CHAN4:DISP ON\n") #Set CH4 on.
#Get all the selected channel's raw datas.
if(self.ch1checkBox.isChecked()==True):
dso.getRawData(True, 1) #Read CH1's raw data from DSO (including header).
if(self.ch2checkBox.isChecked()==True):
dso.getRawData(True, 2) #Read CH2's raw data from DSO (including header).
if(dso.chnum==4):
if(self.ch3checkBox.isChecked()==True):
dso.getRawData(True, 3) #Read CH3's raw data from DSO (including header).
if(self.ch4checkBox.isChecked()==True):
dso.getRawData(True, 4) #Read CH4's raw data from DSO (including header).
#Draw waveform.
total_chnum=len(dso.ch_list)
if(total_chnum==0):
return
if(self.drawWaveform(1)==-1):
time.sleep(5)
self.drawWaveform(0)
else: #Get image.
img_type=1 #1 for RLE format, 0 for PNG format.
if(img_type):
dso.write(':DISP:OUTP?\n') #Send command to get image from DSO.
else:
dso.write(':DISP:PNGOutput?\n') #Send command to get image from DSO.
dso.getBlockData()
dso.ImageDecode(img_type)
self.showImage()
plt.tight_layout(True)
self.canvas.draw()
print('Image is ready!')
def setContinuous(self):
if(self.continuousBtn.isChecked()==False):
self.captured_flag = 0 #Continuous capture stopped.
self.timer.stop()
self.loadBtn.setEnabled(True)
self.captureBtn.setText("Capture")
def showImage(self):
#Turn the ticks off and show image.
plt.clf()
ax = plt.gca()
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
plt.imshow(dso.im)
def drawWaveform(self, mode):
total_chnum=len(dso.ch_list)
num=dso.points_num
ch_colortable=['#C0B020', '#0060FF', '#FF0080', '#00FF60']
ch=int(dso.ch_list[0][2])-1 #Get the channel of first waveform.
plt.cla()
plt.clf()
#Due to the memory limitation of matplotlib, we must reduce the sample points.
if(num==10000000):
if(total_chnum>2):
down_sample_factor=4
elif(total_chnum==2):
down_sample_factor=4
else:
down_sample_factor=1
num=num/down_sample_factor
elif(num==20000000):
if(total_chnum > 1):
down_sample_factor=4
else:
down_sample_factor=2
num=num/down_sample_factor
else:
down_sample_factor=1
dt=dso.dt[0] #Get dt from the first opened channel.
t_start=dso.hpos[0]-num*dt/2
t_end =dso.hpos[0]+num*dt/2
t = np.arange(t_start, t_end, dt)
#print t_start, t_end, dt, len(t)
if((len(t)-num)==1): #Avoid floating point rounding error.
t=t[:-1]
wave_type='-' #Set waveform type to vector.
#Draw waveforms.
ax=[[], [], [], []]
p=[]
for ch in xrange(total_chnum):
if(ch==0):
ax[ch]=host_subplot(111, axes_class=AA.Axes)
ax[ch].set_xlabel("Time (sec)")
else:
ax[ch]=ax[0].twinx()
ax[ch].set_ylabel("%s Units: %s" %(dso.ch_list[ch], dso.vunit[ch]))
ch_color=ch_colortable[int(dso.ch_list[ch][2])-1]
if(ch>1):
new_fixed_axis = ax[ch].get_grid_helper().new_fixed_axis
ax[ch].axis["right"] = new_fixed_axis(loc="right", axes=ax[ch], offset=(60*(ch-1), 0))
ax[ch].set_xlim(t_start, t_end)
ax[ch].set_ylim(-4*dso.vdiv[ch]-dso.vpos[ch], 4*dso.vdiv[ch]-dso.vpos[ch]) #Setup vertical display range.
fwave=dso.convertWaveform(ch, down_sample_factor)
#print('Length=%d'%(len(fwave)))
if(ch==0):
try:
p=ax[ch].plot(t, fwave, color=ch_color, ls=wave_type, label = dso.ch_list[ch])
except:
if(mode==1):
#print sys.exc_info()[0]
time.sleep(5)
print 'Trying to plot again!',
return -1
else:
try:
p+=ax[ch].plot(t, fwave, color=ch_color, ls=wave_type, label = dso.ch_list[ch])
except:
if(mode==1):
#print sys.exc_info()[0]
time.sleep(5)
print 'Trying to plot again!',
return -1
if(total_chnum>1):
labs = [l.get_label() for l in p]
plt.legend(p, labs, loc='upper right')
plt.tight_layout()
self.canvas.draw()
del ax, t, p
return 0
class MplGraphWidget(QtGui.QWidget):
def __init__(self, parent=None, width=3, height=3, dpi=100):
super(MplGraphWidget, self).__init__(parent)
self._dataY = np.array([])
self._dataX = np.array([])
self._spCols = 1
self._spRows = 1
self.all_sp_axes = []
self.fig = Figure(figsize=(width, height), dpi=dpi)
self.all_sp_axes.append(
self.fig.add_subplot(self._spCols, self._spRows, 1))
self.fig.set_frameon(False)
self.fig.set_tight_layout(True)
self.canvas = Canvas(self.fig)
self._navBarOn = True
self.mpl_toolbar = NavigationToolbar(self.canvas, parent)
self.canvas.mpl_connect('key_press_event', self.on_key_press)
self.canvas.mpl_connect('button_press_event', self.on_button_press)
self.canvas.mpl_connect('motion_notify_event', self.on_mouse_move)
self.canvas.setFocusPolicy(QtCore.Qt.ClickFocus)
self.canvas.setFocus()
self.canvas.setParent(parent)
self.canvas.clearMask()
self.canvas.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self.canvas.updateGeometry()
vbox = QtGui.QVBoxLayout()
vbox.addWidget(self.canvas)
if self._navBarOn:
vbox.addWidget(self.mpl_toolbar)
self.setLayout(vbox)
key_pressed = QtCore.pyqtSignal(object, name='keyPressed')
def on_key_press(self, event):
self.key_pressed.emit(event)
key_press_handler(event, self.canvas, self.mpl_toolbar)
button_pressed = QtCore.pyqtSignal(object, name='buttonPressed')
def on_button_press(self, event):
self.button_pressed.emit(event)
key_press_handler(event, self.canvas, self.mpl_toolbar)
mouse_move = QtCore.pyqtSignal(object, name='mouseMoved')
def on_mouse_move(self, event):
self.mouse_move.emit(event)
key_press_handler(event, self.canvas, self.mpl_toolbar)
def get_icon(name):
"""Return Matplotlib icon *name*"""
return QtGui.QIcon(osp.join(rcParams['datapath'], 'images', name))
def generateNewAxes(self):
for ax in self.all_sp_axes:
self.fig.delaxes(ax)
self.all_sp_axes = []
numOfAxes = (self._spRows * self._spCols) + 1
for i in np.arange(1, numOfAxes):
self.all_sp_axes.append(
self.fig.add_subplot(self._spRows, self._spCols, i))
self.canvas.setGeometry(100, 100, 300,
300) #Used to update the new number of axes
self.canvas.updateGeometry(
) #This will bring the size of the canvas back to the original (defined by the vbox)
spRowsChanged = QtCore.pyqtSignal(int)
def getspRows(self):
return self._spRows
@QtCore.pyqtSlot(int)
def setspRows(self, spRows):
self._spRows = spRows
self.generateNewAxes()
self.spRowsChanged.emit(spRows)
def resetspRows(self):
self.setspRows(1)
spRows = QtCore.pyqtProperty(int, getspRows, setspRows, resetspRows)
spColsChanged = QtCore.pyqtSignal(int)
def getspCols(self):
return self._spCols
@QtCore.pyqtSlot(int)
def setspCols(self, spCols):
self._spCols = spCols
self.generateNewAxes()
self.spRowsChanged.emit(spCols)
def resetspCols(self):
self.setspCols(1)
spCols = QtCore.pyqtProperty(int, getspCols, setspCols, resetspCols)
dataChanged = QtCore.pyqtSignal(bool)
def get_Y_data(self):
return self._dataY
@QtCore.pyqtSlot(int)
def set_Y_data(self, y_data):
self._dataY = y_data
self.dataChanged.emit(True)
def plot(self, on_axes=0):
if np.size(self._dataX) == 0:
self.all_sp_axes[on_axes].plot(self._dataY)
else:
self.all_sp_axes[on_axes].plot(self._dataX, self._dataY)
def getNavBarOn(self):
return self._navBarOn
def setNavBarOn(self, navBarOn):
self._navBarOn = navBarOn
if not navBarOn:
self.mpl_toolbar.hide()
else:
self.mpl_toolbar.show()
def resetNavBarOn(self):
self._navBarOn = True
navBarOn = QtCore.pyqtProperty(bool, getNavBarOn, setNavBarOn,
resetNavBarOn)
# def getautoscale(self):
# return self._autoscale
#
# def setautoscale(self, autoscale):
# self._autoscale = autoscale
# for axis in self.all_sp_axes:
# axis.set_autoscale(autoscale)
#
# def resetautoscale(self):
# self._autoscale = False
#
# autoscale = QtCore.pyqtProperty(bool, getautoscale, setautoscale, resetautoscale)
@QtCore.pyqtSlot(bool)
def set_autoscale(self, autoscale):
for axis in self.all_sp_axes:
axis.set_autoscale(autoscale)
class Plot(Widget, QtGui.QWidget):
def __init__(self, parent=None):
Widget.__init__(self)
QtGui.QWidget.__init__(self, parent)
self._data = 0
self._amostras = 20
self._datas = deque(maxlen=self._amostras)
self.create_main_frame()
#self.plot()
def create_main_frame(self):
self.main_frame = QWidget()
self.fig = Figure((5.0, 4.0), dpi=90)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
self.canvas.setFocusPolicy(Qt.StrongFocus)
self.canvas.setFocus()
self.axis = self.fig.add_subplot(111, axisbg='w')
self.axis.hold(False)
self.mpl_toolbar = NavigationToolbar(self.canvas, self.main_frame)
self.mpl_toolbar.hide()
self.canvas.mpl_connect('key_press_event', self.on_key_press)
vbox = QVBoxLayout()
vbox.addWidget(self.canvas) # the matplotlib canvas
vbox.addWidget(self.mpl_toolbar)
#self.main_frame.setLayout(vbox)
self.setLayout(vbox)
#self.setCentralWidget(self.main_frame)
def plot(self):
''' plot some random stuff '''
self.axis.plot(self._datas, '*-')
self.canvas.draw()
@property
def value(self):
return self._data
def add(self, value):
self._datas.append(value)
@value.setter
def value(self, data):
self._data = data
self.add(data)
self.plot()
def setValue(self, data):
self._data = data
self.add(data)
self.plot()
def amostras(self, amostras):
self._amostras = amostras
self._datas = deque(maxlen=self._amostras)
def on_key_press(self, event):
print('Plot pressed', event.key)
# implement the default mpl key press events described at
# http://matplotlib.org/users/navigation_toolbar.html#navigation-keyboard-shortcuts
try:
key_press_handler(event, self.canvas, self.mpl_toolbar)
except:
pass
class PlotWindow(QMainWindow):
def __init__(self, parent, controller):
# create window
QMainWindow.__init__(self)
self.setWindowTitle("Plot")
self.setGeometry(600, 200, 10, 10)
# set controller
self.controller = controller
# set parent's plot_window to point to self
parent.plot_window = self
# create main widget & layout
self.main_widget = QWidget(self)
self.main_widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
self.main_layout = QVBoxLayout(self.main_widget)
# create plot canvas
self.plot_canvas = MplCanvas(None, width=10, height=5, dpi=75)
self.main_layout.addWidget(self.plot_canvas)
# create matplotlib's toolbar but hide it
self.mpl_plot_toolbar = NavigationToolbar(self.plot_canvas, self)
self.mpl_plot_toolbar.hide()
# create toolbar
self.create_plot_toolbar(self.main_layout)
# set central widget
self.setCentralWidget(self.main_widget)
# set window titlebar buttons
self.setWindowFlags(Qt.CustomizeWindowHint | Qt.WindowMinimizeButtonHint | Qt.WindowMaximizeButtonHint)
self.show()
def create_plot_toolbar(self, parent_layout):
# create buttons
zoom_button = QPushButton('Zoom')
zoom_button.clicked.connect(self.mpl_plot_toolbar.zoom)
pan_button = QPushButton('Pan')
pan_button.clicked.connect(self.mpl_plot_toolbar.pan)
home_button = QPushButton('Home')
home_button.clicked.connect(self.mpl_plot_toolbar.home)
save_button = QPushButton('Save')
save_button.clicked.connect(self.mpl_plot_toolbar.save_figure)
# create button layout
button_layout = QHBoxLayout()
button_layout.setSpacing(5)
button_layout.addStretch(1)
# add buttons to button layout
button_layout.addWidget(zoom_button)
button_layout.addWidget(pan_button)
button_layout.addWidget(home_button)
button_layout.addWidget(save_button)
# add button layout to parent layout
parent_layout.addLayout(button_layout)
def plot_tail_angle_array(self, array, extra_tracking=None, keep_xlim=True):
self.plot_canvas.plot_tail_angle_array(array, extra_tracking, keep_xlim)
def plot_heading_angle_array(self, array, keep_xlim=True):
print(array.shape)
self.plot_canvas.plot_heading_angle_array(array, keep_xlim)
class mainWindow(QMainWindow):
def __init__(self):
super(mainWindow, self).__init__()
self.full_filename_dict = {} # { full_filename: group_name }
self.group_name_dict = {} #group name dict, not necessary now?
self.current_full_filename = None #current selected full filename
self.current_hdf5 = None #open( self.current_full_filename, r )
self.current_hdf5_item = None
self.current_group_name = None
self.current_base_filename = '' #current selected base filename
self.current_item_path = '' #current item full path. /io/md/...
self.current_item_name = '' #current selected item name md
self.legend = None
self.values = np.array([])
self.logX_plot = False
self.logY_plot = False
self.X = None
self.guiplot_count = 0
self.testplot_count = 1
self.image_plot_count = 0
self.surface_plot_count = 0
self.plot_type = 'curve'
self.colormap_string = 'jet'
self.colorscale_string = 'log'
self.show_image_data = False
self.rot_image_data = False
self.attributes_flag = False
self.current_selected_HDF = ''
self.dataset_type_list = [
'CFN',
'LiX',
'CHX',
]
self.default_dataset_type = 'CFN'
self.current_dataset_type = 'CFN'
#########################Tobecleaned
self.image_data_keys = [
'avg_img', 'mask', 'pixel_mask', 'roi_mask', 'g12b'
]
self.pds_keys = [
'g2_fit_paras', 'g2b_fit_paras', 'spec_km_pds', 'spec_pds',
'qr_1d_pds'
]
#####################
self.PWT = PlotWidget(self)
self.MPWT = MATPlotWidget(self)
self.initialise_user_interface()
self.vstack_sampling = 20
self.vstack_yshift = 10
def initialise_user_interface(self):
'''
Initialises the main window. '''
grid = QGridLayout()
grid.setSpacing(10)
self.grid = grid
#self.file_items_list = ht.titledTree('File Tree')
self.file_items_list = ht.tree()
self.file_items_list_property = {}
self.file_items_list.tree.itemClicked.connect(self.item_clicked)
#self.file_items_list.tree.itemDoubleClicked.connect(self.item_double_clicked)
self.guiplot_grid_fromRow = 5
self.guiplot_grid_fromColumn = 1
self.guiplot_grid_rowSpan = 5
self.guiplot_grid_columnSpan = 8
self.testplot_grid_fromRow = 6
self.testplot_grid_fromColumn = 1
self.testplot_grid_rowSpan = 4
self.testplot_grid_columnSpan = 8
self.plotLibrary = 'matplotlib'
self.plot_buttons_array = []
# Make dataset table
self.dataset_table = ht.titledTable('Values')
# Make attribute table
self.attribute_table = ht.titledTable('Attribute') # QTableWidget()
self.attribute_table.table.setShowGrid(True)
#dataset type to set buttons layout
self.dataset_type_obj_string = self.default_dataset_type
# Initialise all buttons
self.open_button = self.add_open_button()
self.remove_button = self.add_remove_button()
self.create_button = self.add_create_button()
self.dataset_type_box = self.add_dataset_type_box()
self.add_all_plot_buttons()
self.setX_button = self.add_setX_button()
self.resetX_button = self.add_resetX_button()
self.setlogX_box = self.add_setlogX_box()
self.setlogY_box = self.add_setlogY_box()
#self.clr_plot_checkbox = self.add_clr_plot_box()
self.clr_plot_button = self.add_clr_plot_button()
self.resizeEvent = self.onresize
# Add 'extra' window components
self.make_menu_bar()
self.filename_label = QLabel('H5FileName')
## Add plot window
self.guiplot = pg.PlotWidget() ##using pg
self.testplot = Figure()
self.ax = self.testplot.add_subplot(111)
self.canvas = FigureCanvas(self.testplot)
self.toolbar = NavigationToolbar(self.canvas, self)
self.cbWidget = None
#self.guiplot = pg.ImageView()
# Add the created layouts and widgets to the window
grid.addLayout(self.open_button, 1, 0, 1, 1, QtCore.Qt.AlignLeft)
grid.addLayout(self.remove_button, 6, 0, 1, 1, QtCore.Qt.AlignLeft)
grid.addLayout(self.create_button, 7, 0, 1, 1, QtCore.Qt.AlignLeft)
grid.addLayout(self.dataset_type_box, 1, 0, 1, 1, QtCore.Qt.AlignRight)
grid.addLayout(self.clr_plot_button, 1, 4, 1, 1, QtCore.Qt.AlignLeft)
grid.addLayout(self.setX_button, 1, 8, 1, 1, QtCore.Qt.AlignLeft)
grid.addLayout(self.resetX_button, 2, 8, 1, 1, QtCore.Qt.AlignLeft)
grid.addLayout(self.setlogX_box, 1, 7, 1, 1, QtCore.Qt.AlignLeft)
grid.addLayout(self.setlogY_box, 2, 7, 1, 1, QtCore.Qt.AlignLeft)
grid.addWidget(self.filename_label, 2, 0, 1, 1)
#filename list
#grid.addLayout(self.file_items_list.layout, 4, 0, 3, 1)
grid.addLayout(self.file_items_list.datalayout, 4, 0, 2, 1)
#data dataset table
grid.addLayout(self.dataset_table.layout, 4, 1, 1, 8)
# Add toolbar
grid.addWidget(self.toolbar, 5, 1, 1, 7)
## Add guiplot window, it's not the default so hide
grid.addWidget(self.guiplot, self.guiplot_grid_fromRow,
self.guiplot_grid_fromColumn, self.guiplot_grid_rowSpan,
self.guiplot_grid_columnSpan)
self.guiplot.setWindowOpacity(0)
self.guiplot.hide()
grid.addWidget(self.canvas, self.testplot_grid_fromRow,
self.testplot_grid_fromColumn,
self.testplot_grid_rowSpan,
self.testplot_grid_columnSpan)
# attribute tabel
grid.addLayout(self.attribute_table.layout, 8, 0, 3, 1)
#grid.addWidget(self.attribute_table, 7, 0, 2, 1 )
self.dev_cur_layout(plot_type='curve')
self.dev_cur_layout(plot_type='image')
self.setCentralWidget(QWidget(self))
self.centralWidget().setLayout(grid)
# Other tweaks to the window such as icons etc
self.setWindowTitle('XSH5View--Ver1')
#QtGui.QApplication.setStyle(QtGui.QStyleFactory.create('Cleanlooks'))
self.initialise_layout(
) #to add different type of layout based on self.dataset_type_obj_string
########Start Deal with layout
def initialise_layout(self):
if self.dataset_type_obj_string == 'CFN':
self.delete_dataset_buttons('CHX')
self.dev_dataset_buttons(self.dataset_type_obj_string)
elif self.dataset_type_obj_string == 'LIX':
self.delete_dataset_buttons('CHX')
elif self.dataset_type_obj_string == 'CHX':
self.dev_dataset_buttons(self.dataset_type_obj_string)
else:
pass
def dev_cur_layout(self, plot_type):
if plot_type in plot_curve_type:
self.CurCrossHair = QLabel()
self.CurCrossHair.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.grid.addWidget(self.CurCrossHair, 9, 2, 1, 1)
self.CrossHair_type = 'curve'
elif plot_type in plot_image_type:
self.imageCrossHair = QLabel()
self.imageCrossHair.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.grid.addWidget(self.imageCrossHair, 9, 1, 1, 1)
self.CrossHair_type = 'image'
else:
self.CrossHair_type = 'None'
def delete_cur_layout(self, plot_type):
if plot_type in plot_curve_type:
try:
self.deleteLayout(self.imageCrossHair)
except:
pass
elif plot_type in plot_image_type:
try:
self.deleteLayout(self.CurCrossHair)
except:
pass
else:
pass
def dev_dataset_buttons(self, dataset_type):
if dataset_type == 'CHX':
self.plot_g2_button = self.add_plot_g2_button()
self.plot_c12_button = self.add_plot_c12_button()
self.q_box_input = self.add_q_box()
self.plot_qiq_button = self.add_plot_qiq_button()
self.grid.addLayout(self.plot_g2_button, 2, 1, 1, 1,
QtCore.Qt.AlignLeft)
self.grid.addLayout(self.plot_c12_button, 2, 2, 1, 1,
QtCore.Qt.AlignLeft)
self.grid.addLayout(self.plot_qiq_button, 2, 3, 1, 1,
QtCore.Qt.AlignLeft)
self.grid.addLayout(self.q_box_input, 2, 6, 1, 1,
QtCore.Qt.AlignLeft)
if dataset_type == 'CFN':
self.rot_image_button = self.add_rot_image_button()
self.grid.addLayout(self.rot_image_button, 2, 2, 1, 1,
QtCore.Qt.AlignLeft)
self.stack_plot_button = self.add_stack_plot_button()
self.grid.addLayout(self.stack_plot_button, 2, 1, 1, 1,
QtCore.Qt.AlignLeft)
def add_rot_image_button(self):
rot_image_button = QPushButton("rot image")
rot_image_button.clicked.connect(self.rot_image)
button_section = QHBoxLayout()
button_section.addWidget(rot_image_button)
return button_section
def rot_image(self):
#print('here')
try:
self.value = self.value.T
except:
pass
def delete_dataset_buttons(self, dataset_type):
if dataset_type == 'CHX' and self.current_dataset_type == 'CHX':
self.deleteLayout(self.plot_g2_button)
self.deleteLayout(self.plot_c12_button)
self.deleteLayout(self.plot_qiq_button)
self.deleteLayout(self.q_box_input)
def deleteLayout(self, layout):
for i in range(layout.count()):
layout.itemAt(i).widget().close()
########End Deal with layout
def onresize(self, event):
#print('Here for resize')
self.file_items_list.tree.setMaximumWidth(int(0.3 * self.width()))
#self.dataset_table.table.setMinimumHeight(0.1*self.height())
#self.dataset_table.table.setMaximumWidth( 0.3*self.height() )
self.attribute_table.table.setMaximumWidth(int(0.3 * self.width()))
#self.guiplot.setMinimumHeight( 0.6*self.height() )
#self.guiplot.setMinimumHeight( 0.6*self.height() )
def add_open_button(self):
'''
Initialises the buttons in the button bar at the top of the main window. '''
open_file_btn = QPushButton('Open')
open_file_btn.clicked.connect(self.choose_file)
button_section = QHBoxLayout()
button_section.addWidget(open_file_btn)
#button_section.addStretch(0)
return button_section
def add_remove_button(self):
remove_file_btn = QPushButton('Remove File')
remove_file_btn.clicked.connect(self.remove_file)
button_section = QHBoxLayout()
button_section.addWidget(remove_file_btn)
return button_section
def add_create_button(self):
create_file_btn = QPushButton('Create File')
create_file_btn.clicked.connect(self.create_file)
button_section = QHBoxLayout()
button_section.addWidget(create_file_btn)
return button_section
def add_dataset_type_box(self):
self.dataset_type_obj = QComboBox()
self.dataset_type_obj.addItems(self.dataset_type_list)
self.dataset_type_obj.currentIndexChanged.connect(
self.dataset_type_selection_change)
self.dataset_type_obj_string = self.dataset_type_obj.currentText()
box_section = QHBoxLayout()
box_section.addWidget(self.dataset_type_obj)
return box_section
def dataset_type_selection_change(self, i):
self.dataset_type_obj_string = self.dataset_type_obj.currentText()
self.initialise_layout()
self.current_dataset_type = self.dataset_type_obj.currentText()
#print( self.dataset_type_obj_string , self.dataset_type_obj.currentText() )
def add_all_plot_buttons(self):
self.plot_curve_button = self.add_plot_curve_button()
self.plot_img_button = self.add_plot_img_button()
if self.plotLibrary != 'matplotlib':
self.plot_surface_button = self.add_plot_surface_button()
self.grid.addLayout(self.plot_surface_button, 1, 3, 1, 1,
QtCore.Qt.AlignLeft)
else:
self.plot_acr_datasets_button = self.add_plot_acr_datasets_button()
self.grid.addLayout(self.plot_acr_datasets_button, 2, 3, 1, 1,
QtCore.Qt.AlignLeft)
self.grid.addLayout(self.plot_curve_button, 1, 1, 1, 1,
QtCore.Qt.AlignLeft)
self.grid.addLayout(self.plot_img_button, 1, 2, 1, 1,
QtCore.Qt.AlignLeft)
def add_stack_plot_button(self):
return self.add_generic_plot_button(plot_type='plot_stack',
button_name='Stack Plot')
def add_plot_acr_datasets_button(self):
return self.add_generic_plot_button(
plot_type='stack_across', button_name='Stack Across Datasets')
def add_plot_g2_button(self):
return self.add_generic_plot_button(plot_type='g2',
button_name='Plot_g2')
def add_plot_c12_button(self):
return self.add_generic_plot_button(plot_type='C12',
button_name='Plot_TwoTime')
def add_plot_curve_button(self):
return self.add_generic_plot_button(plot_type='curve',
button_name='Plot_Curve')
def add_plot_qiq_button(self):
return self.add_generic_plot_button(plot_type='qiq',
button_name='Plot_qiq')
def add_plot_img_button(self):
return self.add_generic_plot_button(plot_type='image',
button_name='Plot_Image')
def add_plot_surface_button(self):
return self.add_generic_plot_button(plot_type='surface',
button_name='Plot_Surface')
def add_generic_plot_button(self, plot_type, button_name):
plot_btn = QPushButton(button_name)
pg_plot_type_dict = {
'curve': self.PWT.plot_curve,
'g2': self.PWT.plot_g2,
'qiq': self.PWT.plot_qiq,
'surface': self.PWT.plot_surface,
'image': self.PWT.plot_image,
'C12': self.PWT.plot_C12,
'plot_stack': self.PWT.plot_stack,
}
mat_plot_type_dict = {
'curve': self.MPWT.plot_curve,
'g2': self.PWT.plot_g2,
'qiq': self.PWT.plot_qiq,
'surface': self.MPWT.plot_surface,
'image': self.MPWT.plot_image,
'C12': self.PWT.plot_C12,
'plot_stack': self.MPWT.plot_stack,
'stack_across': self.MPWT.plot_across,
}
if self.plotLibrary == 'pyqtgraph':
plot_btn.clicked.connect(pg_plot_type_dict[plot_type])
if self.plotLibrary == 'matplotlib':
plot_btn.clicked.connect(mat_plot_type_dict[plot_type])
button_section = QHBoxLayout()
button_section.addWidget(plot_btn)
self.plot_buttons_array.append(plot_btn)
return button_section
def add_setlogX_box(self):
self.setlogX_box_obj = QCheckBox("logX")
self.setlogX_box_obj.stateChanged.connect(self.click_setlogX_box)
button_section = QHBoxLayout()
button_section.addWidget(self.setlogX_box_obj)
return button_section
def click_setlogX_box(self, state):
if state == QtCore.Qt.Checked:
self.logX_plot = True
else:
self.logX_plot = False
try:
self.guiplot.setLogMode(x=self.logX_plot, y=self.logY_plot)
except:
pass
def add_setlogY_box(self):
self.setlogY_box_obj = QCheckBox("logY")
self.setlogY_box_obj.stateChanged.connect(self.click_setlogY_box)
button_section = QHBoxLayout()
button_section.addWidget(self.setlogY_box_obj)
return button_section
def click_setlogY_box(self, state):
if state == QtCore.Qt.Checked:
self.logY_plot = True
else:
self.logY_plot = False
try:
self.guiplot.setLogMode(x=self.logX_plot, y=self.logY_plot)
except:
pass
def get_dict_from_qval_dict(self):
l = list(self.current_hdf5['qval_dict'].attrs.items())
dc = {int(i[0]): i[1] for i in l}
return dc
def add_setX_button(self):
self.setX_btn = QPushButton('SetX')
self.setX_btn.clicked.connect(self.setX)
button_section = QHBoxLayout()
button_section.addWidget(self.setX_btn)
return button_section
def add_resetX_button(self):
self.resetX_btn = QPushButton('ReSetX')
self.resetX_btn.clicked.connect(self.resetX)
button_section = QHBoxLayout()
button_section.addWidget(self.resetX_btn)
return button_section
def add_clr_plot_button(self):
self.clr_plot_button = QPushButton("clear plot")
self.clr_plot_button.clicked.connect(self.plot_clear)
button_section = QHBoxLayout()
button_section.addWidget(self.clr_plot_button)
return button_section
def plot_clear(self):
if self.plotLibrary == 'matplotlib':
if self.plot_type in plot_curve_type or self.plot_type in plot_image_type:
if self.plot_type in plot_image_type:
self.grid.removeWidget(self.MPWT.cb)
self.MPWT.cb.setWindowOpacity(0)
self.MPWT.cb.hide()
self.ax.clear()
self.canvas.draw()
self.canvas.hide()
self.canvas.show()
self.testplot_count = 0
elif self.plotLibrary == 'pyqtgraph':
self.guiplot.clear()
#self.surface_plot_count = 0
#self.grid.removeWidget(self.testplot)
#self.guiplot.setWindowOpacity(0)
#self.guiplot.hide()
try:
self.legend.scene().removeItem(self.legend)
except:
pass
def add_q_box(self):
# Create textbox
self.q_box = QLineEdit(
placeholderText="Please enter q-number (int) of two-time function."
)
button_section = QHBoxLayout()
button_section.addWidget(self.q_box)
return button_section
def make_menu_bar(self):
'''
Initialises the menu bar at the top. '''
menubar = self.menuBar()
# Create a File menu and add an open button
self.file_menu = menubar.addMenu('&File')
open_action = QtGui.QAction('&Open', self)
open_action.setShortcut('Ctrl+o')
open_action.triggered.connect(self.choose_file)
self.file_menu.addAction(open_action)
# Add a shortcut to copy and paste data
copy_data_action = QtGui.QAction('&Copy Data', self)
copy_data_action.setShortcut('Ctrl+c')
copy_data_action.triggered.connect(self.copy_data)
self.file_menu.addAction(copy_data_action)
paste_data_action = QtGui.QAction('&Paste Data', self)
paste_data_action.setShortcut('Ctrl+v')
paste_data_action.triggered.connect(self.paste_data)
self.file_menu.addAction(paste_data_action)
new_key_action = QtGui.QAction('&Add New Key', self)
new_key_action.setShortcut('Ctrl+n')
new_key_action.triggered.connect(self.create_key)
self.file_menu.addAction(new_key_action)
# Add an exit button to the file menu
exit_action = QtGui.QAction('&Exit', self)
exit_action.setShortcut('Ctrl+Z')
exit_action.setStatusTip('Exit application')
exit_action.triggered.connect(QtGui.qApp.quit)
self.file_menu.addAction(exit_action)
## Create a view manu
self.view_menu = menubar.addMenu('&View')
#self.view_menu.setShortcut('Alt+v')
self.plot_type_options_menu = self.view_menu.addMenu('&Plot Library')
group = QActionGroup(self.plot_type_options_menu)
texts = ["matplotlib", "pyqtgraph"]
for text in texts:
action = QAction(text,
self.plot_type_options_menu,
checkable=True,
checked=text == texts[0])
self.plot_type_options_menu.addAction(action)
group.addAction(action)
group.setExclusive(True)
group.triggered.connect(self.onTriggered_plotLibrary)
self.image_plot_options_menu = self.view_menu.addMenu(
'&Image Plot Options')
self.colormap_options_menu = self.image_plot_options_menu.addMenu(
'&Colormap')
group = QActionGroup(self.colormap_options_menu)
texts = image_colors
for text in texts:
action = QAction(text,
self.colormap_options_menu,
checkable=True,
checked=text == texts[0])
self.colormap_options_menu.addAction(action)
group.addAction(action)
group.setExclusive(True)
group.triggered.connect(self.onTriggered_colormap)
self.colorscale_options_menu = self.image_plot_options_menu.addMenu(
'&ColorScale')
group = QActionGroup(self.colorscale_options_menu)
texts = ["linear", "log"]
for text in texts:
action = QAction(text,
self.colormap_options_menu,
checkable=True,
checked=text == texts[1])
self.colorscale_options_menu.addAction(action)
group.addAction(action)
group.setExclusive(True)
group.triggered.connect(self.onTriggered_colorscale)
self.display_image_data_options_menu = self.view_menu.addMenu(
'&Display Image Data')
show_image_data_action = QAction('show data',
self,
checkable=True,
checked=False)
show_image_data_action.triggered.connect(
self.onTriggered_show_image_data)
self.display_image_data_options_menu.addAction(show_image_data_action)
self.stack_plot_options_menu = self.view_menu.addMenu(
'&Stack Plot Options')
set_stack_action = QtGui.QAction('Sampling and yshift', self)
set_stack_action.triggered.connect(self.onTriggered_set_stack)
self.stack_plot_options_menu.addAction(set_stack_action)
# Create a Help menu and add an about button
help_menu = menubar.addMenu('&Help')
about_action = QtGui.QAction('About XSH5FView', self)
about_action.setStatusTip('About this program')
about_action.triggered.connect(self.show_about_menu)
help_menu.addAction(about_action)
def onTriggered_set_stack(self, action):
print('set stack opt here.')
i, okPressed = QInputDialog.getInt(self, "Set Sampling Number",
"sampling:", self.vstack_sampling,
0, 10000, 10)
if okPressed:
self.vstack_sampling = i
print(i)
d, okPressed = QInputDialog.getDouble(self, "Set yshift", "Value:",
self.vstack_yshift, 0, 1e8, 2)
if okPressed:
self.vstack_yshift = d
print(d)
def onTriggered_show_image_data(self, action):
#print(action.text())
self.show_image_data = action #.text()
def onTriggered_colormap(self, action):
#print(action.text())
self.colormap_string = action.text()
def onTriggered_colorscale(self, action):
#print(action.text())
self.colorscale_string = action.text()
def onTriggered_plotLibrary(self, action):
self.plotLibrary = action.text()
for i in range(len(self.plot_buttons_array)):
button_to_remove = self.plot_buttons_array.pop()
self.grid.removeWidget(button_to_remove)
button_to_remove.setWindowOpacity(0)
button_to_remove.hide()
if action.text() == 'matplotlib':
self.toolbar.setWindowOpacity(100)
self.toolbar.show()
self.canvas.setWindowOpacity(100)
self.canvas.show()
else:
self.toolbar.setWindowOpacity(0)
self.toolbar.hide()
self.canvas.setWindowOpacity(0)
self.canvas.hide()
if action.text() == 'pyqtgraph':
self.guiplot.setWindowOpacity(100)
self.guiplot.show()
else:
self.guiplot.setWindowOpacity(0)
self.guiplot.hide()
self.add_all_plot_buttons()
self.initialise_layout()
def show_about_menu(self):
'''
Shows the about menu by initialising an about_window object. This class is described in _window_classes.py '''
self.about_window = ht.aboutWindow()
self.about_window.show()
def choose_file(self):
'''
Opens a QFileDialog window to allow the user to choose the hdf5 file they would like to view. '''
filenames_list = QtGui.QFileDialog.getOpenFileNames(
self,
'Open file',
'/home/yugang/Desktop/XPCS_GUI/TestData/test.h5',
filter='*.hdf5 *.h5 *.lst')[0]
for f in filenames_list:
ext = f.split('/')[-1].split('.')[-1]
if ext == 'lst':
full_filename_list = np.loadtxt(
f,
dtype=object,
)
group_name = f.split('/')[-1]
if group_name not in list(self.group_name_dict.keys()):
self.group_name_dict[group_name] = full_filename_list
for fp in full_filename_list:
self.initiate_file_open(fp, group_name=group_name)
else:
self.initiate_file_open(f)
def initiate_file_open(self, full_filename, group_name=None):
base_filename = full_filename.split('/')[-1]
self.full_filename_dict[full_filename] = group_name
self.dataset_table.clear()
self.attribute_table.clear()
try:
self.file_items_list.add_file(full_filename, group_name)
if group_name is None:
self.filename_label.setText(base_filename)
else:
self.filename_label.setText(group_name)
self.setWindowTitle('XSH5View@CHX - ' + base_filename)
except:
self.filename = '' # if it didn't work keep the old value
self.filename_label.setText('')
self.setWindowTitle('XSH5View@CHX')
self.clear_file_items()
self.dataset_table.clear()
self.attribute_table.clear()
print("Error opening file")
def create_file(self):
filename = self.file_items_list.create_file()
self.initiate_file_open(filename)
def remove_file(self, filename):
self.file_items_list.remove_file()
def clear_file_items(self):
self.file_items_list.clear()
def copy_data(self):
self.file_items_list.copy_data()
def paste_data(self):
destination = self.file_items_list.tree.currentItem().text(1)
item_path = self.file_items_list.tree.currentItem().text(2)
#self.file_items_list.remove_file()
self.file_items_list.paste_data(destination, item_path, self)
#self.initiate_file_open(destination)
def create_key(self):
item = self.file_items_list.tree.currentItem()
self.file_items_list.create_key(item.text(1), item.text(2), self)
def get_selected_row_col(self):
selected_items = self.dataset_table.table.selectedItems()
shape = np.shape(self.value)
Ns = len(shape)
if len(selected_items) > 0:
min_row = selected_items[0].row()
max_row = selected_items[-1].row() + 1
min_col = selected_items[0].column()
max_col = selected_items[-1].column() + 1
self.selected_flag = True
else:
if len(shape) == 1:
max_col = 1
else:
max_col = shape[1]
min_row = 0
max_row = shape[0]
min_col = 0
self.selected_flag = False
self.min_row, self.max_row, self.min_col, self.max_col = min_row, max_row, min_col, max_col
def setX(self):
self.get_selected_row_col()
min_row, max_row, min_col, max_col = self.min_row, self.max_row, self.min_col, self.max_col
if self.selected_flag:
try:
self.X = self.value[min_row:max_row, min_col]
except:
self.X = self.value[min_row:max_row]
def resetX(self):
self.X = None
def get_filename_selected(self):
self.dataset_table.clear()
self.item = self.file_items_list.tree.currentItem()
self.current_full_filename = self.item.text(1)
self.current_group_name = self.full_filename_dict[
self.current_full_filename]
#print("in get filename selected:", self.current_full_filename)
self.current_hdf5 = h5py.File(self.current_full_filename, 'r')
self.current_base_filename = self.current_full_filename.split('/')[-1]
self.current_item_path = self.item.text(2)
if self.current_item_path == '':
self.current_hdf5_item = self.current_hdf5
self.current_item_name = self.item.text(2)
else:
self.current_hdf5_item = self.current_hdf5[self.current_item_path]
self.current_item_name = self.item.text(2).split('/')[-1]
def display_dataset(self):
self.get_filename_selected()
text = self.current_item_path #self.item.text(2)
if self.current_item_path != '':
hdf5_file = self.current_hdf5_item
if isinstance(hdf5_file, h5py.Dataset):
#print( 'shows dataset-------------->')
self.group_data = False
#self.current_dataset = self.item_path.split('/')[-1]
shape = hdf5_file.shape
Ns = len(shape)
if Ns == 0:
try:
self.value = bstring_to_string(hdf5_file) #[0]
except:
self.value = np.array([hdf5_file]) #[0]
numrows = 1
numcols = 1
elif Ns == 1:
numrows = shape[0]
numcols = 1
self.value = hdf5_file[:]
elif Ns == 2:
numrows = shape[0]
numcols = shape[1]
self.value = hdf5_file[:]
elif Ns >= 3: #a 3D array, [x,y,z], show [x,y ]
if self.current_dataset_type == 'CHX':
numrows = shape[0]
numcols = shape[1]
try:
self.value = hdf5_file[:, :, self.qth]
except:
print('The max q-th is %s.' % shape[2])
self.value = hdf5_file[text][:, :, 0]
else:
numrows = shape[-2]
numcols = shape[-1]
try:
self.value = hdf5_file[self.qth, :, :]
except:
print('The max q-th is %s.' % shape[0])
elif isinstance(hdf5_file, h5py.Group):
print('display the group data here')
if text in self.pds_keys:
d = pds.read_hdf(self.filename, key=text) #[:]
self.value = np.array(d)
shape = self.value.shape
numrows = shape[0]
numcols = shape[1]
Ns = len(shape)
self.group_data_label = np.array(d.columns)[:]
self.group_data = True
else:
self.dataset_table.clear()
self.value = np.array([])
self.plot_btn.hide()
else:
print('Other format!')
try:
self.dataset_table.table.setRowCount(numrows)
self.dataset_table.table.setColumnCount(numcols)
show_data_flag = True
if not self.show_image_data:
if text in self.image_data_keys:
self.dataset_table.clear()
show_data_flag = False
try:
if self.value.shape[0] > 100 and self.value.shape[
1] > 100:
show_data_flag = False
except:
pass
if show_data_flag:
if Ns != -1:
for i in range(numrows):
if numcols > 1:
for j in range(numcols):
self.dataset_table.set_item(
i, j, str(self.value[i, j]))
else:
self.dataset_table.set_item(
i, 0, str(self.value[i]))
#print( self.attributes_flag )
if not self.attributes_flag:
self.attribute_table.clear()
self.attribute_table.table.setRowCount(1)
self.attribute_table.table.setColumnCount(Ns + 1)
self.attribute_table.table.setItem(
0, 0, QTableWidgetItem('shape'))
for i, s in enumerate(shape):
self.attribute_table.table.setItem(
0, i + 1, QTableWidgetItem('%s' % s))
except:
pass
self.current_hdf5.close()
def display_attributes(self):
# reset the value
self.attribute_table.clear()
self.get_filename_selected()
if self.current_item_path != '':
#print('Here shows the attributes')
hdf5_file = self.current_hdf5_item
try:
attributes = list(hdf5_file.attrs.items())
num_attributes = len(attributes)
self.attribute_table.table.setRowCount(num_attributes)
self.attribute_table.table.setColumnCount(0)
except:
num_attributes = 0
if num_attributes > 0:
self.attribute_table.table.setColumnCount(2)
self.attributes_flag = True
else:
self.attributes_flag = False
print(num_attributes, self.attributes_flag)
# Populate the table
for i in range(num_attributes):
value = attributes[i][1]
self.attribute_table.table.setItem(
i, 0, QTableWidgetItem(attributes[i][0]))
if isinstance(value, np.ndarray):
N = len(value)
self.attribute_table.table.setColumnCount(N + 1)
j = 1
for v in value:
self.attribute_table.table.setItem(
i, j, QTableWidgetItem(str(v)))
#self.attribute_table.setItem(i, 1, QTableWidgetItem(str(value[0].decode())))
j += 1
else:
self.attribute_table.table.setItem(
i, 1, QTableWidgetItem(str(value)))
self.current_hdf5.close()
def item_double_clicked(self):
'''
Responds to a double click on an item in the file_items_list.'''
#self.display_attributes()
try:
self.display_attributes()
#print('display attributes')
except:
pass
def item_clicked(self):
#############
#self.display_dataset()
#################3
try:
self.qth = int(self.q_box.text())
except:
self.qth = 0
try:
self.display_attributes()
#print('display attributes')
except:
pass
try:
self.display_dataset()
except:
pass
try:
self.filename_label.setText(self.current_base_filename)
self.setWindowTitle('XSH5View@CHX - ' + self.current_full_filename)
except:
pass
class PlotMaps(QtGui.QDialog, Ui_PlotMaps):
def __init__(self, modellst, type="sel", parent=None):
QtGui.QDialog.__init__(self,parent)
self.setupUi(self)
# Create the plot
#self.figure = plt.figure()
self.figure, self.axes = plt.subplots(nrows=3, ncols=1)
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.toolbar.hide()
# set the layout
layout = QtGui.QVBoxLayout()
layout.addWidget(self.canvas)
self.plotterBox.setLayout(layout)
self.closeButton.clicked.connect(self.close_)
if type == "sel":
self.modelBox.currentIndexChanged.connect(self.plotselectivitymap)
else:
self.modelBox.currentIndexChanged.connect(self.plotresolutionmap)
self.modellst = modellst
for model in self.modellst:
self.modelBox.addItem(model.modname)
def close_(self):
self.reject()
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 plotresolutionmap(self):
indx = self.modelBox.currentIndex()
if indx >= 0 and indx < len(self.modellst):
lss = self.modellst[indx].lss
flow_sofware = self.modellst[indx].flow
v_m = self.modellst[indx].v_m
v_d = self.modellst[indx].v_d
c_particle = self.modellst[indx].c_particle
c_length = self.modellst[indx].c_length
opt = OptSep(v_m, v_d, flow_sofware, lss)
opt.c_particle = c_particle
opt.c_length = c_length
[gcondlst, reslst, trlst] = opt.getResMapPlot("lss", float(flow_sofware), g_start_min=0.00, g_start_max=0.30, g_stop_min=0.50, g_stop_max=1.0, time_grad_min=2, time_grad_max=60)
#Plot resolution map
x = []
y_gsteepness = []
y_final_b = []
y_tg = []
z = []
for i in range(len(gcondlst)):
#gcondlst.append([init_b, final_b, tg, self.flow, lowest_alpha])
x.append(float(gcondlst[i][0])*100)
y_gsteepness.append(float((gcondlst[i][1]-gcondlst[i][0])/gcondlst[i][2])) # alpha
y_final_b.append(float(gcondlst[i][1])*100) # final b
y_tg.append(float(gcondlst[i][2])) # tg
z.append(float(gcondlst[i][-1]))
x = np.asarray(x)
y_gsteepness = np.asarray(y_gsteepness)
y_final_b = np.asarray(y_final_b)
y_tg = np.asarray(y_tg)
z = np.asarray(z)
# Set up a regular grid of interpolation points
npoints = 500
xi, yi_gsteepness = np.linspace(x.min(), x.max(), npoints), np.linspace(y_gsteepness .min(), y_gsteepness .max(), npoints)
xi, yi_gsteepness = np.meshgrid(xi, yi_gsteepness )
xi, yi_final_b = np.linspace(x.min(), x.max(), npoints), np.linspace(y_final_b.min(), y_final_b.max(), npoints)
xi, yi_final_b = np.meshgrid(xi, yi_final_b)
xi, yi_tg = np.linspace(x.min(), x.max(), npoints), np.linspace(y_tg.min(), y_tg.max(), npoints)
xi, yi_tg = np.meshgrid(xi, yi_tg)
# Interpolate
#rbf = scipy.interpolate.Rbf(x, y, z, function='linear')
#zi = rbf(xi, yi)
zi_gsteepness = scipy.interpolate.griddata((x, y_gsteepness ), z, (xi, yi_gsteepness ), method='linear')
zi_final_b = scipy.interpolate.griddata((x, y_final_b), z, (xi, yi_final_b), method='linear')
zi_tg = scipy.interpolate.griddata((x, y_tg), z, (xi, yi_tg), method='linear')
#f, axarr = plt.subplots(3, sharex=True)
#axes = self.figure.add_subplot(nrows=3, ncols=1)
im = self.axes.flat[0].imshow(zi_gsteepness , vmin=z.min(), vmax=z.max(), origin='lower', extent=[x.min(), x.max(), y_gsteepness .min(), y_gsteepness .max()], aspect='auto')
self.axes.flat[0].set_xlabel('Initial B (%)')
self.axes.flat[0].set_ylabel('Gradient steepness')
im = self.axes.flat[1].imshow(zi_final_b, vmin=z.min(), vmax=z.max(), origin='lower',
extent=[x.min(), x.max(), y_final_b.min(), y_final_b.max()], aspect='auto')
self.axes.flat[1].set_xlabel('Initial B (%)')
self.axes.flat[1].set_ylabel('Final B (%)')
im = self.axes.flat[2].imshow(zi_tg, vmin=z.min(), vmax=z.max(), origin='lower',
extent=[x.min(), x.max(), y_tg.min(), y_tg.max()], aspect='auto')
self.axes.flat[2].set_xlabel('Initial B (%)')
self.axes.flat[2].set_ylabel('Time gradient (min)')
self.figure.colorbar(im, ax=self.axes.ravel().tolist())
self.canvas.draw()
def plotselectivitymap(self):
plt.cla()
indx = self.modelBox.currentIndex()
if indx >= 0 and indx < len(self.modellst):
lss = self.modellst[indx].lss
flow_sofware = self.modellst[indx].flow
v_m = self.modellst[indx].v_m
v_d = self.modellst[indx].v_d
opt = OptSep(v_m, v_d, flow_sofware, lss)
[gcondlst, sellst, trlst] = opt.getSelMapPlot("lss", float(flow_sofware), g_start_min=0.00, g_start_max=0.30, g_stop_min=0.50, g_stop_max=1.0, time_grad_min=2, time_grad_max=60)
#Plot selectivity map
x = []
y_gsteepness = []
y_final_b = []
y_tg = []
z = []
for i in range(len(gcondlst)):
#gcondlst.append([init_b, final_b, tg, self.flow, lowest_alpha])
x.append(float(gcondlst[i][0])*100)
y_gsteepness.append(float((gcondlst[i][1]-gcondlst[i][0])/gcondlst[i][2]+1)) # alpha
y_final_b.append(float(gcondlst[i][1])*100) # final b
y_tg.append(float(gcondlst[i][2])) # tg
z.append(float(gcondlst[i][-1]))
x = np.asarray(x)
y_gsteepness = np.asarray(y_gsteepness)
y_final_b = np.asarray(y_final_b)
y_tg = np.asarray(y_tg)
z = np.asarray(z)
# Set up a regular grid of interpolation points
npoints = 500
xi, yi_gsteepness = np.linspace(x.min(), x.max(), npoints), np.linspace(y_gsteepness.min(), y_gsteepness.max(), npoints)
xi, yi_gsteepness = np.meshgrid(xi, yi_gsteepness)
xi, yi_final_b = np.linspace(x.min(), x.max(), npoints), np.linspace(y_final_b.min(), y_final_b.max(), npoints)
xi, yi_final_b = np.meshgrid(xi, yi_final_b)
xi, yi_tg = np.linspace(x.min(), x.max(), npoints), np.linspace(y_tg.min(), y_tg.max(), npoints)
xi, yi_tg = np.meshgrid(xi, yi_tg)
# Interpolate
#rbf = scipy.interpolate.Rbf(x, y, z, function='linear')
#zi = rbf(xi, yi)
zi_gsteepness = scipy.interpolate.griddata((x, y_gsteepness), z, (xi, yi_gsteepness), method='linear')
zi_final_b = scipy.interpolate.griddata((x, y_final_b), z, (xi, yi_final_b), method='linear')
zi_tg = scipy.interpolate.griddata((x, y_tg), z, (xi, yi_tg), method='linear')
#f, axarr = plt.subplots(3, sharex=True)
#axes = self.figure.add_subplot(nrows=3, ncols=1)
im = self.axes.flat[0].imshow(zi_gsteepness, vmin=z.min(), vmax=z.max(), origin='lower',
extent=[x.min(), x.max(), y_gsteepness.min(), y_gsteepness.max()], aspect='auto')
self.axes.flat[0].set_xlabel('Initial B (%)')
self.axes.flat[0].set_ylabel('Gradient steepness')
im = self.axes.flat[1].imshow(zi_final_b, vmin=z.min(), vmax=z.max(), origin='lower',
extent=[x.min(), x.max(), y_final_b.min(), y_final_b.max()], aspect='auto')
self.axes.flat[1].set_xlabel('Initial B (%)')
self.axes.flat[1].set_ylabel('Final B (%)')
im = self.axes.flat[2].imshow(zi_tg, vmin=z.min(), vmax=z.max(), origin='lower',
extent=[x.min(), x.max(), y_tg.min(), y_tg.max()], aspect='auto')
self.axes.flat[2].set_xlabel('Initial B (%)')
self.axes.flat[2].set_ylabel('Time gradient (min)')
self.figure.colorbar(im, ax=self.axes.ravel().tolist())
self.canvas.draw()
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 ComputeBestGradient(QtGui.QDialog, Ui_ComputeBestGradient):
def __init__(self, models, parent=None):
QtGui.QDialog.__init__(self,parent)
self.setupUi(self)
self.closeButton.clicked.connect(self.close_)
self.calculateButton.clicked.connect(self.calculate)
self.models = models
for model in self.models:
self.modelBox.addItem(model.modname)
# Create the plot
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.toolbar.hide()
# set the layout
layout = QtGui.QVBoxLayout()
layout.addWidget(self.canvas)
self.plotterBox.setLayout(layout)
def close_(self):
self.reject()
def calculate(self):
indx = self.modelBox.currentIndex()
logkw_s_tab = self.models[indx].lss
v_m = self.models[indx].v_m
v_d = self.models[indx].v_d
flow = self.models[indx].flow
opt = OptSep(v_m, v_d, flow, logkw_s_tab)
best_gcond, tr, rs_avg = opt.getgradientconditions(self.tr_min.value(), self.tr_max.value())
init_b = best_gcond[0]
final_b = best_gcond[1]
tg = best_gcond[2]
# Constant flow!
flow_min = flow-(flow*0.2)
flow_max = flow+(flow*0.2)
grad_start_min = init_b-(init_b*0.2)
grad_stop_min = init_b+(init_b*0.2)
grad_start_max = final_b-(final_b*0.2)
grad_stop_max = final_b+(final_b*0.2)
tg_min = tg-(tg*0.2)
tg_max = tg+(tg*0.2)
[gcondlst, rslst, trlst] = opt.getplotgradientconditions(flow_min, flow_max, grad_start_min, grad_start_max, grad_stop_min, grad_stop_max, tg_min, tg_max)
plt.clf()
ax = self.figure.gca(projection='3d')
#X = np.arange(-5, 5, 0.25)
#Y = np.arange(-5, 5, 0.25)
X = []
Y = []
Z = []
for i in range(len(gcondlst)):
row = gcondlst[i]
X.append(100 * ((row[1]-row[0])/row[2]))
Y.append(row[0])
if rslst[i] == -9999:
Z.append(0)
else:
Z.append(rslst[i])
t = Z
scatterplot = ax.scatter(X, Y, Z, c=t, cmap='jet', marker='o')
#X, Y = np.meshgrid(X, Y)
#R = np.sqrt(X**2 + Y**2)
#Z = np.sin(R)
#surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm,
# linewidth=0, antialiased=False)
self.figure.colorbar(scatterplot, shrink=0.5, aspect=5).remove()
self.figure.colorbar(scatterplot, shrink=0.5, aspect=5)
ax.hold(False)
ax.set_xlabel('Gradient slope %/min')
ax.set_ylabel('% initial of gradient')
ax.set_zlabel('Resolution')
self.canvas.draw()
best = Z.index(max(Z))
self.doubleSpinBox_5.setValue(rs_avg)
self.doubleSpinBox_1.setValue(init_b*100)
self.doubleSpinBox_2.setValue(final_b*100)
self.doubleSpinBox_3.setValue(tg)
self.doubleSpinBox_4.setValue(flow)
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 Plot(Widget, QtGui.QWidget):
def __init__(self, parent=None):
Widget.__init__(self)
QtGui.QWidget.__init__(self, parent)
self._data = 0
self._amostras = 20
self._datas = deque(maxlen=self._amostras)
self.create_main_frame()
#self.plot()
def create_main_frame(self):
self.main_frame = QWidget()
self.fig = Figure((5.0, 4.0), dpi=90)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
self.canvas.setFocusPolicy(Qt.StrongFocus)
self.canvas.setFocus()
self.axis = self.fig.add_subplot(111, axisbg='w')
self.axis.hold(False)
self.mpl_toolbar = NavigationToolbar(self.canvas, self.main_frame)
self.mpl_toolbar.hide()
self.canvas.mpl_connect('key_press_event', self.on_key_press)
vbox = QVBoxLayout()
vbox.addWidget(self.canvas) # the matplotlib canvas
vbox.addWidget(self.mpl_toolbar)
#self.main_frame.setLayout(vbox)
self.setLayout(vbox)
#self.setCentralWidget(self.main_frame)
def plot(self):
''' plot some random stuff '''
self.axis.plot(self._datas, '*-')
self.canvas.draw()
@property
def value(self):
return self._data
def add(self, value):
self._datas.append(value)
@value.setter
def value(self, data):
self._data = data
self.add(data)
self.plot()
def setValue(self, data):
self._data = data
self.add(data)
self.plot()
def amostras(self, amostras):
self._amostras = amostras
self._datas = deque(maxlen=self._amostras)
def on_key_press(self, event):
print('Plot pressed', event.key)
# implement the default mpl key press events described at
# http://matplotlib.org/users/navigation_toolbar.html#navigation-keyboard-shortcuts
try:
key_press_handler(event, self.canvas, self.mpl_toolbar)
except:
pass
class PyWeramiWindow(QtGui.QMainWindow, Ui_MainWindow):
def __init__(self, filename=None, parent=None):
super(PyWeramiWindow,self).__init__(parent)
self.settings = QtCore.QSettings("LX", "pywerami")
self.setupUi(self)
self._fig = plt.figure(facecolor="white")
self._ax = self._fig.add_subplot(111)
self._canvas = FigureCanvas(self._fig)
self._canvas.setParent(self.widget)
self._canvas.setFocusPolicy(QtCore.Qt.StrongFocus)
self.matplot.addWidget(self._canvas)
self.mpl_toolbar = NavigationToolbar(self._canvas,self.widget)
self.mpl_toolbar.hide()
self.matplot.addWidget(self.mpl_toolbar)
#set combos
self.cmaps = [m for m in plt.cm.datad if not m.endswith("_r")]
self.mapstyle.addItems(self.cmaps)
# set validators
self.levelmin.setValidator(QtGui.QDoubleValidator(self.levelmin))
self.levelmax.setValidator(QtGui.QDoubleValidator(self.levelmax))
self.levelnum.setValidator(QtGui.QIntValidator(self.levelmin))
self.levelstep.setValidator(QtGui.QDoubleValidator(self.levelstep))
self.clipmin.setValidator(QtGui.QDoubleValidator(self.clipmin))
self.clipmax.setValidator(QtGui.QDoubleValidator(self.clipmax))
# Set icons in toolbar
self.actionOpen.setIcon(QtGui.QIcon.fromTheme('document-open'))
self.actionSave.setIcon(QtGui.QIcon.fromTheme('document-save'))
self.actionSaveas.setIcon(QtGui.QIcon.fromTheme('document-save-as'))
self.actionImport.setIcon(QtGui.QIcon.fromTheme('x-office-spreadsheet'))
self.actionHome.setIcon(self.mpl_toolbar._icon('home.png'))
self.actionPan.setIcon(self.mpl_toolbar._icon('move.png'))
self.actionZoom.setIcon(self.mpl_toolbar._icon('zoom_to_rect.png'))
self.actionGrid.setIcon(QtGui.QIcon.fromTheme('format-justify-fill'))
self.actionAxes.setIcon(self.mpl_toolbar._icon('qt4_editor_options.png'))
self.actionSavefig.setIcon(self.mpl_toolbar._icon('filesave.png'))
#self.action3D.setIcon(QtGui.QIcon.fromTheme(''))
self.actionProperties.setIcon(QtGui.QIcon.fromTheme('preferences-other'))
self.actionQuit.setIcon(QtGui.QIcon.fromTheme('application-exit'))
self.actionAbout.setIcon(QtGui.QIcon.fromTheme('help-about'))
self.actionImport.triggered.connect(self.import_data)
self.actionHome.triggered.connect(self.mpl_toolbar.home)
self.actionPan.triggered.connect(self.plotpan)
self.actionZoom.triggered.connect(self.plotzoom)
self.actionGrid.triggered.connect(self.plotgrid)
self.actionAxes.triggered.connect(self.mpl_toolbar.edit_parameters)
self.actionSavefig.triggered.connect(self.mpl_toolbar.save_figure)
self.actionProperties.triggered.connect(self.edit_options)
self.actionQuit.triggered.connect(self.close)
if filename:
self.import_data(filename)
# ready
self.statusbar.showMessage("Ready", 5000)
def closeEvent(self,event):
reply=QtGui.QMessageBox.question(self,'Message',"Are you sure to quit?",QtGui.QMessageBox.Yes,QtGui.QMessageBox.No)
if reply==QtGui.QMessageBox.Yes:
event.accept()
else:
event.ignore()
def import_data(self, filename=None):
if not filename:
filename = QtGui.QFileDialog.getOpenFileName(self, "Import tab file", ".", "TAB (*.tab);;All files (*.*)")
if filename:
self.data = WeramiData.from_tab(filename)
# populate listview and setup properties
self.props = {}
self._model = QtGui.QStandardItemModel(self.listView)
for var in self.data.dep:
item = QtGui.QStandardItem(var)
item.setCheckable(True)
self._model.appendRow(item)
self.default_var_props(var)
self.listView.setModel(self._model)
self.listView.show()
# connect listview signals
self.varSel = self.listView.selectionModel()
self.varSel.selectionChanged.connect(self.on_var_changed)
self._model.itemChanged.connect(self.plot)
# buttons signals
self.buttonBox.button(QtGui.QDialogButtonBox.Apply).clicked.connect(self.apply_props)
self.buttonBox.button(QtGui.QDialogButtonBox.RestoreDefaults).clicked.connect(self.restore_props)
self.contcolor.clicked.connect(self.contours_color)
self.action3D.triggered.connect(self.switch3d)
# signals to calculate step size
self.levelmin.editingFinished.connect(self.step_from_levels)
self.levelmax.editingFinished.connect(self.step_from_levels)
self.levelnum.editingFinished.connect(self.step_from_levels)
self.setlevels.toggled.connect(self.step_from_levels)
# all done focus
self.action3D.setChecked(False) # no 3d on import
self.varSel.setCurrentIndex(self._model.index(0, 0), QtGui.QItemSelectionModel.ClearAndSelect | QtGui.QItemSelectionModel.Rows)
self.listView.setFocus()
self.plot()
self.statusbar.showMessage("Data from {} imported".format(self.data.label), 5000)
def contours_color(self):
col = QtGui.QColorDialog.getColor()
if col.isValid():
self.contcolor.setStyleSheet("background-color: {}".format(col.name()))
def step_from_levels(self):
if self.setlevels.isChecked():
step = (float(self.levelmax.text()) - float(self.levelmin.text())) / (int(self.levelnum.text()) - 1)
self.levelstep.setText(repr(step))
self.props[self.var]['step'] = step
def default_var_props(self, var):
data = self.data.get_var(var)
prop = {}
#levels
prop['min'] = data.min()
prop['max'] = data.max()
prop['num'] = 10
prop['step'] = (prop['max'] - prop['min']) / (prop['num'] - 1)
prop['levels'] = 'num'
prop['type'] = 'linear'
#style
prop['fill'] = False
prop['opacity'] = 100
prop['cmap'] = 'jet'
prop['contours'] = 'color'
prop['color'] = '#000000'
prop['label'] = False
#processing
prop['resample'] = 1
prop['median'] = 1
prop['gauss'] = 0
prop['clipmin'] = data.min()
prop['clipmax'] = data.max()
self.props[var] = prop
def set_var_props(self, var):
#levels
self.levelmin.setText(repr(self.props[var]['min']))
self.levelmax.setText(repr(self.props[var]['max']))
self.levelnum.setText(repr(self.props[var]['num']))
self.levelstep.setText(repr(self.props[var]['step']))
if self.props[var]['levels'] == 'num':
self.setlevels.setChecked(True)
else:
self.setstep.setChecked(True)
if self.props[var]['type'] == 'linear':
self.linlevel.setChecked(True)
else:
self.cdflevel.setChecked(True)
#style
if self.props[var]['fill']:
self.fillstyle.setChecked(True)
else:
self.fillstyle.setChecked(False)
self.opacity.setValue(self.props[var]['opacity'])
self.mapstyle.setCurrentIndex(self.cmaps.index(self.props[var]['cmap']))
self.contcolor.setStyleSheet("background-color: {}".format(self.props[var]['color']))
if self.props[var]['contours'] == 'map':
self.contcheckmap.setChecked(True)
elif self.props[var]['contours'] == 'color':
self.contcheckcolor.setChecked(True)
else:
self.contchecknone.setChecked(True)
if self.props[var]['label']:
self.contlabel.setChecked(True)
else:
self.contlabel.setChecked(False)
#processing
self.resample.setValue(self.props[var]['resample'])
self.filtersize.setValue(self.props[var]['median'])
self.filtersigma.setValue(self.props[var]['gauss'])
self.clipmin.setText(repr(self.props[var]['clipmin']))
self.clipmax.setText(repr(self.props[var]['clipmax']))
def on_var_changed(self, selected):
self.var = self.data.dep[selected.indexes()[0].row()]
self.set_var_props(self.var)
if self.action3D.isChecked():
self.plot()
def apply_props(self):
#levels
self.props[self.var]['min'] = float(self.levelmin.text())
self.props[self.var]['max'] = float(self.levelmax.text())
self.props[self.var]['num'] = int(self.levelnum.text())
self.props[self.var]['step'] = float(self.levelstep.text())
if self.setlevels.isChecked():
self.props[self.var]['levels'] = 'num'
else:
self.props[self.var]['levels'] = 'step'
if self.linlevel.isChecked():
self.props[self.var]['type'] = 'linear'
else:
self.props[self.var]['type'] = 'cdf'
#style
if self.fillstyle.isChecked():
self.props[self.var]['fill'] = True
else:
self.props[self.var]['fill'] = False
self.props[self.var]['opacity'] = self.opacity.value()
self.props[self.var]['cmap'] = str(self.mapstyle.currentText())
self.props[self.var]['color'] = str(self.contcolor.palette().color(1).name())
if self.contcheckmap.isChecked():
self.props[self.var]['contours'] = 'map'
elif self.contcheckcolor.isChecked():
self.props[self.var]['contours'] = 'color'
else:
self.props[self.var]['contours'] = ''
if self.contlabel.isChecked():
self.props[self.var]['label'] = True
else:
self.props[self.var]['label'] = False
#processing
self.props[self.var]['resample'] = self.resample.value()
self.props[self.var]['median'] = self.filtersize.value()
self.props[self.var]['gauss'] = self.filtersigma.value()
self.props[self.var]['clipmin'] = float(self.clipmin.text())
self.props[self.var]['clipmax'] = float(self.clipmax.text())
self.plot()
def restore_props(self):
self.default_var_props(self.var)
self.set_var_props(self.var)
self.plot()
def edit_options(self):
dlg = OptionsForm(self)
dlg.exec_()
def plotpan(self):
self.actionZoom.setChecked(False)
self.mpl_toolbar.pan()
def plotzoom(self):
self.actionPan.setChecked(False)
self.mpl_toolbar.zoom()
def plotgrid(self):
plt.grid()
self._canvas.draw()
def switch3d(self):
if not self.action3D.isChecked():
self._fig.clear()
self._ax = self._fig.add_subplot(111)
else:
self._fig.clear()
self._ax = self._fig.add_subplot(111, projection='3d')
self.plot()
def plot(self):
self._ax.cla()
if not self.action3D.isChecked():
extent = self.data.get_extent()
i = 0
while self._model.item(i):
if self._model.item(i).checkState():
CS = None
var = str(self._model.item(i).text())
# get data, smooth and clip
data = self.data.get_var(var,nan=np.float(self.settings.value("nan", "NaN", type=str)))
if self.props[var]['resample'] > 1:
data = np.ma.array(ndimage.zoom(data.filled(0), self.props[var]['resample']), mask=ndimage.zoom(data.mask, self.props[var]['resample'], order=0))
if self.props[var]['median'] > 1:
data = np.ma.array(ndimage.median_filter(data, size=self.props[var]['median']*self.props[var]['resample']), mask=data.mask)
if self.props[var]['gauss'] > 0:
data = np.ma.array(ndimage.gaussian_filter(data, sigma=self.props[var]['gauss']*self.props[var]['resample']), mask=data.mask)
data = np.ma.masked_outside(data, self.props[var]['clipmin'], self.props[var]['clipmax'])
if self.props[var]['fill']:
self._ax.imshow(data, interpolation='none', origin='lower', extent=extent, aspect='auto', cmap=plt.get_cmap(self.props[var]['cmap']), alpha=self.props[var]['opacity']/100.0)
if self.props[var]['type'] == 'linear':
if self.props[var]['levels'] == 'num':
clevels = np.linspace(self.props[var]['min'], self.props[var]['max'], self.props[var]['num'])
else:
# trick to include max in levels
clevels = np.arange(self.props[var]['min'], self.props[var]['max'] + 10**np.ceil(np.log10(np.abs(self.props[var]['max']))), self.props[var]['step'])
else:
# cdf based on histogram binned acording to the Freedman-Diaconis rule
v = np.sort(data.compressed())
IQR = v[int(round((v.size-1) * float(0.75)))] - v[int(round((v.size-1) * float(0.25)))]
bin_size = 2 * IQR * v.size**(-1.0/3)
nbins = int(round(max(self.props[var]['num'], (v[-1]-v[0]) / (bin_size+0.001))))
hist, bin_edges = np.histogram(v, bins=nbins)
cdf = np.cumsum(hist)
cdfx = np.cumsum(np.diff(bin_edges)) + bin_edges[:2].sum()/2
clevels = np.interp(np.linspace(cdf[0],cdf[-1],self.props[var]['num'] + 2)[1:-1], cdf, cdfx)
if self.props[var]['contours'] == 'map':
CS = self._ax.contour(self.data.get_xrange(self.props[var]['resample']), self.data.get_yrange(self.props[var]['resample']), data, clevels, cmap=plt.get_cmap(self.props[var]['cmap']))
elif self.props[var]['contours'] == 'color':
CS = self._ax.contour(self.data.get_xrange(self.props[var]['resample']), self.data.get_yrange(self.props[var]['resample']), data, clevels, colors=self.props[var]['color'])
if self.props[var]['label'] and CS:
self._ax.clabel(CS, fontsize=8, inline=1)
i += 1
self._ax.axis(extent)
plt.title(self.data.label)
else:
# get data, smooth and clip
data = self.data.get_var(self.var)
if self.props[self.var]['resample'] > 1:
data = np.ma.array(ndimage.zoom(data.filled(0), self.props[self.var]['resample']), mask=ndimage.zoom(data.mask, self.props[self.var]['resample'], order=0))
if self.props[self.var]['median'] > 1:
data = np.ma.array(ndimage.median_filter(data, size=self.props[self.var]['median']*self.props[self.var]['resample']), mask=data.mask)
if self.props[self.var]['gauss'] > 0:
data = np.ma.array(ndimage.gaussian_filter(data, sigma=self.props[self.var]['gauss']*self.props[self.var]['resample']), mask=data.mask)
data = np.ma.masked_outside(data, self.props[self.var]['clipmin'], self.props[self.var]['clipmax'])
x,y = np.meshgrid(self.data.get_xrange(self.props[self.var]['resample']), self.data.get_yrange(self.props[self.var]['resample']))
self._ax.plot_surface(x, y, data.filled(np.NaN), vmin=data.min(), vmax=data.max(), cmap=plt.get_cmap(self.props[self.var]['cmap']), linewidth=0.5, alpha=self.props[self.var]['opacity']/100.0)
self._ax.view_init(azim=235, elev=30)
plt.xlabel(self.data.ind[self.data.xvar]['name'])
plt.ylabel(self.data.ind[self.data.yvar]['name'])
plt.tight_layout()
self._canvas.draw()
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.QWidget):
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.setWindowTitle('OpenWave-2KE V%s'%__version__)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap("openwave.ico"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.setWindowIcon(icon)
#Waveform area.
self.figure = plt.figure()
self.figure.set_facecolor('white')
self.canvas = FigureCanvas(self.figure)
self.canvas.setMinimumSize(800, 400)
self.toolbar = NavigationToolbar(self.canvas, self)
self.toolbar.hide()
#Zoom In/out and Capture Buttons
self.zoomBtn = QtGui.QPushButton('Zoom')
self.zoomBtn.setFixedSize(100, 30)
self.zoomBtn.clicked.connect(self.toolbar.zoom)
self.panBtn = QtGui.QPushButton('Pan')
self.panBtn.setFixedSize(100, 30)
self.panBtn.clicked.connect(self.toolbar.pan)
self.homeBtn = QtGui.QPushButton('Home')
self.homeBtn.setFixedSize(100, 30)
self.homeBtn.clicked.connect(self.toolbar.home)
self.captureBtn = QtGui.QPushButton('Capture')
self.captureBtn.setFixedSize(100, 50)
self.captureBtn.clicked.connect(self.captureAction)
if(dso.connection_status==0):
self.captureBtn.setEnabled(False)
#Type: Raw Data/Image
self.typeBtn = QtGui.QPushButton('Raw Data')
self.typeBtn.setToolTip("Switch to get raw data or image from DSO.")
self.typeBtn.setFixedSize(120, 50)
self.typeFlag=True #Initial state -> Get raw data
self.typeBtn.setCheckable(True)
self.typeBtn.setChecked(True)
self.typeBtn.clicked.connect(self.typeAction)
#Channel Selection.
self.ch1checkBox = QtGui.QCheckBox('CH1')
self.ch1checkBox.setFixedSize(60, 30)
self.ch2checkBox = QtGui.QCheckBox('CH2')
self.ch2checkBox.setFixedSize(60, 30)
if(dso.chnum==4):
self.ch3checkBox = QtGui.QCheckBox('CH3')
self.ch3checkBox.setFixedSize(60, 30)
self.ch4checkBox = QtGui.QCheckBox('CH4')
self.ch4checkBox.setFixedSize(60, 30)
#Set channel selection layout.
self.selectLayout = QtGui.QHBoxLayout()
self.selectLayout.addWidget(self.ch1checkBox)
self.selectLayout.addWidget(self.ch2checkBox)
if(dso.chnum==4):
self.selectLayout2 = QtGui.QHBoxLayout()
self.selectLayout2.addWidget(self.ch3checkBox)
self.selectLayout2.addWidget(self.ch4checkBox)
self.typeLayout = QtGui.QHBoxLayout()
self.typeLayout.addWidget(self.typeBtn)
self.typeLayout.addLayout(self.selectLayout)
if(dso.chnum==4):
self.typeLayout.addLayout(self.selectLayout2)
#Save/Load/Quit button
self.saveBtn = QtGui.QPushButton('Save')
self.saveBtn.setFixedSize(100, 50)
self.saveMenu = QtGui.QMenu(self)
self.csvAction = self.saveMenu.addAction("&As CSV File")
self.pictAction = self.saveMenu.addAction("&As PNG File")
self.saveBtn.setMenu(self.saveMenu)
self.saveBtn.setToolTip("Save waveform to CSV file or PNG file.")
self.connect(self.csvAction, QtCore.SIGNAL("triggered()"), self.saveCsvAction)
self.connect(self.pictAction, QtCore.SIGNAL("triggered()"), self.savePngAction)
self.loadBtn = QtGui.QPushButton('Load')
self.loadBtn.setToolTip("Load CHx's raw data from file(*.csv, *.lsf).")
self.loadBtn.setFixedSize(100, 50)
self.loadBtn.clicked.connect(self.loadAction)
self.quitBtn = QtGui.QPushButton('Quit')
self.quitBtn.setFixedSize(100, 50)
self.quitBtn.clicked.connect(self.quitAction)
# set the layout
self.waveLayout = QtGui.QHBoxLayout()
self.waveLayout.addWidget(self.canvas)
self.wave_box=QtGui.QVBoxLayout()
self.wave_box.addLayout(self.waveLayout)
self.wavectrlLayout = QtGui.QHBoxLayout()
self.wavectrlLayout.addWidget(self.zoomBtn)
self.wavectrlLayout.addWidget(self.panBtn)
self.wavectrlLayout.addWidget(self.homeBtn)
self.wavectrlLayout.addWidget(self.captureBtn)
self.saveloadLayout = QtGui.QHBoxLayout()
self.saveloadLayout.addWidget(self.saveBtn)
self.saveloadLayout.addWidget(self.loadBtn)
self.saveloadLayout.addWidget(self.quitBtn)
self.ctrl_box=QtGui.QHBoxLayout()
self.ctrl_box.addLayout(self.typeLayout)
self.ctrl_box.addLayout(self.saveloadLayout)
main_box=QtGui.QVBoxLayout()
main_box.addLayout(self.wave_box) #Waveform area.
main_box.addLayout(self.wavectrlLayout) #Zoom In/Out...
main_box.addLayout(self.ctrl_box) #Save/Load/Quit
self.setLayout(main_box)
def typeAction(self):
if(self.typeFlag==True):
self.typeFlag=False
self.typeBtn.setText("Image")
self.csvAction.setEnabled(False)
else:
self.typeFlag=True
self.typeBtn.setText("Raw Data")
self.csvAction.setEnabled(True)
self.typeBtn.setChecked(self.typeFlag)
self.ch1checkBox.setEnabled(self.typeFlag)
self.ch2checkBox.setEnabled(self.typeFlag)
if(dso.chnum==4):
self.ch3checkBox.setEnabled(self.typeFlag)
self.ch4checkBox.setEnabled(self.typeFlag)
def saveCsvAction(self):
if(self.typeFlag==True): #Save raw data to csv file.
file_name=QtGui.QFileDialog.getSaveFileName(self, "Save as", '', "Fast CSV File(*.CSV)")[0]
num=len(dso.ch_list)
#print num
for ch in xrange(num):
if(dso.info[ch]==[]):
print('Failed to save data, raw data information is required!')
return
f = open(file_name, 'wb')
item=len(dso.info[0])
#Write file header.
f.write('%s,\r\n' % dso.info[0][0])
for x in xrange(1, 24):
str=''
for ch in xrange(num):
str+=('%s,' % dso.info[ch][x])
str+='\r\n'
f.write(str)
#Write Fast CSV mode only.
str=''
for ch in xrange(num):
str+='Mode,Fast,'
str+='\r\n'
f.write(str)
str=''
if(num==1):
str+=('%s,' % dso.info[0][25])
else:
for ch in xrange(num):
str+=('%s,,' % dso.info[ch][25])
str+='\r\n'
f.write(str)
#Write raw data.
item=len(dso.iWave[0])
#print item
tenth=int(item/10)
n_tenth=tenth-1
percent=10
for x in xrange(item):
str=''
if(num==1):
str+=('%s,' % dso.iWave[0][x])
else:
for ch in xrange(num):
str+=('%s, ,' % dso.iWave[ch][x])
str+='\r\n'
f.write(str)
if(x==n_tenth):
n_tenth+=tenth
print('%3d %% Saved\r'%percent),
percent+=10
f.close()
def savePngAction(self):
#Save figure to png file.
file_name=QtGui.QFileDialog.getSaveFileName(self, "Save as", '', "PNG File(*.png)")[0]
if(file_name==''):
return
if(self.typeFlag==True): #Save raw data waveform as png file.
main.figure.savefig(file_name)
else: #Save figure to png file.
if(dso.osname=='pi'): #For raspberry pi only.
img=dso.im.transpose(Image.FLIP_TOP_BOTTOM)
img.save(file_name)
else:
dso.im.save(file_name)
print('Saved image to %s.'%file_name)
def loadAction(self):
dso.ch_list=[]
full_path_name=QtGui.QFileDialog.getOpenFileName(self,self.tr("Open File"),".","CSV/LSF files (*.csv *.lsf);;All files (*.*)")
sFileName=unicode(full_path_name).split(',')[0][3:-1] #For PySide
print sFileName
if(len(sFileName)<=0):
return
if os.path.exists(sFileName):
print 'Reading file...'
count=dso.readRawDataFile(sFileName)
#Draw waveform.
if(count>0):
total_chnum=len(dso.ch_list)
if(total_chnum==0):
return
self.drawWaveform(0)
else:
print('File not found!')
def quitAction(self):
if(dso.connection_status==1):
dso.closeIO()
self.close()
def captureAction(self):
dso.iWave=[[], [], [], []]
dso.ch_list=[]
if(self.typeFlag==True): #Get raw data.
draw_flag=False
#Turn on the selected channels.
if((self.ch1checkBox.isChecked()==True) and (dso.isChannelOn(1)==False)):
dso.write(":CHAN1:DISP ON\n") #Set CH1 on.
if((self.ch2checkBox.isChecked()==True) and (dso.isChannelOn(2)==False)):
dso.write(":CHAN2:DISP ON\n") #Set CH2 on.
if(dso.chnum==4):
if((self.ch3checkBox.isChecked()==True) and (dso.isChannelOn(3)==False)):
dso.write(":CHAN3:DISP ON\n") #Set CH3 on.
if((self.ch4checkBox.isChecked()==True) and (dso.isChannelOn(4)==False)):
dso.write(":CHAN4:DISP ON\n") #Set CH4 on.
#Get all the selected channel's raw datas.
if(self.ch1checkBox.isChecked()==True):
dso.getRawData(True, 1) #Read CH1's raw data from DSO (including header).
if(self.ch2checkBox.isChecked()==True):
dso.getRawData(True, 2) #Read CH2's raw data from DSO (including header).
if(dso.chnum==4):
if(self.ch3checkBox.isChecked()==True):
dso.getRawData(True, 3) #Read CH3's raw data from DSO (including header).
if(self.ch4checkBox.isChecked()==True):
dso.getRawData(True, 4) #Read CH4's raw data from DSO (including header).
#Draw waveform.
total_chnum=len(dso.ch_list)
if(total_chnum==0):
return
if(self.drawWaveform(1)==-1):
time.sleep(5)
self.drawWaveform(0)
else: #Get image.
img_type=1 #1 for RLE format, 0 for PNG format.
if(img_type):
dso.write(':DISP:OUTP?\n') #Send command to get image from DSO.
else:
dso.write(':DISP:PNGOutput?\n') #Send command to get image from DSO.
dso.getBlockData()
dso.ImageDecode(img_type)
self.showImage()
plt.tight_layout(True)
self.canvas.draw()
print('Image is ready!')
def showImage(self):
#Turn the ticks off and show image.
plt.clf()
ax = plt.gca()
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
plt.imshow(dso.im)
def drawWaveform(self, mode):
total_chnum=len(dso.ch_list)
num=dso.points_num
ch_colortable=['#C0B020', '#0060FF', '#FF0080', '#00FF60']
ch=int(dso.ch_list[0][2])-1 #Get the channel of first waveform.
plt.cla()
plt.clf()
#Due to the memory limitation of matplotlib, we must reduce the sample points.
if(num==10000000):
if(total_chnum>2):
down_sample_factor=4
elif(total_chnum==2):
down_sample_factor=4
else:
down_sample_factor=1
num=num/down_sample_factor
else:
down_sample_factor=1
dt=dso.dt[0] #Get dt from the first opened channel.
t_start=dso.hpos[0]-num*dt/2
t_end =dso.hpos[0]+num*dt/2
t = np.arange(t_start, t_end, dt)
#print t_start, t_end, dt, len(t)
if((len(t)-num)==1): #Avoid floating point rounding error.
t=t[:-1]
wave_type='-' #Set waveform type to vector.
#Draw waveforms.
ax=[[], [], [], []]
p=[]
for ch in xrange(total_chnum):
if(ch==0):
ax[ch]=host_subplot(111, axes_class=AA.Axes)
ax[ch].set_xlabel("Time (sec)")
else:
ax[ch]=ax[0].twinx()
ax[ch].set_ylabel("%s Units: %s" %(dso.ch_list[ch], dso.vunit[ch]))
ch_color=ch_colortable[int(dso.ch_list[ch][2])-1]
if(ch>1):
new_fixed_axis = ax[ch].get_grid_helper().new_fixed_axis
ax[ch].axis["right"] = new_fixed_axis(loc="right", axes=ax[ch], offset=(60*(ch-1), 0))
ax[ch].set_xlim(t_start, t_end)
ax[ch].set_ylim(-4*dso.vdiv[ch]-dso.vpos[ch], 4*dso.vdiv[ch]-dso.vpos[ch]) #Setup vertical display range.
fwave=dso.convertWaveform(ch, down_sample_factor)
#print('Length=%d'%(len(fwave)))
if(ch==0):
try:
p=ax[ch].plot(t, fwave, color=ch_color, ls=wave_type, label = dso.ch_list[ch])
except:
if(mode==1):
#print sys.exc_info()[0]
time.sleep(5)
print 'Trying to plot again!',
return -1
else:
try:
p+=ax[ch].plot(t, fwave, color=ch_color, ls=wave_type, label = dso.ch_list[ch])
except:
if(mode==1):
#print sys.exc_info()[0]
time.sleep(5)
print 'Trying to plot again!',
return -1
if(total_chnum>1):
labs = [l.get_label() for l in p]
plt.legend(p, labs, loc='upper right')
plt.tight_layout()
self.canvas.draw()
del ax, t, p
return 0
class Window(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.shot = None #opened shot
self.folder_name = '' #folder to search for shots
self.current_num = 0 #current diagram
self.currently_selected = None #selected point plot
self.selected_points = OrderedSet() #point to be added
self.current_point = None #plot of current point
self.overall_selected = None #points added to selected list
#super(Window, self).__init__(parent)
# a figure instance to plot on
self.figure = plt.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.canvas.setParent(parent)
self.canvas.setFocusPolicy(QtCore.Qt.StrongFocus)
self.canvas.setFocus()
self.canvas.setMinimumSize(500, 0)
self.canvas.mpl_connect('pick_event', self.on_pick)
self.canvas.mpl_connect('motion_notify_event', self.on_move)
self.canvas.hide()
# this is the Navigation widget
# it takes the Canvas widget and a pa rent
self.toolbar = NavigationToolbar(self.canvas, self)
self.toolbar.hide()
# Show files widget
self.files = QtGui.QListWidget()
self.files.itemDoubleClicked.connect(self.select_file)
self.files.setMaximumSize(200, 100000)
self.files.setMinimumSize(100, 0)
self.files.hide()
# Show selected points
self.points = ThumbListWidget(self)
#self.points.itemDoubleClicked.connect(self.unselect_point)
self.points.itemClicked.connect(self.points_clicked)
self.points.itemDoubleClicked.connect(self.points_doubleclicked)
self.points.setMaximumSize(200, 100000)
self.points.setMinimumSize(100, 0)
self.points.hide()
#Show diagram widget
self.diagrams = QtGui.QListWidget()
self.diagrams.itemClicked.connect(self.select_item)
self.diagrams.setMaximumSize(250, 100000)
self.diagrams.setMinimumSize(190, 0)
self.diagrams.hide()
#save result button
self.save_button = QtGui.QPushButton('Add time point', self)
self.save_button.clicked.connect(self.add_time)
self.save_button.hide()
#filter menu
self.filters_button = QtGui.QPushButton('Manage filters', self)
self.filters_button.clicked.connect(self.show_filters)
self.filters_button.hide()
self.filters = OrderedDict
self.read_filters()
#diagramms
self.bottom_layout = QtGui.QGridLayout()
self.diagrams_figure = plt.figure()
self.diagrams_canvas = FigureCanvas(self.diagrams_figure)
self.diagrams_canvas.setParent(parent)
self.diagrams_canvas.setMinimumSize(250, 250)
self.diagrams_canvas.setMaximumSize(500, 500)
self.diagrams_toolbar = NavigationToolbar(self.diagrams_canvas, self)
self.diagrams_toolbar.setMaximumWidth(250)
self.diagrams_ax = self.diagrams_figure.add_subplot(111)
self.diagrams_ax.set_ylim(ymin=0)
self.diagrams_ax.set_xlim(xmin=0)
self.diagrams_canvas.draw()
self.enlargre_button = QtGui.QPushButton('Enlarge diagram', self)
self.enlargre_button.clicked.connect(self.enlarge_diagram)
self.bottom_layout.addWidget(self.diagrams_toolbar, 0, 2)
self.bottom_layout.addWidget(self.diagrams_canvas, 1, 2, QtCore.Qt.AlignRight)
self.bottom_layout.addWidget(self.enlargre_button, 0, 1)
# set the layout
self.layout = QtGui.QGridLayout()
self.layout.addWidget(self.filters_button, 0, 1)
self.layout.addWidget(self.toolbar, 0, 2)
self.layout.addWidget(self.canvas, 1, 2)
self.layout.addWidget(self.diagrams, 1, 1)
self.layout.addWidget(self.files, 1, 0)
self.layout.addWidget(self.points, 1, 3)
self.layout.addWidget(self.save_button, 0, 3)
self.layout.addLayout(self.bottom_layout, 2, 2)
self.setLayout(self.layout)
def enlarge_diagram(self): #меняет местами диаграммы
pass
def points_doubleclicked(self):
if self.points._mouse_button == 1:
num = self.points.currentRow()
point = list(self.selected_points)[num]
diag = self.shot.get_diagram(self.current_num)
xs = np.array(diag.x)
ys = np.array(diag.y)
idx = np.absolute(xs - point[0]).argmin()
npoint = (xs[idx], ys[idx], self.current_num, self.shot.file[0])
for point in list(self.selected_points):
if point[2] == self.current_point[2] and point[3] == self.current_point[3]:
self.selected_points.remove(point)
self.selected_points.add(npoint)
self.refresh_points()
def greenvald(self): #диаграмма хьюгилла #TODO - move to another file
temp = {}
names = self.shot.get_diagram_names()
for x in self.selected_points:
if x[3] not in temp:
temp[x[3]] = {}
tag = ""
for name, value in self.filters.items():
if re.compile(value).match(names[x[2]]):
tag = name
break
if tag:
temp[x[3]][tag] = x[0], x[1], x[3] #X, Y, Shot
points = []
for x in temp:
if "Ip" in temp[x] and "neL" in temp[x] and "ITF" in temp[x]:
a = 24
R = 36
k = 1.65
#print("wololo")
Ip = temp[x]["Ip"][1]/1000
Itf = temp[x]["ITF"][1]/1000
neL = temp[x]["neL"][1]
Bt = Itf*0.001*100*16*0.2/R
print(Ip)
print(Itf)
print(neL)
print(Bt)
qcyl = 5*a*a*0.01*0.01*Bt*100*1000/(R*Ip)
print(qcyl)
#print(temp[x])
#print(Itf)
#print(neL)
rqcyl = 1/qcyl
print(rqcyl)
print("wololo")
ne = neL*0.03/k
BtrR = Bt*100/R
print(ne)
print(BtrR)
neRrBt = ne/BtrR
print(neRrBt)
points.append(((neRrBt, rqcyl), temp[x]["Ip"][2]))
return points
def update_diagramms(self):
points = self.greenvald()
x = [tmp[0][0] for tmp in points]
y = [tmp[0][1] for tmp in points]
#self.diagrams_figure.clf()
self.diagrams_ax.set_xlabel('neR/BT, 10^20/(T*m^2)')
self.diagrams_ax.set_ylabel('1/qcyl')
self.diagrams_ax.set_title("Greenwald")
self.diagrams_ax.plot(x, y, 'bo', ms=5, alpha=0.8, markersize=5)
self.diagrams_canvas.draw()
print(points)
def points_clicked(self):#один клик, правая кнопка - удалить точку, левая - подсветить
if self.points._mouse_button == 1:
num = self.points.currentRow()
point = list(self.selected_points)[num]
diag = self.shot.get_diagram(self.current_num)
xs = np.array(diag.x)
ys = np.array(diag.y)
idx = np.absolute(xs - point[0]).argmin()
self.highlight.set_xdata([xs[idx]])
self.highlight.set_ydata([ys[idx]])
else:
self.unselect_point(None)
def read_filters(self):
with open("filters.conf") as inp:
lines = inp.readlines()
n = int(lines[0])
mass = []
for i in range(n):
mass.append((lines[2*i+1].strip(), lines[2*(i+1)].strip()))
self.filters = OrderedDict(mass)
def show_filters(self):
self.f = FiltersPopup(self.filters)
self.f.setGeometry(100, 100, 400, 200)
self.f.exec_()
self.filters = self.f.getValues()
self.show_diagrams()
def add_time(self):
time, ok = QtGui.QInputDialog.getText(self, 'Time point', 'enter time point in seconds(e.g. 0.123):')
if ok:
if time.isdigit:
diag = self.shot.get_diagram(self.current_num)
xs = np.array(diag.x)
ys = np.array(diag.y)
idx = np.absolute(xs - float(time)/1000).argmin()
npoint = (xs[idx], ys[idx], self.current_num, self.shot.file[0])
for point in list(self.selected_points):
if point[2] == self.current_point[2] and point[3] == self.current_point[3]:
print("wololololololo")
self.selected_points.remove(point)
self.selected_points.add(npoint)
self.refresh_points()
def select_item(self, current):
self.figure.clf()
name = self.diagrams.currentItem().text()
names = self.shot.get_diagram_names()
if name in names:
self.current_num = names.index(name)
else:
self.current_num = names.index("".join(name.split(':')[1:])[1:])
self.plot(self.shot.get_diagram(self.current_num))
def unselect_point(self, current):
num = self.points.currentRow()
self.selected_points.remove(list(self.selected_points)[num])
self.refresh_points()
def select_file(self, current):
self.figure.clf()
self.show_shot(Shot(join(self.folder_name, self.files.currentItem().text())))
self.canvas.setFocus()
def on_pick(self, event):
print(self.selected_points)
if self.current_point in self.selected_points:
self.selected_points.remove(self.current_point)
else:
for point in list(self.selected_points):
if point[2] == self.current_point[2] and point[3] == self.current_point[3]:
print("wololo")
self.selected_points.remove(point)
self.selected_points.add(self.current_point)
self.refresh_points()
def refresh_points(self):
self.update_diagramms()
self.points.clear()
self.points.addItems([str(x[0]) for x in self.selected_points])
self.overall_selected.set_xdata(self.active_points[0])
self.overall_selected.set_ydata(self.active_points[1])
def on_move(self, event):
# get the x and y pixel coords
x, y = event.x, event.y
if event.inaxes:
ax = event.inaxes # the axes instance
diag = self.shot.get_diagram(self.current_num)
xs = np.array(diag.x)
ys = np.array(diag.y)
idx = np.absolute(xs - event.xdata).argmin()
self.currently_selected.set_xdata([diag.x[idx]])
self.currently_selected.set_ydata([diag.y[idx]])
self.current_point = (diag.x[idx], diag.y[idx], self.current_num, self.shot.file[0])
self.canvas.draw()
@property
def active_points(self):
x = [x[0] for x in self.selected_points if x[2] == self.current_num and x[3] == self.shot.file[0]]
y = [x[1] for x in self.selected_points if x[2] == self.current_num and x[3] == self.shot.file[0]]
return x, y
def plot(self, diagram=None):
# create an axis
ax = self.figure.add_subplot(111)
# discards the old graph
#pridicted max value
ind = np.argmax(np.array(diagram.y))
# plot data
if diagram:
self.highlight, = ax.plot([diagram.x[ind]], [diagram.y[ind]], 'bo', ms=12, alpha=0.8, markersize=8)
ax.plot(diagram.x, diagram.y, 'b-')
self.currently_selected, = ax.plot([diagram.x[ind]], [diagram.y[ind]], 'yo', ms=12, alpha=0.6, markersize=6,
picker=15)
self.overall_selected, = ax.plot(self.active_points[0], self.active_points[1], 'ro', ms=12, alpha=0.9,
markersize=4)
ax.set_xlabel('t, sec')
ax.set_ylabel(diagram.unit)
ax.set_title(diagram.comment)
self.figure.tight_layout()
# refresh canvas
self.canvas.draw()
def show_diagrams(self):
names = self.shot.get_diagram_names()
self.diagrams.clear()
res = set()
for x in names:
for name, reg in self.filters.items():
try:
if re.compile(reg).match(x):
res.add(str(name) + ': ' + str(x))
break
except:
pass
#self.diagrams.addItems(list(names))
self.diagrams.addItems(list(res))
self.diagrams.show()
def show_shot(self, shot):
self.shot = shot
self.show_diagrams()
self.toolbar.show()
self.canvas.show()
self.files.show()
self.points.show()
self.save_button.show()
self.filters_button.show()
self.current_num = 0
self.plot(self.shot.get_diagram(0))
self.canvas.setFocus()
