class MatplotlibPlot:
""" Class encapsulating a matplotlib plot"""
def __init__(self, parent = None, dpi = 100, size = (5,5)):
""" Class initialiser """
self.dpi = dpi
self.figure = Figure(size, dpi = self.dpi)
self.canvas = FigureCanvas(self.figure)
self.canvas.setParent(parent)
# Create the navigation toolbar, tied to the canvas
self.toolbar = NavigationToolbar(self.canvas, parent)
self.canvas.show()
self.toolbar.show()
# Reset the plot landscape
self.figure.clear()
def plotMultiPixel(self, info, data):
""" Generate multi-pixel plot """
# Tabula Rasa
self.figure.clear()
rows = math.ceil(math.sqrt(info['nbeams']))
# Display a subplot per beam (randomly for now)
for i in range(info['nbeams']):
ax = self.figure.add_subplot(rows, rows, i)
ax.plot(data[:,512,i])
def updatePlot(self):
self.canvas.draw()
class GraphView(qg.QWidget):
def __init__(self, name='Name', title='Title', graph_title='Graph Title', parent = None):
super(GraphView, self).__init__(parent)
self.name = name
self.graph_title = graph_title
self.dpi = 100
self.fig = Figure((5.0, 3.0), dpi = self.dpi, facecolor = (1,1,1), edgecolor = (0,0,0))
self.axes = self.fig.add_subplot(111)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self)
self.toolbar = NavigationToolbar(self.canvas,self)
self.layout = qg.QVBoxLayout()
self.layout.addWidget(self.toolbar)
self.layout.addWidget(self.canvas)
self.layout.setStretchFactor(self.canvas, 1)
self.setLayout(self.layout)
self.canvas.show()
def clear(self):
self.axes.clear()
def plot(self,*args,**kwargs):
self.axes.plot(*args,**kwargs)
def draw(self):
self.canvas.draw()
def add_patch(self,patch):
self.axes.add_patch(patch)
def scatter(self,*args,**kwargs):
self.axes.scatter(*args,**kwargs)
def text(self,*args,**kwargs):
self.axes.text(*args,**kwargs)
class GraphView(qg.QWidget):
def __init__(self, name='Name', title='Title', graph_title='Graph Title', parent = None):
super(GraphView, self).__init__(parent)
self.name = name
self.graph_title = graph_title
self.dpi = 100
self.fig = Figure((5.0, 3.0), dpi = self.dpi, facecolor = (1,1,1), edgecolor = (0,0,0))
self.axes = self.fig.add_subplot(111)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self)
self.toolbar = NavigationToolbar(self.canvas,self)
self.layout = qg.QVBoxLayout()
self.layout.addWidget(self.toolbar)
self.layout.addWidget(self.canvas)
self.layout.setStretchFactor(self.canvas, 1)
self.setLayout(self.layout)
self.canvas.show()
def clear(self):
self.axes.clear()
def plot(self,*args,**kwargs):
self.axes.plot(*args,**kwargs)
def draw(self):
self.canvas.draw()
def add_patch(self,patch):
self.axes.add_patch(patch)
def scatter(self,*args,**kwargs):
self.axes.scatter(*args,**kwargs)
def text(self,*args,**kwargs):
self.axes.text(*args,**kwargs)
def plot_image(self, img):
cv = FigureCanvas(plt.figure(figsize=(5, 3)))
cv.setWindowTitle(self.filename)
plt.imshow(img)
plt.title(self.filename)
plt.gca().axis('off')
cv.show()
class LiveGraphQt4(Backend):
"""Ultimately, this is a QWidget (as well as a FigureCanvasAgg, etc.)."""
def show(self, delay=50):
self.canvas = FigureCanvasQTAgg(self.figure)
self.canvas.show()
self.timer = QtCore.QTimer(self.canvas)
self.timer.timeout.connect(self.run)
super().show(delay)
class LiveGraphQt4(Backend):
"""Ultimately, this is a QWidget (as well as a FigureCanvasAgg, etc.)."""
def show(self, delay=50):
self.canvas = FigureCanvasQTAgg(self.figure)
self.canvas.show()
self.timer = QtCore.QTimer(self.canvas)
self.timer.timeout.connect(self.run)
super().show(delay)
def __graph(self, processFunc):
function = ProcessFun(processFunc).process()
self.__a.clear()
X = np.arange(float(self.__leftBoundE.get()),
float(self.__rightBoundE.get()), np.pi / 24)
y = eval(function)
self.__a.plot(X, y)
pyplot.xlabel("x")
pyplot.ylabel("y")
self.__a.grid(True)
canvas = FigureCanvasQTAgg(self.__f)
canvas.show()
class MatplotlibPlot:
""" Class encapsulating an matplotlib plot"""
def __init__(self, parent=None, dpi=100, size=(5, 4)):
""" Class initialiser """
self.dpi = dpi
self.figure = Figure(size, dpi=self.dpi)
self.canvas = FigureCanvas(self.figure)
self.canvas.setParent(parent)
# Create the navigation toolbar, tied to the canvas
self.toolbar = NavigationToolbar(self.canvas, parent)
self.canvas.show()
self.toolbar.show()
def plotCurve(self,
data,
xAxisRange=None,
yAxisRange=None,
xLabel="",
yLabel=""):
""" Plot the data as a curve"""
# clear the axes and redraw the plot anew
self.figure.clear()
self.axes = self.figure.add_subplot(111)
self.axes.grid(True)
self.axes.plot(range(np.size(data)), data)
if xAxisRange is not None:
self.xAxisRange = xAxisRange
self.axes.xaxis.set_major_formatter(
ticker.FuncFormatter(
lambda x, pos=None: '%.2f' % self.xAxisRange[x]
if 0 <= x < len(xAxisRange) else ''))
for tick in self.axes.xaxis.get_ticklabels():
tick.set_rotation(15)
if yAxisRange is not None:
self.yAxisRange = yAxisRange
self.axes.xaxis.set_major_formatter(
ticker.FuncFormatter(
lambda x, pos=None: '%.1f' % self.yAxisRange[y]
if 0 <= y < len(yAxisRange) else ''))
for tick in self.axes.yaxis.get_ticklabels():
tick.set_rotation(15)
self.axes.xaxis.set_label_text(xLabel)
self.axes.yaxis.set_label_text(yLabel)
self.canvas.draw()
def _show(fig):
"""
show image on canvas
:param fig: matplotlib.figure.Figure instance
:return: matplotlib.backends.backend_qt4agg.FigureCanvasQTAgg instance
"""
w = FigureCanvas(fig)
# store instance to prevent garbage collection
# otherwise widget is not sticking
WIDGETS.append(w)
# show the widget
w.show()
return w
class Grafica(QWidget):
valores = (20, 35, 30, 35, 27) # valores de ejemplo
def __init__(self, parent=None):
super(Grafica, self).__init__()
# FIGUREANDO
self.ordenadas = np.arange(5)
self.width = 1 # the width of the bars
self.figure, self.ax = plt.subplots()
#self.figure = plt.figure()
self.line = self.ax.bar(self.ordenadas, self.valores, self.width, color='g')
#self.line, = plt.plot(self.data)
plt.ion() # animate
N = 10
self.xs = collections.deque(maxlen=N)
self.ys = collections.deque(maxlen=N)
self.xs.append(0)
self.ys.append(0)
self.ax = self.figure.add_subplot(111)
self.ax.hold(False)
self.ax.set_ylim([0, 360])
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.toolbar.hide()
self.canvas.show()
# set the layout
self.layout = QVBoxLayout()
self.layout.addWidget(self.toolbar)
self.layout.addWidget(self.canvas)
self.setLayout(self.layout)
def add_sample(self, valores):
self.valores = valores
self.line = self.ax.bar(self.ordenadas, self.valores, self.width, color='g')
self.canvas.draw() # update the plot
class MatplotlibPlot:
""" Class encapsulating an matplotlib plot"""
def __init__(self, parent = None, dpi = 100, size = (5,4)):
""" Class initialiser """
self.dpi = dpi
self.figure = Figure(size, dpi = self.dpi)
self.canvas = FigureCanvas(self.figure)
self.canvas.setParent(parent)
# Create the navigation toolbar, tied to the canvas
self.toolbar = NavigationToolbar(self.canvas, parent)
self.canvas.show()
self.toolbar.show()
def plotCurve(self, data, xAxisRange = None, yAxisRange = None, xLabel = "", yLabel = ""):
""" Plot the data as a curve"""
# clear the axes and redraw the plot anew
self.figure.clear()
self.axes = self.figure.add_subplot(111)
self.axes.grid(True)
self.axes.plot(range(np.size(data)), data)
if xAxisRange is not None:
self.xAxisRange = xAxisRange
self.axes.xaxis.set_major_formatter(ticker.FuncFormatter(
lambda x, pos=None: '%.2f' % self.xAxisRange[x] if 0 <= x < len(xAxisRange) else ''))
for tick in self.axes.xaxis.get_ticklabels():
tick.set_rotation(15)
if yAxisRange is not None:
self.yAxisRange = yAxisRange
self.axes.xaxis.set_major_formatter(ticker.FuncFormatter(
lambda x, pos=None: '%.1f' % self.yAxisRange[y] if 0 <= y < len(yAxisRange) else ''))
for tick in self.axes.yaxis.get_ticklabels():
tick.set_rotation(15)
self.axes.xaxis.set_label_text(xLabel)
self.axes.yaxis.set_label_text(yLabel)
self.canvas.draw()
class MatplotlibPlot:
""" Class encapsulating a matplotlib plot"""
def __init__(self, parent = None, dpi = 100, size = (5,5)):
""" Class initialiser """
self.dpi = dpi
self.figure = Figure(size, dpi = self.dpi)
self.canvas = FigureCanvas(self.figure)
self.canvas.setParent(parent)
# Create the navigation toolbar, tied to the canvas
self.toolbar = NavigationToolbar(self.canvas, parent)
self.canvas.show()
self.toolbar.show()
# Reset the plot landscape
self.figure.clear()
self.nSubplot=0
def resetSubplots(self):
self.nSubplot=0
def plotCurve(self, data, xAxisRange = None, yAxisRange = None, xLabel = "", yLabel = "", title="", label="", plotLog=False, nSubplots=1, hold=False):
""" Plot the data as a curve"""
if len(data) != 0:
# Plan what dimensions the grid will have if there are to be subplots
# Attempt to be roughly square but give preference to vertical stacking
nSubplots_v = np.ceil(np.sqrt(nSubplots))
nSubplots_h = np.ceil(float(nSubplots)/nSubplots_v)
yAxisRange=np.array(yAxisRange)
if yAxisRange is not None:
auto_scale_y = False
if plotLog:
data[data==0] = 1
yAxisRange[yAxisRange==0] = 1
data= 10*np.log(data)
yAxisRange = 10*np.log(yAxisRange)
else:
auto_scale_y = True
# draw the new plot
if self.nSubplot < nSubplots:
self.axes = self.figure.add_subplot(nSubplots_v, nSubplots_h, self.nSubplot+1, label=label, title=title, ylim=yAxisRange) #subplots start from 1
self.axes.grid(True)
#if plotLog:
# self.axes.semilogy(range(np.size(data)), data, scaley=auto_scale_y)
#else:
# self.axes.plot(range(np.size(data)), data, scaley=auto_scale_y)
self.axes.plot(range(np.size(data)), data, scaley=auto_scale_y)
#if xAxisRange is not None:
# self.xAxisRange = xAxisRange
# self.axes.xaxis.set_major_formatter(ticker.FuncFormatter(
# lambda x, pos=None: '%.2f' % self.xAxisRange[x] if 0 <= x < len(xAxisRange) else ''))
# for tick in self.axes.xaxis.get_ticklabels():
# tick.set_rotation(15)
#if yAxisRange is not None:
# self.yAxisRange = yAxisRange
# self.axes.xaxis.set_major_formatter(ticker.FuncFormatter(
# lambda x, pos=None: '%.1f' % self.yAxisRange[y] if 0 <= y < len(yAxisRange) else ''))
# for tick in self.axes.yaxis.get_ticklabels():
# tick.set_rotation(15)
self.axes.xaxis.set_label_text(xLabel)
self.axes.yaxis.set_label_text(yLabel)
# Increment the subplot number ready for the plot method to be called again.
# Count modulo number of subplots so that nSubplots=1 is the same as having a
# single shared axis.
# Skip this step if hold is set, in which case the next plot will be overlaid with the current one
if not hold:
self.nSubplot = (self.nSubplot + 1)
def plotNewCurve(self, data, xAxisRange=None, yAxisRange=None, xLabel="", yLabel="", plotLog=False):
# Clear the plot
self.figure.clear()
# Start from a new set of subplots
self.nSubplot = 0
self.plotCurve(self, data, xAxisRange=xAxisRange, yAxisRange=yAxisRange, xLabel=xLabel, yLabel=yLabel, plotLog=plotLog)
def updatePlot(self):
self.canvas.draw()
class BottleWindow(QtGui.QWidget):
"Document window for displaying a particular bottle"
def __init__(self, bottle):
super(BottleWindow, self).__init__(None)
self.ui = uic.loadUi(get_ui_file('bottle_window.ui'), self)
self.ui.readings_view.setModel(BottleModel(DataAnalyzer(bottle, delta=True)))
for col in range(self.ui.readings_view.model().columnCount()):
self.ui.readings_view.resizeColumnToContents(col)
self.exporter = BottleExporter(self)
if matplotlib:
self.figure = Figure(figsize=(5.0, 5.0), facecolor='w', edgecolor='w')
self.canvas = FigureCanvas(self.figure)
self.axes = self.figure.add_subplot(111)
self.ui.splitter.addWidget(self.canvas)
self.redraw_timer = QtCore.QTimer()
self.redraw_timer.setInterval(200) # msecs
self.redraw_timer.timeout.connect(self.redraw_timeout)
self.ui.splitter.splitterMoved.connect(self.splitter_moved)
self.refresh_edits()
self.setWindowTitle('Bottle %s' % bottle.serial)
self.ui.absolute_check.toggled.connect(self.absolute_toggled)
self.ui.points_spin.valueChanged.connect(self.points_changed)
@property
def model(self):
return self.ui.readings_view.model()
@property
def bottle(self):
return self.model.analyzer.bottle
def refresh_window(self):
"Forces the list to be re-read from the data logger"
self.model.beginResetModel()
self.model.analyzer.refresh()
self.refresh_edits()
self.model.endResetModel()
def refresh_edits(self):
"Refresh all the edit controls from the bottle"
bottle = self.model.analyzer.bottle
self.ui.bottle_serial_edit.setText(bottle.serial)
self.ui.bottle_id_edit.setText(str(bottle.id))
self.ui.measurement_mode_edit.setText(bottle.mode_string)
self.ui.bottle_volume_spin.setValue(bottle.bottle_volume)
self.ui.sample_volume_spin.setValue(bottle.sample_volume)
self.ui.dilution_spin.setValue(bottle.dilution)
self.ui.start_timestamp_edit.setText(bottle.start.strftime('%c'))
self.ui.finish_timestamp_edit.setText(bottle.finish.strftime('%c'))
self.ui.measurement_complete_edit.setText(bottle.completed)
self.ui.desired_values_edit.setText(str(bottle.expected_measurements))
self.ui.actual_values_edit.setText(str(bottle.actual_measurements))
self.ui.points_spin.setMaximum(
max(1, bottle.actual_measurements - (
1 if bottle.actual_measurements % 2 == 0 else 0)))
self.ui.points_spin.setEnabled(bottle.actual_measurements > 1)
self.ui.absolute_check.setEnabled(bottle.actual_measurements > 1)
if bottle.actual_measurements > 1:
self.canvas.show()
self.invalidate_graph()
else:
self.canvas.hide()
def export_file(self):
"Export the readings to a user-specified filename"
self.exporter.export_file()
def absolute_toggled(self, checked):
"Handler for the toggled signal of the absolute_check control"
self.model.delta = not checked
if matplotlib:
self.invalidate_graph()
def points_changed(self, value):
"Handler for the valueChanged signal of the points_spin control"
self.model.points = value
if matplotlib:
self.invalidate_graph()
def splitter_moved(self, pos, index):
"Handler for the moved signal of the splitter control"
self.invalidate_graph()
def invalidate_graph(self):
"Invalidate the matplotlib graph on a timer"
if self.redraw_timer.isActive():
self.redraw_timer.stop()
self.redraw_timer.start()
def redraw_timeout(self):
"Handler for the redraw_timer's timeout event"
self.redraw_timer.stop()
self.redraw_figure()
def redraw_figure(self):
"Called to redraw the channel image"
# Configure the x and y axes appearance
self.axes.clear()
self.axes.set_frame_on(True)
self.axes.set_axis_on()
self.axes.grid(True)
self.axes.set_xlabel(self.tr('Time'))
if self.ui.absolute_check.isChecked():
self.axes.set_ylabel(self.tr('Pressure (hPa)'))
else:
self.axes.set_ylabel(self.tr('Delta Pressure (hPa)'))
m = self.ui.points_spin.value()
for head_ix, head in enumerate(self.model.analyzer.heads):
self.axes.plot_date(
x=self.model.analyzer.timestamps,
y=head,
fmt='%s-' % matplotlib.rcParams['axes.color_cycle'][
head_ix % len(matplotlib.rcParams['axes.color_cycle'])]
)
self.axes.xaxis.set_major_formatter(DateFormatter('%d %b'))
self.axes.autoscale_view()
self.canvas.draw()
class AdminWindow(QWidget):
def __init__(self, db_connection):
super().__init__()
self.db_connection = db_connection
self.create_window()
def create_window(self):
self.setGeometry(300, 300, 900, 450) #x, y, w, h
self.setWindowTitle('3D Printers DB - Administrator ')
self.main_layout = QHBoxLayout(self)
self.create_menu()
self.menu_spacer = QSpacerItem(40, 10)
self.main_layout.addItem(self.menu_spacer)
self.create_welcome_message_layout()
self.create_assign_print_layout()
self.create_what_is_printed_layout()
self.create_finish_print_layout()
self.create_customer_leaderboards_layout()
self.create_earnings_statistics_layout()
def create_menu(self):
self.menu = QVBoxLayout(self)
self.menu_description = QLabel('Administrator Window', self)
font = QFont()
font.setPixelSize(20)
font.setBold(True)
self.menu_description.setFont(font)
self.finish_print_btn = QPushButton('Finish print', self)
self.customer_leaderboards_btn = QPushButton('Customer leaderboards', self)
self.assign_print_btn = QPushButton('Assign print', self)
self.what_is_printed_btn = QPushButton('What is printed?', self)
self.earnings_statisctics_btn = QPushButton('Earnings Statisctics', self)
self.logout_btn = QPushButton('Logout and exit', self)
#self.make_order_btn.clicked.connect(self.make_oder_button_trigger)
#self.order_history_btn.clicked.connect(self.order_history_button_trigger)
#self.profile_btn.clicked.connect(self.profile_button_trigger)
self.logout_btn.clicked.connect(self.logout_button_trigger)
self.assign_print_btn.clicked.connect(self.assign_print_button_trigger)
self.what_is_printed_btn.clicked.connect(self.what_is_printed_button_trigger)
self.finish_print_btn.clicked.connect(self.finish_print_button_trigger)
self.customer_leaderboards_btn.clicked.connect(self.customer_leaderboards_button_trigger)
self.earnings_statisctics_btn.clicked.connect(self.earnings_statistics_button_trigger)
self.menu.addWidget(self.menu_description)
self.menu.addWidget(self.what_is_printed_btn)
self.menu.addWidget(self.assign_print_btn)
self.menu.addWidget(self.finish_print_btn)
self.menu.addWidget(self.customer_leaderboards_btn)
self.menu.addWidget(self.earnings_statisctics_btn)
self.menu.addWidget(self.logout_btn)
self.menu.addStretch()
self.main_layout.addLayout(self.menu)
def create_welcome_message_layout(self):
self.welcome_message_layout = QVBoxLayout(self)
self.welcome_message_font = QFont()
self.welcome_message_font.setPixelSize(12)
self.welcome_message_text = 'Welcome in Printer DB application in admin mode.\nUse menu ' \
'located on the left site of window for navigation.'
self.welcome_message = QLabel(self.welcome_message_text)
self.welcome_message.setFont(self.welcome_message_font)
self.welcome_message_layout.addWidget(self.welcome_message)
self.welcome_message_layout.addStretch()
self.main_layout.addLayout(self.welcome_message_layout)
def hide_welcome_message_layout(self):
self.welcome_message.hide()
def show_welcome_message_layout(self):
self.welcome_message.show()
def fill_print(self):
self.print_field.clear()
SQL_command = "SELECT id, stl_filename, due_date, filament_type, filament_color, \
estimated_printing_time FROM print_3d \
WHERE completion_date IS NULL \
AND printer_id IS NULL \
ORDER BY due_date;"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
self.prints_to_do = []
res = cursor.fetchone()
while res is not None:
self.prints_to_do.append(res)
self.print_field.addItem(str(res.id) + ', ' + res.stl_filename + ', ' + str(res.due_date)[0:9] +', ' + res.filament_type+', ' + res.filament_color)
res = cursor.fetchone()
def fill_printers(self):
self.printer_field.clear()
SQL_command = "SELECT printer_3d.id, manufacturer, model \
FROM printer_3d \
JOIN print_3d on printer_3d.id = print_3d.printer_id \
WHERE completion_date IS NULL"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
res = cursor.fetchone()
self.busy_printers = []
while res is not None:
self.busy_printers.append(res)
res = cursor.fetchone()
SQL_command = "SELECT printer_3d.id, manufacturer, model \
FROM printer_3d"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
res = cursor.fetchone()
self.all_printers = []
while res is not None:
self.all_printers.append(res)
res = cursor.fetchone()
free_printers = []
for i in self.all_printers:
if i not in self.busy_printers:
free_printers.append(i)
self.printer_field.addItem(str(i.id) + ', ' + i.manufacturer + ' ' + i.model)
def create_assign_print_layout(self):
self.assign_print_layout = QVBoxLayout(self)
self.assign_print_grid = QGridLayout()
self.assign_print_info = QLabel('Assign print: ', self)
self.assign_print_info_font = QFont()
self.assign_print_info_font.setPixelSize(16)
self.assign_print_info_font.setBold(True)
self.assign_print_info.setFont(self.assign_print_info_font)
self.assign_print_layout.addWidget(self.assign_print_info)
self.printer_label = QLabel('Printer:', self)
self.printer_field = QListWidget(self)
self.print_label = QLabel('Print: ', self)
self.print_field = QListWidget(self)
self.assign_print_apply_button = QPushButton('Assign', self)
self.assign_print_apply_button.clicked.connect(self.print_apply_button_trigger)
self.assign_print_grid.addWidget(self.printer_label, 0, 0)
self.assign_print_grid.addWidget(self.printer_field, 0, 1)
self.assign_print_grid.addWidget(self.print_label, 1, 0)
self.assign_print_grid.addWidget(self.print_field, 1, 1)
self.assign_print_grid.addWidget(self.assign_print_apply_button, 2, 1)
self.assign_print_layout.addLayout(self.assign_print_grid)
self.assign_print_layout.addStretch()
self.main_layout.addLayout(self.assign_print_layout)
self.hide_assign_print_layout()
def hide_assign_print_layout(self):
self.assign_print_info.hide()
self.printer_label.hide()
self.printer_field.hide()
self.print_label.hide()
self.print_field.hide()
self.assign_print_apply_button.hide()
def show_assign_print_layout(self):
self.fill_printers()
self.fill_print()
self.assign_print_info.show()
self.printer_label.show()
self.printer_field.show()
self.print_label.show()
self.print_field.show()
self.assign_print_apply_button.show()
def create_what_is_printed_layout(self):
self.what_is_printed_layout = QVBoxLayout(self)
self.what_is_printed_info = QLabel('What is currently printed: ', self)
self.what_is_printed_info_font = QFont()
self.what_is_printed_info_font.setPixelSize(16)
self.what_is_printed_info_font.setBold(True)
self.what_is_printed_info.setFont(self.what_is_printed_info_font)
self.what_is_printed_layout.addWidget(self.what_is_printed_info)
self.what_is_printed_table = QTableWidget(self)
self.what_is_printed_layout.addWidget(self.what_is_printed_table)
self.main_layout.addLayout(self.what_is_printed_layout)
self.what_is_printed_table.setColumnCount(3)
self.what_is_printed_table.setHorizontalHeaderLabels(['Printer', 'Filename', 'Customer name'])
self.what_is_printed_layout.addWidget(self.what_is_printed_table)
self.hide_what_is_printed_layout()
def update_what_is_printed_layout(self):
SQL_command = "SELECT printer_3d.id, manufacturer, model, stl_filename, customer_username \
FROM printer_3d \
JOIN print_3d on printer_3d.id = print_3d.printer_id \
WHERE completion_date IS NULL"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
res = cursor.fetchone()
self.busy_printers = []
while res is not None:
self.busy_printers.append(res)
res = cursor.fetchone()
self.what_is_printed_table.setRowCount(len(self.busy_printers))
for i in range(0, len(self.busy_printers)):
self.what_is_printed_table.setItem(i, 0, QTableWidgetItem(str(self.busy_printers[i].id) + ' ' +\
self.busy_printers[i].manufacturer + ' ' + \
self.busy_printers[i].model))
self.what_is_printed_table.setItem(i, 1, QTableWidgetItem(self.busy_printers[i].stl_filename))
self.what_is_printed_table.setItem(i, 2, QTableWidgetItem(self.busy_printers[i].customer_username))
def show_what_is_printed_layout(self):
self.update_what_is_printed_layout()
self.what_is_printed_info.show()
self.what_is_printed_table.show()
def hide_what_is_printed_layout(self):
self.what_is_printed_info.hide()
self.what_is_printed_table.hide()
def create_finish_print_layout(self):
self.finish_print_layout = QVBoxLayout(self)
self.finish_print_info = QLabel('Finish print: ', self)
self.finish_print_info_font = QFont()
self.finish_print_info_font.setPixelSize(16)
self.finish_print_info_font.setBold(True)
self.finish_print_info.setFont(self.finish_print_info_font)
self.finish_print_layout.addWidget(self.finish_print_info)
self.busy_printers_field = QListWidget(self)
self.finish_print_layout.addWidget(self.busy_printers_field)
self.finish_print_apply_button = QPushButton('Finish print', self)
self.finish_print_apply_button.clicked.connect(self.finish_print_apply_button_trigger)
self.finish_print_filo_layout = QHBoxLayout(self)
self.finish_print_filo_layout_descriptions = QVBoxLayout(self)
self.finish_print_filo_layout_select = QVBoxLayout(self)
self.finish_print_filo_layout.addLayout(self.finish_print_filo_layout_descriptions)
self.finish_print_filo_layout.addLayout(self.finish_print_filo_layout_select)
self.finish_print_filo_manufacturer_description = QLabel('Filament manufacturer: ', self)
self.finish_print_filo_diameter_description = QLabel('Filament diameter: ', self)
self.finish_print_filo_type_description = QLabel('Filament type: ', self)
self.finish_print_filo_color_description = QLabel('Filament color: ', self)
self.finish_print_filo_amount_description = QLabel('Amount [gram]: ', self)
self.finish_print_filo_layout_descriptions.addWidget(self.finish_print_filo_manufacturer_description)
self.finish_print_filo_layout_descriptions.addWidget(self.finish_print_filo_diameter_description)
self.finish_print_filo_layout_descriptions.addWidget(self.finish_print_filo_type_description)
self.finish_print_filo_layout_descriptions.addWidget(self.finish_print_filo_color_description)
self.finish_print_filo_layout_descriptions.addWidget(self.finish_print_filo_amount_description)
self.finish_print_filo_manufacturer_select = QComboBox(self)
self.finish_print_filo_diameter_select = QComboBox(self)
self.finish_print_filo_type_select = QComboBox(self)
self.finish_print_filo_color_select = QComboBox(self)
self.finish_print_filo_amount_select = QLineEdit(self)
self.finish_print_filo_layout_select.addWidget(self.finish_print_filo_manufacturer_select)
self.finish_print_filo_layout_select.addWidget(self.finish_print_filo_diameter_select)
self.finish_print_filo_layout_select.addWidget(self.finish_print_filo_type_select)
self.finish_print_filo_layout_select.addWidget(self.finish_print_filo_color_select)
self.finish_print_filo_layout_select.addWidget(self.finish_print_filo_amount_select)
self.finish_print_layout.addLayout(self.finish_print_filo_layout)
self.finish_print_layout.addWidget(self.finish_print_apply_button)
self.main_layout.addLayout(self.finish_print_layout)
self.hide_finish_print_layout()
def find_filament_id(self, manufacturer, diameter, type, color):
SQL_command = "select id FROM filament WHERE " + \
"manufacturer = '" + manufacturer + "' AND " + \
"diameter = " + diameter + " AND " + \
"color = '" + color + "' AND " + \
"type = '" + type + "'"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
res = cursor.fetchone()
if res is not None:
return res.id
else:
return -1
def update_finish_print_layout(self):
self.busy_printers_field.clear()
SQL_command = "SELECT printer_3d.id, manufacturer, model \
FROM printer_3d \
JOIN print_3d on printer_3d.id = print_3d.printer_id \
WHERE completion_date IS NULL AND printer_id IS NOT NULL"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
res = cursor.fetchone()
while res is not None:
self.busy_printers_field.addItem(str(res.id) + ', ' + res.manufacturer + ' ' + res.model)
res = cursor.fetchone()
#clearing all fields
self.finish_print_filo_manufacturer_select.clear()
self.finish_print_filo_diameter_select.clear()
self.finish_print_filo_type_select.clear()
self.finish_print_filo_color_select.clear()
self.finish_print_filo_amount_select.clear()
SQL_command = "SELECT DISTINCT manufacturer FROM filament"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
res = cursor.fetchone()
while res is not None:
self.finish_print_filo_manufacturer_select.addItem(res.manufacturer)
res = cursor.fetchone()
SQL_command = "SELECT DISTINCT diameter FROM filament"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
res = cursor.fetchone()
while res is not None:
self.finish_print_filo_diameter_select.addItem(str(res.diameter))
res = cursor.fetchone()
SQL_command = "SELECT DISTINCT type FROM filament"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
res = cursor.fetchone()
while res is not None:
self.finish_print_filo_type_select.addItem(res.type)
res = cursor.fetchone()
SQL_command = "SELECT DISTINCT color FROM filament"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
res = cursor.fetchone()
while res is not None:
self.finish_print_filo_color_select.addItem(res.color)
res = cursor.fetchone()
def show_finish_print_layout(self):
self.update_finish_print_layout()
self.busy_printers_field.show()
self.finish_print_info.show()
self.finish_print_apply_button.show()
self.finish_print_filo_manufacturer_description.show()
self.finish_print_filo_diameter_description.show()
self.finish_print_filo_type_description.show()
self.finish_print_filo_color_description.show()
self.finish_print_filo_manufacturer_select.show()
self.finish_print_filo_diameter_select.show()
self.finish_print_filo_type_select.show()
self.finish_print_filo_color_select.show()
self.finish_print_filo_amount_description.show()
self.finish_print_filo_amount_select.show()
def hide_finish_print_layout(self):
self.busy_printers_field.hide()
self.finish_print_info.hide()
self.finish_print_apply_button.hide()
self.finish_print_filo_manufacturer_description.hide()
self.finish_print_filo_diameter_description.hide()
self.finish_print_filo_type_description.hide()
self.finish_print_filo_color_description.hide()
self.finish_print_filo_manufacturer_select.hide()
self.finish_print_filo_diameter_select.hide()
self.finish_print_filo_type_select.hide()
self.finish_print_filo_color_select.hide()
self.finish_print_filo_amount_description.hide()
self.finish_print_filo_amount_select.hide()
def create_customer_leaderboards_layout(self):
self.customer_leaderboards_layout = QVBoxLayout(self)
self.customer_leaderboards_info = QLabel('Customer leaderboards: ', self)
self.customer_leaderboards_info_font = QFont()
self.customer_leaderboards_info_font.setPixelSize(16)
self.customer_leaderboards_info_font.setBold(True)
self.customer_leaderboards_info.setFont(self.customer_leaderboards_info_font)
self.customer_leaderboards_layout.addWidget(self.customer_leaderboards_info)
self.customer_leaderboards_table = QTableWidget(self)
self.customer_leaderboards_layout.addWidget(self.customer_leaderboards_table)
self.main_layout.addLayout(self.customer_leaderboards_layout)
self.customer_leaderboards_table.setColumnCount(4)
self.customer_leaderboards_table.setHorizontalHeaderLabels(['Username', 'First name', 'Last name', 'Loyalty points'])
self.customer_leaderboards_layout.addWidget(self.customer_leaderboards_table)
self.hide_customer_leaderboards_layout()
def update_customer_leaderboards_layout(self):
self.busy_printers_field.clear()
SQL_command = "SELECT TOP 3 username, first_name, last_name, loyalty_points from customer order by loyalty_points DESC"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
res = cursor.fetchone()
customers = []
while res is not None:
customers.append(res)
res = cursor.fetchone()
self.customer_leaderboards_table.setRowCount(len(customers))
for i in range(0, len(customers)):
self.customer_leaderboards_table.setItem(i, 0, QTableWidgetItem(customers[i].username))
self.customer_leaderboards_table.setItem(i, 1, QTableWidgetItem(customers[i].first_name))
self.customer_leaderboards_table.setItem(i, 2, QTableWidgetItem(customers[i].last_name))
self.customer_leaderboards_table.setItem(i, 3, QTableWidgetItem(str(customers[i].loyalty_points)))
def show_customer_leaderboards_layout(self):
self.update_customer_leaderboards_layout()
self.customer_leaderboards_info.show()
self.customer_leaderboards_table.show()
def hide_customer_leaderboards_layout(self):
self.customer_leaderboards_info.hide()
self.customer_leaderboards_table.hide()
def hide_all(self):
self.hide_assign_print_layout()
self.hide_what_is_printed_layout()
self.hide_welcome_message_layout()
self.hide_finish_print_layout()
self.hide_customer_leaderboards_layout()
self.hide_earnings_statistics_layout()
def create_earnings_statistics_layout(self):
self.earnings_statistics_layout = QVBoxLayout(self)
self.main_layout.addLayout(self.earnings_statistics_layout)
self.earnings_statistics_info = QLabel('Earnings Statistics: ', self)
self.earnings_statistics_info_font = QFont()
self.earnings_statistics_info_font.setPixelSize(16)
self.earnings_statistics_info_font.setBold(True)
self.earnings_statistics_info.setFont(self.earnings_statistics_info_font)
self.earnings_statistics_layout.addWidget(self.earnings_statistics_info)
self.earnings_statistics_selection_layout = QHBoxLayout(self)
self.earnings_statistics_layout.addLayout(self.earnings_statistics_selection_layout)
self.earnings_statistics_duration_info = QLabel('Statistics duration: ', self)
self.earnings_statistics_duration_field = QComboBox(self)
self.earnings_statistics_duration_field.addItem('1 Week')
self.earnings_statistics_duration_field.addItem('1 Month')
self.earnings_statistics_duration_field.addItem('1 Year')
self.earnings_statistics_duration_field.currentIndexChanged.connect(self.update_earnings_plot)
self.earnings_statistics_selection_layout.addWidget(self.earnings_statistics_duration_info)
self.earnings_statistics_selection_layout.addWidget(self.earnings_statistics_duration_field)
self.earnings_statistics_figure = Figure()
self.earnings_statistics_canvas = FigureCanvas(self.earnings_statistics_figure)
self.earnings_statistics_layout.addWidget(self.earnings_statistics_canvas)
self.update_earnings_plot()
self.hide_earnings_statistics_layout()
def get_earnings_data_week(self):
d = datetime.datetime.now()
delta = datetime.timedelta(days=1, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
dates = []
earnings = []
xlabels = []
for i in range(0, 7):
dates.append(str(d).split('.')[0])
d = d - delta
xlabels.append(-i-1)
for d in dates:
SQL_command = "SELECT SUM(cost) FROM print_3d WHERE completion_date < '" + d + "';"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
res = cursor.fetchone()
if res is not None:
if res[0] is not None:
earnings.append(res[0])
else:
earnings.append(Decimal(0))
return xlabels, earnings
def get_earnings_data_month(self):
d = datetime.datetime.now()
delta = datetime.timedelta(days=1, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
dates = []
earnings = []
xlabels = []
for i in range(0, 31):
dates.append(str(d).split('.')[0])
d = d - delta
xlabels.append(-i-1)
for d in dates:
SQL_command = "SELECT SUM(cost) FROM print_3d WHERE completion_date < '" + d + "';"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
res = cursor.fetchone()
if res is not None:
if res[0] is not None:
earnings.append(res[0])
else:
earnings.append(Decimal(0))
return xlabels, earnings
def get_earnings_data_year(self):
d = datetime.datetime.now()
delta = relativedelta(months=1)
dates = []
earnings = []
xlabels = []
for i in range(0, 12):
dates.append(str(d).split('.')[0])
d = d - delta
xlabels.append(-i-1)
for d in dates:
SQL_command = "SELECT SUM(cost) FROM print_3d WHERE completion_date < '" + d + "';"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
res = cursor.fetchone()
if res is not None:
if res[0] is not None:
earnings.append(res[0])
else:
earnings.append(Decimal(0))
return xlabels, earnings
def update_earnings_plot(self):
if (str(self.earnings_statistics_duration_field.currentText())) == '1 Week':
''' plot some random stuff '''
print('week')
datax, datay = self.get_earnings_data_week()
self.earnings_statistics_figure.clear()
self.earnings_statiscitcs_subplot = self.earnings_statistics_figure.add_subplot(111)
self.earnings_statiscitcs_subplot.clear()
self.earnings_statiscitcs_subplot.grid(True)
self.earnings_statiscitcs_subplot.set_xlabel('Day (from now)')
self.earnings_statiscitcs_subplot.set_ylabel('Earnings [zl]')
self.earnings_statiscitcs_subplot.plot(datax, datay, '*-')
self.earnings_statistics_canvas.draw()
if (str(self.earnings_statistics_duration_field.currentText())) == '1 Month':
''' plot some random stuff '''
print('month')
# random data
datax, datay = self.get_earnings_data_month()
self.earnings_statistics_figure.clear()
self.earnings_statiscitcs_subplot = self.earnings_statistics_figure.add_subplot(111)
self.earnings_statiscitcs_subplot.clear()
self.earnings_statiscitcs_subplot.grid(True)
self.earnings_statiscitcs_subplot.set_xlabel('Day (from now)')
self.earnings_statiscitcs_subplot.set_ylabel('Earnings [zl]')
self.earnings_statiscitcs_subplot.plot(datax, datay, '*-')
self.earnings_statistics_canvas.draw()
if (str(self.earnings_statistics_duration_field.currentText())) == '1 Year':
''' plot some random stuff '''
datax, datay = self.get_earnings_data_year()
self.earnings_statistics_figure.clear()
self.earnings_statiscitcs_subplot = self.earnings_statistics_figure.add_subplot(111)
self.earnings_statiscitcs_subplot.clear()
self.earnings_statiscitcs_subplot.grid(True)
self.earnings_statiscitcs_subplot.set_xlabel('Month (from now)')
self.earnings_statiscitcs_subplot.set_ylabel('Earnings [zl]')
print(self.earnings_statiscitcs_subplot.get_ylabel())
self.earnings_statiscitcs_subplot.plot(datax, datay, '*-')
self.earnings_statistics_canvas.draw()
def show_earnings_statistics_layout(self):
self.earnings_statistics_info.show()
self.earnings_statistics_duration_info.show()
self.earnings_statistics_duration_field.show()
self.earnings_statistics_canvas.show()
def hide_earnings_statistics_layout(self):
self.earnings_statistics_info.hide()
self.earnings_statistics_duration_info.hide()
self.earnings_statistics_duration_field.hide()
self.earnings_statistics_canvas.hide()
def earnings_statistics_button_trigger(self):
self.hide_all()
self.show_earnings_statistics_layout()
def print_apply_button_trigger(self):
if self.printer_field.currentItem() is not None:
printer_id = self.printer_field.currentItem().text().split(',')[0]
if self.print_field.currentItem() is not None:
print_id = self.print_field.currentItem().text().split(',')[0]
SQL_command = "UPDATE print_3d SET printer_id = " + \
printer_id + " WHERE print_3d.id = " + \
print_id
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
cursor.commit()
self.hide_assign_print_layout()
self.show_assign_print_layout()
popup = QMessageBox()
popup.setIcon(QMessageBox.Information)
popup.setText("Successfully assigned print to printer")
popup.setWindowTitle("Assigned print to printer")
popup.exec_()
else:
popup = QMessageBox()
popup.setIcon(QMessageBox.Critical)
popup.setText("Select print")
popup.setWindowTitle("Error - print not selected")
popup.exec_()
else:
popup = QMessageBox()
popup.setIcon(QMessageBox.Critical)
popup.setText("Select printer")
popup.setWindowTitle("Error - printer not selected")
popup.exec_()
def assign_print_button_trigger(self):
self.hide_all()
self.show_assign_print_layout()
def what_is_printed_button_trigger(self):
self.hide_all()
self.show_what_is_printed_layout()
def finish_print_button_trigger(self):
self.hide_all()
self.show_finish_print_layout()
def finish_print_apply_button_trigger(self):
manufacturer = str(self.finish_print_filo_manufacturer_select.currentText())
diameter = str(self.finish_print_filo_diameter_select.currentText())
type = str(self.finish_print_filo_type_select.currentText())
color = str(self.finish_print_filo_color_select.currentText())
amount = str(self.finish_print_filo_amount_select.text())
if len(amount) != 0:
amount = str((float(amount)) / 1000)
filament_id = str(self.find_filament_id(manufacturer, diameter, type, color))
if filament_id == '-1':
popup = QMessageBox()
popup.setIcon(QMessageBox.Critical)
popup.setText("There is no such filament")
popup.setWindowTitle("No filament")
popup.exec_()
return
date = str(datetime.datetime.now()).split('.')[0]
if len(amount) == 0:
popup = QMessageBox()
popup.setIcon(QMessageBox.Critical)
popup.setText("Please set amount of used filament")
popup.setWindowTitle("No filament amount error")
popup.exec_()
return
if self.busy_printers_field.currentItem() is not None:
now = datetime.datetime.now()
print_id = self.busy_printers_field.currentItem().text().split(',')[0]
SQL_command = "UPDATE print_3d SET completion_date = '" + \
str(now)[0:10] + "' WHERE printer_id = " + \
print_id + "AND completion_date IS NULL"
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
cursor.commit()
self.hide_finish_print_layout()
self.show_finish_print_layout()
else:
popup = QMessageBox()
popup.setIcon(QMessageBox.Critical)
popup.setText("Please select a printer")
popup.setWindowTitle("No printer selected")
popup.exec_()
return
SQL_command = "INSERT INTO filament_history (filament_id, order_date, delivered_date, added_amount) VALUES (" \
+ filament_id + ", '" + date + "', '" + date + "', -" + amount + ')'
cursor = self.db_connection.cursor()
cursor.execute(SQL_command)
cursor.commit()
popup = QMessageBox()
popup.setIcon(QMessageBox.Information)
popup.setText("Successfully finished print")
popup.setWindowTitle("Finished print")
popup.exec_()
def customer_leaderboards_button_trigger(self):
self.hide_all()
self.show_customer_leaderboards_layout()
def logout_button_trigger(self):
self.destroy()
exit(0)
class GraphView(QtGui.QWidget):
def __init__(self, pymol, pmap, parent=None):
super(GraphView, self).__init__(parent)
self.pymol = pymol
self.dpi = 300
self.pmap = pmap
self.fig = Figure((4.5, 4.5), dpi=self.dpi)
self.axes = self.fig.add_subplot(111)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self)
self.canvas.mpl_connect("button_press_event", self._onpick)
self.layout = QtGui.QVBoxLayout()
self.layout.addWidget(self.canvas)
self.layout.setStretchFactor(self.canvas, 1)
self.setLayout(self.layout)
if self.pmap.use_ca:
self.xcoor = self.pmap.residue_numbers_ca[self.pmap.parent.current_model]
else:
self.xcoor = self.pmap.residue_numbers_cb[self.pmap.parent.current_model]
self.ycoor = self.pmap.histogram_maps[self.pmap.parent.current_model]
self.bar = self.axes.bar(self.xcoor, self.ycoor, width=1.0, linewidth=0)
self.canvas.show()
self.set_parameters()
def _get_clicked_residues(self, event):
xmin, xmax = self.axes.get_xlim()
return int(math.ceil(event.xdata - xmin)) - 1
def _onpick(self, event):
if self.pmap.use_ca:
atom = "CA"
chains = self.pmap.chain_names_ca[self.pmap.parent.current_model]
residue_numbers = self.pmap.residue_numbers_ca[self.pmap.parent.current_model]
else:
atom = "CB"
chains = self.pmap.chain_names_cb[self.pmap.parent.current_model]
residue_numbers = self.pmap.residue_numbers_cb[self.pmap.parent.current_model]
index = self._get_clicked_residues(event)
self.pymol.select_density(residue_numbers[index], atom, self.pmap.cutoff, chains[index])
def set_parameters(self):
self.axes.tick_params(axis=u"both", which=u"both", length=0)
self.axes.set_xlim(min(self.xcoor), max(self.xcoor))
self.axes.set_ylim(0, max(self.ycoor) + 1)
self.axes.set_xlabel("Residue Number")
self.axes.set_ylabel("Contact Counts")
fractions = self.ycoor / max(self.ycoor)
normalized_colors = colors.Normalize(fractions.min(), fractions.max())
count = 0
for rect in self.bar:
c = cm.jet(normalized_colors(fractions[count]))
rect.set_facecolor(c)
count += 1
self.fig.patch.set_facecolor((0.886, 0.886, 0.886))
ticks_font = mpl.font_manager.FontProperties(
family="times new roman", style="normal", size=12, weight="normal", stretch="normal"
)
labels = [self.axes.title, self.axes.xaxis.label, self.axes.yaxis.label]
labels += self.axes.get_xticklabels() + self.axes.get_yticklabels()
for item in labels:
item.set_fontproperties(ticks_font)
item.set_fontsize(4)
def update_graph(self):
self.axes.clear()
if self.pmap.use_ca:
self.xcoor = self.pmap.residue_numbers_ca[self.pmap.parent.current_model]
else:
self.xcoor = self.pmap.residue_numbers_cb[self.pmap.parent.current_model]
self.ycoor = self.pmap.histogram_maps[self.pmap.parent.current_model]
self.bar = self.axes.bar(self.xcoor, self.ycoor, width=1.0, linewidth=0)
self.set_parameters()
self.canvas.draw()
class SelectZoneWidget(QtGui.QWidget):
_imageChanged = pyqtSignal(np.ndarray)
_imageReset = pyqtSignal()
_homographyChanged = pyqtSignal(list)
def __init__(self, hWidget, parent=None):
super(SelectZoneWidget, self).__init__(parent)
self._hWidget = hWidget
self._imageChanged.connect(self._hWidget.setImage)
self._homographyChanged.connect(self._hWidget.setHomography)
self._imageReset.connect(self._hWidget.reset)
self._initUI()
# Initialize the UI
def _initUI(self):
# Widget parameters
self.setMinimumWidth(300)
# Create the figure
self._fig = Figure()
# Canvas configuration
self._canvas = FigureCanvas(self._fig)
self._canvas.setParent(self)
self._canvas.mpl_connect('button_press_event', self._onPick)
# Plot configuration
self._plt = self._fig.add_subplot(111)
self._plt.xaxis.set_visible(False)
self._plt.yaxis.set_visible(False)
# Finalize figure
self._fig.subplots_adjust(wspace=0, hspace=0)
# Reset the variables
self.reset()
# Create the layout
vbox = QtGui.QVBoxLayout()
# Add Canvas to the layout
vbox.addWidget(self._canvas)
# Set the layout
self.setLayout(vbox)
zp = ZoomPan()
figZoom = zp.zoom_factory(self._plt)
figPan = zp.pan_factory(self._plt)
# Reset the variables to original state
def reset(self):
self._canvas.hide()
self._image = None
self._points = []
self._imageReset.emit()
# Set an image to the widget
def setImage(self, image):
self.reset()
self._image = image
self._redraw()
self._canvas.show()
self._imageChanged.emit(image)
# Get the image of the widget
def getImage(self):
pass
# Redraw the image and points
def _redraw(self):
# Clear the canvas
self._plt.clear()
# Plot the image
if self._image is not None:
self._plt.autoscale(True)
self._plt.imshow(self._image)
self._plt.autoscale(False)
# Plot the points
if len(self._points) > 0:
xs = [x for (x, _) in self._points]
ys = [y for (_, y) in self._points]
self._plt.plot(xs + [xs[0]], ys + [ys[0]], '-', color='red')
self._plt.plot(xs + [xs[0]], ys + [ys[0]], 'o', color='blue')
# Draw the canvas
self._canvas.draw()
# Handle click events
def _onPick(self, event):
if event.button == 3:
self._redraw()
elif event.button != 1:
return
# Get point position
x = event.xdata
y = event.ydata
if x is None or y is None:
return
# For each existing points
for px, py in self._points:
# Compute distance to current point
dst = np.sqrt((px - x) ** 2 + (py - y) ** 2)
# If the distance is small remove it
if dst < 10:
self._removePoint(px, py)
self._redraw()
return
# Delegate to add the point
self._addPoint(x, y)
# Redraw the image
self._redraw()
# Add a new point
def _addPoint(self, x, y):
# Count points
n = len(self._points)
# If less than 3 points just add it
if n < 3:
self._points.append((x, y))
return
# If already 4 points, ignore it
if n >= 4:
return
# Else a verification must be done
if self._validPoint(x, y):
# Add the point
self._points.append((x, y))
# Reorder points to have consistant rectangle when drawing
self._reorderPoints()
# Lunch the homography
self._homographyChanged.emit(self._points)
# Remove an existing point
def _removePoint(self, x, y):
# Reset homograpy if we remove the 4th point
if len(self._points) == 4:
self._imageChanged.emit(self._image)
# Remove the point
self._points = list(filter(lambda v: v != (x, y), self._points))
# Reorder points to have a planar graph (meaning no line crossing)
def _reorderPoints(self):
# List of reordoned points
ordPoints = [self._points[0]]
# List of selectionnable points
others = self._points[1:]
# Fill reordoned points
while len(ordPoints) < 4:
# Previous point
p = ordPoints[-1]
# Test other points
for pn in others:
# Points to verify side
verify = list(filter(lambda v: v != pn and v != p,
self._points))
# Verify side
if allSameSide(p, pn, verify):
ordPoints.append(pn)
others = list(filter(lambda v: v != pn, others))
break
# Set the reordoned points
self._points = ordPoints
def _validPoint(self, x, y):
a = [p for p in self._points] + [(x, y)]
triangles = [[a[0], a[1], a[2]], [a[0], a[1], a[3]],
[a[0], a[2], a[3]], [a[1], a[2], a[3]]]
points = [a[3], a[2], a[1], a[0]]
for triangle, point in zip(triangles, points):
px, py = point
if lieIntoTriangle(triangle, px, py):
return False
return True
class View(QtGui.QWidget):
def __init__(self,
parent=None,
width=5,
height=4,
dpi=80,
filename=None,
model=None,
plot_type='Image',
trace_num=None,
region=[]):
# plot paramters #
self.t_num = trace_num
self.region = region
# connect model signal #
self.model = model
self.model.dataChanged.connect(self.update_views)
# create a dictionary of views
self.view_options = {
'Image': self.view_image,
'TracePlot': self.view_trace,
'PSD': self.view_psd,
'Surface': self.view_surface
}
super(View, self).__init__(parent)
# make the figure
self.figure = Figure((width, height), dpi)
fig_color = (1.0, 1.0, 1.0, 1.0)
self.figure.set_facecolor(fig_color)
# create the canvas
self.canvas = Canvas(self.figure)
self.canvas.setParent(self)
# create the toolbar and tie it to the canvas
self.toolbar = Toolbar(self.canvas, self)
self.layout = QtGui.QVBoxLayout()
self.layout.addWidget(self.canvas)
self.setLayout(self.layout)
if filename:
self.setWindowTitle(plot_type + ': ' + filename)
if plot_type == 'Surface':
self.axes = self.figure.gca(projection='3d')
else:
self.axes = self.figure.add_subplot(111)
self.axes.hold(False)
self.view_options[plot_type]()
self.canvas.show()
def view_image(self):
self.axes.imshow(self.model.get_agc_data(), cmap=cm.coolwarm)
self.axes.set_xticklabels([])
self.axes.set_yticklabels([])
self.axes.set_xticks([])
self.axes.set_yticks([])
self.axes.set_xlabel('source channel')
self.axes.set_ylabel('time')
def view_trace(self):
print self.t_num
y = self.model.getTrace(self.t_num)
x = np.arange(len(y))
self.axes.fill(x, y, 'r', linewidth=0)
self.axes.set_xlabel('time')
self.axes.set_ylabel('amplitude')
self.axes.set_xlim(0, len(x))
self.axes.grid(True)
def view_surface(self):
#x = np.arange(self.model.getNTraces())
#y = np.arange(self.model.getTLength())
y = np.arange(self.region[1] - self.region[0])
x = np.arange(self.region[3] - self.region[2])
x, y = np.meshgrid(x, y)
z = self.model.get_agc_data()
z = z[self.region[0]:self.region[1], self.region[2]:self.region[3]]
print self.model.getTLength()
self.axes.plot_surface(x,
y,
z,
rstride=1,
cstride=1,
cmap=cm.coolwarm,
linewidth=0,
antialiased=False)
def view_psd(self):
y = self.model.get_psd_of_trace(self.t_num)
x = np.arange(-len(y) / 2, len(y) / 2)
print x.shape
print y.shape
self.axes.semilogy(x, y, 'r', linewidth=1)
self.axes.set_xlabel('frequency')
self.axes.set_ylabel('spectral density')
self.axes.set_xlim(-len(x) / 2, len(x) / 2)
self.axes.grid(True)
def update_views(self):
print "updating views"
class GraphView(QtGui.QWidget):
def __init__(self, image, aa, pymol, pmap, parent=None):
super(GraphView, self).__init__(parent)
self.aa = aa
self.pymol = pymol
self.dpi = 300
self.pmap = pmap
self.fig = Figure((4.5, 4.5), dpi=self.dpi)
self.axes = self.fig.add_subplot(111)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self)
self.canvas.mpl_connect('button_press_event', self._onpick)
self.layout = QtGui.QVBoxLayout()
self.layout.addWidget(self.canvas)
self.layout.setStretchFactor(self.canvas, 1)
self.setLayout(self.layout)
self.dmap = self.cmap_discretize(cm.spectral, 10)
self.image = image
self.map = self.axes.imshow(self.image, interpolation='nearest', cmap=self.dmap, aspect='equal', origin='lower')
self.canvas.show()
self.set_parameters()
def cmap_discretize(self, cmap, N):
"""Return a discrete colormap from the continuous colormap cmap.
cmap: colormap instance, eg. cm.jet.
N: number of colors.
Example
x = resize(arange(100), (5,100))
djet = cmap_discretize(cm.jet, 5)
imshow(x, cmap=djet)
"""
if type(cmap) == str:
cmap = cm.get_cmap(cmap)
colors_i = np.concatenate((np.linspace(0, 1., N), (0., 0., 0., 0.)))
colors_rgba = cmap(colors_i)
indices = np.linspace(0, 1., N + 1)
cdict = {}
for ki, key in enumerate(('red', 'green', 'blue')):
cdict[key] = [(indices[i], colors_rgba[i - 1, ki], colors_rgba[i, ki]) for i in xrange(N + 1)]
# Return colormap object.
return colors.LinearSegmentedColormap(cmap.name + "_%d" % N, cdict, 1024)
def _get_clicked_residues(self, event):
xmin, xmax = self.axes.get_xlim()
ymin, ymax = self.axes.get_ylim()
return(int(math.ceil(event.xdata - xmin))-1, int(math.ceil(event.ydata - ymin))-1)
def _onpick(self, event):
if self.pmap.use_ca:
atom = 'CA'
else:
atom = 'CB'
index1, index2 = self._get_clicked_residues(event)
if self.image[index1][index2] > 0:
self.pymol.select_aminoacids(self.aa[index1], self.aa[index2], atom, self.pmap.cutoff)
def set_parameters(self):
cbar_ax = self.fig.add_axes([0.12, 0.94, 0.75, 0.03])
cbar_ax.xaxis.labelpad = 3.0
cbar_ax.tick_params(length=2.0, direction='out', pad=0.0)
cbar = self.fig.colorbar(self.map, cax=cbar_ax, orientation='horizontal', drawedges=False)
cbar_ax.xaxis.set_ticks_position('top')
cbar_ax.xaxis.set_label_position('bottom')
cbar_ax.xaxis.set_label_text('Contact Counts')
self.axes.tick_params(axis=u'both', which=u'both', length=0)
self.axes.xaxis.set_ticks(range(0, len(self.aa), 1))
self.axes.yaxis.set_ticks(range(0, len(self.aa), 1))
self.axes.set_xticklabels(self.aa, rotation=90)
self.axes.set_yticklabels(self.aa)
self.fig.patch.set_facecolor((0.886, 0.886, 0.886))
ticks_font = mpl.font_manager.FontProperties(family='times new roman', style='normal', size=12, weight='normal',
stretch='normal')
labels = [self.axes.title, self.axes.xaxis.label, self.axes.yaxis.label, cbar.ax.xaxis.label]
labels += self.axes.get_xticklabels() + self.axes.get_yticklabels() + cbar.ax.get_xticklabels()
for item in labels:
item.set_fontproperties(ticks_font)
item.set_fontsize(4)
def update_graph(self, image):
self.axes.clear()
self.image = image
self.map = self.axes.imshow(self.image, interpolation='nearest', cmap=self.dmap, aspect='equal', origin='lower')
self.set_parameters()
self.canvas.draw()
class Plot(Callback.Callbacks):
def __init__(self, logger):
Callback.Callbacks.__init__(self)
self.logger = logger
# For callbacks
for name in ('close', ):
self.enable_callback(name)
self.fig = matplotlib.figure.Figure()
self.ax = self.fig.add_subplot(111)
self.ax.set_xlabel('X values')
self.ax.set_ylabel('Y values')
self.ax.set_title('')
self.ax.grid(True)
self.canvas = FigureCanvas(self.fig)
def get_widget(self):
return self.canvas
def _sanity_check_window(self):
pass
def set_titles(self, xtitle=None, ytitle=None, title=None, rtitle=None):
self._sanity_check_window()
if xtitle != None:
self.ax.set_xlabel(xtitle)
if ytitle != None:
self.ax.set_ylabel(ytitle)
if title != None:
self.ax.set_title(title)
if rtitle != None:
pass
def clear(self):
self._sanity_check_window()
self.logger.debug('clearing canvas...')
self.ax.cla()
def show(self):
self._sanity_check_window()
self.logger.debug('raising window...')
self.canvas.show()
def hide(self):
self._sanity_check_window()
self.logger.debug('hiding window...')
pass
def close(self):
self.logger.debug('closing window....')
self.canvas.destroy()
self.make_callback('close')
return False
def _draw(self):
self.fig.canvas.draw()
def plot(self,
xarr,
yarr,
xtitle=None,
ytitle=None,
title=None,
rtitle=None,
color=None,
alpha=1.0):
self.set_titles(xtitle=xtitle,
ytitle=ytitle,
title=title,
rtitle=rtitle)
if not color:
self.ax.plot(xarr, yarr, linewidth=1.0, alpha=alpha, linestyle='-')
else:
self.ax.plot(xarr,
yarr,
linewidth=1.0,
color=color,
alpha=alpha,
linestyle='-')
self.ax.grid(True)
self._draw()
class JouleBraytonDialog(QDialog, layout_cicloJouleBrayton.Ui_Dialog):
# Estas lineas son medias magicas, pero siempre van:
def __init__(self,parent=None):
super(JouleBraytonDialog, self).__init__(parent)
self.setupUi(self)
self.setWindowTitle(__appName__)
# Creo algunas variables que generales que luego voy a usar
self.Q = []
self.gamma_aire = 1.4
self.R_aire = 287
#Defino las formulas quimicas para selecionar en formulas_comboBox
self.formulas = {"AvGas":{'c':7,'h':16,'o':0,'s':0.00},"Diesel":{'c':12,'h':21,'o':0,'s':0.00}}
# Utilizo las 'keys' de self.formulas para cargar los items en la combobox
for key in self.formulas.keys():
self.formula_comboBox.addItem(key)
self.actualizarFormula()
# Generamos dos figuras, cada una luego asociada a un canvas, que a su vez tiene como padre una de las pestañas
# self.tab -> contiene la pestaña titulada "Diagrama P-S"
# self.tab_2 -> contiene la pestaña titulada "Diagrama T-S"
self.fig1 = Figure(figsize=(4.8,3.4),dpi=72, facecolor=(1,1,1), edgecolor=(0,0,0))
self.axes1 = self.fig1.add_subplot(111)
self.axes1.set_ylabel('p')
self.axes1.set_xlabel('v')
self.axes1.set_title('Ciclo Joule-Brayton')
self.axes1.ticklabel_format(style="sci", scilimits=(0, 0), axis="both") # , useOffset=True,useLocale=True)
self.axes1.tick_params(axis="both", direction='in', length=6, width=2, labelsize="medium")
self.fig2 = Figure(figsize=(4.8,3.4),dpi=72, facecolor=(1,1,1), edgecolor=(0,0,0))
self.axes2 = self.fig2.add_subplot(111)
self.axes2.set_ylabel('T')
self.axes2.ticklabel_format(style='sci', scilimits=(0, 0), axis="both")
self.axes2.set_xlabel('S')
self.axes2.set_title('Ciclo Joule-Brayton')
# generate the canvas to display the plot
self.canvas1 = FigureCanvas(self.fig1)
self.canvas1.setParent(self.tab)
self.canvas1.show()
self.canvas2 = FigureCanvas(self.fig2)
self.canvas2.setParent(self.tab_2)
self.canvas2.show()
# Cambio los lineInput de HVS y HVI a "ReadOnly"
self.HVS_lineEdit.setReadOnly(True)
self.HVI_lineEdit.setReadOnly(True)
#Inicializo la parte de la postcombustión como no habilitada.
self.datoExtra_3.setDisabled(True)
self.selecDatoExtra_3.setDisabled(True)
self.theta1.setDisabled(True)
#Seleccion de una formula en formula_comboBox
self.connect(self.formula_comboBox,SIGNAL("currentIndexChanged(int)"),self.selecionFormula)
#Acciones de actualización de la formula quimica para el calculo de Q
# En este punto tengo que agregar la opción de que si Q surge como resultado
# de otro parametros de entrada, la relación demezcla se tendrá que actualizar
# para que la formula y la relación sean compatibles con el Q obtenido
self.connect(self.formulaC,SIGNAL("textEdited(const QString&)"),self.actualizarFormula)
self.connect(self.formulaH,SIGNAL("textEdited(const QString&)"),self.actualizarFormula)
self.connect(self.formulaO,SIGNAL("textEdited(const QString&)"),self.actualizarFormula)
self.connect(self.formulaS,SIGNAL("textEdited(const QString&)"),self.actualizarFormula)
self.connect(self.relacionMezcla,SIGNAL("valueChanged(double)"),self.actualizarFormula)
self.connect(self.calcular,SIGNAL("clicked()"),self.Calculos)
# Configurando el boton de check para la postcombustion
self.connect(self.PostCombustion,SIGNAL("stateChanged(int)"),self.enable_PostCombustion)
self.connect(self.selecDatoExtra_2,SIGNAL("currentIndexChanged(int)"),self.actualizarFormula)
# Boton para mostrar matriz de resultados
self.connect(self.matrixButton,SIGNAL("clicked()"),self.displayMatrix)
#Boton para seleccionar P1 y T1 a partir de la altura:
self.connect(self.Altura_Button,SIGNAL("clicked()"),self.seleccionAltura)
def enable_PostCombustion(self):
if self.PostCombustion.checkState():
self.datoExtra_3.setEnabled(True)
self.selecDatoExtra_3.setEnabled(True)
self.theta1.setEnabled(True)
else:
self.datoExtra_3.setDisabled(True)
self.selecDatoExtra_3.setDisabled(True)
self.theta1.setDisabled(True)
def selecionFormula(self):
formula = self.formula_comboBox.currentText()
if formula != 'Otra':
self.formulaC.setText(str(self.formulas[formula]['c']))
self.formulaH.setText(str(self.formulas[formula]['h']))
self.formulaO.setText(str(self.formulas[formula]['o']))
self.formulaS.setText(str(self.formulas[formula]['s']))
self.actualizarFormula()
def actualizarFormula(self):
c = self.lecturadatos(self.formulaC,'int')
h = self.lecturadatos(self.formulaH,'int')
o = self.lecturadatos(self.formulaO,'int')
s = self.lecturadatos(self.formulaS,'float')
# si la formula ingresada coincide con alguna formula del comboBox
# poner el comboBox en esa formula.
indexName = 'Otra'
for key in self.formulas.keys():
if (self.formulas[key]['c'] == c) & (self.formulas[key]['h'] == h) & (self.formulas[key]['o'] == o):
indexName = key
index = self.formula_comboBox.findText(indexName)
self.formula_comboBox.setCurrentIndex(index)
Fr = self.relacionMezcla.value()
self.HVS, self.HVI, self.Q, self.lambda_s = PoderCalorifico.PoderCalorifico(c,h,o,s,Fr)
self.HVS_lineEdit.setText('{:.1f}'.format(self.HVS))
self.HVI_lineEdit.setText('{:.1f}'.format(self.HVI))
self.calorQ.setText('{:.1f}'.format(self.Q))
if self.selecDatoExtra_2.currentText().split(" ")[0] == 'Q':
self.datoExtra_2.setText(str(self.Q))
self.datoExtra_2.setReadOnly(True)
else: self.datoExtra_2.setReadOnly(False)
def seleccionAltura(self):
p1 = str(self.presion1.text())
t1 = str(self.temperatura1.text())
dialogo = GUI_atmosfera_estandar.MainDialog(p1,t1)
if dialogo.exec_():
self.presion1.setText('{:.1f}'.format(dialogo.atmosfera['p']))
self.temperatura1.setText('{:.1f}'.format(dialogo.atmosfera['t']))
def lecturadatos(self,lineedit,type):
try:
aux = 0
if type == 'int':
aux = int(lineedit.text())
if type == 'float':
aux = float(lineedit.text())
if aux < 0:
raise NumeroNegativoError
return aux
except (TypeError, ValueError,NumeroNegativoError):
QMessageBox.warning(self,"Error en los datos de entrada! ","Vuelva a ingresar los datos")
lineedit.selectAll()
lineedit.setFocus()
raise
# Genero ahora la función que va a realizar los calculos, es decir,
# que va a llamar la función del ciclo.
def Calculos(self):
# Lectura de los datos de entrada con la función verificacion
p1 = self.lecturadatos(self.presion1,'float')
t1 = self.lecturadatos(self.temperatura1,'float')
tb = self.lecturadatos(self.temperatura_base,'float')
variableExtra1 = self.selecDatoExtra_1.currentText().split(" ")[0]
datoExtra1 = self.lecturadatos(self.datoExtra_1,'float')
variableExtra2 = self.selecDatoExtra_2.currentText().split(" ")[0]
datoExtra2 = self.lecturadatos(self.datoExtra_2,'float')
theta1 = self.lecturadatos(self.theta1,'float')
variableExtra3 = self.selecDatoExtra_3.currentText().split()[0]
datoExtra3 = self.lecturadatos(self.datoExtra_3,'float')
try:
#Procedo a calcular los parametros del ciclo, diferenciando entre el problema
#con y sin post-combustión
if self.PostCombustion.checkState()== Qt.CheckState.Checked:
self.puntos, self.resultados = Ciclo_JouleBrayton.CicloJouleBraytonPostcombustion(p1,t1,tb,theta1,variableExtra1,datoExtra1,variableExtra2,datoExtra2,variableExtra3,datoExtra3)
else:
self.puntos, self.resultados = Ciclo_JouleBrayton.CicloJouleBraytonSimple(p1,t1,tb,variableExtra1,datoExtra1,variableExtra2,datoExtra2)
except MayorAUnoError as e:
QMessageBox.warning(self,"Error en los datos de entrada! ","La variable "+str(e.variableName)+" no puede ser menor a 1")
if e.variableName == 'theta1':
self.theta1.selectAll()
self.theta1.setFocus()
else:
self.datoExtra_1.selectAll()
self.datoExtra_1.setFocus()
except TemperaturaIncompatibleError as e:
QMessageBox.warning(self,"Error en los datos de entrada! ","La temperatura "+str(e.variableName)+" no puede ser menor a la "+
"temepratura del estado anterior ("+str(e.value)+" K)")
if e.variableName == 't3':
self.datoExtra_2.selectAll()
self.datoExtra_2.setFocus()
else:
self.datoExtra_3.selecAll()
self.datoExtra_3.setFocus()
else:
#Grafico el resultado
self.plotCiclo(self.puntos)
# Muestro los resultados
self.calor2.setText(str(self.resultados[1]))
self.calorU.setText(str(self.resultados[2]))
self.trabajoW.setText(str(self.resultados[3]))
self.presionMedia.setText(str(self.resultados[4]))
self.rendimiento.setText(str(self.resultados[5]))
# En caso de que realice un calculo con "Temp. max" como parametro de
#entrada, Q es resultado del calculo. Como la formula quimica del combustible
# y por ende, su poder calorifico, no varian, debo cambiar la relación
# de mezcla de entrada para que sea compatible con el nuevo calor calculado.
self.Q = self.resultados[0]/1000
if self.selecDatoExtra_2.currentText().split(" ")[0] == "Temp. max":
self.calorQ.setText(str(self.Q))
self.relacionMezcla.setValue(self.Q*self.lambda_s/self.HVI)
def plotCiclo(self,puntos):
presion = []
temperatura = []
densidad = []
volumen = []
entropia = []
for punto in puntos:
presion.append(punto[0])
temperatura.append(punto[1])
densidad.append(punto[2])
volumen.append(punto[3])
entropia.append(punto[4])
v1 = np.append(np.arange(volumen[1],volumen[0],(volumen[0]-volumen[1])/100),volumen[0])
v2 = np.append(np.arange(volumen[-2],volumen[-1],(volumen[-1]-volumen[-2])/100),volumen[-1])
self.axes1.clear()
self.axes1.plot(v1,presion[1]*volumen[1]**self.gamma_aire*(1/v1**self.gamma_aire),'r')
self.axes1.plot(volumen[1:3],presion[1:3],'r')
self.axes1.plot((volumen[0],volumen[-1]),(presion[0],presion[-1]),'r')
self.axes1.plot(v2,presion[-2]*volumen[-2]**self.gamma_aire*(1/v2**self.gamma_aire),'r')
if self.PostCombustion.checkState() == Qt.CheckState.Checked:
self.axes1.plot((volumen[-3],volumen[-2]),(presion[-3],presion[-2]),'r')
v3 = np.append(np.arange(volumen[2],volumen[3],(volumen[3]-volumen[2])/100),volumen[3])
self.axes1.plot(v3,presion[2]*volumen[2]**self.gamma_aire*(1/v3**self.gamma_aire),'r')
self.canvas1.draw()
S1 = np.append(np.arange(entropia[1],entropia[2],(entropia[2]-entropia[1])/100),entropia[2])
S2 = np.append(np.arange(entropia[0],entropia[-1],(entropia[-1]-entropia[0])/100),entropia[-1])
self.axes2.clear()
self.axes2.plot(entropia[0:2],temperatura[0:2],'r',entropia[-2::],temperatura[-2::],'r')
self.axes2.plot(S1,temperatura[1]*np.exp((self.gamma_aire-1)*(S1-entropia[1])/(self.R_aire*self.gamma_aire)),'r')
self.axes2.plot(S2,temperatura[0]*np.exp((self.gamma_aire-1)*(S2-entropia[0])/(self.R_aire*self.gamma_aire)),'r')
if self.PostCombustion.checkState()==Qt.CheckState.Checked:
S3 = np.append(np.arange(entropia[3],entropia[4],(entropia[4]-entropia[3])/100),entropia[4])
self.axes2.plot(entropia[2:4],temperatura[2:4],'r')
self.axes2.plot(S3,temperatura[3]*np.exp((self.gamma_aire-1)*(S3-entropia[3])/self.R_aire/self.gamma_aire),'r')
self.canvas2.draw()
def displayMatrix(self):
matriz = MatrixDialog(self.puntos)
matriz.exec_()
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 GraphView(QtGui.QWidget):
def __init__(self, pymol, pmap, parent=None):
super(GraphView, self).__init__(parent)
self.pymol = pymol
self.dpi = 300
self.pmap = pmap
self.fig = Figure((4.5, 4.5), dpi=self.dpi)
self.axes = self.fig.add_subplot(111)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self)
self.canvas.mpl_connect('button_press_event', self._onpick)
self.layout = QtGui.QVBoxLayout()
self.layout.addWidget(self.canvas)
self.layout.setStretchFactor(self.canvas, 1)
self.setLayout(self.layout)
if self.pmap.use_ca:
self.xcoor = self.pmap.residue_numbers_ca[
self.pmap.parent.current_model]
else:
self.xcoor = self.pmap.residue_numbers_cb[
self.pmap.parent.current_model]
self.ycoor = self.pmap.histogram_maps[self.pmap.parent.current_model]
self.bar = self.axes.bar(self.xcoor,
self.ycoor,
width=1.0,
linewidth=0)
self.canvas.show()
self.set_parameters()
def _get_clicked_residues(self, event):
xmin, xmax = self.axes.get_xlim()
return (int(math.ceil(event.xdata - xmin)) - 1)
def _onpick(self, event):
if self.pmap.use_ca:
atom = 'CA'
chains = self.pmap.chain_names_ca[self.pmap.parent.current_model]
residue_numbers = self.pmap.residue_numbers_ca[
self.pmap.parent.current_model]
else:
atom = 'CB'
chains = self.pmap.chain_names_cb[self.pmap.parent.current_model]
residue_numbers = self.pmap.residue_numbers_cb[
self.pmap.parent.current_model]
index = self._get_clicked_residues(event)
self.pymol.select_density(residue_numbers[index], atom,
self.pmap.cutoff, chains[index])
def set_parameters(self):
self.axes.tick_params(axis=u'both', which=u'both', length=0)
self.axes.set_xlim(min(self.xcoor), max(self.xcoor))
self.axes.set_ylim(0, max(self.ycoor) + 1)
self.axes.set_xlabel('Residue Number')
self.axes.set_ylabel('Contact Counts')
fractions = self.ycoor / max(self.ycoor)
normalized_colors = colors.Normalize(fractions.min(), fractions.max())
count = 0
for rect in self.bar:
c = cm.jet(normalized_colors(fractions[count]))
rect.set_facecolor(c)
count += 1
self.fig.patch.set_facecolor((0.886, 0.886, 0.886))
ticks_font = mpl.font_manager.FontProperties(family='times new roman',
style='normal',
size=12,
weight='normal',
stretch='normal')
labels = [
self.axes.title, self.axes.xaxis.label, self.axes.yaxis.label
]
labels += self.axes.get_xticklabels() + self.axes.get_yticklabels()
for item in labels:
item.set_fontproperties(ticks_font)
item.set_fontsize(4)
def update_graph(self):
self.axes.clear()
if self.pmap.use_ca:
self.xcoor = self.pmap.residue_numbers_ca[
self.pmap.parent.current_model]
else:
self.xcoor = self.pmap.residue_numbers_cb[
self.pmap.parent.current_model]
self.ycoor = self.pmap.histogram_maps[self.pmap.parent.current_model]
self.bar = self.axes.bar(self.xcoor,
self.ycoor,
width=1.0,
linewidth=0)
self.set_parameters()
self.canvas.draw()
class GraphView(QtGui.QWidget):
def __init__(self, filename, parent=None):
super(GraphView, self).__init__(parent)
self.dpi = 300
self.filename = filename
self.data = None
self.fig = Figure((4.5, 4.5), dpi=self.dpi)
self.axes = self.fig.add_subplot(111)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self)
self.canvas.mpl_connect('button_press_event', self._onpick)
self.layout = QtGui.QVBoxLayout()
self.layout.addWidget(self.canvas)
self.layout.setStretchFactor(self.canvas, 1)
self.setLayout(self.layout)
self.x = []
self.y = []
self.read_data()
self.load_data()
self.canvas.show()
self.set_parameters()
def read_data(self):
fh = open(self.filename)
for line in fh.readlines():
if not re.match(r'[A-Za-z]', line):
values = line.strip().split(',')
try:
self.x.append(float(values[0]))
self.y.append(float(values[2]))
except:
pass
self.x = np.array(self.x)
self.y = np.array(self.y)
def load_data(self):
self.bar = self.axes.plot(self.x, self.y, linewidth=1.0)
def _get_clicked_residues(self, event):
xmin, xmax = self.axes.get_xlim()
return(int(math.ceil(event.xdata - xmin))-1)
def _onpick(self, event):
pass
def set_parameters(self):
self.axes.tick_params(axis=u'both', which=u'both', length=0)
self.axes.set_xlim(min(self.x), max(self.x))
self.axes.set_ylim(0, max(self.y) + 1)
self.axes.set_xlabel('Threshold')
self.axes.set_ylabel('Overdispersion')
# fractions = self.y / max(self.y)
# normalized_colors = colors.Normalize(fractions.min(), fractions.max())
# count = 0
# for rect in self.bar:
# c = cm.jet(normalized_colors(fractions[count]))
# rect.set_facecolor(c)
# count += 1
# self.fig.patch.set_facecolor((0.886, 0.886, 0.886))
ticks_font = mpl.font_manager.FontProperties(family='times new roman', style='normal', size=12,
weight='normal', stretch='normal')
labels = [self.axes.title, self.axes.xaxis.label, self.axes.yaxis.label]
labels += self.axes.get_xticklabels() + self.axes.get_yticklabels()
for item in labels:
item.set_fontproperties(ticks_font)
item.set_fontsize(4)
self.fig.set_size_inches(30, self.fig.get_figheight(), forward=True)
class BottleWindow(QtGui.QWidget):
"Document window for displaying a particular bottle"
def __init__(self, bottle):
super(BottleWindow, self).__init__(None)
self.ui = uic.loadUi(get_ui_file('bottle_window.ui'), self)
self.ui.readings_view.setModel(
BottleModel(DataAnalyzer(bottle, delta=True)))
for col in range(self.ui.readings_view.model().columnCount()):
self.ui.readings_view.resizeColumnToContents(col)
self.exporter = BottleExporter(self)
if matplotlib:
self.figure = Figure(figsize=(5.0, 5.0),
facecolor='w',
edgecolor='w')
self.canvas = FigureCanvas(self.figure)
self.axes = self.figure.add_subplot(111)
self.ui.splitter.addWidget(self.canvas)
self.redraw_timer = QtCore.QTimer()
self.redraw_timer.setInterval(200) # msecs
self.redraw_timer.timeout.connect(self.redraw_timeout)
self.ui.splitter.splitterMoved.connect(self.splitter_moved)
self.refresh_edits()
self.setWindowTitle('Bottle %s' % bottle.serial)
self.ui.absolute_check.toggled.connect(self.absolute_toggled)
self.ui.points_spin.valueChanged.connect(self.points_changed)
@property
def model(self):
return self.ui.readings_view.model()
@property
def bottle(self):
return self.model.analyzer.bottle
def refresh_window(self):
"Forces the list to be re-read from the data logger"
self.model.beginResetModel()
self.model.analyzer.refresh()
self.refresh_edits()
self.model.endResetModel()
def refresh_edits(self):
"Refresh all the edit controls from the bottle"
bottle = self.model.analyzer.bottle
self.ui.bottle_serial_edit.setText(bottle.serial)
self.ui.bottle_id_edit.setText(str(bottle.id))
self.ui.measurement_mode_edit.setText(bottle.mode_string)
self.ui.bottle_volume_spin.setValue(bottle.bottle_volume)
self.ui.sample_volume_spin.setValue(bottle.sample_volume)
self.ui.dilution_spin.setValue(bottle.dilution)
self.ui.start_timestamp_edit.setText(bottle.start.strftime('%c'))
self.ui.finish_timestamp_edit.setText(bottle.finish.strftime('%c'))
self.ui.measurement_complete_edit.setText(bottle.completed)
self.ui.desired_values_edit.setText(str(bottle.expected_measurements))
self.ui.actual_values_edit.setText(str(bottle.actual_measurements))
self.ui.points_spin.setMaximum(
max(
1, bottle.actual_measurements -
(1 if bottle.actual_measurements % 2 == 0 else 0)))
self.ui.points_spin.setEnabled(bottle.actual_measurements > 1)
self.ui.absolute_check.setEnabled(bottle.actual_measurements > 1)
if bottle.actual_measurements > 1:
self.canvas.show()
self.invalidate_graph()
else:
self.canvas.hide()
def export_file(self):
"Export the readings to a user-specified filename"
self.exporter.export_file()
def absolute_toggled(self, checked):
"Handler for the toggled signal of the absolute_check control"
self.model.delta = not checked
if matplotlib:
self.invalidate_graph()
def points_changed(self, value):
"Handler for the valueChanged signal of the points_spin control"
self.model.points = value
if matplotlib:
self.invalidate_graph()
def splitter_moved(self, pos, index):
"Handler for the moved signal of the splitter control"
self.invalidate_graph()
def invalidate_graph(self):
"Invalidate the matplotlib graph on a timer"
if self.redraw_timer.isActive():
self.redraw_timer.stop()
self.redraw_timer.start()
def redraw_timeout(self):
"Handler for the redraw_timer's timeout event"
self.redraw_timer.stop()
self.redraw_figure()
def redraw_figure(self):
"Called to redraw the channel image"
# Configure the x and y axes appearance
self.axes.clear()
self.axes.set_frame_on(True)
self.axes.set_axis_on()
self.axes.grid(True)
self.axes.set_xlabel(self.tr('Time'))
if self.ui.absolute_check.isChecked():
self.axes.set_ylabel(self.tr('Pressure (hPa)'))
else:
self.axes.set_ylabel(self.tr('Delta Pressure (hPa)'))
m = self.ui.points_spin.value()
for head_ix, head in enumerate(self.model.analyzer.heads):
self.axes.plot_date(
x=self.model.analyzer.timestamps,
y=head,
fmt='%s-' %
matplotlib.rcParams['axes.color_cycle'][head_ix % len(
matplotlib.rcParams['axes.color_cycle'])])
self.axes.xaxis.set_major_formatter(DateFormatter('%d %b'))
self.axes.autoscale_view()
self.canvas.draw()
class PointsView(QtGui.QDialog, Ui_PointsView):
"""
Window for exploring and delating points
"""
def __init__(self, reac_data, parent=None):
QtGui.QDialog.__init__(self, parent)
self.setupUi(self)
self.setWindowTitle("Points view")
self.reac_data = deepcopy(reac_data)
self.axes = None
self.axes2 = None
self.fig = Figure()
self.canvas = FigureCanvas(self.fig)
self.mpl_toolbar = NavigationToolbar(self.canvas, parent)
self.verticalLayout_3.addWidget(self.canvas)
self.verticalLayout_3.addWidget(self.mpl_toolbar)
# SS init
if self.reac_data.is_single():
self.label.hide()
self.label_2.hide()
self.VarBox.hide()
self.SetBox.hide()
self.qbox_level3()
# DS init
else:
self.qbox_level1()
# make change
self.VarBox.activated.connect(self.qbox_level1)
self.SetBox.activated.connect(self.qbox_level2)
self.RepBox.activated.connect(self.qbox_level3)
self.DelBut.clicked.connect(self.delete_points)
def select_rep(self):
"""
Returns you rep which should be bold
"""
sel_set = self.SetBox.currentIndex()
varsub = self.VarBox.currentIndex() == 0
return [sel_set if varsub else -2, sel_set if not varsub else -2]
def draw_plots(self):
"""
Draw or re-draw plots
"""
self.fig.clear()
if self.reac_data.is_single():
self.axes = self.fig.add_subplot(111)
# Graph plot
reaction_plots.plot_singlegraph(self.reac_data, self.axes, 0, pick=self.RepBox.currentIndex())
self.canvas.draw()
self.canvas.show()
else:
self.axes = self.fig.add_subplot(121)
self.axes2 = self.fig.add_subplot(122)
picks = self.select_rep()
reaction_plots.plot_singlegraph(self.reac_data.get_repres(True), self.axes, 0, pick=picks[0], alpha1=0.75)
reaction_plots.plot_singlegraph(self.reac_data.get_repres(False), self.axes2, 0, pick=picks[1], alpha1=0.75)
# enhance single point
sub_group = True if self.VarBox.currentIndex() == 0 else False
plot_obj = self.axes if sub_group else self.axes2
dat_set = self.SetBox.currentIndex()
dat_rep = self.RepBox.currentIndex()
# plot if possible
try:
plot_obj.plot(self.reac_data.AllVar[sub_group][dat_set][dat_rep],
self.reac_data.AllRates[sub_group][dat_set][dat_rep], 'o', color='red')
except IndexError:
pass
self.canvas.draw()
self.canvas.show()
def qbox_level1(self):
"""
Display changes stage 1
"""
idx = self.VarBox.currentIndex()
idx = 0 if idx == -1 else idx
self.VarBox.clear()
self.VarBox.addItems([self.reac_data.nameA, self.reac_data.nameB])
self.VarBox.setCurrentIndex(idx)
self.qbox_level2()
def qbox_level2(self):
"""
Display changes stage 2
"""
idx = self.SetBox.currentIndex()
idx = 0 if idx == -1 else idx
self.SetBox.clear()
subs_sel = True if self.VarBox.currentIndex() == 0 else False
self.SetBox.addItems(['Set {}'.format(i + 1) for i in range(len(self.reac_data.AllVar[subs_sel]))])
self.SetBox.setCurrentIndex(idx if idx < len(self.SetBox) else 0)
self.qbox_level3()
def qbox_level3(self):
"""
Display changes stage 3
"""
idx = self.RepBox.currentIndex()
idx = 0 if idx == -1 else idx
self.RepBox.clear()
if self.reac_data.is_single():
self.RepBox.addItems(['Replicate {}'.format(i + 1) for i in range(self.reac_data.replicates)])
self.RepBox.setCurrentIndex(idx if idx < len(self.RepBox) else 0)
else:
subs_sel = True if self.VarBox.currentIndex() == 0 else False
sub_set = self.SetBox.currentIndex()
try:
self.RepBox.addItems(['Replicate {}'.format(i + 1) for i in range(len(
self.reac_data.AllVar[subs_sel][sub_set]))])
self.RepBox.setCurrentIndex(idx if idx < len(self.RepBox) else 0)
except:
WarningMessage('You have no replicates for selected substrate')
self.draw_plots()
def delete_points(self):
"""
Deletes replicate points
"""
# SS delete
if self.reac_data.is_single():
if self.reac_data.replicates > 0:
posit = self.RepBox.currentIndex()
self.reac_data.rates.pop(posit)
self.reac_data.concentrations.pop(posit)
self.reac_data.replicates -= 1
self.qbox_level3()
else:
WarningMessage("No points to delete")
# DS delete
else:
subs_sel = True if self.VarBox.currentIndex() == 0 else False
set_pos = self.SetBox.currentIndex()
rep_pos = self.RepBox.currentIndex()
self.reac_data.AllVar[subs_sel][set_pos].pop(rep_pos)
self.reac_data.AllRates[subs_sel][set_pos].pop(rep_pos)
self.reac_data.AllConst[subs_sel][set_pos].pop(rep_pos)
if not self.reac_data.AllVar[subs_sel][set_pos]:
self.reac_data.AllVar[subs_sel].pop(set_pos)
self.reac_data.AllRates[subs_sel].pop(set_pos)
self.reac_data.AllConst[subs_sel].pop(set_pos)
self.qbox_level1()
class MainWindow(QtGui.QWidget):
def __init__(self):
super(MainWindow, self).__init__()
QtCore.pyqtRemoveInputHook()
self.mutex = QtCore.QMutex()
self.initUI()
def initUI(self):
#### MSP CONNECTION CONFIG #########################
self.mspConfigPortBox = QtGui.QLineEdit(self)
if sys.platform == "win32":
self.mspConfigPortBox.setText("COM1")
else:
self.mspConfigPortBox.setText("/dev/ttyUSB0")
self.mspConfigBaudBox = QtGui.QLineEdit(self)
self.mspConfigBaudBox.setText("9600")
#### MSP COMMAND STUFF #############################
self.btnMspConnect = QtGui.QPushButton("CONNECT")
self.btnMspConnect.clicked.connect(self.mspConnect)
self.btnSendCommand = QtGui.QPushButton("SEND")
self.btnSendCommand.clicked.connect(self.mspSend)
self.commandBox = QtGui.QLineEdit(self)
self.commandBox.setText("CMD?")
#### CURVE TRACE APP MAIN LAYOUT ###################
vbox = QtGui.QVBoxLayout()
#### CURVE TRACE APP CONNECTION ####################
self.mspConnectGroup = QtGui.QGroupBox("Connection")
self.mspConnectGroup.setFlat(False)
# btnTest = QtGui.QPushButton("TEST")
# btnTest.clicked.connect(self.tester)
# btnTest.clicked.connect(self.sweepVoltageAction)
gridConnect = QtGui.QGridLayout()
gridConnect.addWidget(self.mspConfigPortBox, 0, 0)
gridConnect.addWidget(self.mspConfigBaudBox, 0, 1)
gridConnect.addWidget(self.btnMspConnect, 0, 2)
self.mspConnectGroup.setLayout(gridConnect)
#### CURVE TRACE APP COMMANDS ######################
mspCommandGroup = QtGui.QGroupBox("Send Manual Command")
mspCommandGroup.setFlat(False)
gridCommand = QtGui.QGridLayout()
gridCommand.addWidget(self.commandBox, 0, 0, 0, 1)
gridCommand.addWidget(self.btnSendCommand, 0, 2)
mspCommandGroup.setLayout(gridCommand)
#### SWEEPER GROUP #################################
self.groupSweeper = QtGui.QGroupBox("Sweeper Settings")
gridSweeper = QtGui.QGridLayout()
sweepVoltageMinLabel = QtGui.QLabel("Min Voltage (mV)")
self.sweepVoltageMin = QtGui.QLineEdit(self)
self.sweepVoltageMin.setMinimumWidth(50)
self.sweepVoltageMin.setText("-1000")
# self.sweepVoltageMin.setAlignment(QtCore.Qt.AlignCenter)
sweepVoltageMaxLabel = QtGui.QLabel("Max Voltage (mV)")
self.sweepVoltageMax = QtGui.QLineEdit(self)
self.sweepVoltageMax.setText("1000")
self.sweepVoltageMax.setMinimumWidth(50)
sweepVoltageIncrLabel = QtGui.QLabel("Step Size (mV)")
self.sweepVoltageIncr = QtGui.QLineEdit(self)
self.sweepVoltageIncr.setText("10")
self.sweepVoltageIncr.setMinimumWidth(40)
self.btnSweepCommand = QtGui.QPushButton("SWEEP")
self.btnSweepCommand.clicked.connect(self.sweepVoltageAction)
self.btnSweepCommand.setFixedWidth(60)
self.sweepSampleRateLabel = QtGui.QLabel("Sample Rate (x_)")
self.sweepSampleRate = QtGui.QLineEdit(self)
self.sweepSampleRate.setText("2")
self.sweepSampleRate.setFixedWidth(60)
self.vcc5VoltageLabel = QtGui.QLabel("5V Value (V)")
self.vcc5Voltage = QtGui.QLineEdit(self)
self.vcc5Voltage.setText("5.00")
self.vcc5Voltage.setFixedWidth(50)
self.vcc3VoltageLabel = QtGui.QLabel("3.3V Value (V)")
self.vcc3Voltage = QtGui.QLineEdit(self)
self.vcc3Voltage.setText("3.30")
self.vcc3Voltage.setFixedWidth(50)
self.currentGainLabel = QtGui.QLabel("Shunt Resistor Gain")
self.currentGain = QtGui.QLineEdit(self)
self.currentGain.setText("-50")
self.currentGain.setFixedWidth(50)
self.btnExportLog = QtGui.QPushButton("Export")
self.btnExportLog.clicked.connect(self.btnExportLogAction)
self.btnExportLog.setFixedWidth(60)
self.btnExportLog.setEnabled(False) # Cannot export log without a run
# self.tempCheck = QtGui.QCheckBox()
# self.tempCheckLabel = QtGui.QLabel("Temperature?")
gridSweeper.addWidget(sweepVoltageMaxLabel, 0, 0)
gridSweeper.addWidget(self.sweepVoltageMax, 0, 1)
gridSweeper.addWidget(sweepVoltageMinLabel, 1, 0)
gridSweeper.addWidget(self.sweepVoltageMin, 1, 1)
gridSweeper.addWidget(self.vcc5VoltageLabel, 2, 0)
gridSweeper.addWidget(self.vcc5Voltage, 2, 1)
gridSweeper.addWidget(self.vcc3VoltageLabel, 3, 0)
gridSweeper.addWidget(self.vcc3Voltage, 3, 1)
gridSweeper.addWidget(self.currentGainLabel, 4, 0)
gridSweeper.addWidget(self.currentGain, 4, 1)
gridSweeper.addWidget(sweepVoltageIncrLabel, 0, 4)
gridSweeper.addWidget(self.sweepVoltageIncr, 0, 5)
gridSweeper.addWidget(self.sweepSampleRateLabel, 1, 4)
gridSweeper.addWidget(self.sweepSampleRate, 1, 5)
gridSweeper.addWidget(self.btnSweepCommand, 3, 6)
gridSweeper.addWidget(self.btnExportLog, 4, 6)
self.groupSweeper.setLayout(gridSweeper)
#### STATUS GROUP ###################################
self.groupStatus = QtGui.QGroupBox("Sweep Status")
gridStatus = QtGui.QGridLayout()
measuredVoltageLabel = QtGui.QLabel("Voltage [mV]")
self.measuredVoltage = QtGui.QLineEdit(self)
self.measuredVoltage.setReadOnly(True)
measuredCurrentLabel = QtGui.QLabel("Current [mA]")
self.measuredCurrent = QtGui.QLineEdit(self)
self.measuredCurrent.setReadOnly(True)
gridStatus.addWidget(measuredVoltageLabel, 0, 0)
gridStatus.addWidget(self.measuredVoltage, 0, 1)
gridStatus.addWidget(measuredCurrentLabel, 1, 0)
gridStatus.addWidget(self.measuredCurrent, 1, 1)
self.groupStatus.setLayout(gridStatus)
#### VBOX LAYOUT
vbox.addWidget(self.mspConnectGroup)
vbox.addWidget(mspCommandGroup)
vbox.addWidget(self.groupSweeper)
vbox.addWidget(self.groupStatus)
self.setLayout(vbox)
self.show()
self.setGeometry(300, 300, 300, 150)
self.setWindowTitle('Curve Tracer Prototype')
self.toggleCommandField("OFF")
self.toggleConnectField("ON")
self.show()
def mspConnect(self):
source = self.sender()
if source.text() == "CONNECT":
port = self.mspConfigPortBox.text()
rate = self.mspConfigBaudBox.text()
self.mspInst = curveTracerSerial.Connection(port, rate)
self.btnMspConnect.setText("DISCONNECT")
self.toggleConnectField("OFF")
elif source.text() == "DISCONNECT":
self.mspInst.close()
del self.mspInst
self.btnMspConnect.setText("CONNECT")
self.toggleConnectField("ON")
def sweepVoltageAction(self):
sender = self.sender()
senderName = sender.text()
if senderName == "SWEEP":
maxV = self.sweepVoltageMax.text()
minV = self.sweepVoltageMin.text()
incr = self.sweepVoltageIncr.text()
sampleRate = self.sweepSampleRate.text()
vcc5Voltage = self.vcc5Voltage.text()
vcc3Voltage = self.vcc3Voltage.text()
currentGain = self.currentGain.text()
try:
self.c = cts.SweepThread(self.mutex, self.mspInst, minV, maxV,
incr, sampleRate, vcc5Voltage,
vcc3Voltage, currentGain)
self.c.signalSweepDone.connect(self.sweepDoneAction)
self.c.signalUpdateStats.connect(self.updateStats)
self.c.begin()
except:
print("unable to start")
elif senderName == "STOP":
try:
self.c.stopSweep()
# del self.c
self.toggleSweepField("ON")
self.btnSweepCommand.setText("SWEEP")
except:
print("Could not kill process")
def sweepDoneAction(self, check):
if check is False:
self.btnSweepCommand.setText("STOP")
self.toggleSweepField("OFF")
elif check is True:
print("voltage", self.voltageArray)
print("current", self.currentArray)
self.toggleSweepField("ON")
self.btnExportLog.setEnabled(True)
self.btnSweepCommand.setText("SWEEP")
def btnExportLogAction(self):
csvFile = QtGui.QFileDialog.getSaveFileName(self, 'Open file', '.')
print(csvFile)
with open(csvFile, 'w', newline='') as fp:
a = csv.writer(fp, delimiter=',')
a.writerow(('VOLTAGE [mV]', 'CURRENT [mA]'))
for i in range(len(self.voltageArray)):
a.writerow((self.voltageArray[i], self.currentArray[i]))
def updateStats(self, type, value):
valueRounded = round(value, 4)
if type == "VOLTAGE":
self.measuredVoltage.setText(str(valueRounded) + " mV")
self.voltageArray.append(value)
elif type == "CURRENT":
self.measuredCurrent.setText(str(valueRounded) + " mA")
self.currentArray.append(value)
for i in range(len(self.currentArray)):
ax = self.figure.add_subplot(111)
ax.hold(False)
ax.plot(self.voltageArray[0:i], self.currentArray[0:i])
ax.set_title('SOLAR CELL IV CURVE')
ax.set_xlabel('VOLTAGE [mV]')
ax.set_ylabel('CURRENT [mA]')
self.canvas.draw()
elif type == "SIZE":
self.voltageArray = array.array('f')
self.currentArray = array.array('f')
self.figure = plt.figure()
self.canvas = FigCanvas(self.figure)
self.canvas.show()
def mspSend(self):
command = self.commandBox.text()
self.mspInst.sendCommand(command)
print(self.mspInst.read())
def toggleConnectField(self, value):
if value == "ON":
self.mspConfigBaudBox.setEnabled(True)
self.mspConfigPortBox.setEnabled(True)
self.toggleCommandField("OFF")
elif value == "OFF":
self.toggleCommandField("ON")
self.mspConfigBaudBox.setEnabled(False)
self.mspConfigPortBox.setEnabled(False)
def toggleCommandField(self, value):
if value == "ON":
self.btnSendCommand.setEnabled(True)
self.commandBox.setEnabled(True)
self.groupSweeper.setEnabled(True)
elif value == "OFF":
self.btnSendCommand.setEnabled(False)
self.commandBox.setEnabled(False)
self.groupSweeper.setEnabled(False)
def toggleSweepField(self, value):
if value == "ON":
self.sweepVoltageMin.setEnabled(True)
self.sweepVoltageMax.setEnabled(True)
elif value == "OFF":
self.sweepVoltageMin.setEnabled(False)
self.sweepVoltageMax.setEnabled(False)
class GraphView(QtGui.QWidget):
def __init__(self, image, aa, pymol, pmap, parent=None):
super(GraphView, self).__init__(parent)
self.aa = aa
self.pymol = pymol
self.dpi = 300
self.pmap = pmap
self.fig = Figure((4.5, 4.5), dpi=self.dpi)
self.axes = self.fig.add_subplot(111)
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self)
self.canvas.mpl_connect('button_press_event', self._onpick)
self.layout = QtGui.QVBoxLayout()
self.layout.addWidget(self.canvas)
self.layout.setStretchFactor(self.canvas, 1)
self.setLayout(self.layout)
self.dmap = self.cmap_discretize(cm.spectral, 10)
self.image = image
self.map = self.axes.imshow(self.image,
interpolation='nearest',
cmap=self.dmap,
aspect='equal',
origin='lower')
self.canvas.show()
self.set_parameters()
def cmap_discretize(self, cmap, N):
"""Return a discrete colormap from the continuous colormap cmap.
cmap: colormap instance, eg. cm.jet.
N: number of colors.
Example
x = resize(arange(100), (5,100))
djet = cmap_discretize(cm.jet, 5)
imshow(x, cmap=djet)
"""
if type(cmap) == str:
cmap = cm.get_cmap(cmap)
colors_i = np.concatenate((np.linspace(0, 1., N), (0., 0., 0., 0.)))
colors_rgba = cmap(colors_i)
indices = np.linspace(0, 1., N + 1)
cdict = {}
for ki, key in enumerate(('red', 'green', 'blue')):
cdict[key] = [(indices[i], colors_rgba[i - 1, ki], colors_rgba[i,
ki])
for i in xrange(N + 1)]
# Return colormap object.
return colors.LinearSegmentedColormap(cmap.name + "_%d" % N, cdict,
1024)
def _get_clicked_residues(self, event):
xmin, xmax = self.axes.get_xlim()
ymin, ymax = self.axes.get_ylim()
return (int(math.ceil(event.xdata - xmin)) - 1,
int(math.ceil(event.ydata - ymin)) - 1)
def _onpick(self, event):
if self.pmap.use_ca:
atom = 'CA'
else:
atom = 'CB'
index1, index2 = self._get_clicked_residues(event)
if self.image[index1][index2] > 0:
self.pymol.select_aminoacids(self.aa[index1], self.aa[index2],
atom, self.pmap.cutoff)
def set_parameters(self):
cbar_ax = self.fig.add_axes([0.12, 0.94, 0.75, 0.03])
cbar_ax.xaxis.labelpad = 3.0
cbar_ax.tick_params(length=2.0, direction='out', pad=0.0)
cbar = self.fig.colorbar(self.map,
cax=cbar_ax,
orientation='horizontal',
drawedges=False)
cbar_ax.xaxis.set_ticks_position('top')
cbar_ax.xaxis.set_label_position('bottom')
cbar_ax.xaxis.set_label_text('Contact Counts')
self.axes.tick_params(axis=u'both', which=u'both', length=0)
self.axes.xaxis.set_ticks(range(0, len(self.aa), 1))
self.axes.yaxis.set_ticks(range(0, len(self.aa), 1))
self.axes.set_xticklabels(self.aa, rotation=90)
self.axes.set_yticklabels(self.aa)
self.fig.patch.set_facecolor((0.886, 0.886, 0.886))
ticks_font = mpl.font_manager.FontProperties(family='times new roman',
style='normal',
size=12,
weight='normal',
stretch='normal')
labels = [
self.axes.title, self.axes.xaxis.label, self.axes.yaxis.label,
cbar.ax.xaxis.label
]
labels += self.axes.get_xticklabels() + self.axes.get_yticklabels(
) + cbar.ax.get_xticklabels()
for item in labels:
item.set_fontproperties(ticks_font)
item.set_fontsize(4)
def update_graph(self, image):
self.axes.clear()
self.image = image
self.map = self.axes.imshow(self.image,
interpolation='nearest',
cmap=self.dmap,
aspect='equal',
origin='lower')
self.set_parameters()
self.canvas.draw()
class PlotTab(QtGui.QWidget):
delete_this_tab = QtCore.pyqtSignal()
dataset = None
def __init__(self, delete_plot_button=True, parent=None):
QtGui.QWidget.__init__(self, parent=parent)
self.layout = QtGui.QGridLayout()
self.setLayout(self.layout)
# Title lable and enter title name
plot_title_label = QtGui.QLabel("Title: ")
self.layout.addWidget(plot_title_label, 0, 0)
self.plot_title_edit = QtGui.QLineEdit()
self.layout.addWidget(self.plot_title_edit, 0, 1)
#make the axes config widget
axes_config_widget = QtGui.QWidget()
axes_config_widget_layout = QtGui.QHBoxLayout()
axes_config_widget.setLayout(axes_config_widget_layout)
self.layout.addWidget(axes_config_widget, 1, 0, 1, 2)
self.axes_config_struct = []
# this struct should contain axes config objects
#[ [ var, label, flatten, flatten, ...], [var, label, flatten, flatten, ...], ... ]
#make the x axis config, setup
x_config_widget = QtGui.QWidget()
self.x_config_widget_layout = QtGui.QGridLayout()
x_config_widget.setLayout(self.x_config_widget_layout)
#label the seciton
x_config_widget_label = QtGui.QLabel("X Axis")
self.x_config_widget_layout.addWidget(x_config_widget_label, 0, 0)
#variable selection
x_config_var_label = QtGui.QLabel("Var: ")
self.x_config_widget_layout.addWidget(x_config_var_label, 1, 0)
self.x_config_var_select = QtGui.QComboBox()
self.x_config_var_select.currentIndexChanged.connect(self.x_var_selected)
self.x_config_widget_layout.addWidget(self.x_config_var_select, 1, 1)
#axis label config
x_config_axis_label_label = QtGui.QLabel("x axis label:")
self.x_config_widget_layout.addWidget(x_config_axis_label_label, 2, 0)
self.x_config_axis_label_edit = QtGui.QLineEdit()
self.x_config_widget_layout.addWidget(self.x_config_axis_label_edit, 2, 1)
axes_config_widget_layout.addWidget(x_config_widget, 0)
#make the y axis config stuff
y_config_widget = QtGui.QWidget()
self.y_config_widget_layout = QtGui.QGridLayout()
y_config_widget.setLayout(self.y_config_widget_layout)
#label the section
y_config_widget_label = QtGui.QLabel("Y Axis")
self.y_config_widget_layout.addWidget(y_config_widget_label, 0, 0)
#variable selection
y_config_var_label = QtGui.QLabel("Var: ")
self.y_config_widget_layout.addWidget(y_config_var_label, 1, 0)
self.y_config_var_select = QtGui.QComboBox()
self.y_config_var_select.currentIndexChanged.connect(self.y_var_selected)
self.y_config_widget_layout.addWidget(self.y_config_var_select, 1, 1)
#axis label config
y_config_axis_label_label = QtGui.QLabel("y axis label")
self.y_config_widget_layout.addWidget(y_config_axis_label_label, 2, 0)
self.y_config_axis_label_edit = QtGui.QLineEdit()
self.y_config_widget_layout.addWidget(self.y_config_axis_label_edit, 2, 1)
axes_config_widget_layout.addWidget(y_config_widget, 1)
#create buttons to perform certain actions
config_actions_widget = QtGui.QWidget()
config_actions_widget_layout = QtGui.QHBoxLayout()
config_actions_widget.setLayout(config_actions_widget_layout)
# should the widget have a delete plot button? make on if so
# The first tab should never have a delete button on it,
# The interface should always have one tab besides the "+" tab
if delete_plot_button == True:
config_actions_widget_delete = QtGui.QPushButton("Delete plot")
config_actions_widget_delete.clicked.connect(self.delete_clicked)
config_actions_widget_layout.addWidget(config_actions_widget_delete)
#button to click to import a variable from the console to be able to plot
config_actions_widget_importvar = QtGui.QPushButton("Import var from console")
config_actions_widget_importvar.clicked.connect(self.importvar_clicked)
config_actions_widget_layout.addWidget(config_actions_widget_importvar)
#button to click when they are done config and want to create the plot
config_actions_widget_plot = QtGui.QPushButton("Create Plot")
config_actions_widget_plot.clicked.connect(self.plot_clicked)
config_actions_widget_layout.addWidget(config_actions_widget_plot)
self.layout.addWidget(config_actions_widget, 2, 1)
# connect to the mainwindow dataset_imported fufn
self.window().dataset_imported.connect(self.dataset_imported)
def x_var_selected(self):
xvar = self.x_config_var_select.currentText()
if self.x_config_widget_layout.itemAtPosition(3, 0):
oldcontaineritem = self.x_config_widget_layout.itemAtPosition(3, 0).widget()
self.x_config_widget_layout.removeWidget(oldcontaineritem)
oldcontaineritem.deleteLater()
oldcontaineritem = None
self.x_flatten = None
#if the variable is not flat, need to flatten it
if len(self.dataset.variables[xvar].shape)>1:
container = QtGui.QWidget()
container_layout = QtGui.QGridLayout()
container.setLayout(container_layout)
message = QtGui.QLabel("not flat, select dims to flatten")
container_layout.addWidget(message, 0, 0, 1, 2)
#not flat! how to flatten?
self.x_flatten = []
for dim in self.dataset.variables[xvar].shape:
label = QtGui.QLabel("dim %s" % dim)
container_layout.addWidget(label)
options = QtGui.QComboBox()
options.dim = dim
options.addItem("all")
for i in range(dim):
options.addItem(str(i))
self.x_flatten.append(options)
container_layout.addWidget(options)
self.x_config_widget_layout.addWidget(container, 3, 0, 1, 2)
#if the variable has time in it, see if we prettify
if re.search("time", xvar):
container = QtGui.QWidget()
self.pretty_time_container_layout = QtGui.QGridLayout()
container.setLayout(self.pretty_time_container_layout)
self.x_pretty_time_checkbox = QtGui.QCheckBox("Is this a time variable, make it pretty?")
self.x_pretty_time_checkbox.stateChanged.connect(self.make_time_pretty)
self.pretty_time_container_layout.addWidget(self.x_pretty_time_checkbox, 0, 0, 1, 2)
self.x_config_widget_layout.addWidget(container, 4, 0, 1, 2)
self.x_config_axis_label_edit.setText("time")
else:
units = self.dataset.variables[xvar].units
self.x_config_axis_label_edit.setText("%s [%s]" % (xvar, units))
def y_var_selected(self):
yvar = self.y_config_var_select.currentText()
units = self.dataset.variables[yvar].units
self.y_config_axis_label_edit.setText("%s [%s]" % (yvar, units))
if self.y_config_widget_layout.itemAtPosition(3, 0):
oldcontaineritem = self.y_config_widget_layout.itemAtPosition(3, 0).widget()
self.y_config_widget_layout.removeWidget(oldcontaineritem)
oldcontaineritem.deleteLater()
oldcontaineritem = None
self.y_flatten = None
if len(self.dataset.variables[yvar].shape)>1:
container = QtGui.QWidget()
container_layout = QtGui.QGridLayout()
container.setLayout(container_layout)
message = QtGui.QLabel("not flat, select dims to flatten")
container_layout.addWidget(message, 0, 0, 1, 2)
#not flat! how to flatten?
self.y_flatten = []
for dim in self.dataset.variables[yvar].shape:
label = QtGui.QLabel("dim %s" % dim)
container_layout.addWidget(label)
options = QtGui.QComboBox()
options.dim = dim
options.addItem("all")
for i in range(dim):
options.addItem(str(i))
self.y_flatten.append(options)
container_layout.addWidget(options)
self.y_config_widget_layout.addWidget(container, 3, 0, 1, 2)
def make_time_pretty(self, state):
if state == QtCore.Qt.Checked:
# when the make time pretty checkbox is checked...
# make a container to put the parsing widget in
container = QtGui.QWidget()
container_layout = QtGui.QGridLayout()
container.setLayout(container_layout)
xvar = self.x_config_var_select.currentText()
# init variable as self so that can access from the plot clicked button,
# want to make sure we delete when the checkbox is unchecked
self.x_pretty_time_epoch_type = QtGui.QComboBox()
for timetype in epoch2datetime.timetypes:
self.x_pretty_time_epoch_type.addItem(timetype)
# if the timetype shows up in the units of the variable, autoselect it
if re.search(timetype, self.dataset.variables[xvar].units):
i = self.x_pretty_time_epoch_type.findText(timetype)
self.x_pretty_time_epoch_type.setCurrentIndex(i)
since = QtGui.QLabel("since")
self.x_pretty_time_epoch_start = QtGui.QDateTimeEdit()
# search for the timestring in the units, should match something like 2015-03-20
tryparsetime = re.search("[0-9,:,/,-]+ [0-9,:,/,-]+", self.dataset.variables[xvar].units)
if tryparsetime: #otherwise user has to configure themselves
tryparsetime = dateutil.parser.parse(tryparsetime.group(0))
self.x_pretty_time_epoch_start.setDateTime(tryparsetime)
# put things in the container
container_layout.addWidget(self.x_pretty_time_epoch_type, 0, 0)
container_layout.addWidget(since, 0, 1)
container_layout.addWidget(self.x_pretty_time_epoch_start, 0, 2)
# add the container to the parent container
self.pretty_time_container_layout.addWidget(container, 1, 0, 1, 2)
else:
# all the stuff above (combobox since datetimedit) was put in one container
# fixed at (1, 0) in pretty_time_container_layout so get it and delete it if
# the box was unchecked
container = self.pretty_time_container_layout.getItemAtPosition(1, 0).widget()
self.pretty_time_container_layout.removeWidget(container)
container.deleteLater()
self.x_pretty_time_epoch_type = None
def delete_clicked(self):
#delete the tab when the delete button is clicked
self.delete_this_tab.emit()
def importvar_clicked(self):
#TODO: how to pull a local variable from the scope of the console
#print self.window().console.kernel_manager.kernel.shell.__dict__
pass
def plot_clicked(self):
xvar = self.x_config_var_select.currentText()
yvar = self.y_config_var_select.currentText()
self.fig = Figure(figsize=(5, 4), dpi=100)
axes = self.fig.add_subplot(111)
axes.hold(False)
x = self.dataset.variables[xvar][:]
y = self.dataset.variables[yvar][:]
if self.x_config_widget_layout.itemAtPosition(3, 0):
#flatten x
flattening = []
for widget in self.x_flatten:
dim = widget.currentText()
if dim == "all":
flattening.append(slice(None))
else:
flattening.append(int(dim))
x = x[flattening].flatten()
if re.search("time", xvar):
if self.x_pretty_time_checkbox.isChecked():
#if this is a time variable and the checkbox for pretty time is checked
# then we know we need to parse the x variable and turn it into a datetime
# object to pass to matplotlib
tmp_epochtypestr = self.x_pretty_time_epoch_type.currentText()
tmp_epochbegin = self.x_pretty_time_epoch_start.dateTime().toPyDateTime()
convertor = epoch2datetime.Epoch2Datetime(tmp_epochtypestr, tmp_epochbegin)
x = [convertor.int2datetime(tmp_epoch) for tmp_epoch in x]
if self.y_config_widget_layout.itemAtPosition(3, 0):
#flatten y
flattening = []
for widget in self.y_flatten:
dim = widget.currentText()
if dim == "all":
flattening.append(slice(None))
else:
flattening.append(int(dim))
y = y[flattening].flatten()
self.plotwidget = FigureCanvas(self.fig)
axes.plot(x, y)
axes.set_title(self.plot_title_edit.text())
axes.set_xlabel(self.x_config_axis_label_edit.text())
axes.set_ylabel(self.y_config_axis_label_edit.text())
self.fig.autofmt_xdate()
self.plotwidget.show()
def dataset_imported(self, dataset):
self.dataset = dataset
# clear the comboboxes in case they are already populated
# ie. reimporting a dataset, also b/c this is called on new tab
self.x_config_var_select.clear()
self.y_config_var_select.clear()
self.plot_title_edit.setText(self.dataset.title)
for var in self.dataset.variables:
self.x_config_var_select.addItem(var)
self.y_config_var_select.addItem(var)
class mywidget(QWidget):
def __init__(self, Parent=None):
super(mywidget, self).__init__(Parent)
self.figure = plt.figure(figsize=(15, 25), facecolor='w', dpi=50)
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.slider = QSlider(Qt.Horizontal, self)
self.slider.setRange(1, 100)
self.slider.setValue(5)
self.slider.valueChanged[int].connect(self.changeValue)
self.label = QLabel('Taxa de amostragem 50 Hz')
self.spinbox = QSpinBox()
self.spinbox.setValue(5)
self.spinbox.valueChanged.connect(self.sliderchange)
self.spinbox.setRange(1, 100)
layout = QVBoxLayout()
layout.addWidget(self.toolbar)
layout.addWidget(self.canvas)
layout.addWidget(self.slider)
layout.addWidget(self.spinbox)
layout.addWidget(self.label)
self.slider.valueChanged.connect(self.changeValue)
self.setLayout(layout)
self.plot()
#self.changeValue(5)
def sliderchange(self, value):
self.slider.setValue(value)
def plot(self):
self.amostrasporseg = 15 * 5 #samples/sec
frequenciasinal = 5 #Hz
omega = frequenciasinal
self.z = 2 * np.pi * np.arange(0, 2 * np.pi, 1 / self.amostrasporseg)
y = np.sin(self.z * omega)
k = y * signal.hann(len(y))
ylinha = 20 * np.log10(abs(np.fft.fft(k, 2048)))
ylinha = np.tile(ylinha, 3)
zlinha = np.linspace(-2, 4, len(ylinha))
self.figure.subplots_adjust(bottom=.75)
gs = gridspec.GridSpec(5, 1, height_ratios=[0.2, 1, 0.25, 1, 0.2])
ax = self.figure.add_subplot(gs[1])
self.plot2, = plt.plot(zlinha, ylinha)
plt.title('Espectro do sinal')
plt.xlabel(r'$\omega$')
plt.ylabel(r'|X($\omega$)|')
plt.xticks((-2, -1, 0, 1, 2, 3, 4), [
r'$-2\pi$', r'$-\pi$', '0', r'$\pi$', r'$2\pi$', r'$3\pi$',
r'$4\pi$'
])
#ax.set_xticks([-0.0442,0.0442], minor=True)
ax.xaxis.grid(True,
which='major',
linewidth=0.75,
color='k',
linestyle='--')
self.beta = self.figure.add_subplot(gs[3])
self.plot3, = plt.plot(self.z, y, label='Amostragem Correta')
plt.plot(self.z, y, 'o', label='Amostragem Fixa')
plt.legend(loc='upper right')
self.beta.set_xlabel(r't')
self.beta.set_ylabel(r'x(t)')
self.beta.set_xlim([0, 2 * np.pi])
self.figure.tight_layout()
def changeValue(self, value):
self.spinbox.setValue(value)
freq = value
znovo = np.arange(0, 2 * np.pi, 0.001)
omega = freq
omeganovo = freq
y = np.sin(self.z * omega)
yf = np.sin(znovo * omeganovo)
k = y * signal.hann(len(y))
ylinha = np.fft.fft(k, 2048)
ylinha = np.tile(ylinha, 3)
self.beta.clear()
self.beta.plot(znovo, yf, label='Amostragem Correta')
self.beta.plot(self.z, y, 'o-', lw=2, label='Amostragem Fixa')
plt.legend(loc='upper right')
self.beta.set_xlim([0, 2 * np.pi])
self.beta.set_xlabel(r't')
self.beta.set_ylabel(r'x(t)')
self.beta.set_title(
'Sinal com amostragem correta x Sinal com amostragem fixa')
self.plot2.set_ydata(20 * np.log10(abs(ylinha)))
self.canvas.draw()
self.canvas.show()
class Spectra_Tab(QtGui.QTabWidget):
start_comp = QtCore.pyqtSignal()
kill_thread = QtCore.pyqtSignal()
def __init__(self, parent, temp_spectra):
self.parent = parent
QtGui.QTabWidget.__init__(self, parent)
self.temp_spectra = temp_spectra
self.top_layer_grid = QtGui.QGridLayout(self)
self.canvas_frame = QtGui.QFrame(self)
self.canvas_frame.setFrameShape(QtGui.QFrame.StyledPanel)
self.results_frame = QtGui.QFrame(self)
self.results_frame.setFrameShape(QtGui.QFrame.StyledPanel)
self.top_layer_grid.addWidget(self.canvas_frame)
self.top_layer_grid.addWidget(self.results_frame)
self.canvas_grid = QtGui.QGridLayout(self.canvas_frame)
self.top_left_frame = QtGui.QFrame(self.canvas_frame)
self.top_left_frame.setFrameShape(QtGui.QFrame.StyledPanel)
self.canvas_grid.addWidget(self.top_left_frame)
self.bottom_canvas_frame = QtGui.QFrame(self.canvas_frame)
self.bottom_canvas_frame.setFrameShape(QtGui.QFrame.StyledPanel)
self.canvas_grid.addWidget(self.bottom_canvas_frame)
vertical_splitter = QtGui.QSplitter(QtCore.Qt.Vertical)
vertical_splitter.addWidget(self.top_left_frame)
vertical_splitter.addWidget(self.bottom_canvas_frame)
self.canvas_grid.addWidget(vertical_splitter)
self.results_grid = QtGui.QGridLayout(self.results_frame)
self.treeWidget = QtGui.QTreeWidget(self.results_frame)
self.treeWidget.setFocusPolicy(QtCore.Qt.WheelFocus)
self.treeWidget.setAutoFillBackground(True)
self.treeWidget.setAlternatingRowColors(True)
self.treeWidget.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
self.treeWidget.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
self.treeWidget.setHorizontalScrollMode(QtGui.QAbstractItemView.ScrollPerItem)
self.treeWidget.setAutoExpandDelay(-1)
self.treeWidget.setHeaderLabels(["(n,m)/Property","%, [value]"])
self.other_properties = QtGui.QTreeWidgetItem(self.treeWidget, ["Properties"])
self.nm_species = QtGui.QTreeWidgetItem(self.treeWidget, ["(n,m)"])
self.semiconducting = QtGui.QTreeWidgetItem(self.other_properties, ["Semiconducting %"])
self.metallic = QtGui.QTreeWidgetItem(self.other_properties, ["Metallic %"])
self.avg_diameter = QtGui.QTreeWidgetItem(self.other_properties, ["Average Diameter"])
self.step_in_tree = QtGui.QTreeWidgetItem(self.other_properties, ["Iteration #"])
self.dict_of_nm_tree = {}
for swcnt in temp_spectra.SWCNT_list:
self.dict_of_nm_tree[swcnt] = QtGui.QTreeWidgetItem(self.nm_species, [swcnt.strNM()])
self.results_grid.addWidget(self.treeWidget)
graph_results_splitter = QtGui.QSplitter(QtCore.Qt.Horizontal)
graph_results_splitter.addWidget(self.canvas_frame)
graph_results_splitter.addWidget(self.results_frame)
self.top_layer_grid.addWidget(graph_results_splitter)
policy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred,QtGui.QSizePolicy.Preferred)
policy.setHorizontalStretch(8)
self.canvas_frame.setSizePolicy(policy)
# Make figure for original line, background line, and total fit line
self.top_left_fig = matplotlib.figure.Figure()
self.top_left_plot = self.top_left_fig.add_subplot(111)
self.top_left_plot.set_ylabel('Absorbance [a.u.]')
self.top_left_plot.set_xlabel('Photon Energy [eV]')
self.top_left_plot.set_title('Total Absorbance Fit')
init_values = np.zeros(len(self.temp_spectra.X))
self.top_left_line, = self.top_left_plot.plot(self.temp_spectra.X, self.temp_spectra.Y, 'r-')
self.top_left_background_line, self.top_left_total_fit_line, = self.top_left_plot.plot(self.temp_spectra.X, init_values, 'k-', self.temp_spectra.X, init_values, 'b-', animated=True)
self.top_left_canvas = FigureCanvas(self.top_left_fig)
plotLayout = QtGui.QVBoxLayout()
plotLayout.addWidget(self.top_left_canvas)
self.top_left_frame.setLayout(plotLayout)
self.top_left_canvas.show()
self.top_left_canvas.draw()
self.top_left_canvas_BBox = self.top_left_plot.figure.canvas.copy_from_bbox(self.top_left_plot.bbox)
self.ax1 = self.top_left_plot.figure.axes[0]
self.ax1.set_xlim(self.temp_spectra.X.min(), self.temp_spectra.X.max())
self.ax1.set_ylim(0, self.temp_spectra.Y.max() + .05*self.temp_spectra.Y.max())
self.top_left_plot_old_size = self.top_left_plot.bbox.width, self.top_left_plot.bbox.height
# Make bottom figure
self.bottom_fig = matplotlib.figure.Figure()
self.bottom_plot = self.bottom_fig.add_subplot(111)
self.bottom_plot.set_ylabel('Absorbance [a.u.]')
self.bottom_plot.set_xlabel('Photon Energy [eV]')
self.bottom_plot.set_title('Background Subtracted Fit')
self.bottom_line_original_without_background, = self.bottom_plot.plot(self.temp_spectra.X, self.temp_spectra.Y, 'r-', linewidth=3, animated=True)
self.bottom_line, = self.bottom_plot.plot(self.temp_spectra.X, init_values, 'b-', linewidth=3, animated=True)
self.swcnt_line_dict = {}
for swcnt in temp_spectra.SWCNT_list:
self.swcnt_line_dict[swcnt], = self.bottom_plot.plot(self.temp_spectra.X, swcnt.line, animated=True)
self.bottom_canvas = FigureCanvas(self.bottom_fig)
bottomplotLayout = QtGui.QVBoxLayout()
bottomplotLayout.addWidget(self.bottom_canvas)
self.bottom_canvas_frame.setLayout(bottomplotLayout)
self.bottom_canvas.show()
self.bottom_canvas.draw()
self.bottom_canvas_BBox = self.bottom_plot.figure.canvas.copy_from_bbox(self.bottom_plot.bbox)
self.bottom_ax1 = self.bottom_plot.figure.axes[0]
self.bottom_ax1.set_xlim(self.temp_spectra.X.min(), self.temp_spectra.X.max())
self.bottom_ax1.set_ylim(0, self.temp_spectra.Y.max() + .05*self.temp_spectra.Y.max())
self.bottom_plot_old_size = self.bottom_plot.bbox.width, self.bottom_plot.bbox.height
# Make Thread associated with the tab
thread = QtCore.QThread(parent=self)
self.worker = self.temp_spectra
self.worker.moveToThread(thread)
self.worker.update_signal.connect(self.update_GUI)
self.worker.done_signal.connect(self.closeEvent)
self.start_comp.connect(self.worker.deconvolute)
self.kill_thread.connect(thread.quit)
thread.start()
@QtCore.pyqtSlot(Spectra)
def update_GUI(self, tmp_spectra):
# change the GUI to reflect changes made to Spectra
# Get the first background of the plots to blits lines to
if(tmp_spectra.step==1):
self.top_left_canvas_BBox = self.top_left_plot.figure.canvas.copy_from_bbox(self.top_left_plot.bbox)
self.bottom_canvas_BBox = self.bottom_plot.figure.canvas.copy_from_bbox(self.bottom_plot.bbox)
# If the size of the box changes, get that background instead
top_left_plot_current_size = self.top_left_plot.bbox.width, self.top_left_plot.bbox.height
bottom_plot_current_size = self.bottom_plot.bbox.width, self.bottom_plot.bbox.height
if( self.top_left_plot_old_size != top_left_plot_current_size or self.bottom_plot_old_size != bottom_plot_current_size):
self.top_left_plot_old_size = top_left_plot_current_size
self.top_left_plot.clear()
self.top_left_canvas.draw()
self.top_left_canvas_BBox = self.top_left_plot.figure.canvas.copy_from_bbox(self.top_left_plot.bbox)
self.top_left_plot.set_ylabel('Absorbance [a.u.]')
self.top_left_plot.set_xlabel('Photon Energy [eV]')
self.top_left_plot.set_title('Total Absorbance Fit')
self.bottom_plot_old_size = bottom_plot_current_size
self.bottom_plot.clear()
self.bottom_canvas.draw()
self.bottom_canvas_BBox = self.bottom_plot.figure.canvas.copy_from_bbox(self.bottom_plot.bbox)
self.bottom_plot.set_ylabel('Absorbance [a.u.]')
self.bottom_plot.set_xlabel('Photon Energy [eV]')
self.bottom_plot.set_title('Background Subtracted Fit')
# Write to the Top Left Plot with original data, background data, and total fit
self.top_left_background_line.set_ydata(tmp_spectra.background_model)
self.top_left_total_fit_line.set_ydata(tmp_spectra.model)
self.top_left_plot.figure.canvas.restore_region(self.top_left_canvas_BBox)
if( tmp_spectra.background_model.max() > tmp_spectra.Y.max()):
self.ax1.set_ylim(0, 1.05*tmp_spectra.background_model.max())
elif(tmp_spectra.model.max() > tmp_spectra.Y.max()):
self.ax1.set_ylim(0, 1.05*tmp_spectra.model.max())
else:
self.ax1.set_ylim(0, 1.05*tmp_spectra.Y.max())
self.top_left_plot.draw_artist(self.top_left_line)
self.top_left_plot.draw_artist(self.top_left_background_line)
self.top_left_plot.draw_artist(self.top_left_total_fit_line)
self.top_left_plot.figure.canvas.blit(self.top_left_plot.bbox)
# Write to the Bottom Plot with each nanotube peak
self.bottom_line_original_without_background.set_ydata(tmp_spectra.Y-tmp_spectra.background_model)
self.bottom_line.set_ydata(tmp_spectra.model_without_background)
try:
for swcnt in self.dict_of_nm_tree:
self.swcnt_line_dict[swcnt].set_ydata(swcnt.line)
self.swcnt_line_dict[swcnt].set_linewidth(1)
current_swcnt = None
for swcnt in self.dict_of_nm_tree:
if(self.dict_of_nm_tree[swcnt] == self.treeWidget.currentItem()):
current_swcnt = swcnt
break
self.swcnt_line_dict[current_swcnt].set_linewidth(4)
except KeyError:
pass
self.bottom_plot.figure.canvas.restore_region(self.bottom_canvas_BBox)
if( np.amax(tmp_spectra.Y-tmp_spectra.background_model) > np.amax(tmp_spectra.model_without_background) ):
self.bottom_ax1.set_ylim(0, 1.05*np.amax(tmp_spectra.Y-tmp_spectra.background_model))
if( np.amax(tmp_spectra.model_without_background) < 0.05):
self.bottom_ax1.set_ylim(0, 0.05)
else:
self.bottom_ax1.set_ylim(0, 1.05*np.amax(tmp_spectra.model_without_background))
self.bottom_plot.draw_artist(self.bottom_line_original_without_background)
self.bottom_plot.draw_artist(self.bottom_line)
for swcnt in tmp_spectra.SWCNT_list:
self.bottom_plot.draw_artist(self.swcnt_line_dict[swcnt])
self.bottom_plot.figure.canvas.blit(self.bottom_plot.bbox)
# Show percentage of species on the side bar
try:
percent_dict = tmp_spectra.species_percentage_dictionary
percent_error_dict = tmp_spectra.species_percentage_error_dictionary
for swcnt in tmp_spectra.SWCNT_list:
self.dict_of_nm_tree[swcnt].setText(1, str(round(percent_dict[swcnt], 0)).rstrip('0') + ' % +-' + str(round(percent_error_dict[swcnt], 1)))
self.semiconducting.setText(1, str(round(100.-tmp_spectra.metallic_percentage, 0)).rstrip('0') + ' %')
self.metallic.setText(1, str(round(tmp_spectra.metallic_percentage, 0)).rstrip('0') + ' %')
self.avg_diameter.setText(1, str(round(tmp_spectra.mean_diameter,2)) + ' nm')
self.step_in_tree.setText(1, str(tmp_spectra.step))
except KeyError:
pass
def output_results(self):
print "Making Excel Workbook..."
date_time = datetime.datetime.now().strftime("%Y-%m-%d(%H-%M-%S)")
name = str(self.temp_spectra.spectra_name)
book = xlsxwriter.Workbook(name + ' -- ' + date_time +'_OA_Results.xlsx')
OA_sheet_name = "Optical Absorption Data"
Results_sheet_name = "Results"
Other_params_name = "Other Parameters"
OA_sheet = book.add_worksheet(OA_sheet_name)
Results_sheet = book.add_worksheet(Results_sheet_name)
Other_params_sheet = book.add_worksheet(Other_params_name)
# Write x, y data for main and all species
OA_sheet.write('A1', "Energy (eV)")
OA_sheet.write_column('A2', self.temp_spectra.X)
OA_sheet.write('B1', name )
OA_sheet.write_column('B2', self.temp_spectra.Y)
OA_sheet.write('C1', "Model")
OA_sheet.write_column('C2', self.temp_spectra.model)
OA_sheet.write('D1', "Background")
OA_sheet.write_column('D2', self.temp_spectra.background_model)
for i, swcnt in enumerate(self.temp_spectra.SWCNT_list):
OA_sheet.write(0, 3+i, swcnt.strNM())
OA_sheet.write_column(1, 3+i, swcnt.line)
Results_sheet.write('A1', "(n,m)")
Results_sheet.write('B1', "%")
quant_dict = self.temp_spectra.species_percentage_dictionary.iteritems()
for i, (swcnt, amount) in enumerate(sorted(quant_dict)):
Results_sheet.write(i+1, 0, swcnt.strNM())
Results_sheet.write(i+1, 1, round(amount,1))
Results_sheet.write('D1', "Semiconducting %")
Results_sheet.write('D2', "Metallic %")
Results_sheet.write('E1', round(100-self.temp_spectra.calc_metallic_percentage(),1))
Results_sheet.write('E2', round(self.temp_spectra.calc_metallic_percentage(),1))
Other_params_sheet.write("A1", "(n,m)")
Other_params_sheet.write_column("A2", [swcnt.strNM() for swcnt in self.temp_spectra.SWCNT_list])
Other_params_sheet.write("B1", "SWCNT Solution Vector")
Other_params_sheet.write_column("B2", self.temp_spectra.swcnts_soln)
book.close()
print "Excel Workbook Made."
def start_computation(self):
self.start_comp.emit()
return
def closeEvent(self):
print 'done with processing'
self.kill_thread.emit()
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 SabatheDialog(QDialog, CicloSabatheGUI.Ui_Dialog):
def __init__(self, parent=None):
super(SabatheDialog, self).__init__(parent)
self.setWindowTitle(__appName__)
self.setupUi(self)
self.Q = []
#Defino las formulas quimicas para selecionar en formulas_comboBox
self.formulas = {"AvGas":{'c':7,'h':16,'o':0,'s':0.00},"Diesel":{'c':12,'h':21,'o':0,'s':0.00}}
# Utilizo las 'keys' de self.formulas para cargar los items en la combobox
for key in self.formulas.keys():
self.formula_comboBox.addItem(key)
# Generamos dos figuras, cada una luego asociada a un canvas, que a su vez tiene como padre una de las pestañas
# self.tab -> contiene la pestaña titulada "Diagrama P-S"
# self.tab_2 -> contiene la pestaña titulada "Diagrama T-S"
self.fig1 = Figure(figsize=(4.8,3.4),dpi=72, facecolor=(1,1,1), edgecolor=(0,0,0))
self.axes1 = self.fig1.add_subplot(111)
self.axes1.set_ylabel('p')
self.axes1.set_xlabel('v')
self.axes1.set_title('Ciclo Sabathe')
self.fig2 = Figure(figsize=(4.8,3.4),dpi=72, facecolor=(1,1,1), edgecolor=(0,0,0))
self.axes2 = self.fig2.add_subplot(111)
self.axes2.set_ylabel('T')
self.axes2.set_xlabel('S')
self.axes2.set_title('Ciclo Sabathe')
# generate the canvas to display the plot
self.canvas1 = FigureCanvas(self.fig1)
self.canvas1.setParent(self.tab)
self.canvas1.show()
self.canvas2 = FigureCanvas(self.fig2)
self.canvas2.setParent(self.tab_2)
self.canvas2.show()
self.gamma_aire = 1.4
self.R_aire = 287
self.actualizarFormula()
#Cambio los lineInput de HVS y HVI a "ReadOnly"
self.HVS_lineEdit.setReadOnly(True)
self.HVI_lineEdit.setReadOnly(True)
#Seleccion de una formula en formula_comboBox
self.connect(self.formula_comboBox,SIGNAL("currentIndexChanged(int)"),self.selecionFormula)
# Acciones de actualización de la formula quimica para el calculo de Q
self.connect(self.formulaC,SIGNAL("textEdited(const QString&)"),self.actualizarFormula)
self.connect(self.formulaH,SIGNAL("textEdited(const QString&)"),self.actualizarFormula)
self.connect(self.formulaO,SIGNAL("textEdited(const QString&)"),self.actualizarFormula)
self.connect(self.formulaS,SIGNAL("textEdited(const QString&)"),self.actualizarFormula)
self.connect(self.relacionMezcla,SIGNAL("valueChanged(double)"),self.actualizarFormula)
self.connect(self.calcular,SIGNAL("clicked()"),self.Calculos)
# Boton para mostrar matriz de resultados
self.connect(self.matrixButton,SIGNAL("clicked()"),self.displayMatrix)
#Boton para seleccionar P1 y T1 a partir de la altura:
self.connect(self.Altura_Button,SIGNAL("clicked()"),self.seleccionAltura)
def selecionFormula(self):
formula = self.formula_comboBox.currentText()
if formula != 'Otra':
self.formulaC.setText(str(self.formulas[formula]['c']))
self.formulaH.setText(str(self.formulas[formula]['h']))
self.formulaO.setText(str(self.formulas[formula]['o']))
self.formulaS.setText(str(self.formulas[formula]['s']))
self.actualizarFormula()
def actualizarFormula(self):
try:
c = self.lecturadatos(self.formulaC, 'int')
h = self.lecturadatos(self.formulaH, 'int')
o = self.lecturadatos(self.formulaO, 'int')
s = self.lecturadatos(self.formulaS, 'float')
except: pass
else:
# si la formula ingresada coincide con alguna formula del comboBox
# poner el comboBox en esa formula.
indexName = 'Otra'
for key in self.formulas.keys():
if (self.formulas[key]['c'] == c) & (self.formulas[key]['h'] == h) & (self.formulas[key]['o'] == o):
indexName = key
index = self.formula_comboBox.findText(indexName)
self.formula_comboBox.setCurrentIndex(index)
Fr = self.relacionMezcla.value()
HVS, HVI, self.Q, self.lambda_s = PoderCalorifico.PoderCalorifico(c,h,o,s,Fr)
self.HVS_lineEdit.setText('{:.1f}'.format(HVS))
self.HVI_lineEdit.setText('{:.1f}'.format(HVS))
self.calorQ.setText('{:.1f}'.format(self.Q))
def seleccionAltura(self):
p1 = str(self.presion1.text())
t1 = str(self.temperatura1.text())
dialogo = GUI_atmosfera_estandar.MainDialog(p1,t1)
if dialogo.exec_():
self.presion1.setText('{:.1f}'.format(dialogo.atmosfera['p']))
self.temperatura1.setText('{:.1f}'.format(dialogo.atmosfera['t']))
# Genero ahora la función que va a realizar los calculos, es decir,
# que va a llamar la función del ciclo. A esta le agrego una subclase de
# Exception para capturar los valores de entrada negativos.
class NumeroNegativo(Exception): pass
def lecturadatos(self, lineedit, type):
try:
aux = 0
if type == 'int':
aux = int(lineedit.text())
if type == 'float':
aux = float(lineedit.text())
if aux < 0:
raise NumeroNegativoError
return aux
except (TypeError, ValueError, NumeroNegativoError):
QMessageBox.warning(self,"Error en los datos de entrada! ","Vuelva a ingresar los datos")
lineedit.selectAll()
lineedit.setFocus()
raise
def Calculos(self):
Q = self.Q
# Lectura de los datos de entrada con la función verificacion
try:
p1 = self.lecturadatos(self.presion1, 'float')
t1 = self.lecturadatos(self.temperatura1, 'float')
variableExtra1 = self.selecDatoExtra1.currentText().split(" ")[0]
datoExtra1 = self.lecturadatos(self.datoExtra1, 'float')
variableExtra2 = self.selecDatoExtra2.currentText().split(" ")[0]
datoExtra2 = self.lecturadatos(self.datoExtra2, 'float')
self.puntos, resultados = ciclo_sabathe.CicloSabathe(p1, t1, Q * 1000, variableExtra1, datoExtra1,
variableExtra2, datoExtra2)
except MayorAUnoError as e:
QMessageBox.warning(self, "Error en los datos de entrada! ",
"La variable " + str(e.variableName) + " no puede ser menor a 1")
if e.variableName == 'r_comp':
self.datoExtra1.selectAll()
self.datoExtra1.setFocus()
elif e.variableName == 'Alpha':
self.datoExtra2.selectAll()
self.datoExtra2.setFocus()
else:
pass
except TemperaturaIncompatibleError as e:
QMessageBox.warning(self, "Error en los datos de entrada! ",
"La temperatura " + str(e.variableName) + " no puede ser menor a la " + \
"temepratura del estado anterior (" + str(e.value) + " K)")
self.datoExtra1.selectAll()
self.datoExtra1.setFocus()
except Var2IncompatibleError as e:
QMessageBox.warning(self, "Error en los datos de entrada!",
e.varname + " no puede ser mayor a " + str(e.value1) + \
", ni menor a = " + str(e.value2))
self.datoExtra2.selectAll()
self.datoExtra2.setFocus()
else:
self.plotCiclo(self.puntos)
self.calor2.setText(str(resultados[0]))
self.calorU.setText(str(resultados[1]))
self.trabajoW.setText(str(resultados[2]))
self.presionMedia.setText(str(resultados[3]))
self.rendimiento.setText(str(resultados[4]))
def plotCiclo(self,puntos):
presion = []
temperatura = []
densidad = []
volumen = []
entropia = []
for punto in puntos:
presion.append(punto[0])
temperatura.append(punto[1])
densidad.append(punto[2])
volumen.append(punto[3])
entropia.append(punto[4])
v1 = np.append(np.arange(volumen[1],volumen[0],(volumen[0]-volumen[1])/100),volumen[0])
v2 = np.append(np.arange(volumen[3],volumen[4],(volumen[4]-volumen[3])/100),volumen[4])
self.axes1.clear()
self.axes1.plot(v1,presion[1]*volumen[1]**self.gamma_aire*(1/v1**self.gamma_aire),'r')
self.axes1.plot(volumen[1:4],presion[1:4],'r',(volumen[4],volumen[0]),(presion[4],presion[0]),'r')
self.axes1.plot(v2,presion[3]*volumen[3]**self.gamma_aire*(1/v2**self.gamma_aire),'r')
self.canvas1.draw()
S1 = np.append(np.arange(entropia[1],entropia[2],(entropia[2]-entropia[1])/100),entropia[2])
S2 = np.append(np.arange(entropia[2],entropia[3],(entropia[3]-entropia[2])/100),entropia[3])
S3 = np.append(np.arange(entropia[4],entropia[0],(entropia[0]-entropia[4])/100),entropia[0])
self.axes2.clear()
self.axes2.plot(S1,temperatura[1]*np.exp((self.gamma_aire-1)*(S1-entropia[1])/self.R_aire),'r')
self.axes2.plot(S2,temperatura[2]*np.exp((self.gamma_aire-1)*(S2-entropia[2])/self.R_aire/self.gamma_aire),'r')
self.axes2.plot(entropia[0:2],temperatura[0:2],'r',entropia[3::],temperatura[3::],'r')
self.axes2.plot(S3,temperatura[4]*np.exp((self.gamma_aire-1)*(S3-entropia[4])/self.R_aire),'r')
self.canvas2.draw()
def displayMatrix(self):
matriz = MatrixDialog(self.puntos)
matriz.exec_()
class MatplotlibPlot:
""" Class encapsulating an matplotlib plot """
def __init__(self, parent = None, dpi = 100, size = (5,4)):
""" Class initialiser """
self.dpi = dpi
self.figure = Figure(dpi = self.dpi)
self.canvas = FigureCanvas(self.figure)
self.canvas.setParent(parent)
# Create the navigation toolbar, tied to the canvas
self.toolbar = NavigationToolbar(self.canvas, parent)
self.canvas.show()
self.toolbar.show()
def plotCurve(self, data, numCurves = 1, labels = None, xAxisRange = None, yAxisRange = None, xLabel = "", yLabel = ""):
""" Normal plots """
self.figure.clear()
self.axes = self.figure.add_subplot(111)
self.axes.grid(True)
# Set empty labels if non defined
if labels is None:
labels = ['' for i in range(numImages)]
# Place all plots in axes
for i in range(numCurves):
self.axes.plot(data[:,i], label=labels[i])
self.axes.set_xlim((0, len(data[:,i])))
# Final touches
self.axes.xaxis.set_label_text(xLabel)
self.axes.yaxis.set_label_text(yLabel)
self.canvas.draw()
def subplotCurve(self, data, numPlots = 1, labels = None, xAxisRange = None, yAxisRange = None, xLabel = "", yLabel = ""):
""" Subplot mode """
self.figure.clear()
# Set empty labels if non defined
if labels is None:
labels = ['' for i in range(numImages)]
if numPlots == 1:
ax = self.figure.add_subplot(111)
ax.plot(data[:])
ax.set_xlabel(xLabel)
ax.set_ylabel(yLabel)
ax.set_title(labels[0])
ax.grid(True)
else:
# Plot each image
num_rows = ceil(sqrt(numPlots))
for i in range(numPlots):
ax = self.figure.add_subplot(num_rows, num_rows, i + 1)
ax.plot(data[:,i])
ax.set_xlim((0, len(data[:,i])))
ax.set_xlabel(xLabel)
ax.set_ylabel(yLabel)
ax.set_title(labels[i])
ax.grid(True)
# Final touches
self.figure.tight_layout()
self.canvas.draw()
def plotImage(self, data, numImages = 1, labels = None, xAxisRange = None, yAxisRange = None, xLabel = "", yLabel = ""):
""" Image plot """
self.figure.clear()
self.axes = self.figure.add_subplot(111)
# Show image
im = self.axes.imshow(data, origin='lower', aspect='auto')
# Final touches
self.axes.xaxis.set_label_text(xLabel)
self.axes.yaxis.set_label_text(yLabel)
self.figure.colorbar(im)
self.canvas.draw()
def subplotImage(self, data, numImages = 1, labels = None, xAxisRange = None, yAxisRange = None, xLabel = "", yLabel = ""):
""" Image subplot """
# Clear figure
self.figure.clear()
# Set empty labels if non defined
if labels is None:
labels = ['' for i in range(numImages)]
# Plot each image
num_rows = ceil(sqrt(numImages))
for i in range(numImages):
ax = self.figure.add_subplot(num_rows, num_rows, i + 1)
im = ax.imshow(data[:,:,i], origin='lower', aspect='auto')
ax.set_xlabel(xLabel)
ax.set_ylabel(yLabel)
ax.set_title(labels[i])
# Final touches
self.figure.tight_layout()
self.canvas.draw()
class Window(QtGui.QDialog):
def __init__(self, parent=None):
super(Window, self).__init__(parent)
#self.setGeometry(300, 100, 800, 600)
# distance from sx, from top, length, heigth
self.showMaximized()
self.figure, ((self.ax1, self.ax2), (self.ax3,
self.ax4)) = plt.subplots(2, 2)
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.button = QtGui.QPushButton('Browse')
self.button.clicked.connect(self.browse)
# set the layout
layout = QtGui.QVBoxLayout()
layout.addWidget(self.toolbar)
layout.addWidget(self.canvas)
layout.addWidget(self.button)
self.setLayout(layout)
#self.ax = self.figure.add_subplot(111)
self.span1 = SpanSelector(self.ax1,
self.extremes1,
'horizontal',
useblit=True,
rectprops=dict(alpha=0.5, facecolor='green'))
self.span2 = SpanSelector(self.ax2,
self.extremes2,
'horizontal',
useblit=True,
rectprops=dict(alpha=0.5, facecolor='green'))
self.span3 = SpanSelector(self.ax3,
self.extremes3,
'horizontal',
useblit=True,
rectprops=dict(alpha=0.5, facecolor='green'))
self.span4 = SpanSelector(self.ax4,
self.extremes4,
'horizontal',
useblit=True,
rectprops=dict(alpha=0.5, facecolor='green'))
def extremes1(self, xmin, xmax):
return xmin, xmax
def extremes2(self, xmin, xmax):
return xmin, xmax
def extremes3(self, xmin, xmax):
return xmin, xmax
def extremes4(self, xmin, xmax):
return xmin, xmax
def browse(self):
fName = QtGui.QFileDialog.getOpenFileName(
self, 'Browse file', "Open new file",
self.tr("All Files (*);;Text Files (*txt)"))
if fName.isEmpty() == False:
self.fileLocation = fName
self.ax1.clear()
self.ax2.clear()
self.ax3.clear()
self.ax4.clear()
self.printSig()
def printSig(self):
import Signals as ss
import PreAllinea
segnali = ss.Signals(str(self.fileLocation))
lista_segnali = []
shift = PreAllinea.getShift()
for i in range(24):
if i < 8:
segnale = segnali.SigData(i)
lista_segnali.append(segnale)
lista_segnali[i].SigShift(shift[i])
self.ax1.plot(segnale.x, segnale.SigFir(10))
self.ax1.set_xlim(1000, 2300)
self.ax1.set_ylim(1e-1, 100000)
elif (i > 7 and i < 16):
segnale = segnali.SigData(i)
lista_segnali.append(segnale)
lista_segnali[i].SigShift(shift[i])
self.ax2.plot(segnale.x, segnale.SigFir(10))
self.ax2.set_xlim(1000, 2300)
self.ax2.set_ylim(1e-1, 100000)
elif (i > 15 and i < 24):
segnale = segnali.SigData(i)
lista_segnali.append(segnale)
lista_segnali[i].SigShift(shift[i])
self.ax3.plot(segnale.x, segnale.SigFir(10))
self.ax3.set_xlim(1000, 2300)
self.ax3.set_ylim(1e-1, 100000)
else:
segnale = segnali.SigData(i)
lista_segnali.append(segnale)
lista_segnali[i].SigShift(shift[i])
self.ax4.plot(segnale.x, segnale.SigFir(10))
self.ax4.set_xlim(1000, 2300)
self.ax4.set_ylim(1e-1, 100000)
self.ax1.semilogy()
self.ax2.semilogy()
self.ax3.semilogy()
self.ax4.semilogy()
self.canvas.show()
class MainDialog(QDialog, layout.Ui_Dialog):
def __init__(self, parent=None):
super(MainDialog, self).__init__(parent)
self.setupUi(self)
self.AIRFOIL_DATA = None
# Generamos dos figuras, cada una luego asociada a un canvas, que a su vez tiene como padre una de las pestanias
# self.tab -> contiene la pestania titulada "Diagrama P-S"
# self.tab_2 -> contiene la pestania titulada "Diagrama T-S"
self.fig1 = Figure(figsize=(4.8, 3.4), dpi=72, facecolor=(1, 1, 1), edgecolor=(0, 0, 0))
self.axes1 = self.fig1.add_subplot(111)
self.axes1.set_ylabel('Cl')
self.axes1.set_xlabel('AoA')
self.fig2 = Figure(figsize=(4.8, 3.4), dpi=72, facecolor=(1, 1, 1), edgecolor=(0, 0, 0))
self.axes2 = self.fig2.add_subplot(111)
self.axes2.set_ylabel('Cd')
self.axes2.set_xlabel('Cl')
# generate the canvas to display the plot
self.canvas1 = FigureCanvas(self.fig1)
self.canvas1.setParent(self.frame_ClAlpha)
self.canvas1.show()
self.canvas2 = FigureCanvas(self.fig2)
self.canvas2.setParent(self.frame_CdCl)
self.canvas2.show()
#Ponemos el primer checkbox en "checked"
self.checkBox_Re3.setCheckState(Qt.Checked)
# Cargamos los numeros de Reynolds
self.Reynolds = ['Re_3', 'Re_6', 'Re_9', 'Re_std']
# Cargamos los parametros caracteristicos del perfil
self.vHeader = ['CL_max', 'beta_max',
'CL_betamax', 'alpha_betamax', 'dbeta_dalpha', 'b_max',
'CD_min', 'CL_CD_max', 'cuspide', 'CM0']
# Cargamos el formato en que se deben mostrar cada parametro caracteristico
self.HeadersFormat = ['{:.2f}', '{:.1f}', '{:.2f}', '{:.1f}', '{:.3f}', '{:.1f}',
'{:.5f}', '{:.1f}', str, '{:.2}']
self.tableDatos.setVerticalHeaderLabels(self.vHeader)
self.tableDatos.setHorizontalHeaderLabels(self.Reynolds)
self.connect(self.openButton, SIGNAL("clicked()"), self.Open)
self.connect(self.okButton, SIGNAL("clicked()"), self, SLOT('accept()'))
self.connect(self.cancelButton, SIGNAL("clicked()"), self, SLOT('reject()'))
self.connect(self.checkBox_Re3, SIGNAL("toggled(bool)"), self.plotGraph)
self.connect(self.checkBox_Re6, SIGNAL("toggled(bool)"), self.plotGraph)
self.connect(self.checkBox_Re9, SIGNAL("toggled(bool)"), self.plotGraph)
self.connect(self.checkBox_SR, SIGNAL("toggled(bool)"), self.plotGraph)
def Open(self):
dir = '.'
fileAdress = QFileDialog.getOpenFileName(self,"Selecionar Perfil",dir,filter="Text File (*.txt)")
self.AIRFOIL_DATA = profile.lectura_perfiles(fileAdress[0])
#print self.AIRFOIL_DATA
for j in range(len(self.Reynolds)):
for i in range(len(self.vHeader)):
if self.vHeader[i] in self.AIRFOIL_DATA[self.Reynolds[j]].keys():
item = QTableWidgetItem(self.HeadersFormat[i].format(self.AIRFOIL_DATA[self.Reynolds[j]][self.vHeader[i]]))
self.tableDatos.setItem(i, j, item)
nombrePerfil = fileAdress[0].split('/')[-1].split('.')[0]
#print nombrePerfil
self.labelPerfil.setText('Datos Perfil: NACA '+nombrePerfil)
self.plotGraph()
def plotGraph(self):
self.axes1.clear()
self.axes2.clear()
if self.checkBox_Re3.isChecked():
self.plotReynolds('Re_3', 'b')
if self.checkBox_Re6.isChecked():
self.plotReynolds('Re_6', 'r')
if self.checkBox_Re9.isChecked():
self.plotReynolds('Re_9', 'g')
if self.checkBox_SR.isChecked():
self.plotReynolds('Re_std', 'y')
self.canvas1.draw()
self.canvas2.draw()
def plotReynolds(self, reynolds, color):
x1 = [value[0] for value in self.AIRFOIL_DATA[reynolds]['AoA_Cl']]
y1 = [value[1] for value in self.AIRFOIL_DATA[reynolds]['AoA_Cl']]
x2 = [value[0] for value in self.AIRFOIL_DATA[reynolds]['Cl_Cd']]
y2 = [value[1] for value in self.AIRFOIL_DATA[reynolds]['Cl_Cd']]
self.axes1.plot(x1, y1, color)
self.axes2.plot(x2, y2, color)
class Plot(Callback.Callbacks):
def __init__(self, logger):
Callback.Callbacks.__init__(self)
self.logger = logger
# For callbacks
for name in ('close', ):
self.enable_callback(name)
self.fig = matplotlib.figure.Figure()
self.ax = self.fig.add_subplot(111)
self.ax.set_xlabel('X values')
self.ax.set_ylabel('Y values')
self.ax.set_title('')
self.ax.grid(True)
self.canvas = FigureCanvas(self.fig)
def get_widget(self):
return self.canvas
def _sanity_check_window(self):
pass
def set_titles(self, xtitle=None, ytitle=None, title=None,
rtitle=None):
self._sanity_check_window()
if xtitle != None:
self.ax.set_xlabel(xtitle)
if ytitle != None:
self.ax.set_ylabel(ytitle)
if title != None:
self.ax.set_title(title)
if rtitle != None:
pass
def clear(self):
self._sanity_check_window()
self.logger.debug('clearing canvas...')
self.ax.cla()
def show(self):
self._sanity_check_window()
self.logger.debug('raising window...')
self.canvas.show()
def hide(self):
self._sanity_check_window()
self.logger.debug('hiding window...')
pass
def close(self):
self.logger.debug('closing window....')
self.canvas.destroy()
self.make_callback('close')
return False
def _draw(self):
self.fig.canvas.draw()
def plot(self, xarr, yarr, xtitle=None, ytitle=None, title=None,
rtitle=None, **kwdargs):
self.set_titles(xtitle=xtitle, ytitle=ytitle, title=title,
rtitle=rtitle)
self.ax.plot(xarr, yarr, **kwdargs)
self.ax.grid(True)
self._draw()
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 Load_win_fn(QtGui.QWidget):
"""The class for loading and processing images"""
def __init__(self,par_obj,win):
super(Load_win_fn, self).__init__()
#Vertical layout
vbox = QtGui.QVBoxLayout()
self.setLayout(vbox)
hbox0 = QtGui.QHBoxLayout()
vbox.addLayout(hbox0)
#Load images button
self.loadImages_button = QtGui.QPushButton("Load Images", self)
hbox0.addWidget(self.loadImages_button)
hbox0.addStretch()
about_btn = QtGui.QPushButton('About')
about_btn.clicked.connect(self.on_about)
hbox0.addWidget(about_btn)
#Load button.
self.Text_CHopt = QtGui.QLabel()
vbox.addWidget(self.Text_CHopt)
self.ex = fileDialog(self)
self.loadImages_button.clicked.connect(self.ex.showDialog)
#SigmaData input field.
self.feature_scale_input = QtGui.QLineEdit(str(par_obj.feature_scale))
#SigmaData input Text.
self.feature_scaleText = QtGui.QLabel()
hbox1 = QtGui.QHBoxLayout()
vbox.addWidget(self.feature_scaleText)
vbox.addLayout(hbox1)
self.feature_scaleText.resize(40,20)
self.feature_scaleText.setText('Input sigma for feature calculation default (0.8):')
self.feature_scaleText.hide()
hbox1.addWidget(self.feature_scale_input)
hbox1.addStretch()
self.feature_scale_input.resize(10,10)
self.feature_scale_input.textChanged[str].connect(self.feature_scale_change)
self.feature_scale_input.hide()
CH_pX = 0
CH_pY = 50
#Channel dialog generation.
vbox.addWidget(self.Text_CHopt)
self.Text_CHopt.setText('Please select which channels you want to include in the training:')
self.Text_CHopt.resize(500,40)
self.Text_CHopt.hide()
hbox2 = QtGui.QHBoxLayout()
#Object factory for channel selection.
for i in range(0,10):
name = 'self.CH_cbx'+str(i+1)+'_txt = QtGui.QLabel()'
exec(name)
name = 'self.CH_cbx'+str(i+1)+'_txt.setText(\'CH '+str(i+1)+':\')'
exec(name)
name = 'hbox2.addWidget(self.CH_cbx'+str(i+1)+'_txt)'
exec(name)
name = 'self.CH_cbx'+str(i+1)+'_txt.hide()'
exec(name)
name = 'self.CH_cbx'+str(i+1)+'= checkBoxCH()'
exec(name)
name = 'hbox2.addWidget(self.CH_cbx'+str(i+1)+')'
exec(name)
name = 'self.CH_cbx'+str(i+1)+'.hide()'
exec(name)
name = 'self.CH_cbx'+str(i+1)+'.setChecked(True)'
exec(name)
name = 'self.CH_cbx'+str(i+1)+'.type =\'feature_ch\''
exec(name)
hbox2.addStretch()
vbox.addLayout(hbox2)
self.figure1 = Figure(figsize=(2,2))
self.canvas1 = FigureCanvas(self.figure1)
#self.figure1.patch.set_facecolor('white')
self.plt1 = self.figure1.add_subplot(1,1,1)
self.resize(100,100)
self.canvas1.hide()
self.figure1.subplots_adjust(left=0.001, right=0.999, top=0.999, bottom=0.001)
self.plt1.set_xticklabels([])
self.plt1.set_yticklabels([])
hbox3 = QtGui.QHBoxLayout()
vbox.addLayout(hbox3)
hbox3.addWidget(self.canvas1)
hbox3.addStretch()
#Channel dialog generation.
self.Text_FrmOpt2 = QtGui.QLabel()
vbox.addWidget(self.Text_FrmOpt2)
self.Text_FrmOpt2.hide()
#Image frames dialog.
Text_FrmOpt1_panel = QtGui.QHBoxLayout()
self.Text_FrmOpt1 = QtGui.QLabel()
self.Text_FrmOpt1.setText('Please choose the frames you wish to use for training. Use either \',\' to separate individual frames or a \'-\' to indicate a range:')
self.Text_FrmOpt1.hide()
Text_FrmOpt1_panel.addWidget(self.Text_FrmOpt1)
vbox.addLayout(Text_FrmOpt1_panel)
#Image frames input.
linEdit_Frm_panel = QtGui.QHBoxLayout()
self.linEdit_Frm = QtGui.QLineEdit()
self.linEdit_Frm.hide()
linEdit_Frm_panel.addWidget(self.linEdit_Frm)
linEdit_Frm_panel.addStretch()
vbox.addLayout(linEdit_Frm_panel)
#Feature calculation to perform:
self.Text_Radio = QtGui.QLabel()
vbox.addWidget(self.Text_Radio)
self.Text_Radio.setText('Feature select which kind of feature detection you would like to use:')
self.Text_Radio.resize(500,40)
self.Text_Radio.hide()
self.radio_group=QtGui.QButtonGroup(self) # Number
self.r0 = QtGui.QRadioButton("Basic",self)
self.r1 = QtGui.QRadioButton("Fine",self)
self.r1.setChecked(True)
self.radio_group.addButton(self.r0)
self.radio_group.addButton(self.r1)
vbox.addWidget(self.r0)
vbox.addWidget(self.r1)
self.r0.hide()
self.r1.hide()
vbox.addStretch()
#Green status text.
#Load images button
hbox1 = QtGui.QHBoxLayout()
vbox.addLayout(hbox1)
self.confirmImages_button = QtGui.QPushButton("Confirm Images")
hbox1.addWidget(self.confirmImages_button)
self.confirmImages_button.clicked.connect(self.processImgs)
self.confirmImages_button.setEnabled(False)
#Move to training button.
self.selIntButton = QtGui.QPushButton("Goto Training")
hbox1.addWidget(self.selIntButton)
self.selIntButton.clicked.connect(win.loadTrainFn)
self.selIntButton.setEnabled(False)
self.image_status_text = QtGui.QStatusBar()
self.image_status_text.setStyleSheet("QLabel { color : green }")
self.image_status_text.showMessage('Status: Highlight training images in folder. ')
vbox.addWidget(self.image_status_text)
hbox1.addStretch()
#File browsing functions
layout = QtGui.QVBoxLayout()
def on_about(self):
self.about_win = QtGui.QWidget()
self.about_win.setWindowTitle('About QuantiFly Software v2.0')
license = return_license()
#with open (sys.path[0]+'/GNU GENERAL PUBLIC LICENSE.txt', "r") as myfile:
# data=myfile.read().replace('\n', ' ')
# license.append(data)
# And give it a layout
layout = QtGui.QVBoxLayout()
self.view = QtWebKit.QWebView()
self.view.setHtml('''
<html>
<body>
<form>
<h1 >About</h1>
<p>Software written by Dominic Waithe (c) 2015</p>
'''+str(license)+'''
</form>
</body>
</html>
''')
layout.addWidget(self.view)
self.about_win.setLayout(layout)
self.about_win.show()
self.about_win.raise_()
def feature_scale_change(self,text):
"""Updates on change of feature scale"""
par_obj.feature_scale = float(text)
def updateAfterImport(self):
"""Specific to ui updates"""
if par_obj.file_ext == 'tif' or par_obj.file_ext == 'tiff':
if par_obj.tiff_file.maxFrames >1:
self.linEdit_Frm.setText('1-'+str(par_obj.uploadLimit))
self.Text_FrmOpt2.setText('There are '+str(par_obj.tiff_file.maxFrames+1)+' frames in total.')
self.Text_FrmOpt1.show()
self.Text_FrmOpt2.show()
self.linEdit_Frm.show()
self.confirmImages_button.setEnabled(True)
self.plt1.cla()
self.plt1.imshow(255-par_obj.ex_img)
self.plt1.set_xticklabels([])
self.plt1.set_yticklabels([])
self.canvas1.show()
self.canvas1.draw()
par_obj.ch_active =[];
if par_obj.numCH> 2:
self.Text_CHopt.show()
for i in range(0,par_obj.numCH):
name = 'self.CH_cbx'+str(i+1)+'.show()'
exec(name)
name = 'self.CH_cbx'+str(i+1)+'_txt.show()'
exec(name)
par_obj.ch_active.append(i)
else:
par_obj.ch_active.append(0)
self.feature_scale_input.show()
self.feature_scaleText.show()
self.r0.show()
self.r1.show()
self.Text_Radio.show()
def hyphen_range(self,s):
""" yield each integer from a complex range string like "1-9,12, 15-20,23"
>>> list(hyphen_range('1-9,12, 15-20,23'))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 15, 16, 17, 18, 19, 20, 23]
>>> list(hyphen_range('1-9,12, 15-20,2-3-4'))
Traceback (most recent call last):
...
ValueError: format error in 2-3-4
"""
for x in s.split(','):
elem = x.split('-')
if len(elem) == 1: # a number
yield int(elem[0])
elif len(elem) == 2: # a range inclusive
start, end = map(int, elem)
for i in xrange(start, end+1):
yield i
else: # more than one hyphen
raise ValueError('format error in %s' % x)
def processImgs(self):
"""Loads images and calculates the features."""
#Resets everything should this be another patch of images loaded.
imgs =[]
gt_im_sing_chgs =[]
fmStr = self.linEdit_Frm.text()
par_obj.feat_arr ={}
par_obj.pred_arr ={}
par_obj.sum_pred ={}
par_obj.frames_2_load ={}
par_obj.left_2_calc =[]
par_obj.saved_ROI =[]
par_obj.saved_dots=[]
par_obj.curr_img = 0
par_obj.eval_load_im_win_eval = False
if self.r0.isChecked():
par_obj.feature_type = 'basic'
if self.r1.isChecked():
par_obj.feature_type = 'fine'
#Now we commit our options to our imported files.
if par_obj.file_ext == 'png':
for i in range(0,par_obj.file_array.__len__()):
par_obj.left_2_calc.append(i)
par_obj.frames_2_load[i] = [0]
self.image_status_text.showMessage('Status: Loading Images. Loading Image Num: '+str(par_obj.file_array.__len__()))
v2.im_pred_inline_fn(par_obj, self)
elif par_obj.file_ext =='tiff' or par_obj.file_ext =='tif':
if par_obj.tiff_file.maxFrames>1:
for i in range(0,par_obj.file_array.__len__()):
par_obj.left_2_calc.append(i)
try:
np.array(list(self.hyphen_range(fmStr)))-1
par_obj.frames_2_load[i] = np.array(list(self.hyphen_range(fmStr)))-1
except:
self.image_status_text.showMessage('Status: The supplied range of image frames is in the wrong format. Please correct and click confirm images.')
return
self.image_status_text.showMessage('Status: Loading Images.')
v2.im_pred_inline_fn(par_obj, self)
else:
for i in range(0,par_obj.file_array.__len__()):
par_obj.left_2_calc.append(i)
par_obj.frames_2_load[i] = [0]
v2.im_pred_inline_fn(par_obj, self)
count = 0
for b in par_obj.left_2_calc:
frames =par_obj.frames_2_load[b]
for i in frames:
count = count+1
par_obj.test_im_start= 0
par_obj.test_im_end= count
for i in par_obj.left_2_calc:
im_array = np.zeros((par_obj.height,par_obj.width))
par_obj.dense_array[i]=im_array
self.image_status_text.showMessage('Status: Images loaded. Click \'Goto Training\'')
self.selIntButton.setEnabled(True)
par_obj.imgs = imgs
def report_progress(self,message):
self.image_status_text.showMessage('Status: '+message)
app.processEvents()
class MatplotlibPlot:
""" Class encapsulating an matplotlib plot """
def __init__(self, parent=None, dpi=100, size=(5, 4)):
""" Class initialiser """
self.dpi = dpi
self.figure = Figure(dpi=self.dpi)
self.canvas = FigureCanvas(self.figure)
self.canvas.setParent(parent)
# Create the navigation toolbar, tied to the canvas
self.toolbar = NavigationToolbar(self.canvas, parent)
self.canvas.show()
self.toolbar.show()
def plotCurve(self,
data,
numCurves=1,
labels=None,
xAxisRange=None,
yAxisRange=None,
xLabel="",
yLabel=""):
""" Normal plots """
self.figure.clear()
self.axes = self.figure.add_subplot(111)
self.axes.grid(True)
# Set empty labels if non defined
if labels is None:
labels = ['' for i in range(numImages)]
# Place all plots in axes
for i in range(numCurves):
self.axes.plot(data[:, i], label=labels[i])
self.axes.set_xlim((0, len(data[:, i])))
# Final touches
self.axes.xaxis.set_label_text(xLabel)
self.axes.yaxis.set_label_text(yLabel)
self.canvas.draw()
def subplotCurve(self,
data,
numPlots=1,
labels=None,
xAxisRange=None,
yAxisRange=None,
xLabel="",
yLabel=""):
""" Subplot mode """
self.figure.clear()
# Set empty labels if non defined
if labels is None:
labels = ['' for i in range(numImages)]
if numPlots == 1:
ax = self.figure.add_subplot(111)
ax.plot(data[:])
ax.set_xlabel(xLabel)
ax.set_ylabel(yLabel)
ax.set_title(labels[0])
ax.grid(True)
else:
# Plot each image
num_rows = ceil(sqrt(numPlots))
for i in range(numPlots):
ax = self.figure.add_subplot(num_rows, num_rows, i + 1)
ax.plot(data[:, i])
ax.set_xlim((0, len(data[:, i])))
ax.set_xlabel(xLabel)
ax.set_ylabel(yLabel)
ax.set_title(labels[i])
ax.grid(True)
# Final touches
self.figure.tight_layout()
self.canvas.draw()
def plotImage(self,
data,
numImages=1,
labels=None,
xAxisRange=None,
yAxisRange=None,
xLabel="",
yLabel=""):
""" Image plot """
self.figure.clear()
self.axes = self.figure.add_subplot(111)
# Show image
im = self.axes.imshow(data, origin='lower', aspect='auto')
# Final touches
self.axes.xaxis.set_label_text(xLabel)
self.axes.yaxis.set_label_text(yLabel)
self.figure.colorbar(im)
self.canvas.draw()
def subplotImage(self,
data,
numImages=1,
labels=None,
xAxisRange=None,
yAxisRange=None,
xLabel="",
yLabel=""):
""" Image subplot """
# Clear figure
self.figure.clear()
# Set empty labels if non defined
if labels is None:
labels = ['' for i in range(numImages)]
# Plot each image
num_rows = ceil(sqrt(numImages))
for i in range(numImages):
ax = self.figure.add_subplot(num_rows, num_rows, i + 1)
im = ax.imshow(data[:, :, i], origin='lower', aspect='auto')
ax.set_xlabel(xLabel)
ax.set_ylabel(yLabel)
ax.set_title(labels[i])
# Final touches
self.figure.tight_layout()
self.canvas.draw()
class HomographyWidget(QtGui.QWidget):
def __init__(self, parent=None):
super(HomographyWidget, self).__init__(parent)
self._initUI()
# Initialize the UI
def _initUI(self):
# Widget parameters
self.setMinimumWidth(300)
# Create the figure
self._fig = Figure()
# Canvas configuration
self._canvas = FigureCanvas(self._fig)
self._canvas.setParent(self)
self._canvas.mpl_connect('button_press_event', self._onPick)
# Plot configuration
self._plt = self._fig.add_subplot(111)
self._plt.xaxis.set_visible(False)
self._plt.yaxis.set_visible(False)
# Finalize figure
self._fig.subplots_adjust(wspace=0, hspace=0)
# Reset the variables
self.reset()
# Create the layout
vbox = QtGui.QVBoxLayout()
# Add Canvas to the layout
vbox.addWidget(self._canvas)
# Set the layout
self.setLayout(vbox)
zp = ZoomPan()
figZoom = zp.zoom_factory(self._plt)
figPan = zp.pan_factory(self._plt)
# Reset the variables to original state
def reset(self):
self._image = None
self._render = None
self._points = []
self._lastPoints = []
self._canvas.hide()
# Set an image to the widget
def setImage(self, image):
self._image = image
self._render = image
self._canvas.show()
self._redraw()
# Get the image of the widget
def getImage(self):
pass
def setHomography(self, points):
# Save points
self._lastPoints = points
# Redraw canvas
self._redraw()
# Redraw the image and points
def _redraw(self):
# Clear the canvas
self._plt.clear()
if len(self._points) == 2 and len(self._lastPoints) == 4:
# Get points
src = self._pointsToVector(self._lastPoints)
dest = self._pointsToVector(self._rectangle())
# Compute Transformation
self._projective = ProjectiveTransform()
self._projective.estimate(src, dest)
# Prepare output image
self._render = warp(self._image, self._projective.inverse)
# Plot the image
if self._render is not None:
self._plt.autoscale(True)
self._plt.imshow(self._render)
self._plt.autoscale(False)
# Plot the points
if len(self._points) > 0:
xs = [x for (x, _) in self._rectangle()]
ys = [y for (_, y) in self._rectangle()]
self._plt.plot(xs + [xs[0]], ys + [ys[0]], '-', color='green')
xs = [x for (x, _) in self._points]
ys = [y for (_, y) in self._points]
self._plt.plot(xs + [xs[0]], ys + [ys[0]], 'o', color='blue')
# Draw the canvas
self._canvas.draw()
# Handle click events
def _onPick(self, event):
if event.button == 3:
self._redraw()
elif event.button != 1:
return
# Get point position
x = event.xdata
y = event.ydata
if x is None or y is None:
return
# For each existing points
for px, py in self._points:
# Compute distance to current point
dst = np.sqrt((px - x) ** 2 + (py - y) ** 2)
# If the distance is small remove it
if dst < 10:
self._removePoint(px, py)
self._redraw()
return
# Delegate to add the point
self._addPoint(x, y)
# Redraw the image
self._redraw()
# Add a new point
def _addPoint(self, x, y):
# Count points
n = len(self._points)
# If less than 3 points just add it
if n < 2:
self._points.append((x, y))
return
# Remove an existing point
def _removePoint(self, x, y):
# Remove the point
self._points = list(filter(lambda v: v != (x, y), self._points))
def _rectangle(self):
# Get xs and ys
xs = [x for (x, _) in self._points]
ys = [y for (_, y) in self._points]
# Compute ranges
xmax = max(xs)
xmin = min(xs)
ymax = max(ys)
ymin = min(ys)
# Return rectangle
return [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)]
def _pointsToVector(self, points):
# Get points values
x1, y1 = points[0]
x2, y2 = points[1]
x3, y3 = points[2]
x4, y4 = points[3]
# Return the vector
return np.array([[x1, y1], [x2, y2], [x3, y3], [x4, y4]])
class Window(QtGui.QDialog):
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.setGeometry(500, 300, 800, 600)
self.setWindowTitle("PyQT Mappn!")
#_________________________________________________________________________
#(Menubah)
self.myQMenuBar = QtGui.QMenuBar(self)
FileMenu = self.myQMenuBar.addMenu('File')
AboutMenu = self.myQMenuBar.addMenu('About')
exchangeChoice = self.myQMenuBar.addMenu('Exchanges')
dataTF = self.myQMenuBar.addMenu('Data Time')
OHLCI = self.myQMenuBar.addMenu('OHLC Interval')
topIndicator = self.myQMenuBar.addMenu('Top Indicator')
middleIndicator = self.myQMenuBar.addMenu('Middle Indicator')
#______________
exitAction = QtGui.QAction('Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Quit Program')
exitAction.triggered.connect(QtGui.qApp.quit)
popupmsgAction = QtGui.QAction('Open', self)
popupmsgAction.setStatusTip('Popup')
popupmsgAction.triggered.connect(self.popupmsg)
#-----
exchange2 = QtGui.QAction('BTC-E', self)
exchange2.setStatusTip('BTC-E')
exchange2.triggered.connect(self.btce)
exchange1 = QtGui.QAction('BITFINEX', self)
exchange1.setStatusTip('BITFINEX')
exchange1.triggered.connect(self.bitfinex)
exchange3 = QtGui.QAction('Bitstamp', self)
exchange3.setStatusTip('bitstamp')
exchange3.triggered.connect(self.bitstamp)
#_________
tick = QtGui.QAction('Tick', self)
tick.setStatusTip('Tick Data')
tick.triggered.connect(self.btce)
oned = QtGui.QAction('1 day', self)
oned.setStatusTip('One Day')
oned.triggered.connect(self.bitfinex)
threed = QtGui.QAction('3 day', self)
threed.setStatusTip('three day')
threed.triggered.connect(self.bitstamp)
sevend = QtGui.QAction('7 day', self)
sevend.setStatusTip('seven day')
sevend.triggered.connect(self.bitstamp)
#__________
tick1 = QtGui.QAction('tick', self)
tick1.setStatusTip('seven day')
tick1.triggered.connect(self.bitstamp)
onem = QtGui.QAction('1 minute', self)
onem.setStatusTip('seven day')
onem.triggered.connect(self.bitstamp)
fivem = QtGui.QAction('5 minute', self)
fivem.setStatusTip('seven day')
fivem.triggered.connect(self.bitstamp)
fifteenm = QtGui.QAction('15 minute', self)
fifteenm.setStatusTip('seven day')
fifteenm.triggered.connect(self.bitstamp)
thirtymin = QtGui.QAction('30 mins', self)
thirtymin.setStatusTip('seven day')
thirtymin.triggered.connect(self.bitstamp)
oneh = QtGui.QAction('1 hour', self)
oneh.setStatusTip('seven day')
oneh.triggered.connect(self.bitstamp)
threeh = QtGui.QAction('3 hour', self)
threeh.setStatusTip('seven day')
threeh.triggered.connect(self.bitstamp)
#------------Top indicator
noner = QtGui.QAction('None', self)
noner.setStatusTip('None')
noner.triggered.connect(self.btce)
sma = QtGui.QAction('EMA', self)
sma.setStatusTip('EMA')
sma.triggered.connect(self.addTopIndicator)
ema = QtGui.QAction('SMA', self)
ema.setStatusTip('SMA')
ema.triggered.connect(self.bitstamp)
#------------Middle Indicator
noner = QtGui.QAction('None', self)
noner.setStatusTip('None')
noner.triggered.connect(self.btce)
rsi = QtGui.QAction('RSI', self)
rsi.setStatusTip('RSI')
rsi.triggered.connect(self.bitfinex)
macd = QtGui.QAction('MACD', self)
macd.setStatusTip('MACD')
macd.triggered.connect(self.bitstamp)
#---------------------------------------------------------------
FileMenu.addAction(exitAction)
AboutMenu.addAction(popupmsgAction)
exchangeChoice.addAction(exchange1)
exchangeChoice.addAction(exchange2)
exchangeChoice.addAction(exchange3)
dataTF.addAction(tick)
dataTF.addAction(oned)
dataTF.addAction(threed)
dataTF.addAction(sevend)
OHLCI.addAction(tick1)
OHLCI.addAction(onem)
OHLCI.addAction(fivem)
OHLCI.addAction(fifteenm)
OHLCI.addAction(thirtymin)
OHLCI.addAction(oneh)
OHLCI.addAction(threeh)
topIndicator.addAction(noner)
topIndicator.addAction(rsi)
topIndicator.addAction(macd)
middleIndicator.addAction(noner)
middleIndicator.addAction(ema)
middleIndicator.addAction(sma)
#_________________________________________________________________________
#
#Canvas------------------
self.canvas = FigureCanvas(f)
self.canvas.show()
self.show()
#_________________________________________________________________________
#(down starting from top, from left, continuing, how many rows it spas across)
grid = QtGui.QGridLayout()
grid.addWidget(self.canvas, 0, 0, 2, 4)
self.setLayout(grid)
#_________________________________________________________________________
#_________________________________________________________________________
#Functions--------------------------------------------------------------
def close_application(self):
print("whooaaaa so custom!!!")
sys.exit()
def popupmsg(self):
msg = QtGui.QMessageBox.question(self, "Error!",
"Not supported just yet..",
QtGui.QMessageBox.Yes | QtGui.QMessageBox.No)
if msg == QtGui.QMessageBox.Yes:
print("Exiting!!!!")
sys.exit()
else:
pass
#Info------------
def changeExchange(self, toWhat, pn):
global exchange
global DatCounter
global programName
exchange = toWhat
programName=pn
DatCounter=9000
def btce(self):
pass
def bitfinex(self):
pass
def bitstamp(self):
pass
def changeTimeFrame(self, tf, popupmsg):
global DatCounter
global datapace
if tf == "7 day" and resampleSize == "1 minute":
popupmsg("Way to much data!")
else:
datapace = tf
DatCounter = 9000
def changeSampleSize(self, size, width, popupmsg):
global resampleSize
global DatCounter
global candleWidth
if datapace == "7 day" and resampleSize == "1 minute":
popupmsg("Way to much data!")
elif datapace == "tick":
popupmsg("Your currently viewing ticking data")
else:
resampleSize = size
DatCounter = 9000
candleWidth = width
#-------Indicators
def addTopIndicator(self):
global topIndicator
global DatCounter
text, ok = QtGui.QInputDialog.getText(self, 'Input Dialog',
'Enter your name:')
if ok:
self.le.setText(str(text))
class mywidget(QWidget):
def __init__(self,Parent=None):
super(mywidget,self).__init__(Parent)
self.figure=plt.figure(figsize=(15,25),facecolor='w',dpi=50)
self.canvas=FigureCanvas(self.figure)
self.toolbar=NavigationToolbar(self.canvas,self)
self.slider=QSlider(Qt.Horizontal,self)
self.slider.setRange(1, 100)
self.slider.setValue(5)
self.slider.valueChanged[int].connect(self.changeValue)
self.label=QLabel('Taxa de amostragem 50 Hz')
self.spinbox=QSpinBox()
self.spinbox.setValue(5)
self.spinbox.valueChanged.connect(self.sliderchange)
self.spinbox.setRange(1,100)
layout=QVBoxLayout()
layout.addWidget(self.toolbar)
layout.addWidget(self.canvas)
layout.addWidget(self.slider)
layout.addWidget(self.spinbox)
layout.addWidget(self.label)
self.slider.valueChanged.connect(self.changeValue)
self.setLayout(layout)
self.plot()
#self.changeValue(5)
def sliderchange(self,value):
self.slider.setValue(value)
def plot(self):
self.amostrasporseg=15*5 #samples/sec
frequenciasinal=5 #Hz
omega= frequenciasinal
self.z=2*np.pi*np.arange(0,2*np.pi,1/self.amostrasporseg)
y=np.sin(self.z*omega)
k=y*signal.hann(len(y))
ylinha= 20*np.log10(abs(np.fft.fft(k,2048)))
ylinha=np.tile(ylinha,3)
zlinha=np.linspace(-2,4,len(ylinha))
self.figure.subplots_adjust(bottom=.75)
gs = gridspec.GridSpec(5, 1,height_ratios=[0.2,1,0.25,1,0.2])
ax =self.figure.add_subplot(gs[1])
self.plot2,=plt.plot(zlinha,ylinha)
plt.title('Espectro do sinal')
plt.xlabel(r'$\omega$')
plt.ylabel(r'|X($\omega$)|')
plt.xticks((-2,-1,0,1,2,3,4),[r'$-2\pi$',r'$-\pi$','0',r'$\pi$',r'$2\pi$',r'$3\pi$',r'$4\pi$'])
#ax.set_xticks([-0.0442,0.0442], minor=True)
ax.xaxis.grid(True,which='major',linewidth=0.75,color='k',linestyle='--')
self.beta=self.figure.add_subplot(gs[3])
self.plot3,=plt.plot(self.z,y,label='Amostragem Correta')
plt.plot(self.z,y,'o',label='Amostragem Fixa')
plt.legend(loc='upper right')
self.beta.set_xlabel(r't')
self.beta.set_ylabel(r'x(t)')
self.beta.set_xlim([0,2*np.pi])
self.figure.tight_layout()
def changeValue(self,value):
self.spinbox.setValue(value)
freq = value
znovo=np.arange(0,2*np.pi,0.001)
omega= freq
omeganovo= freq
y=np.sin(self.z*omega)
yf=np.sin(znovo*omeganovo)
k=y*signal.hann(len(y))
ylinha=np.fft.fft(k,2048)
ylinha=np.tile(ylinha,3)
self.beta.clear()
self.beta.plot(znovo,yf,label='Amostragem Correta')
self.beta.plot(self.z,y,'o-',lw=2,label='Amostragem Fixa')
plt.legend(loc='upper right')
self.beta.set_xlim([0,2*np.pi])
self.beta.set_xlabel(r't')
self.beta.set_ylabel(r'x(t)')
self.beta.set_title('Sinal com amostragem correta x Sinal com amostragem fixa')
self.plot2.set_ydata(20*np.log10(abs(ylinha)))
self.canvas.draw()
self.canvas.show()
class View(QtGui.QWidget):
def __init__(self, parent = None, width=5, height=4, dpi=80, filename = None, model = None,
plot_type = 'Image', trace_num = None, region = []):
# plot paramters #
self.t_num = trace_num
self.region = region
# connect model signal #
self.model = model
self.model.dataChanged.connect(self.update_views)
# create a dictionary of views
self.view_options = {'Image': self.view_image,
'TracePlot': self.view_trace,
'PSD': self.view_psd,
'Surface':self.view_surface}
super(View,self).__init__(parent)
# make the figure
self.figure = Figure((width, height), dpi)
fig_color = (1.0, 1.0, 1.0, 1.0)
self.figure.set_facecolor(fig_color)
# create the canvas
self.canvas = Canvas(self.figure)
self.canvas.setParent(self)
# create the toolbar and tie it to the canvas
self.toolbar = Toolbar(self.canvas, self)
self.layout = QtGui.QVBoxLayout()
self.layout.addWidget(self.canvas)
self.setLayout(self.layout)
if filename:
self.setWindowTitle(plot_type+': '+filename)
if plot_type == 'Surface':
self.axes = self.figure.gca(projection='3d')
else:
self.axes = self.figure.add_subplot(111)
self.axes.hold(False)
self.view_options[plot_type]()
self.canvas.show()
def view_image(self):
self.axes.imshow(self.model.get_agc_data(),cmap = cm.coolwarm)
self.axes.set_xticklabels([])
self.axes.set_yticklabels([])
self.axes.set_xticks([])
self.axes.set_yticks([])
self.axes.set_xlabel('source channel')
self.axes.set_ylabel('time')
def view_trace(self):
print self.t_num
y = self.model.getTrace(self.t_num)
x = np.arange(len(y))
self.axes.fill(x,y,'r',linewidth = 0)
self.axes.set_xlabel('time')
self.axes.set_ylabel('amplitude')
self.axes.set_xlim(0,len(x))
self.axes.grid(True)
def view_surface(self):
#x = np.arange(self.model.getNTraces())
#y = np.arange(self.model.getTLength())
y = np.arange(self.region[1]-self.region[0])
x = np.arange(self.region[3]-self.region[2])
x, y = np.meshgrid(x, y)
z = self.model.get_agc_data()
z = z[self.region[0]:self.region[1], self.region[2]:self.region[3]]
print self.model.getTLength()
self.axes.plot_surface(x,y,z, rstride=1, cstride=1, cmap=cm.coolwarm,
linewidth=0, antialiased=False)
def view_psd(self):
y = self.model.get_psd_of_trace(self.t_num)
x = np.arange(-len(y)/2,len(y)/2)
print x.shape
print y.shape
self.axes.semilogy(x,y,'r', linewidth = 1)
self.axes.set_xlabel('frequency')
self.axes.set_ylabel('spectral density')
self.axes.set_xlim(-len(x)/2,len(x)/2)
self.axes.grid(True)
def update_views(self):
print "updating views"
class DiagramaDeRafagasyManiobrasDialog(QFrame, layout_DiagramaDeRafagasyManiobras.Ui_Dialog):
def __init__(self, parent=None):
super(DiagramaDeRafagasyManiobrasDialog, self).__init__(parent)
self.setupUi(self)
self.setWindowTitle(__appName__)
# Define input unit's label for SI and IM
self.length_label = {'IM': 'ft', 'SI': 'm'}
self.area_label = {'IM': 'ft^2', 'SI': 'm^2'}
self.weight_label = {'IM': 'lb', 'SI': 'kg'}
self.speed_label = {'IM': 'ft/s', 'SI': 'm/s'}
self.den_label = {'IM': 'slug/ft^2', 'SI': 'kg/m^3'}
self.ft2m = 0.3048
self.lb2kg = 0.453592
datos = {
'CAM': {'SI': 2.461, 'IM': 2.461/self.ft2m},
'sw': {'SI': 60, 'IM': 60 / self.ft2m / self.ft2m},
'a3D': 5.0037,
'MTOW': {'SI': 23000, 'IM': 23000 / self.lb2kg},
'MLW': {'SI': 23000, 'IM': 23000 / self.lb2kg},
'MZFW': {'SI': 16376.0, 'IM': 16376.0 / self.lb2kg},
'Vc': {'SI': 151.93, 'IM': 151.93 / self.ft2m},
'clmax': 1.2463,
'clmax_flap': 1.499,
'clmin': -0.75*1.2463,
'Zmo': {'SI': 9999.2, 'IM': 9999.2 / self.ft2m}
}
w = {'SI': 20000, 'IM': 20000 / self.lb2kg}
h = {'SI': 5000, 'IM': 5000 / self.ft2m}
den = {'SI': 1.225, 'IM': 1.225 / self.lb2kg * self.ft2m**3}
self.diagramas = Diagramas(datos, w, h, den, units='SI')
self.update_units()
self.atmosfera_estandar_dialog = AtmosferaEstandarDialog(unit=self.units)
self.fig1 = Figure((5.0, 3.0), dpi=72, facecolor=(1, 1, 1), edgecolor=(0, 0, 0))
self.fig1.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.25)
self.axes1 = self.fig1.add_subplot(111)
self.axes1.set_ylabel('n')
self.axes1.set_xlabel(self.speed_label[self.units])
self.axes1.set_title('Diagrama de Maniobras')
self.axes1.ticklabel_format(style="sci", scilimits=(0, 0), axis="both") # , useOffset=True,useLocale=True)
self.axes1.tick_params(axis="both", direction='in', length=6, width=2, labelsize="medium")
self.fig2 = Figure(dpi=72, facecolor=(1, 1, 1), edgecolor=(0, 0, 0))
self.fig2.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.25)
self.axes2 = self.fig2.add_subplot(111)
self.axes2.set_ylabel('n')
self.axes2.ticklabel_format(style='sci', scilimits=(0, 0), axis="both")
self.axes2.set_xlabel(self.speed_label[self.units])
self.axes2.set_title('Diagrama de Rafagas')
self.fig3 = Figure(dpi=72, facecolor=(1, 1, 1), edgecolor=(0, 0, 0))
self.fig3.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.25)
self.axes3 = self.fig3.add_subplot(111)
self.axes3.set_ylabel('n')
self.axes3.ticklabel_format(style='sci', scilimits=(0, 0), axis="both")
self.axes3.set_xlabel(self.speed_label[self.units])
self.axes3.set_title('Diagrama de Rafagas y maniobras')
# generate the canvas to display the plot
self.canvas1 = FigureCanvas(self.fig1)
self.canvas1.setParent(self.manoeuvre_tab)
self.canvas1.show()
self.canvas2 = FigureCanvas(self.fig2)
self.canvas2.setParent(self.gust_tab)
self.canvas2.show()
self.canvas3 = FigureCanvas(self.fig3)
self.canvas3.setParent(self.combined_tab)
self.canvas3.show()
# SIGNALS & SLOTS
self.connect(self.IM_radioButton, SIGNAL("clicked()"), self.update_units)
self.connect(self.SI_radioButton, SIGNAL("clicked()"), self.update_units)
self.connect(self.Altura_Button, SIGNAL("clicked()"), self.seleccionAltura)
self.connect(self.grafiacar_pushButton, SIGNAL("clicked()"), self.calculos())
self.CAM_lineEdit.editingFinished.connect(lambda: self.lecturadatos(self.diagramas.CAM, float(self.CAM_lineEdit.text()), self.ft2m))
self.sw_lineEdit.editingFinished.connect(lambda: self.lecturadatos(self.diagramas.sw, float(self.sw_lineEdit.text()), self.ft2m**2))
self.MTOW_lineEdit.editingFinished.connect(lambda: self.lecturadatos(self.diagramas.MTOW, float(self.MTOW_lineEdit.text()), self.lb2kg))
self.MLW_lineEdit.editingFinished.connect(lambda: self.lecturadatos(self.diagramas.MLW, float(self.MLW_lineEdit.text()), self.lb2kg))
self.MZFW_lineEdit.editingFinished.connect(lambda: self.lecturadatos(self.diagramas.MZFW, float(self.MZFW_lineEdit.text()), self.lb2kg))
self.a3D_lineEdit.editingFinished.connect(lambda: self.lecturadatos(self.diagramas.a3D, float(self.a3D_lineEdit.text())))
self.clmax_lineEdit.editingFinished.connect(lambda: self.lecturadatos(self.diagramas.clmax, float(self.clmax_lineEdit.text())))
self.clmax_flap_lineEdit.editingFinished.connect(lambda: self.lecturadatos(self.diagramas.clmax_flap, float(self.clmax_flap_lineEdit.text())))
self.Zmo_lineEdit.editingFinished.connect(lambda: self.lecturadatos(self.diagramas.Zmo, float(self.Zmo_lineEdit.text()), self.ft2m))
self.Vc_lineEdit.editingFinished.connect(lambda: self.lecturadatos(self.diagramas.Vc, float(self.Vc_lineEdit.text()), self.ft2m))
self.W_lineEdit.editingFinished.connect(lambda: self.lecturadatos(self.diagramas.W, float(self.W_lineEdit.text()), self.lb2kg))
self.h_lineEdit.editingFinished.connect(lambda: self.lecturadatos(self.diagramas.h, float(self.h_lineEdit.text()), self.ft2m))
self.den_lineEdit.editingFinished.connect(lambda: self.lecturadatos(self.diagramas.den, float(self.den_lineEdit.text()), self.lb2kg / self.ft2m**3))
self.grafiacar_pushButton.clicked.connect(self.calculos)
def resizeEvent(self, event):
self.canvas1.setGeometry(self.PlotArea.rect())
self.canvas2.setGeometry(self.PlotArea.rect())
self.canvas3.setGeometry(self.PlotArea.rect())
def lecturadatos(self, variable, value, unit_converter = 1.0):
logger.debug(value)
if self.units == 'IM':
variable['IM'] = value
variable['SI'] = value*unit_converter
else:
variable['SI'] = value
variable['IM'] = value/unit_converter
def update_units(self):
if self.IM_radioButton.isChecked():
self.units = "IM"
self.diagramas.units = "IM"
elif self.SI_radioButton.isChecked():
self.units = "SI"
self.diagramas.units = "SI"
else:
return -1
self.update_unitLabels()
self.write_lineEdits()
def calculos(self):
self.print_input_variables()
self.diagramas.calculos()
self.plot_diagrams()
def seleccionAltura(self):
# TODO: actualizar atmosfera_estandar_dialog con los valores de diagramas.h y diagramas.den
# update units
self.atmosfera_estandar_dialog.units = self.units
self.atmosfera_estandar_dialog.update_labels()
self.atmosfera_estandar_dialog.atmosfera[self.units]['h'] = self.diagramas.h[self.units]
self.atmosfera_estandar_dialog.write_lineEdits()
self.atmosfera_estandar_dialog.actualizar('altura')
self.atmosfera_estandar_dialog.actualizarRho(self.diagramas.den[self.units])
if self.atmosfera_estandar_dialog.exec_():
self.diagramas.h[self.units] = self.atmosfera_estandar_dialog.atmosfera[self.units]['h']
self.diagramas.den[self.units] = self.atmosfera_estandar_dialog.atmosfera[self.units]['rho']
self.write_lineEdits()
def plot_diagrams(self):
self.axes1.clear()
self.diagramas.plot_diagrama_de_maniobras(self.axes1, 0.5)
self.diagramas.plot_diagrama_de_maniobras_con_flap(self.axes1, 0.5)
self.canvas1.draw()
self.axes2.clear()
self.diagramas.plot_diagrama_de_rafagas(self.axes2, 0.5)
self.canvas2.draw()
self.axes3.clear()
self.diagramas.plot_diagrama_de_maniobras_y_rafagas(self.axes3, 0.5)
self.canvas3.draw()
def update_unitLabels(self):
self.CAM_unitlabel.setText(self.length_label[self.units])
self.sw_unitlabel.setText(self.area_label[self.units])
self.MTOW_unitlabel.setText(self.weight_label[self.units])
self.MLW_unitlabel.setText(self.weight_label[self.units])
self.MZFW_unitlabel.setText(self.weight_label[self.units])
self.W_unitlabel.setText(self.weight_label[self.units])
self.Zmo_unitlabel.setText(self.length_label[self.units])
self.h_unitlabel.setText(self.length_label[self.units])
self.den_unitlabel.setText(self.den_label[self.units])
self.Vc_unitlabel.setText(self.speed_label[self.units])
def write_lineEdits(self):
# TODO: set decimals to print
self.CAM_lineEdit.setText(str(self.diagramas.CAM[self.units]))
self.sw_lineEdit.setText(str(self.diagramas.sw[self.units]))
self.MTOW_lineEdit.setText(str(self.diagramas.MTOW[self.units]))
self.MLW_lineEdit.setText(str(self.diagramas.MLW[self.units]))
self.MZFW_lineEdit.setText(str(self.diagramas.MZFW[self.units]))
self.W_lineEdit.setText(str(self.diagramas.W[self.units]))
self.Zmo_lineEdit.setText(str(self.diagramas.Zmo[self.units]))
self.h_lineEdit.setText(str(self.diagramas.h[self.units]))
self.den_lineEdit.setText(str(self.diagramas.den[self.units]))
self.Vc_lineEdit.setText(str(self.diagramas.Vc[self.units]))
self.a3D_lineEdit.setText(str(self.diagramas.a3D))
self.clmax_lineEdit.setText(str(self.diagramas.clmax))
self.clmax_flap_lineEdit.setText(str(self.diagramas.clmax_flap))
self.clmin_lineEdit.setText(str(self.diagramas.clmin))
def print_input_variables(self):
logger.info("CAM = {}".format(self.diagramas.CAM[self.units]))
logger.info("Sw = {}".format(self.diagramas.sw[self.units]))
logger.info("MTOW = {}".format(self.diagramas.MTOW[self.units]))
logger.info("MLW = {}".format(self.diagramas.MLW[self.units]))
logger.info("MZFW = {}".format(self.diagramas.MZFW[self.units]))
logger.info("a3D = {}".format(self.diagramas.a3D))
logger.info("clmax = {}".format(self.diagramas.clmax))
logger.info("clmax_flap = {}".format(self.diagramas.clmax_flap))
logger.info("clmin = {}".format(self.diagramas.clmin))
logger.info("Zmo = {}".format(self.diagramas.Zmo[self.units]))
logger.info("Vc = {}".format(self.diagramas.Vc[self.units]))
class RTWindowWidget(QtGui.QWidget):
"""Matplotlib wxFrame with animation effect"""
### connects widgets and signals ###
def __init__(self, parent = None):
super(RTWindowWidget, self).__init__(parent)
# Matplotlib Figure
self.fig = Figure((6, 4), 100)
# bind the Figure to the backend specific canvas
self.canvas = FigureCanvas(self.fig)
# add a subplot
self.ax = self.fig.add_subplot(111)
# limit the X and Y axes dimensions
# we prefer 2 separate functions for clarity
self.ax.set_ylim([0, 100])
self.ax.set_xlim([0, POINTS])
# but we want a "frozen" window (defined by y/xlim functions)
self.ax.set_autoscale_on(False)
# we do not want ticks on X axis
self.ax.set_xticks([])
# we want a tick every 10 point on Y (101 is to have 100 too)
self.ax.set_yticks(range(0, 101, 10))
# disable autoscale, since we don't want the Axes to adapt
# draw a grid (it will be only for Y)
self.ax.grid(True)
# generates first "empty" plots
self.user = [None] * POINTS
self.nice = [None] * POINTS
self.sys = [None] * POINTS
self.idle = [None] * POINTS
self.l_user, = self.ax.plot(range(POINTS), self.user, label='User %')
self.l_nice, = self.ax.plot(range(POINTS), self.nice, label='Nice %')
self.l_sys, = self.ax.plot(range(POINTS), self.sys, label='Sys %')
self.l_idle, = self.ax.plot(range(POINTS), self.idle, label='Idle %')
# add the legend
self.ax.legend(loc='upper center',
ncol=4,
prop=font_manager.FontProperties(size=10))
# force a draw on the canvas()
# trick to show the grid and the legend
self.canvas.draw()
# save the clean background - everything but the line
# is drawn and saved in the pixel buffer background
self.bg = self.canvas.copy_from_bbox(self.ax.bbox)
# take a snapshot of CPU usage, needed for the update algorithm
self.before = self.prepare_cpu_usage()
# timerCallback = lambda: self.onTimer()
myTimer = QtCore.QTimer()
myTimer.timeout.connect(self.onTimer)
myTimer.start(1000) #once a sec
# print 1
self.canvas.show()
def prepare_cpu_usage(self):
"""helper function to return CPU usage info"""
# get the CPU times using psutil module
t = p.cpu_times()
# return only the values we're interested in
if hasattr(t, 'nice'):
return [t.user, t.nice, t.system, t.idle]
else:
# special case for Windows, without 'nice' value
return [t.user, 0, t.system, t.idle]
def get_cpu_usage(self):
"""Compute CPU usage comparing previous and current measurements"""
# take the current CPU usage information
now = self.prepare_cpu_usage()
# compute deltas between current and previous measurements
delta = [now[i]-self.before[i] for i in range(len(now))]
# compute the total (needed for percentages calculation)
total = sum(delta)
# save the current measurement to before object
self.before = now
# return the percentage of CPU usage for our 4 categories
return [(100.0*dt)/total for dt in delta]
def onTimer(self):
"""callback function for timer events"""
print 1
# get the CPU usage information
tmp = self.get_cpu_usage()
# restore the clean background, saved at the beginning
self.canvas.restore_region(self.bg)
# update the data
self.user = self.user[1:] + [tmp[0]]
self.nice = self.nice[1:] + [tmp[1]]
self.sys = self.sys[1:] + [tmp[2]]
self.idle = self.idle[1:] + [tmp[3]]
# update the plot
self.l_user.set_ydata(self.user)
self.l_nice.set_ydata(self.nice)
self.l_sys.set_ydata( self.sys)
self.l_idle.set_ydata(self.idle)
# just draw the "animated" objects
self.ax.draw_artist(self.l_user)
self.ax.draw_artist(self.l_nice)
self.ax.draw_artist(self.l_sys)
self.ax.draw_artist(self.l_idle)
# "blit" the background with the animated lines
self.canvas.blit(self.ax.bbox)
def generate_est_png(tasks, number=10, display=False):
if len(tasks) > 0 and mpl_available:
# Allocate arrays
N = len(tasks)
x = numpy.arange(N)
lbe = numpy.zeros(N)
errors = numpy.zeros(N)
average = numpy.zeros(N)
sigma_minus = numpy.zeros(N)
sigma_plus = numpy.zeros(N)
colors = []
# Plot properties
M = max([0, N - number]) # index of first task to show
w = 0.4 # width of the bars
# Compute values
for i, task in enumerate(tasks):
lbe[i] = i - w/2
errors[i] = (task.duration - task.estimate) / 60.0 # in minutes
average[i] = numpy.average(errors[:i+1]) / (i + 1)
sigma_minus[i] = average[i] - numpy.std(errors[:i+1])
sigma_plus[i] = average[i] + numpy.std(errors[:i+1])
if errors[i] <= 0:
# Logged duration was less than estimate
colors.append(GREEN)
else:
# Logged duration was more than estimate
colors.append(RED)
# Create plot
fig = Figure()
canvas = FigureCanvas(fig)
ax = fig.add_subplot(1, 1, 1)
ax.hold(True)
ax.set_xlim(M-w/2, N-1+w/2)
ax.set_xticks([])
ax.set_xticklabels([])
ax.set_ylim(min([-10, numpy.min(errors)-10]), max([180, numpy.max(errors)+10]))
ax.set_ylabel('Estimation error [minutes]')
ax.grid(axis='y')
# Plot data
ax.plot(x[M:], average[M:], color=DARK_BLUE)
ax.plot(x[M:], sigma_minus[M:], color=LIGHT_BLUE)
ax.plot(x[M:], sigma_plus[M:], color=LIGHT_BLUE)
ax.fill_between(x[M:], y1=sigma_minus[M:], y2=sigma_plus[M:], color=LIGHT_BLUE)
ax.bar(lbe[M:], errors[M:], w, color=colors[M:], alpha=0.4)
# Create labels
for x, task in enumerate(tasks[M:]):
ax.text(x+M, 1, task.name, rotation=90, ha='center', va='bottom')
# Output
if not display:
# Output as base64-encoded string
im = sio.StringIO()
fig.savefig(im, format='png')
png = im.getvalue().encode('base64').strip()
return png
else:
# Show on screen
canvas.show()
return None
else:
return None
class Window(QtGui.QWidget):
def __init__(self):
QtGui.QWidget.__init__(self)
self.setGeometry(200,100,500,120)
p = self.palette()
p.setColor(self.backgroundRole(), QtGui.QColor(200,100,100))
self.setPalette(p)
# Supprime les bords de la fentre
self.setWindowFlags( QtCore.Qt.FramelessWindowHint)
tempLabel = QtGui.QLabel(self)
# Pour ne pas avoir de probleme avec le °
text = QtCore.QString.fromUtf8("Temperature\n125°C")
tempLabel.setText(text)
humLabel = QtGui.QLabel(self)
text = QtCore.QString.fromUtf8("Humidité\n100%")
humLabel.setText(text)
self.heure = QtGui.QLabel()
self.date = QtGui.QLabel()
pathToImage = "/home/francois/Documents/test_git/PiMeteo/"
# pathToImage = "/home/user/Documents/PiMeteo/"
b1 = QtGui.QPushButton()
b1.setMaximumSize(90,70)
b1.setMinimumSize(90,70)
image_temp = QtGui.QPixmap()
image_temp.load(pathToImage+"image_temp.png")
labelImage = QtGui.QLabel(b1)
labelImage.setPixmap(image_temp)
self.b2 = QtGui.QPushButton()
self.b2.setMaximumSize(90,70)
self.b2.setMinimumSize(90,70)
image_hum = QtGui.QPixmap()
image_hum.load(pathToImage+"image_hum.png")
labelImage = QtGui.QLabel(self.b2)
labelImage.setPixmap(image_hum)
b3 = QtGui.QPushButton()
b3.setMaximumSize(90,70)
b3.setMinimumSize(90,70)
self.b5 = QtGui.QListView()
self.main_frame = QtGui.QWidget()
self.main_frame.setGeometry(200,100,100,100)
fig = Figure(figsize=None, dpi=None, facecolor=((0.78,0.39,0.39,1)))
self.canvas = FigureCanvas(fig)
self.canvas.setParent(self.main_frame)
self.axes = fig.add_subplot(111)
# axes.plot([1,2,3])
self.axes.plot([3,2,1])
self.canvas.draw()
# connect the signals to the slots
b1.clicked.connect(self.plot_1)
self.b2.clicked.connect(self.plot_2)
b3.clicked.connect(self.draw_infos)
# set the layout_boutton
self.layout_boutton = QtGui.QGridLayout()
self.layout_boutton.addWidget(self.date,0,0)
self.layout_boutton.addWidget(self.heure,0,1)
self.layout_boutton.addWidget(tempLabel,1,0)
self.layout_boutton.addWidget(b1,1,1)
self.layout_boutton.addWidget(self.b2,2,1)
self.layout_boutton.addWidget(b3,3,1)
self.layout_boutton.addWidget(humLabel,2,0)
# set the layout_window
self.layout_window = QtGui.QGridLayout()
self.layout_window.addLayout(self.layout_boutton,0,0)
self.layout_window.addWidget(self.b5,0,1)
self.setLayout(self.layout_window)
def update_time(self,heure_courante):
self.heure.setText(heure_courante)
def update_date(self,date_courante):
self.date.setText(date_courante)
def plot_1(self):
if -1 == self.layout_window.indexOf(self.canvas):
self.layout_window.removeWidget(self.b5)
self.b5.hide()
self.layout_window.addWidget(self.canvas,0,1)
self.canvas.show()
# discards the old graph
self.axes.hold(False)
# plot data
self.axes.plot([1,2,3])
# refresh canvas
self.canvas.draw()
def plot_2(self):
if -1 == self.layout_window.indexOf(self.canvas):
self.layout_window.removeWidget(self.b5)
self.b5.hide()
self.layout_window.addWidget(self.canvas,0,1)
self.canvas.show()
# discards the old graph
self.axes.hold(False)
# plot data
self.axes.plot([3,2,1])
# refresh canvas
self.canvas.draw()
def draw_infos(self):
if -1 == self.layout_window.indexOf(self.b5):
self.layout_window.removeWidget(self.canvas)
self.canvas.hide()
self.layout_window.addWidget(self.b5,0,1)
self.b5.show()
for dr in range(ndir):
rao[fr, dr, :] = MotionFreq(
self._data_h['m_m'] + self._data_h['m_add'][fr, :, :],
self._data_h['c_rad'][fr, :, :] +
self._data_p['c_pto'][te, hs, ang, :, :] +
self._data_p['c_fit'][te, hs, ang, :, :] +
self._data_p['c_ext'][te, hs, ang, :, :],
self._data_h['k_hst'] +
self._data_p['k_mooring'][te, hs, ang, :, :] +
self._data_p['k_fit'][te, hs, ang, :, :] +
self._data_p['k_ext'][te, hs, ang, :, :],
self._data_h['f_ex'][fr, dr].T, omeg[fr])
return rao
if __name__ == "__main__":
vi = Visualiser()
data = {
'periods': np.array([0, 1]),
'f_ex': np.array([[[0, 1]]], dtype=complex).T,
'c_rad': np.array([[[0, 1]]], 'f').T,
'm_add': np.array([[[0, 1]]], 'f').T
}
figu = vi.show_diffraction_problem(0, 0)
vi.set_hydrodynamic_data(data)
figu = vi.show_radiation_problem(0, 0)
canvas = FigureCanvas(figu)
canvas.draw()
canvas.show()
class MainForm(QtGui.QMainWindow):
signalShowMessage = QtCore.pyqtSignal(str)
signalGraphUpdate = QtCore.pyqtSignal()
def __init__(self):
QtGui.QWidget.__init__(self)
self.config = configparser.ConfigParser()
self.config.read('../Lib/TMV3.ini')
self.ui = uic.loadUi("Viewer.ui", self)
self.workBenchDB = self.config['DataBases']['workbench']
self.figure_canvasReference = FigureCanvas(Figure())
self.figure_canvasCurrent = FigureCanvas(Figure())
self.plotsRef = []
self.plotsRefPos = 0
self.plotsCur = []
self.plotsCurPos = 0
self.mode = -1
self.defBackground = 0
self.ui.BtnCurrent.setChecked(False)
self.ui.BtnReference.setChecked(False)
self.ui.BtnLoadPlotsRef.clicked.connect(self.onBtnLoadRef)
self.ui.BtnLoadPlotsCur.clicked.connect(self.onBtnLoadCur)
self.ui.BtnSum.clicked.connect(self.onBtnApply)
self.ui.BtnDiff.clicked.connect(self.onBtnApply)
self.ui.BtnPrint.clicked.connect(self.onBtnApply)
self.ui.BtnEditor.clicked.connect(self.onBtnApply)
self.ui.BtnReference.clicked.connect(self.onBtnRefCur)
self.ui.BtnCurrent.clicked.connect(self.onBtnRefCur)
self.ui.BtnFRwd.clicked.connect(self.onBtnFRwd)
self.ui.BtnRwd.clicked.connect(self.onBtnRwd)
self.ui.BtnFwd.clicked.connect(self.onBtnFwd)
self.ui.BtnFFwd.clicked.connect(self.onBtnFFwd)
self.signalGraphUpdate.connect(self.onGraphUpdate)
self.ui.BtnReference.setStyleSheet("QPushButton {background-color: lightGray}"
"QPushButton:checked {background-color: yellow}")
self.ui.BtnCurrent.setStyleSheet("QPushButton {background-color: lightGray}"
"QPushButton:checked {background-color: green}")
self.initGraph()
def contextMenuEvent(self, event):
self.menu = QtGui.QMenu(self)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
renameAction = QtGui.QAction('Rename', self)
renameAction.triggered.connect(lambda: self.renameSlot(event))
self.menu.addAction(renameAction)
# add other required actions
self.menu.popup(QtGui.QCursor.pos())
def renameSlot(self,event):
print('renameSlot')
def onBtnFRwd(self):
if self.mode == Ref:
self.plotsRefPos = 0
self.onShowPlot(self.plotsRef[0],Ref)
if self.mode == Cur:
self.plotsCurPos = 0
self.onShowPlot(self.plotsCur[0],Cur)
if self.mode == Both:
self.plotsRefPos = 0
self.plotsCurPos = 0
self.onShowPlot(self.plotsRef[0],Ref)
self.onShowPlot(self.plotsCur[0],Cur)
pass
def onBtnRwd(self):
if self.mode == Ref:
if self.plotsRefPos > 0:
self.plotsRefPos -= 1
self.onShowPlot(self.plotsRef[self.plotsRefPos],Ref)
if self.mode == Cur:
if self.plotsCurPos > 0:
self.plotsCurPos -= 1
self.onShowPlot(self.plotsCur[self.plotsCurPos],Cur)
if self.mode == Both:
if self.plotsRefPos > 0:
self.plotsRefPos -= 1
self.onShowPlot(self.plotsRef[self.plotsRefPos],Ref)
if self.plotsCurPos > 0:
self.plotsCurPos -= 1
self.onShowPlot(self.plotsCur[self.plotsCurPos],Cur)
pass
def onBtnFwd(self):
print ("FWD",self.mode)
if self.mode == Ref:
if self.plotsRefPos < len(self.plotsRef)-1:
self.plotsRefPos += 1
self.onShowPlot(self.plotsRef[self.plotsRefPos],Ref)
if self.mode == Cur:
if self.plotsCurPos < len(self.plotsCur)-1:
self.plotsCurPos += 1
self.onShowPlot(self.plotsCur[self.plotsCurPos],Cur)
if self.mode == Both:
if self.plotsRefPos < len(self.plotsRef)-1:
self.plotsRefPos += 1
self.onShowPlot(self.plotsRef[self.plotsRefPos],Ref)
if self.plotsCurPos < len(self.plotsCur)-1:
self.plotsCurPos += 1
self.onShowPlot(self.plotsCur[self.plotsCurPos],Cur)
pass
def onBtnFFwd(self):
if self.mode == Ref:
self.plotsRefPos = len(self.plotsRef)-1
self.onShowPlot(self.plotsRef[self.plotsRefPos],Ref)
if self.mode == Cur:
self.plotsCurPos = len(self.plotsCur)-1
self.onShowPlot(self.plotsCur[self.plotsCurPos],Cur)
if self.mode == Both:
self.plotsRefPos = len(self.plotsRef)-1
self.onShowPlot(self.plotsRef[self.plotsRefPos],Ref)
self.plotsCurPos = len(self.plotsCur)-1
self.onShowPlot(self.plotsCur[self.plotsCurPos],Cur)
pass
def onBtnRefCur(self):
if (self.ui.BtnCurrent.isChecked() and self.ui.BtnReference.isChecked()):
self.mode = Both
print (self.mode)
elif (self.ui.BtnCurrent.isChecked() and not self.ui.BtnReference.isChecked()):
self.mode = Cur
print (self.mode)
elif (not self.ui.BtnCurrent.isChecked() and self.ui.BtnReference.isChecked()):
self.mode = Ref
print (self.mode)
else:
self.mode = -1
print (self.mode)
def openSession(self):
session = Session()
session.exec()
if session.ret:
if session.new:
self.onBtnLoadRef()
else:
print(session.sel)
def onGraphUpdate(self):
self.figure_canvas.draw()
def onShowMessageB(self, text):
self.addItem(text)
pass
def onShowMessageA(self, data):
text = pickle.loads(data)
#Message from foreign thread => access gui via qt-signal
self.signalShowMessage.emit(text)
def onBtnApply(self):
pass
def onBtnLoadRef(self):
filter = Filter()
filter.exec()
if filter.ret:
print(filter.sel)
self.plotsRef = filter.sel
pass
def onBtnLoadCur(self):
filter = Filter()
filter.exec()
if filter.ret:
print(filter.sel)
self.plotCur = filter.sel
pass
def onShowPlot(self, id, dest):
print ("id, dest",id,dest)
_Plot = Tpl3Plot(self.workBenchDB,id)
if _Plot.read():
self.onNewPlot(_Plot, dest)
for _t in _Plot.traces:
self.onNewTrace(_t, dest)
#_lines = eval (data.lineObjects)
for _line in _Plot.lineObjects:
self.onNewLine(_line, dest)
return True
else:
_err = "Error reading Plot {}".format(str(id))
QtGui.QMessageBox.information(self, 'TMV3', _err, QtGui.QMessageBox.Ok)
return False
def onNewPlot(self, data, dest):
if dest == Ref:
self.axesR.set_xlim(data.x1,data.x2)
self.axesR.set_ylim(data.y1,data.y2)
if dest == Cur:
self.axesC.set_xlim(data.x1,data.x2)
self.axesC.set_ylim(data.y1,data.y2)
# self.signalShowTitle.emit(data.plot_title)
self.signalGraphUpdate.emit()
pass
def onShowTitleRef(self,txt):
#access to Gui only via signal
self.setWindowTitle(txt)
def onGraphUpdate(self):
self.figure_canvasReference.draw()
self.figure_canvasCurrent.draw()
def onNewLine(self, data, dest):
try:
# print ('Graph: new Line {0} {1} {2}'.format(data.type, str(data.line_id), str(len(data.data_xy))))
_xyf = eval(data.data_xy)
# print(_xyf, type(_xyf))
_xys = sorted(_xyf,key = lambda x: x[0])
_x, _y = zip(*_xys)
self.getDefaultLineStyle(data.type)
_color = self.defaultColor
_style = self.defaultStyle
_width = self.defaultWidth
# print(data.color, data.style, data.width)
if data.color == '': _color = self.defaultColor
if data.style == '': style = self.defaultStyle
if data.style == '0.0': _width = self.defaultWidth
#if self.backgroundPlot == 'True':
# _color = 'grey'
# if dest == Ref:
self.axesR.plot(_x, _y, picker=5, label=data.title, color=_color,ls=_style, lw=1)
# else:
# self.axesC.plot(_x, _y, picker=5, label=data.title, color=_color,ls=_style, lw=1)
if data.type == "Limit":
_yTextPos = _y[-1]
_xTextPos = self.axes.get_xlim()[1]
_text = ' ' + data.title
if dest == Ref:
self.axesR.text(_xTextPos,_yTextPos,_text)
else:
self.axesC.text(_xTextPos,_yTextPos,_text)
pass
#self.figure_canvas.draw()
self.signalGraphUpdate.emit()
except Exception as _err:
print("Graph: onNewLine: {0}".format(str(_err)))
logging.exception(_err)
def onNewTrace(self, data, dest):
print('GRAPH NewTrace')
_x = []
_y = []
try:
_startFreq = data.x1
_stopFreq = data.x2
if data.data_xy_mode == 'Sweep':
if type(data.data_y) == str:
_y = eval(data.data_y)
else:
_y = data.data_y
_stepFreq = (_stopFreq - _startFreq)/len(_y)
_x = numpy.arange(_startFreq,_stopFreq,_stepFreq)
else:
pass
self.getDefaultLineStyle('Trace')
if data.hf_overload == True or data.if_overload == True:
self.getDefaultLineStyle('TraceOverload')
if data.uncal == True:
self.getDefaultLineStyle('TraceUncal')
_color = self.defaultColor
_style = self.defaultStyle
_width = self.defaultWidth
# if self.backgroundPlot == 'True': _color = 'grey'
self.axesR.plot(_x, _y, picker=5,color=_color, ls=_style, lw=1)
self.signalGraphUpdate.emit()
pass
except Exception as _err:
print("Graph: onNewTrace: {0}".format(str(_err)))
logging.exception(_err)
pass
def onResult(self,data):
right = 0.9
top = 0.9
self.axes.text(right, top, data,
horizontalalignment='right',
verticalalignment='top',
fontsize=20, color='red',
transform=self.axes.transAxes)
self.signalGraphUpdate.emit()
def onNewAnnotation(self, data):
print('GRAPH NewAnnotation')
pass
def onNewClassification(self, data):
print('GRAPH NewClassification')
pass
def onNewDescription(self, data):
print('GRAPH NewDescription')
pass
def onNewNumber(self, data):
print('GRAPH NewNumber')
pass
def onPrint(self, data):
print('GRAPH Print')
pass
def onStop(self, data):
print('GRAPH Stop')
self.Client.stop()
pass
def getDefaultLineStyle(self,type):
if type == 'Limit':
self.defaultColor = self.config['LineStyle']['limit_color']
self.defaultStyle = self.config['LineStyle']['limit_style']
self.defaultWidth = self.config['LineStyle']['limit_width']
if type == 'Antenna':
self.defaultColor = self.config['LineStyle']['antenna_color']
self.defaultStyle = self.config['LineStyle']['antenna_style']
self.defaultWidth = self.config['LineStyle']['antenna_width']
if type == 'Cable':
self.defaultColor = self.config['LineStyle']['cable_color']
self.defaultStyle = self.config['LineStyle']['cable_style']
self.defaultWidth = self.config['LineStyle']['cable_width']
if type == 'Line':
self.defaultColor = self.config['LineStyle']['line_color']
self.defaultStyle = self.config['LineStyle']['line_style']
self.defaultWidth = self.config['LineStyle']['line_width']
if type == 'Trace':
self.defaultColor = self.config['LineStyle']['trace_color']
self.defaultStyle = self.config['LineStyle']['trace_style']
self.defaultWidth = self.config['LineStyle']['trace_width']
if type == 'TraceOverload':
self.defaultColor = self.config['LineStyle']['trace_overload_color']
self.defaultStyle = self.config['LineStyle']['trace_overload_style']
self.defaultWidth = self.config['LineStyle']['trace_overload_width']
if type == 'TraceUncal':
self.defaultColor = self.config['LineStyle']['trace_uncal_color']
self.defaultStyle = self.config['LineStyle']['trace_uncal_style']
self.defaultWidth = self.config['LineStyle']['trace_uncal_width']
if type == 'Analyse':
self.defaultColor = self.config['LineStyle']['anaylse_color']
self.defaultStyle = self.config['LineStyle']['anaylse_style']
self.defaultWidth = self.config['LineStyle']['anaylse_width']
pass
def initGraph(self):
# create a figure
self.figure_canvasReference.setParent(self.ui.frame_3)
layoutR = QtGui.QVBoxLayout()
self.ui.frame_3.setLayout(layoutR)
layoutR.addWidget(self.figure_canvasReference, 0)
# and the axes for the figure
self.axesR = self.figure_canvasReference.figure.add_subplot(111)
self.axesR.set_ylabel('dBµV')
self.axesR.set_xlabel('Hz')
self.axesR.grid(True)
self.axesR.set_xscale('log')
formatterHZ = EngFormatter(unit = '',places=0)
formatterDB = EngFormatter(unit = '',places=1)
self.axesR.xaxis.set_major_formatter(formatterHZ)
self.axesR.yaxis.set_major_formatter(formatterDB)
self.axesR.xaxis.label.set_color('yellow')
self.axesR.yaxis.label.set_color('yellow')
self.axesR.title.set_color('yellow')
self.axesR.title.set_text('Reference')
self.figure_canvasReference.show()
self.figure_canvasCurrent.setParent(self.ui.frame_4)
layoutC = QtGui.QVBoxLayout()
self.ui.frame_4.setLayout(layoutC)
layoutC.addWidget(self.figure_canvasCurrent, 2)
self.ui.frame_4.setLayout(layoutC)
# and the axes for the figure
self.axesC = self.figure_canvasCurrent.figure.add_subplot(111)
self.axesC.set_ylabel('dBµV')
self.axesC.set_xlabel('Hz')
self.axesC.grid(True)
self.axesC.set_xscale('log')
formatterHZ = EngFormatter(unit = '',places=0)
formatterDB = EngFormatter(unit = '',places=1)
self.axesC.xaxis.set_major_formatter(formatterHZ)
self.axesC.yaxis.set_major_formatter(formatterDB)
self.axesC.xaxis.label.set_color('green')
self.axesC.yaxis.label.set_color('green')
self.axesC.title.set_color('green')
self.axesC.title.set_text('Current')
self.figure_canvasCurrent.show()
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()
