def _init_plotarea(self):
plot_splitter = QtWidgets.QSplitter(QtCore.Qt.Vertical)
plot_splitter.setObjectName('plots')
# Volume slices figure
self.fig = matplotlib.figure.Figure(figsize=(14, 5))
self.fig.subplots_adjust(left=0.0, bottom=0.00, right=0.99, wspace=0.0)
#self.fig.set_facecolor('#232629')
self.fig.set_facecolor('#112244')
self.canvas = FigureCanvas(self.fig)
self.canvas.show()
plot_splitter.addWidget(self.canvas)
self.vol_plotter = VolumePlotter(self.fig, self.recon_type, self.num_modes)
self.need_replot = self.vol_plotter.need_replot
# Progress plots figure
self.log_fig = matplotlib.figure.Figure(figsize=(14, 5), facecolor='w')
#self.log_fig.set_facecolor('#232629')
self.log_fig.set_facecolor('#112244')
self.plotcanvas = FigureCanvas(self.log_fig)
self.plotcanvas.show()
plot_splitter.addWidget(self.plotcanvas)
self.log_plotter = LogPlotter(self.log_fig, self.folder)
return plot_splitter
def __init__(self, parent):
fig = Figure()
super(MyMplCanvas, self).__init__(fig)
# figure stuff
self.htype = 'Linear'
self.cbar = cm.jet
self.data = []
self.gmode = None
self.argb = [None, None, None]
self.hhist = [None, None, None]
self.hband = [None, None, None]
self.htxt = [None, None, None]
self.patches = []
self.lines = []
self.image = None
self.cnt = None
self.cntf = None
self.background = None
self.pwidth = 0.001
self.isgeog = True
self.axes = fig.add_subplot(111)
# self.axes.xaxis.set_visible(False)
# self.axes.yaxis.set_visible(False)
self.setParent(parent)
FigureCanvas.setSizePolicy(self,
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
def __init__(self, parent=None):
# figure stuff
fig = Figure()
self.axes = fig.add_subplot(111)
self.line = None
self.ind = None
self.parent = parent
FigureCanvas.__init__(self, fig)
def create_figure_widget(cls, parent=None):
"""
:rtype tuple(QWidget, Figure)
"""
# Inspiration:
# http://matplotlib.org/examples/user_interfaces/embedding_in_qt4_wtoolbar.html
fig = Figure()
widget = QtWidgets.QWidget(parent)
layout = QtWidgets.QVBoxLayout()
widget.setLayout(layout)
# The canvas widget
canvas = FigureCanvas(fig)
canvas.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
canvas.setFocusPolicy(QtCore.Qt.StrongFocus)
canvas.updateGeometry()
# The toolbar
mpl_toolbar = NavigationToolbar(canvas, widget)
def on_key_press(event):
key_press_handler(event, canvas, mpl_toolbar)
canvas.mpl_connect('key_press_event', on_key_press)
# Lay it out
layout.addWidget(canvas)
layout.addWidget(mpl_toolbar)
return widget, fig
def __init__(self, parent, lmod):
fig = Figure()
FigureCanvas.__init__(self, fig)
self.myparent = parent
self.lmod = lmod
self.cbar = cm.jet
self.curmodel = 0
self.mywidth = 1
self.xold = None
self.yold = None
self.press = False
self.newline = False
self.mdata = np.zeros([10, 100])
self.ptitle = ''
self.punit = ''
self.xlabel = 'Eastings (m)'
self.plotisinit = False
self.crd = None
# Events
self.figure.canvas.mpl_connect('motion_notify_event', self.move)
self.figure.canvas.mpl_connect('button_press_event', self.button_press)
self.figure.canvas.mpl_connect('button_release_event',
self.button_release)
# Initial Images
self.paxes = fig.add_subplot(211)
self.paxes.yaxis.set_label_text("mGal")
self.paxes.ticklabel_format(useOffset=False)
self.cal = self.paxes.plot([], [], zorder=10, color='blue')
self.obs = self.paxes.plot([], [], '.', zorder=1, color='orange')
self.axes = fig.add_subplot(212)
self.axes.xaxis.set_label_text(self.xlabel)
self.axes.yaxis.set_label_text("Altitude (m)")
tmp = self.cbar(self.mdata)
tmp[:, :, 3] = 0
self.ims2 = self.axes.imshow(tmp.copy(), interpolation='nearest',
aspect='auto')
self.ims = self.axes.imshow(tmp.copy(), interpolation='nearest',
aspect='auto')
self.figure.canvas.draw()
self.bbox = self.figure.canvas.copy_from_bbox(self.axes.bbox)
self.pbbox = self.figure.canvas.copy_from_bbox(self.paxes.bbox)
self.prf = self.axes.plot([0, 0])
self.figure.canvas.draw()
self.lbbox = self.figure.canvas.copy_from_bbox(self.axes.bbox)
def __init__(self, parent):
self.figure = Figure()
FigureCanvas.__init__(self, self.figure)
self.setParent(parent)
self.parent = parent
self.polyi = None
self.data = []
self.cdata = []
self.mindx = [0, 0]
self.csp = None
self.subplot = None
def __init__(self, parent=None):
self.figure = Figure()
FigureCanvas.__init__(self, self.figure)
self.setParent(parent)
self.nullfmt = NullFormatter()
self.pntxy = None
self.polyi = None
self.axhistx = None
self.axhisty = None
self.axscatter = None
self.histx = None
self.histy = None
self.xcoord = None
self.ycoord = None
self.data = []
self.cindx = [0, 1, 0]
self.cdata = []
self.csp = None
def __init__(self, ncust=1):
# figure stuff
fig = Figure()
self.cbar = cm.jet
self.gmode = None
self.xlims = None
self.ylims = None
self.axes = fig.add_subplot(111)
self.axes.xaxis.set_label_text("Eastings (m)")
self.axes.yaxis.set_label_text("Northings (m)")
FigureCanvas.__init__(self, fig)
dat = np.zeros([100, 100])
self.ims2 = self.axes.imshow(dat, cmap=self.cbar,
interpolation='nearest')
self.ims = self.axes.imshow(self.cbar(dat), interpolation='nearest')
self.ims2.set_clim(0, 1)
self.ibar = self.figure.colorbar(self.ims, fraction=0.025, pad=0.1)
self.ibar2 = self.figure.colorbar(self.ims2, cax=self.ibar.ax.twinx())
self.ibar.ax.set_aspect('auto')
self.ibar.set_label('')
self.ibar2.set_label('')
self.ibar.ax.yaxis.set_label_position('left')
self.figure.canvas.draw()
self.bbox = self.figure.canvas.copy_from_bbox(self.axes.bbox)
self.lbbox = self.figure.canvas.copy_from_bbox(self.axes.bbox)
self.prf = self.axes.plot([0, 1], [0, 1])
for _ in range(ncust):
self.prf += self.axes.plot([0, 1], [0, 1])
self.figure.canvas.draw()
self.gcol1 = self.cbar(dat)
def __init__(self, parent, lmod):
fig = Figure()
FigureCanvas.__init__(self, fig)
self.myparent = parent
self.lmod = lmod
self.cbar = cm.jet
self.curmodel = 0
self.mywidth = 1
self.xold = None
self.yold = None
self.press = False
self.newline = False
self.mdata = np.zeros([100, 100])
self.opac = 1.0
self.xlims = None
self.ylims = None
# Events
self.figure.canvas.mpl_connect('motion_notify_event', self.move)
self.figure.canvas.mpl_connect('button_press_event', self.button_press)
self.figure.canvas.mpl_connect('button_release_event',
self.button_release)
# Initial Images
self.axes = fig.add_subplot(111)
self.axes.xaxis.set_label_text("Eastings (m)")
self.axes.yaxis.set_label_text("Northings (m)")
self.ims2 = self.axes.imshow(self.mdata, cmap=self.cbar,
interpolation='nearest')
self.ims = self.axes.imshow(self.cbar(self.mdata),
interpolation='nearest')
self.figure.canvas.draw()
self.bbox = self.figure.canvas.copy_from_bbox(self.axes.bbox)
self.prf = self.axes.plot([0, 1], [0, 1])
self.figure.canvas.draw()
self.lbbox = self.figure.canvas.copy_from_bbox(self.axes.bbox)
def __init__(self):
super(ApplicationWindow, self).__init__()
self._main = QtWidgets.QWidget()
self.setCentralWidget(self._main)
layout = QtWidgets.QVBoxLayout(self._main)
static_canvas = FigureCanvas(Figure(figsize=(5, 3)))
layout.addWidget(static_canvas)
self.addToolBar(NavigationToolbar(static_canvas, self))
dynamic_canvas = FigureCanvas(Figure(figsize=(5, 3)))
layout.addWidget(dynamic_canvas)
self.addToolBar(QtCore.Qt.BottomToolBarArea,
NavigationToolbar(dynamic_canvas, self))
self._static_ax = static_canvas.figure.subplots()
t = np.linspace(0, 10, 501)
self._static_ax.plot(t, np.tan(t), ".")
self._dynamic_ax = dynamic_canvas.figure.subplots()
self._timer = dynamic_canvas.new_timer(
100, [(self._update_canvas, (), {})])
self._timer.start()
def __init__(self, parent=None, width=5, height=5, dpi=100):
fig = Figure(figsize=(width, height), dpi=dpi)
fig.set_tight_layout({"pad": 1})
self.axes = fig.add_subplot(111)
self.plot_data = None
FigureCanvas.__init__(self, fig)
self.setParent(parent)
FigureCanvas.setSizePolicy(self, QSizePolicy.Expanding, QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
def __init__(self, parent=None, width=5, height=5, dpi=100):
fig = Figure(figsize=(width, height), dpi=dpi)
fig.set_facecolor("#282828")
fig.set_tight_layout({"pad": 1})
self.axes = fig.add_subplot(111)
self.plot_data = [[[0], [0]], [datetime.datetime.now()]]
FigureCanvas.__init__(self, fig)
self.setParent(parent)
FigureCanvas.setSizePolicy(self, QSizePolicy.Expanding, QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
self.compute_initial_figure()
def __init__(self):
# Initialize the figure and axes
self.fig = Figure()
self.axes = self.fig.add_subplot(111)
# Give it some default plot (if desired).
x = np.arange(0.0, 3.0, 0.01)
y = np.sin(2*np.pi*x)
self.axes.plot(x, y)
self.axes.set_xlabel('x')
self.axes.set_ylabel('y(x)')
# Now do the initialization of the super class
FigureCanvas.__init__(self, self.fig)
#self.setParent(parent)
FigureCanvas.setSizePolicy(self,
QSizePolicy.Expanding,
QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
def setupPlot(self):
self.figure = Figure()
self.canvas = FigureCanvas(self.figure)
self.plot = self.figure.add_subplot(111)
self.figure.tight_layout()
def __init__(self, presenter, parent = None, name = '', isMD=False, noExp = 0):
super(SampleLogsView, self).__init__(parent)
self.presenter = presenter
self.setWindowTitle("{} sample logs".format(name))
self.setWindowFlags(Qt.Window)
# Create sample log table
self.table = QTableView()
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.clicked.connect(self.presenter.clicked)
self.table.doubleClicked.connect(self.presenter.doubleClicked)
self.table.contextMenuEvent = self.tableMenu
self.addWidget(self.table)
frame_right = QFrame()
layout_right = QVBoxLayout()
#Add full_time and experimentinfo options
layout_options = QHBoxLayout()
if isMD:
layout_options.addWidget(QLabel("Experiment Info #"))
self.experimentInfo = QSpinBox()
self.experimentInfo.setMaximum(noExp-1)
self.experimentInfo.valueChanged.connect(self.presenter.changeExpInfo)
layout_options.addWidget(self.experimentInfo)
self.full_time = QCheckBox("Relative Time")
self.full_time.setChecked(True)
self.full_time.stateChanged.connect(self.presenter.plot_logs)
layout_options.addWidget(self.full_time)
layout_right.addLayout(layout_options)
# Sample log plot
self.fig = Figure()
self.canvas = FigureCanvas(self.fig)
self.canvas.setSizePolicy(QSizePolicy.Expanding,QSizePolicy.Expanding)
self.canvas.mpl_connect('button_press_event', self.presenter.plot_clicked)
self.ax = self.fig.add_subplot(111, projection='mantid')
layout_right.addWidget(self.canvas)
# Sample stats
self.create_stats_widgets()
layout_stats = QFormLayout()
layout_stats.addRow('', QLabel("Log Statistics"))
layout_stats.addRow('Min:', self.stats_widgets["minimum"])
layout_stats.addRow('Max:', self.stats_widgets["maximum"])
layout_stats.addRow('Mean:', self.stats_widgets["mean"])
layout_stats.addRow('Median:', self.stats_widgets["median"])
layout_stats.addRow('Std Dev:', self.stats_widgets["standard_deviation"])
layout_stats.addRow('Time Avg:', self.stats_widgets["time_mean"])
layout_stats.addRow('Time Std Dev:', self.stats_widgets["time_standard_deviation"])
layout_stats.addRow('Duration:', self.stats_widgets["duration"])
layout_right.addLayout(layout_stats)
frame_right.setLayout(layout_right)
self.addWidget(frame_right)
self.setStretchFactor(0,1)
self.resize(1200,800)
self.show()
class LinearArray(QMainWindow, Ui_MainWindow):
def __init__(self):
super(self.__class__, self).__init__()
self.setupUi(self)
# Connect to the input boxes, when the user presses enter the form updates
self.frequency.returnPressed.connect(self._update_canvas)
self.number_of_elements.returnPressed.connect(self._update_canvas)
self.scan_angle.returnPressed.connect(self._update_canvas)
self.element_spacing.returnPressed.connect(self._update_canvas)
self.side_lobe_level.returnPressed.connect(self._update_canvas)
self.antenna_type.currentIndexChanged.connect(self._update_canvas)
# Set up a figure for the plotting canvas
fig = Figure()
self.fig = fig
self.axes1 = fig.add_subplot(111)
self.my_canvas = FigureCanvas(fig)
# Add the canvas to the vertical layout
self.verticalLayout.addWidget(self.my_canvas)
self.addToolBar(QtCore.Qt.TopToolBarArea,
NavigationToolbar(self.my_canvas, self))
# Update the canvas for the first display
self._update_canvas()
def _update_canvas(self):
"""
Update the figure when the user changes an input value
:return:
"""
# Get the parameters from the form
frequency = float(self.frequency.text())
number_of_elements = int(self.number_of_elements.text())
scan_angle = float(self.scan_angle.text())
element_spacing = float(self.element_spacing.text())
side_lobe_level = float(self.side_lobe_level.text())
# Get the selected antenna from the form
antenna_type = self.antenna_type.currentText()
# Set the angular span
theta = linspace(0.0, pi, 1000)
# Set up the args
kwargs = {
'number_of_elements': number_of_elements,
'scan_angle': radians(scan_angle),
'element_spacing': element_spacing,
'frequency': frequency,
'theta': theta,
'window_type': antenna_type,
'side_lobe_level': side_lobe_level
}
# Get the array factor
af = linear_array.array_factor(**kwargs)
# Clear the axes for the updated plot
self.axes1.clear()
# Create the line plot
self.axes1.plot(degrees(theta),
20.0 * log10(abs(af) + finfo(float).eps), '')
# Set the y axis limit
self.axes1.set_ylim(-80, 5)
# Set the x and y axis labels
self.axes1.set_xlabel("Theta (degrees)", size=12)
self.axes1.set_ylabel("Array Factor (dB)", size=12)
# Turn on the grid
self.axes1.grid(linestyle=':', linewidth=0.5)
# Set the plot title and labels
self.axes1.set_title('Linear Array Antenna Pattern', size=14)
# Set the tick label size
self.axes1.tick_params(labelsize=12)
# Update the canvas
self.my_canvas.draw()
class LissajousCurve(QWidget):
def __init__(self):
super().__init__()
layout = QHBoxLayout()
self.setLayout(layout)
self.static_canvas = FigureCanvas(Figure(figsize=(5, 3)))
self.static_canvas.setFixedWidth(self.height() - 50)
layout.addWidget(self.static_canvas)
self._static_ax = self.static_canvas.figure.subplots()
fontBig = QFont()
fontBig.setPointSize(20)
fontBig.setFamily("arial")
fontLittle = QFont()
fontLittle.setPointSize(18)
fontLittle.setFamily("arial")
a_layout = QVBoxLayout()
self.a_formulaDescription = QLabel("x = A * sin(ɷA * t + φ)")
self.a_formulaDescription.setFont(fontLittle)
self.a_formulaDescription.setAlignment(Qt.AlignBottom)
self.a_formula = QLabel()
self.a_formula.setTextFormat(Qt.TextFormat.RichText)
self.a_formula.setFont(fontBig)
self.a_formula.setAlignment(Qt.AlignTop)
a_layout.addWidget(self.a_formulaDescription)
a_layout.addWidget(self.a_formula)
b_layout = QVBoxLayout()
self.b_formulaDescription = QLabel("y = B * sin(ɷB * t)")
self.b_formulaDescription.setFont(fontLittle)
self.b_formulaDescription.setAlignment(Qt.AlignBottom)
self.b_formula = QLabel()
self.b_formula.setTextFormat(Qt.TextFormat.RichText)
self.b_formula.setFont(fontBig)
self.b_formula.setAlignment(Qt.AlignTop)
b_layout.addWidget(self.b_formulaDescription)
b_layout.addWidget(self.b_formula)
ab_layout = QVBoxLayout()
ab_layout.addLayout(a_layout)
ab_layout.addLayout(b_layout)
layout.addStretch()
layout.addLayout(ab_layout)
layout.addStretch()
self.setVariables(5, 5, 5, 5, 5)
def setVariables(self, aAmp, bAmp, aOmega, bOmega, phaseDiff):
self.aAmp = aAmp
self.bAmp = bAmp
self.aOmega = aOmega
self.bOmega = bOmega
self.phaseDiff = phaseDiff
self.updatePlot()
def updatePlot(self):
self._static_ax.clear()
t = np.linspace(-np.pi, np.pi, 300)
self._static_ax.plot(
self.aAmp * np.sin(self.aOmega * t + self.phaseDiff),
self.bAmp * np.sin(self.bOmega * t), "-b")
self._static_ax.figure.canvas.draw()
self.updateFormula()
def updateFormula(self):
self.a_formula.setText("x = <b>" + ("%.2f" % self.aAmp) +
"</b> * sin(<b>" + str(self.aOmega) +
"</b> * t + <b>" + ("%.2f" % self.phaseDiff) +
"</b>)")
self.b_formula.setText("y = <b>" + ("%.2f" % self.bAmp) +
"</b> * sin(<b>" + str(self.bOmega) +
"</b> * t)")
fig.canvas.mpl_connect("motion_notify_event", self.on_move)
def on_move(self, event):
draw = False
for item in self.menuitems:
draw = item.set_hover(event)
if draw:
self.figure.canvas.draw()
break
app = QApplication(sys.argv)
fig = Figure(figsize=(8, 6))
canvas = FigureCanvas(fig)
canvas.resize(640, 480)
canvas.show()
fig.subplots_adjust(left=0.3)
props = ItemProperties(labelcolor="black",
bgcolor="yellow",
fontsize=15,
alpha=0.2)
hoverprops = ItemProperties(labelcolor="white",
bgcolor="blue",
fontsize=15,
alpha=0.2)
menuitems = []
for label in ("open", "close", "save", "save as", "quit"):
def __init__(self, parent, x_tsne, y_tsne, x, y, SV):
super().__init__(parent)
self.allData = parent.globalData
self._x = x
self._SV = SV
self._x_tsne = x_tsne
self._y_tsne = y_tsne
self.target = y
self.menubar = self.menuBar()
self.parametersMenu = self.menubar.addMenu("Параметры")
self._selectionPolygon = []
self._selectedPoints = []
self._modelIndex = []
self._xData = []
self._yData = []
self.setGeometry(100, 100, 1500, 480)
self.setWindowTitle("TSNE")
self.centralWidget = QWidget()
self.setCentralWidget(self.centralWidget)
self.layout = QHBoxLayout(self.centralWidget)
self.layout.setContentsMargins(0, 0, 0, 0)
self.tabWidget = QTabWidget()
self.layout.addWidget(self.tabWidget)
self.figure = Figure()
self.barWidget = FigureCanvas(self.figure)
self.layout.addWidget(self.barWidget)
self.setLayout(self.layout)
self._axes = self.figure.add_subplot(111)
self._axes.scatter(x_tsne, y_tsne, c=self.target, cmap=plt.cm.coolwarm)
self.barWidget.draw()
# "МОЁ"
self.supportVectorView = QWidget()
self.tabWidget.addTab(self.supportVectorView, "Точки")
self.supportVectorViewLayout = QVBoxLayout(self.supportVectorView)
self.tableHeaderSV = QLabel("Выделенные точки")
self.tableHeaderSV.setAlignment(Qt.AlignCenter)
self.supportVectorViewLayout.addWidget(self.tableHeaderSV)
self.pointsTable = QTableWidget()
self.pointsTable.setColumnCount(3)
self.pointsTable.setHorizontalHeaderLabels(
["абсцисса", "ордината", ""])
self.supportVectorViewLayout.addWidget(self.pointsTable)
self.buttonGroupSV = QWidget()
self.buttonGroupSVLayout = QGridLayout(self.buttonGroupSV)
self.clearSelectionButtonSV = QPushButton("Очистить выделение")
self.clearSelectionButtonSV.clicked.connect(self.clearSelection)
self.selectionCompleteButtonSV = QPushButton("Завершить выделение")
self.selectionCompleteButtonSV.clicked.connect(self.selectionCompleted)
self.noteOnAllGraphButtonSV = QPushButton("Выделить на др. графиках")
self.noteOnAllGraphButtonSV.clicked.connect(self.noteOnAll)
self.noteTrueButtonSV = QPushButton("Выделить опорные векторы")
self.noteTrueButtonSV.clicked.connect(self.noteTrueSV)
self.noteCancelSV = QPushButton("Отменить выделение на др. графиках")
self.noteCancelSV.clicked.connect(self.noteCancel)
self.addSelectionButton = QPushButton("Добавить выделение")
self.addSelectionButton.clicked.connect(self.addSelection)
self.buildModelButton = QPushButton("Построить модель")
self.buildModelButton.clicked.connect(self.buildModel)
self.buttonGroupSVLayout.addWidget(self.selectionCompleteButtonSV, 1,
1)
self.buttonGroupSVLayout.addWidget(self.clearSelectionButtonSV, 1, 2)
self.buttonGroupSVLayout.addWidget(self.noteOnAllGraphButtonSV, 2, 1)
self.buttonGroupSVLayout.addWidget(self.noteTrueButtonSV, 2, 2)
self.buttonGroupSVLayout.addWidget(self.addSelectionButton, 3, 1)
self.buttonGroupSVLayout.addWidget(self.noteCancelSV, 3, 2)
self.buttonGroupSVLayout.addWidget(self.buildModelButton, 4, 1)
self.supportVectorViewLayout.addWidget(self.buttonGroupSV)
cid2 = self.barWidget.mpl_connect('button_press_event', self.onclick)
self.show()
def run(self, data):
print('processing ', data['regime name'])
output = {}
# calculate data-sets
t = data['results']['simTime']
yd = data['results']['trajectory_output.0']
y = []
for i in range(4):
y.append(data['results']['model_output.' + str(i)])
eps = np.subtract(y[0], yd)
traj = data['results']['trajectory_output.0']
# plots
fig = Figure()
fig.subplots_adjust(wspace=0.3, hspace=0.25)
fig.suptitle(r'' + data['modules']['controller']['type'] + ' ' + \
'$A_d$ =' + str(data['modules']['trajectory']['Amplitude']) + ' ' + \
'$f_d$ =' + str(data['modules']['trajectory']['Frequency']),
size=st.title_size)
axes1 = fig.add_subplot(2, 1, 1)
# axes2.set_title(r'\textbf{Beam Angle}')
axes1.plot(t, traj, c='k', ls='-', label='yd(t)')
axes1.plot(t,
y[0],
c=st.color_cycle[data['modules']['controller']['type']],
ls='-',
label='y(t)')
axes1.set_xlim(left=0, right=t[-1])
axes1.set_xlabel(r'$t [s]$', size=st.label_size)
axes1.set_ylabel(r'$r [m]$', size=st.label_size)
leg = [r'$y_d(t)$', r'$y(t)$']
axes1.legend(leg, loc=0)
axes2 = fig.add_subplot(2, 1, 2)
# axes.set_title(r'output error = yd - x0')
# deltaE = 0.01
# eMax = line([0, t[-1]], [deltaE, deltaE], lw=1,\
# ls='--', c=self.line_color)
# eMin = line([0, t[-1]], [-deltaE, -deltaE], lw=1,\
# ls='--', c=self.line_color)
# axes2.add_line(eMax)
# axes2.add_line(eMin)
axes2.plot(t, eps, c='k')
axes2.set_xlim(left=0, right=t[-1])
# axes2.set_ylim(top=0.4, bottom=-0.4)
axes2.set_xlabel(r'$t [s]$', size=st.label_size)
axes2.set_ylabel(r'$output error = x_{0} - y_{d} [m]$',
size=st.label_size)
self.calcMetrics(data, output)
# check for sim succes
if not data['results']['finished']:
for key in list(output.keys()):
output[key] = None
# add settings and metrics to dictionary results
results = {}
results.update({'metrics': output})
results.update({'modules': data['modules']})
canvas = FigureCanvas(fig)
self.writeOutputFiles(self.name, data['regime name'], fig, results)
return {
'name': '_'.join([data['regime name'], self.name]),
'figure': canvas
}
def setupUi(self, Form):
Form.setObjectName("Form")
Form.resize(947, 547)
self.gridLayout = QtWidgets.QGridLayout(Form)
self.gridLayout.setContentsMargins(3, 3, 3, 3)
self.gridLayout.setSpacing(2)
self.gridLayout.setObjectName("gridLayout")
self.tabWidget = QtWidgets.QTabWidget(Form)
self.tabWidget.setObjectName("tabWidget")
self.tab = QtWidgets.QWidget()
self.tab.setObjectName("tab")
self.gridLayout_3 = QtWidgets.QGridLayout(self.tab)
self.gridLayout_3.setObjectName("gridLayout_3")
self.frame = QtWidgets.QFrame(self.tab)
self.frame.setMinimumSize(QtCore.QSize(0, 0))
self.frame.setMaximumSize(QtCore.QSize(16777215, 16777215))
self.frame.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frame.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame.setObjectName("frame")
self.gridLayout_2 = QtWidgets.QGridLayout(self.frame)
self.gridLayout_2.setContentsMargins(2, 2, 2, 2)
self.gridLayout_2.setSpacing(1)
self.gridLayout_2.setObjectName("gridLayout_2")
self.figure_video, self.figaxes_video = plt.subplots()
self.figure_video.subplots_adjust(left=0.01,
top=0.99,
right=0.98,
bottom=0.01)
self.canvas_video = FigureCanvas(self.figure_video)
# self.toolbar_video = NavigationToolbar(self.canvas_video, self.tab)
# self.toolbar_video.setMinimumSize(QtCore.QSize(0, 41))
# self.toolbar_video.setMaximumSize(QtCore.QSize(16777215, 41))
# self.widget_2 = QtWidgets.QWidget(self.frame)
# self.widget_2.setObjectName("widget_2")
self.gridLayout_2.addWidget(self.canvas_video, 0, 1, 1, 1)
self.gridLayout_3.addWidget(self.frame, 0, 0, 1, 1)
self.frame_2 = QtWidgets.QFrame(self.tab)
self.frame_2.setMinimumSize(QtCore.QSize(211, 0))
self.frame_2.setMaximumSize(QtCore.QSize(211, 16777215))
self.frame_2.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frame_2.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_2.setObjectName("frame_2")
self.gridLayout_7 = QtWidgets.QGridLayout(self.frame_2)
self.gridLayout_7.setContentsMargins(0, 0, 0, 0)
self.gridLayout_7.setSpacing(1)
self.gridLayout_7.setObjectName("gridLayout_7")
self.frame_6 = QtWidgets.QFrame(self.frame_2)
self.frame_6.setMinimumSize(QtCore.QSize(211, 351))
self.frame_6.setMaximumSize(QtCore.QSize(211, 351))
self.frame_6.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frame_6.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_6.setObjectName("frame_6")
self.widget = QtWidgets.QWidget(self.frame_6)
self.widget.setGeometry(QtCore.QRect(10, 100, 183, 248))
self.widget.setObjectName("widget")
self.verticalLayout = QtWidgets.QVBoxLayout(self.widget)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setSpacing(2)
self.verticalLayout.setObjectName("verticalLayout")
self.horizontalLayout_2 = QtWidgets.QHBoxLayout()
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.label_2 = QtWidgets.QLabel(self.widget)
self.label_2.setObjectName("label_2")
self.horizontalLayout_2.addWidget(self.label_2)
self.zhengshu_spinBox = QtWidgets.QSpinBox(self.widget)
self.zhengshu_spinBox.setMinimumSize(QtCore.QSize(109, 27))
self.zhengshu_spinBox.setMaximumSize(QtCore.QSize(27, 16777215))
self.zhengshu_spinBox.setMaximum(1000000000)
self.zhengshu_spinBox.setObjectName("zhengshu_spinBox")
self.horizontalLayout_2.addWidget(self.zhengshu_spinBox)
self.verticalLayout.addLayout(self.horizontalLayout_2)
self.horizontalLayout_10 = QtWidgets.QHBoxLayout()
self.horizontalLayout_10.setObjectName("horizontalLayout_10")
self.label_4 = QtWidgets.QLabel(self.widget)
self.label_4.setMinimumSize(QtCore.QSize(64, 27))
self.label_4.setMaximumSize(QtCore.QSize(64, 27))
self.label_4.setObjectName("label_4")
self.horizontalLayout_10.addWidget(self.label_4)
self.fbl_comboBox = QtWidgets.QComboBox(self.widget)
self.fbl_comboBox.setMinimumSize(QtCore.QSize(109, 27))
self.fbl_comboBox.setMaximumSize(QtCore.QSize(109, 27))
self.fbl_comboBox.setObjectName("fbl_comboBox")
self.fbl_comboBox.addItem("")
self.fbl_comboBox.addItem("")
self.fbl_comboBox.addItem("")
self.fbl_comboBox.addItem("")
self.fbl_comboBox.addItem("")
self.fbl_comboBox.addItem("")
self.fbl_comboBox.addItem("")
self.horizontalLayout_10.addWidget(self.fbl_comboBox)
self.verticalLayout.addLayout(self.horizontalLayout_10)
self.horizontalLayout_8 = QtWidgets.QHBoxLayout()
self.horizontalLayout_8.setObjectName("horizontalLayout_8")
self.label_11 = QtWidgets.QLabel(self.widget)
self.label_11.setMinimumSize(QtCore.QSize(64, 27))
self.label_11.setMaximumSize(QtCore.QSize(64, 27))
self.label_11.setObjectName("label_11")
self.horizontalLayout_8.addWidget(self.label_11)
self.sd_SpinBox = QtWidgets.QDoubleSpinBox(self.widget)
self.sd_SpinBox.setMinimumSize(QtCore.QSize(109, 27))
self.sd_SpinBox.setMaximumSize(QtCore.QSize(109, 27))
self.sd_SpinBox.setMaximum(10000000.0)
self.sd_SpinBox.setSingleStep(0.1)
self.sd_SpinBox.setObjectName("sd_SpinBox")
self.horizontalLayout_8.addWidget(self.sd_SpinBox)
self.verticalLayout.addLayout(self.horizontalLayout_8)
self.horizontalLayout_9 = QtWidgets.QHBoxLayout()
self.horizontalLayout_9.setObjectName("horizontalLayout_9")
self.label_12 = QtWidgets.QLabel(self.widget)
self.label_12.setMinimumSize(QtCore.QSize(64, 27))
self.label_12.setMaximumSize(QtCore.QSize(64, 27))
self.label_12.setObjectName("label_12")
self.horizontalLayout_9.addWidget(self.label_12)
self.bg_SpinBox = QtWidgets.QDoubleSpinBox(self.widget)
self.bg_SpinBox.setMinimumSize(QtCore.QSize(109, 27))
self.bg_SpinBox.setMaximumSize(QtCore.QSize(109, 27))
self.bg_SpinBox.setMaximum(10000000.0)
self.bg_SpinBox.setSingleStep(0.1)
self.bg_SpinBox.setObjectName("bg_SpinBox")
self.horizontalLayout_9.addWidget(self.bg_SpinBox)
self.verticalLayout.addLayout(self.horizontalLayout_9)
self.horizontalLayout_7 = QtWidgets.QHBoxLayout()
self.horizontalLayout_7.setObjectName("horizontalLayout_7")
self.label_5 = QtWidgets.QLabel(self.widget)
self.label_5.setMinimumSize(QtCore.QSize(64, 27))
self.label_5.setMaximumSize(QtCore.QSize(64, 27))
self.label_5.setObjectName("label_5")
self.horizontalLayout_7.addWidget(self.label_5)
self.ld_SpinBox = QtWidgets.QDoubleSpinBox(self.widget)
self.ld_SpinBox.setMinimumSize(QtCore.QSize(109, 27))
self.ld_SpinBox.setMaximumSize(QtCore.QSize(109, 27))
self.ld_SpinBox.setMaximum(10000000.0)
self.ld_SpinBox.setSingleStep(0.1)
self.ld_SpinBox.setObjectName("ld_SpinBox")
self.horizontalLayout_7.addWidget(self.ld_SpinBox)
self.verticalLayout.addLayout(self.horizontalLayout_7)
self.horizontalLayout_6 = QtWidgets.QHBoxLayout()
self.horizontalLayout_6.setObjectName("horizontalLayout_6")
self.label_6 = QtWidgets.QLabel(self.widget)
self.label_6.setMinimumSize(QtCore.QSize(64, 27))
self.label_6.setMaximumSize(QtCore.QSize(64, 27))
self.label_6.setObjectName("label_6")
self.horizontalLayout_6.addWidget(self.label_6)
self.dbd_SpinBox = QtWidgets.QDoubleSpinBox(self.widget)
self.dbd_SpinBox.setMinimumSize(QtCore.QSize(109, 27))
self.dbd_SpinBox.setMaximumSize(QtCore.QSize(109, 27))
self.dbd_SpinBox.setMaximum(10000000.0)
self.dbd_SpinBox.setSingleStep(0.1)
self.dbd_SpinBox.setObjectName("dbd_SpinBox")
self.horizontalLayout_6.addWidget(self.dbd_SpinBox)
self.verticalLayout.addLayout(self.horizontalLayout_6)
self.horizontalLayout_12 = QtWidgets.QHBoxLayout()
self.horizontalLayout_12.setObjectName("horizontalLayout_12")
self.label_13 = QtWidgets.QLabel(self.widget)
self.label_13.setMinimumSize(QtCore.QSize(64, 27))
self.label_13.setMaximumSize(QtCore.QSize(64, 27))
self.label_13.setObjectName("label_13")
self.horizontalLayout_12.addWidget(self.label_13)
self.zl_SpinBox = QtWidgets.QDoubleSpinBox(self.widget)
self.zl_SpinBox.setMinimumSize(QtCore.QSize(109, 27))
self.zl_SpinBox.setMaximumSize(QtCore.QSize(109, 27))
self.zl_SpinBox.setMaximum(10000000.0)
self.zl_SpinBox.setSingleStep(0.1)
self.zl_SpinBox.setObjectName("zl_SpinBox")
self.horizontalLayout_12.addWidget(self.zl_SpinBox)
self.verticalLayout.addLayout(self.horizontalLayout_12)
self.horizontalLayout_11 = QtWidgets.QHBoxLayout()
self.horizontalLayout_11.setObjectName("horizontalLayout_11")
self.label_7 = QtWidgets.QLabel(self.widget)
self.label_7.setMinimumSize(QtCore.QSize(64, 27))
self.label_7.setMaximumSize(QtCore.QSize(64, 27))
self.label_7.setObjectName("label_7")
self.horizontalLayout_11.addWidget(self.label_7)
self.bhd_SpinBox = QtWidgets.QDoubleSpinBox(self.widget)
self.bhd_SpinBox.setMinimumSize(QtCore.QSize(109, 27))
self.bhd_SpinBox.setMaximumSize(QtCore.QSize(109, 27))
self.bhd_SpinBox.setMaximum(10000000.0)
self.bhd_SpinBox.setSingleStep(0.1)
self.bhd_SpinBox.setObjectName("bhd_SpinBox")
self.horizontalLayout_11.addWidget(self.bhd_SpinBox)
self.verticalLayout.addLayout(self.horizontalLayout_11)
self.closeUSBBtn = QtWidgets.QPushButton(self.frame_6)
self.closeUSBBtn.setGeometry(QtCore.QRect(10, 40, 91, 27))
self.closeUSBBtn.setObjectName("closeUSBBtn")
self.openFileBtn = QtWidgets.QPushButton(self.frame_6)
self.openFileBtn.setGeometry(QtCore.QRect(110, 10, 91, 27))
self.openFileBtn.setObjectName("openFileBtn")
self.stopFileBtn = QtWidgets.QPushButton(self.frame_6)
self.stopFileBtn.setGeometry(QtCore.QRect(160, 40, 41, 27))
self.stopFileBtn.setObjectName("stopFileBtn")
self.capBtn = QtWidgets.QPushButton(self.frame_6)
self.capBtn.setGeometry(QtCore.QRect(60, 70, 41, 27))
self.capBtn.setObjectName("capBtn")
self.faceCheckBox = QtWidgets.QCheckBox(self.frame_6)
self.faceCheckBox.setGeometry(QtCore.QRect(110, 70, 63, 29))
self.faceCheckBox.setObjectName("faceCheckBox")
self.openUSBBtn = QtWidgets.QPushButton(self.frame_6)
self.openUSBBtn.setGeometry(QtCore.QRect(10, 10, 91, 27))
self.openUSBBtn.setObjectName("openUSBBtn")
self.startFileBtn = QtWidgets.QPushButton(self.frame_6)
self.startFileBtn.setGeometry(QtCore.QRect(110, 40, 41, 27))
self.startFileBtn.setObjectName("startFileBtn")
self.luzhiBtn = QtWidgets.QPushButton(self.frame_6)
self.luzhiBtn.setGeometry(QtCore.QRect(10, 70, 41, 27))
self.luzhiBtn.setObjectName("luzhiBtn")
self.gridLayout_7.addWidget(self.frame_6, 0, 0, 1, 1)
self.info_textEdit = QtWidgets.QTextEdit(self.frame_2)
self.info_textEdit.setObjectName("info_textEdit")
self.gridLayout_7.addWidget(self.info_textEdit, 1, 0, 1, 1)
self.gridLayout_3.addWidget(self.frame_2, 0, 1, 1, 1)
self.tabWidget.addTab(self.tab, "")
self.tab_2 = QtWidgets.QWidget()
self.tab_2.setObjectName("tab_2")
self.gridLayout_4 = QtWidgets.QGridLayout(self.tab_2)
self.gridLayout_4.setObjectName("gridLayout_4")
self.frame_4 = QtWidgets.QFrame(self.tab_2)
self.frame_4.setMinimumSize(QtCore.QSize(351, 0))
self.frame_4.setMaximumSize(QtCore.QSize(351, 16777215))
self.frame_4.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frame_4.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_4.setObjectName("frame_4")
self.layoutWidget_2 = QtWidgets.QWidget(self.frame_4)
self.layoutWidget_2.setGeometry(QtCore.QRect(10, 40, 337, 28))
self.layoutWidget_2.setObjectName("layoutWidget_2")
self.horizontalLayout = QtWidgets.QHBoxLayout(self.layoutWidget_2)
self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout.setObjectName("horizontalLayout")
self.label = QtWidgets.QLabel(self.layoutWidget_2)
self.label.setObjectName("label")
self.horizontalLayout.addWidget(self.label)
self.sf_W_spinBox = QtWidgets.QSpinBox(self.layoutWidget_2)
self.sf_W_spinBox.setMinimumSize(QtCore.QSize(81, 26))
self.sf_W_spinBox.setMaximumSize(QtCore.QSize(81, 26))
self.sf_W_spinBox.setMaximum(1000000000)
self.sf_W_spinBox.setProperty("value", 100)
self.sf_W_spinBox.setObjectName("sf_W_spinBox")
self.horizontalLayout.addWidget(self.sf_W_spinBox)
self.label_3 = QtWidgets.QLabel(self.layoutWidget_2)
self.label_3.setObjectName("label_3")
self.horizontalLayout.addWidget(self.label_3)
self.sf_H_spinBox = QtWidgets.QSpinBox(self.layoutWidget_2)
self.sf_H_spinBox.setMinimumSize(QtCore.QSize(81, 26))
self.sf_H_spinBox.setMaximumSize(QtCore.QSize(81, 26))
self.sf_H_spinBox.setMaximum(1000000000)
self.sf_H_spinBox.setProperty("value", 100)
self.sf_H_spinBox.setObjectName("sf_H_spinBox")
self.horizontalLayout.addWidget(self.sf_H_spinBox)
self.layoutWidget = QtWidgets.QWidget(self.frame_4)
self.layoutWidget.setGeometry(QtCore.QRect(10, 70, 301, 28))
self.layoutWidget.setObjectName("layoutWidget")
self.horizontalLayout_4 = QtWidgets.QHBoxLayout(self.layoutWidget)
self.horizontalLayout_4.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout_4.setObjectName("horizontalLayout_4")
self.label_8 = QtWidgets.QLabel(self.layoutWidget)
self.label_8.setObjectName("label_8")
self.horizontalLayout_4.addWidget(self.label_8)
self.xz_X_spinBox = QtWidgets.QSpinBox(self.layoutWidget)
self.xz_X_spinBox.setMinimumSize(QtCore.QSize(81, 26))
self.xz_X_spinBox.setMaximumSize(QtCore.QSize(81, 26))
self.xz_X_spinBox.setMaximum(1000000000)
self.xz_X_spinBox.setProperty("value", 0)
self.xz_X_spinBox.setObjectName("xz_X_spinBox")
self.horizontalLayout_4.addWidget(self.xz_X_spinBox)
self.label_10 = QtWidgets.QLabel(self.layoutWidget)
self.label_10.setObjectName("label_10")
self.horizontalLayout_4.addWidget(self.label_10)
self.xz_Y_spinBox = QtWidgets.QSpinBox(self.layoutWidget)
self.xz_Y_spinBox.setMinimumSize(QtCore.QSize(81, 26))
self.xz_Y_spinBox.setMaximumSize(QtCore.QSize(81, 26))
self.xz_Y_spinBox.setMaximum(1000000000)
self.xz_Y_spinBox.setProperty("value", 0)
self.xz_Y_spinBox.setObjectName("xz_Y_spinBox")
self.horizontalLayout_4.addWidget(self.xz_Y_spinBox)
self.layoutWidget1 = QtWidgets.QWidget(self.frame_4)
self.layoutWidget1.setGeometry(QtCore.QRect(10, 100, 151, 28))
self.layoutWidget1.setObjectName("layoutWidget1")
self.horizontalLayout_3 = QtWidgets.QHBoxLayout(self.layoutWidget1)
self.horizontalLayout_3.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout_3.setObjectName("horizontalLayout_3")
self.label_9 = QtWidgets.QLabel(self.layoutWidget1)
self.label_9.setObjectName("label_9")
self.horizontalLayout_3.addWidget(self.label_9)
self.xz_D_spinBox = QtWidgets.QSpinBox(self.layoutWidget1)
self.xz_D_spinBox.setMaximum(360)
self.xz_D_spinBox.setObjectName("xz_D_spinBox")
self.horizontalLayout_3.addWidget(self.xz_D_spinBox)
self.frame_5 = QtWidgets.QFrame(self.frame_4)
self.frame_5.setGeometry(QtCore.QRect(0, 170, 351, 251))
self.frame_5.setMinimumSize(QtCore.QSize(351, 251))
self.frame_5.setMaximumSize(QtCore.QSize(351, 251))
self.frame_5.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frame_5.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_5.setObjectName("frame_5")
self.gridLayout_6 = QtWidgets.QGridLayout(self.frame_5)
self.gridLayout_6.setContentsMargins(2, 2, 2, 2)
self.gridLayout_6.setSpacing(1)
self.gridLayout_6.setObjectName("gridLayout_6")
self.figure_face, self.figaxes_face = plt.subplots()
# self.figure_face.subplots_adjust(left=0.01,top=0.99, right=0.98, bottom=0.01)
self.canvas_face = FigureCanvas(self.figure_face)
# self.toolbar_face = NavigationToolbar(self.canvas_face, self.tab)
# self.toolbar_face.setMinimumSize(QtCore.QSize(0, 41))
# self.toolbar_face.setMaximumSize(QtCore.QSize(16777215, 41))
self.gridLayout_6.addWidget(self.canvas_face, 0, 0, 1, 1)
self.openBtn = QtWidgets.QPushButton(self.frame_4)
self.openBtn.setGeometry(QtCore.QRect(10, 10, 71, 26))
self.openBtn.setMinimumSize(QtCore.QSize(71, 26))
self.openBtn.setMaximumSize(QtCore.QSize(71, 26))
self.openBtn.setObjectName("openBtn")
self.pushFaceBtn = QtWidgets.QPushButton(self.frame_4)
self.pushFaceBtn.setGeometry(QtCore.QRect(260, 460, 71, 25))
self.pushFaceBtn.setObjectName("pushFaceBtn")
self.cap_face_Btn = QtWidgets.QPushButton(self.frame_4)
self.cap_face_Btn.setGeometry(QtCore.QRect(260, 430, 71, 25))
self.cap_face_Btn.setObjectName("cap_face_Btn")
self.widget2 = QtWidgets.QWidget(self.frame_4)
self.widget2.setGeometry(QtCore.QRect(10, 130, 340, 33))
self.widget2.setObjectName("widget2")
self.horizontalLayout_5 = QtWidgets.QHBoxLayout(self.widget2)
self.horizontalLayout_5.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout_5.setObjectName("horizontalLayout_5")
self.spBtn = QtWidgets.QPushButton(self.widget2)
self.spBtn.setMinimumSize(QtCore.QSize(0, 26))
self.spBtn.setMaximumSize(QtCore.QSize(16777215, 26))
self.spBtn.setObjectName("spBtn")
self.horizontalLayout_5.addWidget(self.spBtn)
self.czBtn = QtWidgets.QPushButton(self.widget2)
self.czBtn.setMinimumSize(QtCore.QSize(0, 26))
self.czBtn.setMaximumSize(QtCore.QSize(16777215, 26))
self.czBtn.setObjectName("czBtn")
self.horizontalLayout_5.addWidget(self.czBtn)
self.saveBtn = QtWidgets.QPushButton(self.widget2)
self.saveBtn.setMinimumSize(QtCore.QSize(0, 26))
self.saveBtn.setMaximumSize(QtCore.QSize(16777215, 26))
self.saveBtn.setObjectName("saveBtn")
self.horizontalLayout_5.addWidget(self.saveBtn)
self.saveFaceBtn = QtWidgets.QPushButton(self.widget2)
self.saveFaceBtn.setMinimumSize(QtCore.QSize(0, 26))
self.saveFaceBtn.setMaximumSize(QtCore.QSize(16777215, 26))
self.saveFaceBtn.setObjectName("saveFaceBtn")
self.horizontalLayout_5.addWidget(self.saveFaceBtn)
self.widget3 = QtWidgets.QWidget(self.frame_4)
self.widget3.setGeometry(QtCore.QRect(180, 100, 161, 33))
self.widget3.setObjectName("widget3")
self.horizontalLayout_13 = QtWidgets.QHBoxLayout(self.widget3)
self.horizontalLayout_13.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout_13.setObjectName("horizontalLayout_13")
self.face_1_checkBox = QtWidgets.QCheckBox(self.widget3)
self.face_1_checkBox.setObjectName("face_1_checkBox")
self.horizontalLayout_13.addWidget(self.face_1_checkBox)
self.xzBtn = QtWidgets.QPushButton(self.widget3)
self.xzBtn.setMinimumSize(QtCore.QSize(41, 26))
self.xzBtn.setMaximumSize(QtCore.QSize(41, 26))
self.xzBtn.setObjectName("xzBtn")
self.horizontalLayout_13.addWidget(self.xzBtn)
self.sfBtn = QtWidgets.QPushButton(self.widget3)
self.sfBtn.setMinimumSize(QtCore.QSize(41, 26))
self.sfBtn.setMaximumSize(QtCore.QSize(41, 26))
self.sfBtn.setObjectName("sfBtn")
self.horizontalLayout_13.addWidget(self.sfBtn)
self.widget4 = QtWidgets.QWidget(self.frame_4)
self.widget4.setGeometry(QtCore.QRect(10, 430, 241, 58))
self.widget4.setObjectName("widget4")
self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.widget4)
self.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_2.setSpacing(2)
self.verticalLayout_2.setObjectName("verticalLayout_2")
self.horizontalLayout_14 = QtWidgets.QHBoxLayout()
self.horizontalLayout_14.setObjectName("horizontalLayout_14")
self.label_14 = QtWidgets.QLabel(self.widget4)
self.label_14.setObjectName("label_14")
self.horizontalLayout_14.addWidget(self.label_14)
self.ID_lineEdit = QtWidgets.QLineEdit(self.widget4)
self.ID_lineEdit.setObjectName("ID_lineEdit")
self.horizontalLayout_14.addWidget(self.ID_lineEdit)
self.verticalLayout_2.addLayout(self.horizontalLayout_14)
self.horizontalLayout_15 = QtWidgets.QHBoxLayout()
self.horizontalLayout_15.setObjectName("horizontalLayout_15")
self.label_16 = QtWidgets.QLabel(self.widget4)
self.label_16.setObjectName("label_16")
self.horizontalLayout_15.addWidget(self.label_16)
self.name_lineEdit = QtWidgets.QLineEdit(self.widget4)
self.name_lineEdit.setObjectName("name_lineEdit")
self.horizontalLayout_15.addWidget(self.name_lineEdit)
self.verticalLayout_2.addLayout(self.horizontalLayout_15)
self.gridLayout_4.addWidget(self.frame_4, 0, 0, 1, 1)
self.frame_3 = QtWidgets.QFrame(self.tab_2)
self.frame_3.setFrameShape(QtWidgets.QFrame.StyledPanel)
self.frame_3.setFrameShadow(QtWidgets.QFrame.Raised)
self.frame_3.setObjectName("frame_3")
self.gridLayout_5 = QtWidgets.QGridLayout(self.frame_3)
self.gridLayout_5.setObjectName("gridLayout_5")
self.figure_pic, self.figaxes_pic = plt.subplots()
# self.figure_pic.subplots_adjust(left=0.01,top=0.99, right=0.98, bottom=0.01)
self.canvas_pic = FigureCanvas(self.figure_pic)
self.toolbar_pic = NavigationToolbar(self.canvas_pic, self.tab)
self.toolbar_pic.setMinimumSize(QtCore.QSize(0, 41))
self.toolbar_pic.setMaximumSize(QtCore.QSize(16777215, 41))
self.gridLayout_5.addWidget(self.toolbar_pic, 0, 0, 1, 1)
self.gridLayout_5.addWidget(self.canvas_pic, 1, 0, 1, 1)
# self.widget_3 = QtWidgets.QWidget(self.frame_3)
# self.widget_3.setMinimumSize(QtCore.QSize(0, 41))
# self.widget_3.setMaximumSize(QtCore.QSize(16777215, 41))
# self.widget_3.setObjectName("widget_3")
# self.widget_4 = QtWidgets.QWidget(self.frame_3)
# self.widget_4.setObjectName("widget_4")
self.gridLayout_4.addWidget(self.frame_3, 0, 1, 1, 1)
self.tabWidget.addTab(self.tab_2, "")
self.gridLayout.addWidget(self.tabWidget, 0, 0, 1, 1)
self.retranslateUi(Form)
self.tabWidget.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(Form)
def run(self, data):
print('processing ', data['regime name'])
output = {}
# vectorise skalar functions
vSubt = np.vectorize(self.subt)
# calculate data-sets
t = data['results']['simTime']
xm = []
xo = []
e = []
for i in range(4):
xm.append(data['results']['model_output.' + str(i)])
xo.append(data['results']['observer_output.' + str(i)])
e.append(vSubt(xo[i], xm[i]))
# plots
fig = Figure()
fig.subplots_adjust(wspace=0.3, hspace=0.25)
axes = []
for i in range(4):
axes.append(fig.add_subplot(5, 1, i + 1))
axes[i].plot(t, xo[i], c='b', ls='-', label='xo[' + str(i) + ']')
axes[i].plot(t, xm[i], c='k', ls='-', label='xm[' + str(i) + ']')
axes[i].set_xlim(left=0, right=t[-1])
axes.append(fig.add_subplot(5, 1, 5))
leg = []
for i in range(4):
axes[4].plot(t, e[i], ls='-', label='e[' + str(i) + ']')
leg.append('e[' + str(i) + ']')
axes[4].legend(leg, loc=0, fontsize='small')
# calculate results
# L1
dt = 1.0 / data['modules']['solver']['measure rate']
errorIntegrals = [0, 0, 0, 0]
# check for sim success
if not data['results']['finished']:
for key in output.keys():
output[key] = None
for i in range(len(errorIntegrals)):
for k, val in enumerate(xo[i]):
# vgl. Betragskriterium L^1
errorIntegrals[i] += 1
errorIntegrals[i] += abs(val - xm[i][k]) * dt
print('errorIntegral_x[' + str(i) + ']:', errorIntegrals[i])
output.update(
{'error_L1Norm_x[' + str(i) + ']': errorIntegrals[i]})
# add settings and metrics to dictionary results
results = {}
results.update({'metrics': output})
results.update({'modules': data['modules']})
canvas = FigureCanvas(fig)
self.writeOutputFiles(self.name, data["regime name"], fig, results)
return dict(name="_".join({data["regime name"], self.name}),
figure=canvas)
def process(self, files):
print('processing ', self.name)
# reset counter
self.counter = 0
# dict for calculated values
# output = {}
yd = 0
# create plot
fig = Figure()
axes = fig.add_subplot(111)
axes.set_title(r'Sprungantworten')
# search t max
t_max = 0
for data in files:
t = data['modules']['solver']['end time']
if t > t_max:
t_max = t
axes.set_xlim(left=0, right=t_max)
axes.set_ylim(0, 4, 5)
axes.set_xlabel(r'\textit{Zeit [s]}')
axes.set_ylabel(r'\textit{Ballposition r(t) [m]}')
controllerName = []
# create plots
counter = 0
for data in files:
# print data['modules']
# print data['regime name']
# print data['results']['finished']
# calculate data-sets
t = data['results']['simTime']
y = data['results']['model_output.0']
yd = data['results']['trajectory_output.0'][-1]
controllerName.append(data['modules']['controller']['type'])
axes.plot(t,
y,
label=r'$r_{0} = ' +
str(data['modules']['controller']['r0']) + '$',
c=mpl.rcParams['axes.color_cycle'][counter])
counter += 1
# check for sim success
# if not data['results']['finished']:
# for key in output.keys():
# output[key] = None
# self.posLabel = np.arange(np.min(y) + 0.1*yd, yd, (yd-np.min(y))/4)
# plot legend
axes.legend()
# create desired line
desiredLine = Line2D([0, t[-1]], [yd, yd],
lw=1,
ls=self.line_style,
c='k')
axes.add_line(desiredLine)
# create epsilon tube
upperBoundLine = Line2D([0, t[-1]], [yd + st.R, yd + st.R],
ls='--',
c=self.line_color)
axes.add_line(upperBoundLine)
lowerBoundLine = Line2D([0, t[-1]], [yd - st.R, yd - st.R],
ls='--',
c=self.line_color)
axes.add_line(lowerBoundLine)
# #calc control deviation
# control_deviation = y[-1] - yd
# output.update({'control_deviation': control_deviation})
# self.calcMetrics(data, output)
# add settings and metrics to dictionary results
results = {}
# results.update({'metrics': output})
# results.update({'modules': data['modules']})
canvas = FigureCanvas(fig)
self.writeOutputFiles(self.name, 'steps_in_one_plot', fig, results)
return [{
'name': '_'.join([controllerName[0], self.name]),
'figure': canvas
}]
def process(self, dataList):
print('process() of C2 called')
output = []
for cName in st.smoothPoles.keys():
# check whether controller was in result files
t = [None, None]
t[0] = self.extractValues(dataList, [cName, '_unlimited'],
'simTime')
t[1] = self.extractValues(dataList, [cName, '_limited'], 'simTime')
if not (t[0] and t[1]):
continue
timeIdx = 0
if len(t[1]) > len(t[0]):
# limited controller lastet longer
timeIdx = 1
print('found entry of ', cName)
# get curves
r = [None, None]
y = [None, None]
ydes = [None, None]
r[0] = self.extractValues(dataList, [cName, '_unlimited'],
'controller_output.0')
r[1] = self.extractValues(dataList, [cName, '_limited'],
'controller_output.0')
l = self.extractValues(dataList, [cName, '_limited'],
'limiter_output.0')
ydes[0] = self.extractValues(dataList, [cName, '_unlimited'],
'trajectory_output.0')
ydes[1] = self.extractValues(dataList, [cName, '_limited'],
'trajectory_output.0')
ydEnd = ydes[timeIdx][-1]
y[0] = self.extractValues(dataList, [cName, '_unlimited'],
'model_output.0')
y[1] = self.extractValues(dataList, [cName, '_limited'],
'model_output.0')
# get settings
limits = self.extractSetting(dataList, [cName, '_limited'],
'limiter', 'limits')
eps = st.R
# create plot
fig = Figure()
fig.subplots_adjust(hspace=0.4)
axes = []
# fig1 controller output
axes.append(fig.add_subplot(211))
axes[0].set_title("Reglerausgänge im Vergleich")
# create limitation tube
upperBoundLine = Line2D([0, t[timeIdx][-1]], [limits[0]] * 2,
ls='--',
c=self.line_color)
axes[0].add_line(upperBoundLine)
lowerBoundLine = Line2D([0, t[timeIdx][-1]], [limits[1]] * 2,
ls='--',
c=self.line_color)
axes[0].add_line(lowerBoundLine)
axes[0].plot(t[0],
r[0],
c='limegreen',
ls='-',
label='r(t) unlimitriert')
axes[0].plot(t[1],
r[1],
c='indianred',
ls='-',
label='r(t) limitiert')
# customize
axes[0].set_xlim(left=0, right=t[timeIdx][-1])
# axes.set_ylim(bottom=(self.offset+yd*(1-self.padding/2)),\
# top=(self.offset+yd*(1+self.padding)))
axes[0].legend(loc=0, fontsize='small')
axes[0].set_xlabel(r'$t \, \lbrack s \rbrack$')
axes[0].set_ylabel(r'$\tau \, \lbrack Nm \rbrack$')
# fig2 model output
axes.append(fig.add_subplot(212))
axes[1].set_title("Ausgangsverläufe im Vergleich")
# create epsilon tube
upperBoundLine = Line2D([0, t[timeIdx][-1]],
[ydEnd + eps, ydEnd + eps],
ls='--',
c=self.line_color)
axes[1].add_line(upperBoundLine)
lowerBoundLine = Line2D([0, t[timeIdx][-1]],
[ydEnd - eps, ydEnd - eps],
ls='--',
c=self.line_color)
axes[1].add_line(lowerBoundLine)
axes[1].plot(t[timeIdx],
ydes[timeIdx],
c='b',
ls='-',
label='w(t)')
axes[1].plot(t[0],
y[0],
c='limegreen',
ls='-',
label='y(t) unlimitriert')
axes[1].plot(t[1],
y[1],
c='indianred',
ls='-',
label='y(t) limitiert')
# customize
axes[1].set_xlim(left=0, right=t[timeIdx][-1])
# axes.set_ylim(bottom=(self.offset+yd*(1-self.padding/2)),\
# top=(self.offset+yd*(1+self.padding)))
axes[1].legend(loc=0, fontsize='small')
axes[1].set_xlabel(r'$t \, \lbrack s \rbrack$')
axes[1].set_ylabel(r'$r \, \lbrack m \rbrack$')
canvas = FigureCanvas(fig)
# create output files because run is not called
data_sets = [
dataSet for dataSet in dataList
if cName in dataSet['regime name']
]
for data in data_sets:
results = {}
results.update({'metrics': {}})
self.calcMetrics(data, results['metrics'])
# add settings and metrics to dictionary results
results.update({'modules': data['modules']})
if '_unlimited' in data['regime name']:
appendix = '_unlimited'
else:
appendix = '_limited'
self.writeOutputFiles(self.name, data['regime name'], fig,
results)
output.append({'name': '_'.join([cName, self.name]), \
'figure': canvas})
return output
def process(self, dataList):
print('process() of B called')
output = {}
# ideal regime name
regName = next((result['regime name'] \
for result in dataList if 'ideal' in result['regime name']), None)
# extract the needed curves
t = self.extractValues(dataList, 'ideal', 'simTime')
y_ideal = self.extractValues(dataList, 'ideal', 'model_output.0')
y_desired = self.extractValues(dataList, 'ideal',
'trajectory_output.0')
yd = y_desired[-1]
y_pTolMin = self.extractValues(dataList, 'paramTolMin',
'model_output.0')
y_pTolMax = self.extractValues(dataList, 'paramTolMax',
'model_output.0')
par = next(
(param for param in st.paramVariationListB if param in regName),
None)
print('assuming that', par, 'has been varied.')
# sort files by variied parameter
modDataList = sorted(dataList,
key=lambda k: k['modules']['model'][par],
reverse=False)
# find minimal stable iteration
resAbsMin = next((res \
for res in modDataList if res['results']['finished']), None)
y_pAbsMin = resAbsMin['results']['model_output.0']
# find maximum stable iteration
resAbsMax = next((res \
for res in reversed(modDataList) if res['results']['finished']), None)
y_pAbsMax = resAbsMax['results']['model_output.0']
# print len(y_pAbsMin), len(y_pAbsMax), len(y_ideal)
print('stablity limits are:', \
resAbsMin['modules']['model'][par], '/', resAbsMax['modules']['model'][par])
output.update({'parameter': par, \
'minLimit': resAbsMin['modules']['model'][par], \
'maxLimit': resAbsMax['modules']['model'][par], \
})
# create plot
fig = Figure()
axes = fig.add_subplot(111)
axes.set_title('Vergleich Signalverläufe')
# create epsilon tub
# eps = self.epsPercent*yd/100
eps = st.R
upperBoundLine = Line2D([0, t[-1]], [yd + eps, yd + eps],
ls='--',
c=self.line_color)
axes.add_line(upperBoundLine)
lowerBoundLine = Line2D([0, t[-1]], [yd - eps, yd - eps],
ls='--',
c=self.line_color)
axes.add_line(lowerBoundLine)
# create signals
axes.add_line(lowerBoundLine)
axes.plot(t, y_desired, c='b', ls='-', label='w(t)')
axes.plot(t, y_ideal, c='limegreen', ls='-', label='exakter Wert')
axes.plot(t,
y_pTolMin,
c='indianred',
ls='-',
label='untere Toleranzgrenze')
axes.plot(t,
y_pTolMax,
c='darkorange',
ls='-',
label='obere Toleranzgrenze')
# axes.plot(t, y_pAbsMin, c='orange', ls='-', label='untere Stabilitaetsgrenze')
# axes.plot(t, y_pAbsMax, c='r', ls='-', label='obere Stabilitaetsgrenze')
# customize
axes.set_xlim(left=0, right=t[-1])
# axes.set_ylim(bottom=(self.offset+yd*(1-self.padding/2)),\
# top=(self.offset+yd*(1+self.padding)))
axes.legend(loc=0, fontsize='small')
axes.set_xlabel(r'$t \, \lbrack s \rbrack$')
axes.set_ylabel(r'$r \, \lbrack m \rbrack$')
canvas = FigureCanvas(fig)
extendedName = os.path.join(self.name, par)
# create output files because run is not called
for data in dataList:
results = {}
results.update({'metrics': {}})
self.calcMetrics(data, results['metrics'])
# add settings and metrics to dictionary results
results.update({'modules': data['modules']})
self.writeOutputFiles(extendedName, data['regime name'], None,
results)
results = {'metrics': output}
# create new dir for parameter
self.writeOutputFiles(extendedName, 'paramLimits_' + regName[:-len('ideal')], \
fig, results)
return [{'name': '_'.join([regName[:-len('ideal')], 'paramLimits', self.name]), \
'figure': canvas}]
def initWidgets(self):
btnCol = QPushButton('Wybierz kolor', self) #przycisk
btn = QPushButton('Rysuj', self)
btnsave = QPushButton('Zapisz wynik', self)
xaLabel = QLabel('Xa', self) #sluzy nad do podpisywania
yaLabel = QLabel('Ya', self)
xbLabel = QLabel('Xb', self)
ybLabel = QLabel('Yb', self)
xcLabel = QLabel('Xc', self)
ycLabel = QLabel('Yc', self)
xdLabel = QLabel('Xd', self)
ydLabel = QLabel('Yd', self)
xpLabel = QLabel('Xp', self)
ypLabel = QLabel('Yp', self)
NAPISLabel = QLabel('Gdzie się znajduję punkt ?', self)
self.xpEdit = QLineEdit() #pole w ktorym wpisujemy tekst badz liczbe
self.ypEdit = QLineEdit()
self.xaEdit = QLineEdit()
self.yaEdit = QLineEdit()
self.xbEdit = QLineEdit()
self.ybEdit = QLineEdit()
self.xcEdit = QLineEdit()
self.ycEdit = QLineEdit()
self.xdEdit = QLineEdit()
self.ydEdit = QLineEdit()
self.NAPISEdit = QLineEdit()
resultLabel = QLabel('', self)
#wykres
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
grid = QGridLayout() #tworzenie siatki
grid.addWidget(xaLabel, 2, 0) #2wiersz 0 kolumna
grid.addWidget(self.xaEdit, 2, 1)
grid.addWidget(yaLabel, 3, 0)
grid.addWidget(self.yaEdit, 3, 1)
grid.addWidget(xbLabel, 4, 0)
grid.addWidget(self.xbEdit, 4, 1)
grid.addWidget(ybLabel, 5, 0)
grid.addWidget(self.ybEdit, 5, 1)
grid.addWidget(xcLabel, 6, 0)
grid.addWidget(self.xcEdit, 6, 1)
grid.addWidget(ycLabel, 7, 0)
grid.addWidget(self.ycEdit, 7, 1)
grid.addWidget(xdLabel, 8, 0)
grid.addWidget(self.xdEdit, 8, 1)
grid.addWidget(xpLabel, 10, 0)
grid.addWidget(self.xpEdit, 10, 1, 1, 2)
grid.addWidget(ypLabel, 11, 0)
grid.addWidget(self.ypEdit, 11, 1, 1, 2)
grid.addWidget(NAPISLabel, 12, 0)
grid.addWidget(self.NAPISEdit, 13, 0, 1, 4)
grid.addWidget(ydLabel, 9, 0)
grid.addWidget(self.ydEdit, 9, 1)
grid.addWidget(
btn, 14, 0, 1, 2
) #czternasty wiersz, zerowa kolumna, rozciaga sie na jeden wiersz i dwie kolumny
grid.addWidget(btnCol, 15, 0, 1, 2)
grid.addWidget(btnsave, 16, 0, 1, 2)
grid.addWidget(resultLabel, 17, 0)
grid.addWidget(self.canvas, 1, 7, -1, -1)
self.setLayout(grid)
btn.clicked.connect(
self.oblicz
) #przycisk ktory za pomoca klikniecia wywoluje sygnal ktory w dalszej czesci cos robi
btnCol.clicked.connect(self.zmienKolor)
btnsave.clicked.connect(self.zapisz)
class ProgressViewer(QtWidgets.QMainWindow):
'''GUI to track progress of EMC reconstruction
Shows orthogonal volumes slices, plots of metrics vs iteration and log file
Can periodically poll log file for updates and automatically update plots
Can also be used to view slices through other 3D volumes using the '-f' option
'''
def __init__(self, config='config.ini', model=None):
super(ProgressViewer, self).__init__()
self.config = config
self.model_name = model
self.max_iternum = 0
plt.style.use('dark_background')
self.beta_change = self.num_rot_change = []
self.checker = QtCore.QTimer(self)
self._read_config(config)
self._init_ui()
if model is not None:
self._parse_and_plot()
self.old_fname = self.fname.text()
def _init_ui(self):
with open(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'py_src/style.css'), 'r') as f:
self.setStyleSheet(f.read())
self.setWindowTitle('Dragonfly Progress Viewer')
self.setGeometry(100, 100, 1600, 800)
overall = QtWidgets.QWidget()
self.setCentralWidget(overall)
layout = QtWidgets.QHBoxLayout(overall)
layout.setContentsMargins(0, 0, 0, 0)
self._init_menubar()
plot_splitter = self._init_plotarea()
options_widget = self._init_optionsarea()
main_splitter = QtWidgets.QSplitter(QtCore.Qt.Horizontal)
main_splitter.setObjectName('frame')
layout.addWidget(main_splitter)
main_splitter.addWidget(plot_splitter)
main_splitter.addWidget(options_widget)
self.show()
def _init_menubar(self):
menubar = self.menuBar()
menubar.setNativeMenuBar(False)
# File Menu
filemenu = menubar.addMenu('&File')
action = QtWidgets.QAction('&Load Volume', self)
action.triggered.connect(self._load_volume)
filemenu.addAction(action)
action = QtWidgets.QAction('&Save Image', self)
action.triggered.connect(self._save_plot)
filemenu.addAction(action)
action = QtWidgets.QAction('Save Log &Plot', self)
action.triggered.connect(self._save_log_plot)
filemenu.addAction(action)
action = QtWidgets.QAction('&Quit', self)
action.triggered.connect(self.close)
filemenu.addAction(action)
# Color map picker
cmapmenu = menubar.addMenu('&Color Map')
self.color_map = QtWidgets.QActionGroup(self, exclusive=True)
for i, cmap in enumerate(['coolwarm', 'cubehelix', 'CMRmap', 'gray', 'gray_r', 'jet']):
action = self.color_map.addAction(QtWidgets.QAction(cmap, self, checkable=True))
if i == 0:
action.setChecked(True)
action.triggered.connect(self._cmap_changed)
cmapmenu.addAction(action)
def _init_plotarea(self):
plot_splitter = QtWidgets.QSplitter(QtCore.Qt.Vertical)
plot_splitter.setObjectName('plots')
# Volume slices figure
self.fig = matplotlib.figure.Figure(figsize=(14, 5))
self.fig.subplots_adjust(left=0.0, bottom=0.00, right=0.99, wspace=0.0)
#self.fig.set_facecolor('#232629')
self.fig.set_facecolor('#112244')
self.canvas = FigureCanvas(self.fig)
self.canvas.show()
plot_splitter.addWidget(self.canvas)
self.vol_plotter = VolumePlotter(self.fig, self.recon_type, self.num_modes)
self.need_replot = self.vol_plotter.need_replot
# Progress plots figure
self.log_fig = matplotlib.figure.Figure(figsize=(14, 5), facecolor='w')
#self.log_fig.set_facecolor('#232629')
self.log_fig.set_facecolor('#112244')
self.plotcanvas = FigureCanvas(self.log_fig)
self.plotcanvas.show()
plot_splitter.addWidget(self.plotcanvas)
self.log_plotter = LogPlotter(self.log_fig, self.folder)
return plot_splitter
def _init_optionsarea(self):
options_widget = QtWidgets.QWidget()
vbox = QtWidgets.QVBoxLayout()
options_widget.setLayout(vbox)
# -- Log file
hbox = QtWidgets.QHBoxLayout()
vbox.addLayout(hbox)
label = QtWidgets.QLabel('Log file name:', self)
hbox.addWidget(label)
self.logfname = QtWidgets.QLineEdit(self.logfname, self)
self.logfname.setMinimumWidth(160)
hbox.addWidget(self.logfname)
label = QtWidgets.QLabel('VRange:', self)
hbox.addWidget(label)
self.rangemin = QtWidgets.QLineEdit('0', self)
self.rangemin.setFixedWidth(48)
self.rangemin.returnPressed.connect(self._range_changed)
hbox.addWidget(self.rangemin)
self.rangestr = QtWidgets.QLineEdit('1', self)
self.rangestr.setFixedWidth(48)
self.rangestr.returnPressed.connect(self._range_changed)
hbox.addWidget(self.rangestr)
# -- Volume file
hbox = QtWidgets.QHBoxLayout()
vbox.addLayout(hbox)
label = QtWidgets.QLabel('File name:', self)
hbox.addWidget(label)
if self.model_name is None:
self.fname = QtWidgets.QLineEdit(self.folder+'/output/intens_001.bin', self)
else:
self.fname = QtWidgets.QLineEdit(self.model_name, self)
self.fname.setMinimumWidth(160)
hbox.addWidget(self.fname)
label = QtWidgets.QLabel('Exp:', self)
hbox.addWidget(label)
self.expstr = QtWidgets.QLineEdit('1', self)
self.expstr.setFixedWidth(48)
self.expstr.returnPressed.connect(self._range_changed)
hbox.addWidget(self.expstr)
# -- Sliders
hbox = QtWidgets.QHBoxLayout()
vbox.addLayout(hbox)
label = QtWidgets.QLabel('Layer num.', self)
hbox.addWidget(label)
self.layer_slider = QtWidgets.QSlider(QtCore.Qt.Horizontal, self)
self.layer_slider.setRange(0, 200)
self.layer_slider.sliderMoved.connect(self._layerslider_moved)
self.layer_slider.sliderReleased.connect(self._layernum_changed)
hbox.addWidget(self.layer_slider)
self.layernum = MySpinBox(self)
self.layernum.setValue(self.layer_slider.value())
self.layernum.setMinimum(0)
self.layernum.setMaximum(200)
self.layernum.valueChanged.connect(self._layernum_changed)
self.layernum.editingFinished.connect(self._layernum_changed)
self.layernum.setFixedWidth(48)
hbox.addWidget(self.layernum)
hbox = QtWidgets.QHBoxLayout()
vbox.addLayout(hbox)
label = QtWidgets.QLabel('Iteration', self)
hbox.addWidget(label)
self.iter_slider = QtWidgets.QSlider(QtCore.Qt.Horizontal, self)
self.iter_slider.setRange(0, 1)
self.iter_slider.sliderMoved.connect(self._iterslider_moved)
self.iter_slider.sliderReleased.connect(self._iternum_changed)
hbox.addWidget(self.iter_slider)
self.iternum = MySpinBox(self)
self.iternum.setValue(self.iter_slider.value())
self.iternum.setMinimum(0)
self.iternum.setMaximum(1)
self.iternum.valueChanged.connect(self._iternum_changed)
self.iternum.editingFinished.connect(self._iternum_changed)
self.iternum.setFixedWidth(48)
hbox.addWidget(self.iternum)
if self.num_modes > 1:
hbox = QtWidgets.QHBoxLayout()
vbox.addLayout(hbox)
label = QtWidgets.QLabel('Mode', self)
hbox.addWidget(label)
self.mode_slider = QtWidgets.QSlider(QtCore.Qt.Horizontal, self)
self.mode_slider.setRange(0, self.num_modes-1)
self.mode_slider.sliderMoved.connect(self._modeslider_moved)
self.mode_slider.sliderReleased.connect(self._modenum_changed)
hbox.addWidget(self.mode_slider)
self.modenum = MySpinBox(self)
self.modenum.setValue(self.iter_slider.value())
self.modenum.setMinimum(0)
self.modenum.setMaximum(self.num_modes-1)
self.modenum.valueChanged.connect(self._modenum_changed)
self.modenum.editingFinished.connect(self._modenum_changed)
self.modenum.setFixedWidth(48)
hbox.addWidget(self.modenum)
self.old_modenum = self.modenum.value()
# -- Buttons
hbox = QtWidgets.QHBoxLayout()
vbox.addLayout(hbox)
button = QtWidgets.QPushButton('Check', self)
button.clicked.connect(self._check_for_new)
hbox.addWidget(button)
self.ifcheck = QtWidgets.QCheckBox('Keep checking', self)
self.ifcheck.stateChanged.connect(self._keep_checking)
self.ifcheck.setChecked(False)
hbox.addWidget(self.ifcheck)
hbox.addStretch(1)
hbox = QtWidgets.QHBoxLayout()
vbox.addLayout(hbox)
hbox.addStretch(1)
button = QtWidgets.QPushButton('Plot', self)
button.clicked.connect(self._parse_and_plot)
hbox.addWidget(button)
button = QtWidgets.QPushButton('Reparse', self)
button.clicked.connect(self._force_plot)
hbox.addWidget(button)
button = QtWidgets.QPushButton('Quit', self)
button.clicked.connect(self.close)
hbox.addWidget(button)
# -- Log file display
log_area = QtWidgets.QScrollArea(self)
vbox.addWidget(log_area)
log_area.setMinimumWidth(300)
log_area.setWidgetResizable(True)
self.emclog_text = QtWidgets.QTextEdit(
'Press \'Check\' to synchronize with log file<br>'
'Select \'Keep Checking\' to periodically synchronize<br><br>'
'The top half of the display area will show three orthogonal<br>'
'slices of the 3D volume. The bottom half will show plots of<br>'
'various parameters vs iteration.', self)
self.emclog_text.setReadOnly(True)
self.emclog_text.setFontPointSize(8)
self.emclog_text.setFontFamily('Courier')
self.emclog_text.setFontWeight(QtGui.QFont.DemiBold)
self.emclog_text.setTabStopWidth(22)
self.emclog_text.setLineWrapMode(QtWidgets.QTextEdit.NoWrap)
self.emclog_text.setObjectName('logtext')
log_area.setWidget(self.emclog_text)
return options_widget
def _layernum_changed(self, value=None):
if value is None:
# Slider released or editing finished
self.need_replot = True
elif value == self.layernum.value():
self.layer_slider.setValue(value)
self._parse_and_plot()
def _layerslider_moved(self, value):
self.layernum.setValue(value)
def _iternum_changed(self, value=None):
if value is None:
self.fname.setText(self.folder+'/output/intens_%.3d.bin' % self.iternum.value())
elif value == self.iternum.value():
self.iter_slider.setValue(value)
if self.need_replot:
self.fname.setText(self.folder+'/output/intens_%.3d.bin' % value)
self._parse_and_plot()
def _iterslider_moved(self, value):
self.iternum.setValue(value)
def _modenum_changed(self, value=None):
if value == self.modenum.value():
self.mode_slider.setValue(value)
self._parse_and_plot()
def _modeslider_moved(self, value):
self.modenum.setValue(value)
def _range_changed(self):
self.need_replot = True
def _read_config(self, config):
try:
self.folder = read_config.get_filename(config, 'emc', 'output_folder')
except read_config.configparser.NoOptionError:
self.folder = 'data/'
try:
self.logfname = read_config.get_filename(config, 'emc', 'log_file')
except read_config.configparser.NoOptionError:
self.logfname = 'EMC.log'
try:
self.recon_type = read_config.get_param(config, 'emc', 'recon_type').lower()
except read_config.configparser.NoOptionError:
self.recon_type = '3d'
try:
self.num_modes = int(read_config.get_param(config, 'emc', 'num_modes'))
except read_config.configparser.NoOptionError:
self.num_modes = 1
def _update_layers(self, size, center):
self.layer_slider.setRange(0, size-1)
self.layernum.setMaximum(size-1)
self.layer_slider.setValue(center)
self._layerslider_moved(center)
def _plot_vol(self, num=None):
if num is None:
num = int(self.layernum.text())
self.vol_plotter.plot(num,
(float(self.rangemin.text()),
float(self.rangestr.text())),
float(self.expstr.text()),
self.color_map.checkedAction().text())
if self.recon_type == '2d':
self.canvas.mpl_connect('button_press_event', self._select_mode)
def _parse_and_plot(self):
if not self.vol_plotter.image_exists or self.old_fname != self.fname.text():
self.old_fname, size, center = self.vol_plotter.parse(self.fname.text())
self._update_layers(size, center)
self._plot_vol()
elif self.num_modes > 1 and self.modenum.value() != self.old_modenum:
self.old_fname, size, center = self.vol_plotter.parse(self.fname.text(),
modenum=self.modenum.value())
self._update_layers(size, center)
self._plot_vol()
elif self.need_replot:
self._plot_vol()
else:
pass
def _check_for_new(self):
with open(self.logfname.text(), 'r') as fptr:
last_line = fptr.readlines()[-1].rstrip().split()
try:
iteration = int(last_line[0])
except ValueError:
iteration = 0
if iteration > 0 and self.max_iternum != iteration:
self.fname.setText(self.folder+'/output/intens_%.3d.bin' % iteration)
self.max_iternum = iteration
self.iter_slider.setRange(0, self.max_iternum)
self.iternum.setMaximum(self.max_iternum)
self.iter_slider.setValue(iteration)
self._iterslider_moved(iteration)
log_text = self.log_plotter.plot(self.logfname.text(),
self.color_map.checkedAction().text())
self._parse_and_plot()
self.emclog_text.setText(log_text)
def _keep_checking(self):
if self.ifcheck.isChecked():
self._check_for_new()
self.checker.timeout.connect(self._check_for_new)
self.checker.start(5000)
else:
self.checker.stop()
def _select_mode(self, event):
curr_mode = -1
for i, subp in enumerate(self.vol_plotter.subplot_list):
if event.inaxes is subp:
curr_mode = i
if curr_mode >= 0 and curr_mode != self.layernum.value():
self.layer_slider.setValue(curr_mode)
self.layernum.setValue(curr_mode)
self._plot_vol(curr_mode)
def _force_plot(self):
self.old_fname, size, center = self.vol_plotter.parse(self.fname.text())
self._update_layers(size, center)
self._plot_vol()
def _load_volume(self):
fname, _ = QtWidgets.QFileDialog.getOpenFileName(self, 'Load 3D Volume',
'data/', 'Binary data (*.bin)')
if fname:
self.fname.setText(fname)
self._parse_and_plot()
def _save_plot(self):
default_name = 'images/'+os.path.splitext(os.path.basename(self.fname.text()))[0]+'.png'
fname, _ = QtWidgets.QFileDialog.getSaveFileName(self, 'Save Volume Image',
default_name, 'Image (*.png)')
if fname:
self.fig.savefig(fname, bbox_inches='tight', dpi=120)
sys.stderr.write('Saved to %s\n'%fname)
def _save_log_plot(self):
default_name = 'images/log_fig.png'
fname, _ = QtWidgets.QFileDialog.getSaveFileName(self, 'Save Log Plots',
default_name, 'Image (*.png)')
if fname:
self.log_fig.savefig(fname, bbox_inches='tight', dpi=120)
sys.stderr.write("Saved to %s\n"%fname)
def _cmap_changed(self):
if self.vol_plotter.image_exists:
self.need_replot = True
self._parse_and_plot()
def keyPressEvent(self, event): # pylint: disable=C0103
'''Override of default keyPress event handler'''
key = event.key()
mod = int(event.modifiers())
if key == QtCore.Qt.Key_Return or key == QtCore.Qt.Key_Enter:
self._parse_and_plot()
elif QtGui.QKeySequence(mod+key) == QtGui.QKeySequence('Ctrl+Q'):
self.close()
elif QtGui.QKeySequence(mod+key) == QtGui.QKeySequence('Ctrl+S'):
self._save_plot()
else:
event.ignore()
def run(self, data):
results = {}
output = {}
print('processing ', data['regime name'])
# calculate data-sets
t = data['results']['simTime']
yd = data['results']['trajectory_output.0']
y = []
for i in range(4):
y.append(data['results']['model_output.' + str(i)])
error = np.subtract(yd, y[0])
# controlleroutput is a torque
tau = data['results']['controller_output.0']
# u in the neglected nonlinearity is theta_dd
u = np.true_divide( \
np.subtract( \
np.subtract( \
tau, \
np.multiply( \
np.multiply( \
np.multiply( \
2 * st.M, \
y[0] \
), \
y[1] \
), \
y[3] \
) \
), \
np.multiply( \
st.M * st.G, \
np.multiply( \
y[0], \
np.cos(y[2]) \
) \
) \
), \
np.add(
np.multiply( \
st.M, \
np.power(y[0], 2) \
), \
st.J + st.Jb \
) \
)
# Parameter from Controller -> modelling (estimate/meausre paramters)
# and then neglect psi therm
# if you are interested in the error through the negligence
if data['modules']['controller']['type'] == 'FController':
psi = np.multiply(np.multiply(st.B, y[0]), np.power(y[3], 2))
elif data['modules']['controller']['type'] == 'GController':
psi = np.multiply(np.multiply(np.dot(2 * st.B, y[0]), y[3]), u)
elif data['modules']['controller']['type'] == 'JController':
psi = np.multiply(np.multiply(np.multiply(st.B, y[0]), np.power(y[3], 2)), \
np.multiply(st.B * st.G, np.subtract(y[2], np.sin(y[2]))))
else:
# psi is not defined in this case
psi = np.dot(0, t)
# plots
fig = Figure()
fig.subplots_adjust(wspace=0.3, hspace=0.25)
axes1 = fig.add_subplot(2, 2, 1)
# axes1.set_title(r'\textbf{output error = yd - x0}')
axes1.plot(t, error, c='k')
axes1.set_xlim(left=0, right=t[-1])
axes1.set_xlabel(r'$t \,[s]$', size=st.label_size)
axes1.set_ylabel(r'$e \,[m]$', size=st.label_size)
axes2 = fig.add_subplot(2, 2, 2)
# axes2.set_title(r'\textbf{Beam Angle}')
axes2.plot(t, y[2], c='k')
axes2.set_xlim(left=0, right=t[-1])
axes2.set_xlabel(r'$t \, [s]$', size=st.label_size)
axes2.set_ylabel(r'$\theta \, [rad]$', size=st.label_size)
axes3 = fig.add_subplot(2, 2, 3)
# axes3.set_title(r'\textbf{neglected nonlinearity}')
axes3.plot(t, psi, c='k')
axes3.set_xlim(left=0, right=t[-1])
axes3.set_xlabel(r'$t [s]$', size=st.label_size)
if data['modules']['controller']['type'] == 'FController':
axes3.set_ylabel(r'$\psi_2 \, [\frac{m}{s^2}]$',
size=st.label_size)
if data['modules']['controller']['type'] == 'JController':
axes3.set_ylabel(r'$\psi_2 \, [\frac{m}{s^2}]$',
size=st.label_size)
if data['modules']['controller']['type'] == 'GController':
axes3.set_ylabel(r'$\psi_3 \, [\frac{m}{s^3}]$',
size=st.label_size)
axes4 = fig.add_subplot(2, 2, 4)
# axes4.set_title(r'\textbf{Beam Torque}')
axes4.plot(t, tau, c='k')
axes4.set_xlim(left=0, right=t[-1])
axes4.set_xlabel(r'$t \,[s]$', size=st.label_size)
axes4.set_ylabel(r'$\tau \,[Nm]$', size=st.label_size)
# calculate maximumError
start = 30
end = 40
tStartIdx = next((idx for idx, x in enumerate(t) if x >= start), 0)
tEndIdx = next((idx for idx, x in enumerate(t[start:]) if x >= end),
len(t) - 1)
maximumError = None
if tStartIdx < tEndIdx:
maximumError = max(error[tStartIdx:tEndIdx])
print('maximum error between %d and %d seconds: %f' % \
(start, end, maximumError))
# collect results
output.update({'maximumError': maximumError})
# check for sim succes
if not data['results']['finished']:
for key in list(output.keys()):
output[key] = None
results.update({'metrics': output})
results.update({'modules': data['modules']})
# write results
filePath = os.path.join(os.path.pardir, 'results', 'postprocessing',
'HauserDiagrams')
if not os.path.isdir(filePath):
os.makedirs(filePath)
fileName = os.path.join(filePath, data['regime name'])
with open(fileName + '.pof',
'w') as f: # POF - Postprocessing Output File
f.write(repr(results))
canvas = FigureCanvas(fig)
fig.savefig(fileName + '.svg')
fig.savefig(fileName + '.png')
fig.savefig(fileName + '.pdf')
return {'name': '_'.join([data['regime name'], self.name]), \
'figure': canvas}
class FramePanel(QtWidgets.QWidget):
'''GUI panel containing frame display widget
Can scroll through frames of parent's EMCReader object
Other parameters:
compare - Side-by-side view of frames and best guess tomograms from reconstruction
powder - Show sum of all frames
Required members of parent class:
emc_reader - Instance of EMCReader class
geom - Instance of DetReader class
output_folder - (Only for compare mode) Folder with output data
need_scaling - (Only for compare mode) Whether reconstruction was done with scaling
'''
def __init__(self, parent, compare=False, powder=False, **kwargs):
super(FramePanel, self).__init__(**kwargs)
matplotlib.rcParams.update({
'text.color': '#eff0f1',
'xtick.color': '#eff0f1',
'ytick.color': '#eff0f1',
'axes.labelcolor': '#eff0f1',
#'axes.facecolor': '#232629',
#'figure.facecolor': '#232629'})
'axes.facecolor': '#2a2a2f',
'figure.facecolor': '#2a2a2f'})
self.parent = parent
self.emc_reader = self.parent.emc_reader
self.do_compare = compare
self.do_powder = powder
if self.do_compare:
self.slices = slices.SliceGenerator(self.parent.geom, 'data/quat.dat',
folder=self.parent.output_folder,
need_scaling=self.parent.need_scaling)
if self.do_powder:
self.powder_sum = self.emc_reader.get_powder()
self.numstr = '0'
self.rangestr = '10'
self._init_ui()
def _init_ui(self):
vbox = QtWidgets.QVBoxLayout(self)
self.fig = Figure(figsize=(6, 6))
self.fig.subplots_adjust(left=0.05, right=0.99, top=0.9, bottom=0.05)
self.canvas = FigureCanvas(self.fig)
self.navbar = MyNavigationToolbar(self.canvas, self)
self.canvas.mpl_connect('button_press_event', self._frame_focus)
vbox.addWidget(self.navbar)
vbox.addWidget(self.canvas)
hbox = QtWidgets.QHBoxLayout()
vbox.addLayout(hbox)
if not self.do_powder:
label = QtWidgets.QLabel('Frame number: ', self)
hbox.addWidget(label)
self.numstr = QtWidgets.QLineEdit('0', self)
self.numstr.setFixedWidth(64)
hbox.addWidget(self.numstr)
label = QtWidgets.QLabel('/%d'%self.emc_reader.num_frames, self)
hbox.addWidget(label)
hbox.addStretch(1)
if not self.do_powder and self.do_compare:
self.compare_flag = QtWidgets.QCheckBox('Compare', self)
self.compare_flag.clicked.connect(self._compare_flag_changed)
self.compare_flag.setChecked(False)
hbox.addWidget(self.compare_flag)
label = QtWidgets.QLabel('CMap:', self)
hbox.addWidget(label)
self.slicerange = QtWidgets.QLineEdit('10', self)
self.slicerange.setFixedWidth(30)
hbox.addWidget(self.slicerange)
label = QtWidgets.QLabel('^', self)
hbox.addWidget(label)
self.exponent = QtWidgets.QLineEdit('1.0', self)
self.exponent.setFixedWidth(30)
hbox.addWidget(self.exponent)
hbox.addStretch(1)
label = QtWidgets.QLabel('PlotMax:', self)
hbox.addWidget(label)
self.rangestr = QtWidgets.QLineEdit('10', self)
self.rangestr.setFixedWidth(48)
hbox.addWidget(self.rangestr)
hbox = QtWidgets.QHBoxLayout()
vbox.addLayout(hbox)
button = QtWidgets.QPushButton('Plot', self)
button.clicked.connect(self.plot_frame)
hbox.addWidget(button)
if self.do_powder:
button = QtWidgets.QPushButton('Save', self)
button.clicked.connect(self._save_powder)
hbox.addWidget(button)
else:
gui_utils.add_scroll_hbox(self, hbox)
hbox.addStretch(1)
button = QtWidgets.QPushButton('Quit', self)
button.clicked.connect(self.parent.close)
hbox.addWidget(button)
self.show()
#if not self.do_compare:
self.plot_frame()
def plot_frame(self, frame=None):
'''Update canvas according to GUI parameters
Updated plot depends on mode (for classifier) and whether the GUI is in
'compare' or 'powder' mode.
'''
try:
mode = self.parent.mode_val
except AttributeError:
mode = None
if frame is not None:
pass
elif self.do_powder:
frame = self.powder_sum
num = None
else:
num = self.get_num()
if num is None:
return
frame = self.emc_reader.get_frame(num)
try:
for point in self.parent.embedding_panel.roi_list:
point.remove()
except (ValueError, AttributeError):
pass
self.fig.clear()
if mode == 2:
subp = self.parent.conversion_panel.plot_converted_frame()
elif self.do_compare and self.compare_flag.isChecked():
subp = self._plot_slice(num)
else:
subp = self.fig.add_subplot(111)
subp.imshow(frame.T, vmin=0, vmax=float(self.rangestr.text()),
interpolation='none', cmap=self.parent.cmap)
subp.set_title(self._get_plot_title(frame, num, mode))
self.fig.tight_layout()
self.canvas.draw()
def get_num(self):
'''Get valid frame number from GUI
Returns None if the types number is either unparseable or out of bounds
'''
try:
num = int(self.numstr.text())
except ValueError:
sys.stderr.write('Frame number must be integer\n')
return None
if num < 0 or num >= self.emc_reader.num_frames:
sys.stderr.write('Frame number %d out of range!\n' % num)
return None
return num
def _plot_slice(self, num):
with open(self.parent.log_fname, 'r') as fptr:
line = fptr.readlines()[-1]
try:
iteration = int(line.split()[0])
except (IndexError, ValueError):
sys.stderr.write('Unable to determine iteration number from %s\n' %
self.parent.log_fname)
sys.stderr.write('%s\n' % line)
iteration = None
if iteration > 0:
subp = self.fig.add_subplot(121)
subpc = self.fig.add_subplot(122)
tomo, info = self.slices.get_slice(iteration, num)
subpc.imshow(tomo**float(self.exponent.text()), cmap=self.parent.cmap, vmin=0, vmax=float(self.slicerange.text()), interpolation='gaussian')
subpc.set_title('Mutual Info. = %f'%info)
self.fig.add_subplot(subpc)
else:
subp = self.fig.add_subplot(111)
return subp
def _next_frame(self):
num = int(self.numstr.text()) + 1
if num < self.emc_reader.num_frames:
self.numstr.setText(str(num))
self.plot_frame()
def _prev_frame(self):
num = int(self.numstr.text()) - 1
if num > -1:
self.numstr.setText(str(num))
self.plot_frame()
def _rand_frame(self):
num = np.random.randint(0, self.emc_reader.num_frames)
self.numstr.setText(str(num))
self.plot_frame()
def _get_plot_title(self, frame, num, mode):
title = '%d photons' % frame.sum()
if frame is None and (mode == 1 or mode == 3):
title += ' (%s)' % self.parent.classes.clist[num]
if mode == 4 and self.parent.mlp_panel.predictions is not None:
title += ' [%s]' % self.parent.mlp_panel.predictions[num]
if (mode is None and
not self.do_powder and
self.parent.blacklist is not None and
self.parent.blacklist[num] == 1):
title += ' (bad frame)'
return title
def _compare_flag_changed(self):
self.plot_frame()
def _frame_focus(self, event): # pylint: disable=unused-argument
self.setFocus()
def _save_powder(self):
fname = '%s/assem_powder.bin' % self.parent.output_folder
sys.stderr.write('Saving assembled powder sum with shape %s to %s\n' %
((self.powder_sum.shape,), fname))
self.powder_sum.data.tofile(fname)
raw_powder = self.emc_reader.get_powder(raw=True)
fname = '%s/powder.bin' % self.parent.output_folder
sys.stderr.write('Saving raw powder sum with shape %s to %s\n' %
((raw_powder.shape,), fname))
raw_powder.tofile(fname)
def keyPressEvent(self, event): # pylint: disable=C0103
'''Override of default keyPress event handler'''
key = event.key()
mod = int(event.modifiers())
if QtGui.QKeySequence(mod+key) == QtGui.QKeySequence('Ctrl+N'):
self._next_frame()
elif QtGui.QKeySequence(mod+key) == QtGui.QKeySequence('Ctrl+P'):
self._prev_frame()
elif QtGui.QKeySequence(mod+key) == QtGui.QKeySequence('Ctrl+R'):
self._rand_frame()
elif key == QtCore.Qt.Key_Return or key == QtCore.Qt.Key_Enter:
self.plot_frame()
elif key == QtCore.Qt.Key_Right or key == QtCore.Qt.Key_Down:
self._next_frame()
elif key == QtCore.Qt.Key_Left or key == QtCore.Qt.Key_Up:
self._prev_frame()
else:
event.ignore()
def process(self, files):
print('process() of A2Hauser_LikeHauser called')
results = {}
output = {}
l = []
controllerDict = {'FController': [], \
'GController': [], \
'JController': []}
for elem in controllerDict:
controllerDict.update(
{elem: {
'e': {},
'theta': {},
'psi': {},
'tau': {}
}})
for var in controllerDict[elem]:
for i in range(1, 4, 1):
controllerDict[elem][var].update({i: [[], []]})
for res in files:
# calculate data-sets
t = res['results']['simTime']
yd = res['results']['trajectory_output.0']
y = []
for i in range(4):
y.append(res['results']['model_output.' + str(i)])
error = np.subtract(yd, y[0])
# controlleroutput is a torque
tau = res['results']['controller_output.0']
# u in the neglected nonlinearity is theta_dd
u = np.true_divide( \
np.subtract( \
np.subtract( \
tau, \
np.multiply( \
np.multiply( \
np.multiply( \
2 * st.M, \
y[0] \
), \
y[1] \
), \
y[3] \
) \
), \
np.multiply( \
st.M * st.G, \
np.multiply( \
y[0], \
np.cos(y[2]) \
) \
) \
), \
np.add(
np.multiply( \
st.M, \
np.power(y[0], 2) \
), \
st.J + st.Jb \
) \
)
# Parameter from Controller -> modelling (estimate/meausre paramters)
# and then neglect psi therm
# if you are interested in the error through the negligence
if res['modules']['controller']['type'] == 'FController':
psi = np.multiply(np.multiply(st.B, y[0]), np.power(y[3], 2))
elif res['modules']['controller']['type'] == 'GController':
psi = np.multiply(np.multiply(np.dot(2 * st.B, y[0]), y[3]), u)
elif res['modules']['controller']['type'] == 'JController' or \
res['modules']['controller']['type'] == 'LSSController':
psi = np.multiply(np.multiply(np.multiply(st.B, y[0]), np.power(y[3], 2)), \
np.multiply(st.B * st.G, np.subtract(y[2], np.sin(y[2]))))
else:
# psi is not defined in this case
psi = np.dot(0, t)
# Dict füllen
level1 = res['modules']['controller']['type']
level3 = res['modules']['trajectory']['Amplitude']
# Zeit anhängen
# controllerDict[level1].update({'t':t})
controllerDict[level1]['e'][level3][0] = t
controllerDict[level1]['theta'][level3][0] = t
controllerDict[level1]['psi'][level3][0] = t
controllerDict[level1]['tau'][level3][0] = t
# # Werte anhängen
controllerDict[level1]['e'][level3][1] = error
controllerDict[level1]['theta'][level3][1] = y[2]
controllerDict[level1]['psi'][level3][1] = psi
controllerDict[level1]['tau'][level3][1] = tau
# Plots erzeugen
# contr = ['FController', 'GController', 'JController', 'LSSController']
contr = ['FController', 'GController', 'JController']
for c in contr:
print('controller:', c)
fig = Figure()
# fig.subplots_adjust(wspace=0.3, hspace=0.25)
fig.subplots_adjust(wspace=0.6, hspace=0.6)
fig.suptitle(r'\textbf{' + c + '}', size=st.title_size)
for i in range(1, 4, 1):
axes1 = fig.add_subplot(2, 2, 1)
axes1.set_title(r'output error = yd - x0', size=st.label_size)
axes1.plot(controllerDict[c]['e'][i][0],
controllerDict[c]['e'][i][1])
axes1.set_xlim(left=0, right=controllerDict[c]['e'][1][0][-1])
axes1.set_xlabel(r'$t \,[s]$', size=st.label_size)
axes1.set_ylabel(r'$e \,[m]$', size=st.label_size)
axes1.grid(color='#ababab', linestyle='--')
axes2 = fig.add_subplot(2, 2, 2)
axes2.set_title(r'beam angle', size=st.label_size)
axes2.plot(controllerDict[c]['theta'][i][0],
controllerDict[c]['theta'][i][1])
axes2.set_xlim(left=0,
right=controllerDict[c]['theta'][1][0][-1])
axes2.set_xlabel(r'$t \, [s]$', size=st.label_size)
axes2.set_ylabel(r'$\theta \, [rad]$', size=st.label_size)
axes2.grid(color='#ababab', linestyle='--')
axes3 = fig.add_subplot(2, 2, 3)
axes3.set_title(r'neglected nonlinearity', size=st.label_size)
axes3.plot(controllerDict[c]['psi'][i][0],
controllerDict[c]['psi'][i][1])
axes3.set_xlim(left=0,
right=controllerDict[c]['psi'][1][0][-1])
axes3.set_xlabel(r'$t [s]$', size=st.label_size)
if res['modules']['controller']['type'] == 'FController':
axes3.set_ylabel(r'$\psi_2 \, [\frac{m}{s^2}]$',
size=st.label_size)
if res['modules']['controller']['type'] == 'JController':
axes3.set_ylabel(r'$\psi_2 \, [\frac{m}{s^2}]$',
size=st.label_size)
# axes3.set_ylim(top = 0.6, bottom = -0.6)
if res['modules']['controller']['type'] == 'GController':
axes3.set_ylabel(r'$\psi_3 \, [\frac{m}{s^3}]$',
size=st.label_size)
axes3.grid(color='#ababab', linestyle='--')
axes4 = fig.add_subplot(2, 2, 4)
axes4.set_title(r'beam torque', size=st.label_size)
axes4.plot(controllerDict[c]['tau'][i][0],
controllerDict[c]['tau'][i][1])
axes4.set_xlim(left=0,
right=controllerDict[c]['tau'][1][0][-1])
axes4.set_xlabel(r'$t \,[s]$', size=st.label_size)
axes4.set_ylabel(r'$\tau \,[Nm]$', size=st.label_size)
axes4.grid(color='#ababab', linestyle='--')
# calculate maximumError
start = 30
end = 40
tStartIdx = next(
(idx for idx, x in enumerate(controllerDict[c]['e'][i][0])
if x >= start), 0)
tEndIdx = next((idx for idx, x in enumerate(controllerDict[c]['e'][i][0][start:]) if x >= end), \
len(controllerDict[c]['e'][i][0]) - 1)
maximumError = None
if tStartIdx < tEndIdx:
maximumError = max(
controllerDict[c]['e'][i][1][tStartIdx:tEndIdx])
print('maximum error between %d and %d seconds: %f' % \
(start, end, maximumError))
# check for sim succes
if not res['results']['finished']:
for key in list(output.keys()):
output[key] = None
results.update({'metrics': output})
results.update({'modules': res['modules']})
# write results
filePath = os.path.join(os.path.pardir, 'results',
'postprocessing',
'HauserDiagramsLikeHauser')
if not os.path.isdir(filePath):
os.makedirs(filePath)
fileName = os.path.join(filePath, c) # res['regime name'])
with open(fileName + '.pof',
'w') as f: # POF - Postprocessing Output File
f.write(repr(results))
canvas = FigureCanvas(fig)
fig.savefig(fileName + '.svg')
fig.savefig(fileName + '.png')
fig.savefig(fileName + '.pdf')
# l.append({'name':'_'.join([res['regime name'], self.name]),\
# 'figure': canvas})
l.append({'name': '_'.join([c, self.name]), \
'figure': canvas})
return l
def __init__(self, presenter, parent=None, name='', isMD=False, noExp=0):
super(SampleLogsView, self).__init__(parent)
self.presenter = presenter
self.setWindowTitle("{} sample logs".format(name))
self.setWindowFlags(Qt.Window)
self.setAttribute(Qt.WA_DeleteOnClose, True)
# Create sample log table
self.table = QTableView()
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.clicked.connect(self.presenter.clicked)
self.table.doubleClicked.connect(self.presenter.doubleClicked)
self.table.contextMenuEvent = self.tableMenu
self.addWidget(self.table)
frame_right = QFrame()
layout_right = QVBoxLayout()
#Add full_time and experimentinfo options
layout_options = QHBoxLayout()
if isMD:
layout_options.addWidget(QLabel("Experiment Info #"))
self.experimentInfo = QSpinBox()
self.experimentInfo.setMaximum(noExp - 1)
self.experimentInfo.valueChanged.connect(
self.presenter.changeExpInfo)
layout_options.addWidget(self.experimentInfo)
self.full_time = QCheckBox("Relative Time")
self.full_time.setChecked(True)
self.full_time.stateChanged.connect(self.presenter.plot_logs)
layout_options.addWidget(self.full_time)
layout_right.addLayout(layout_options)
# Sample log plot
self.fig = Figure()
self.canvas = FigureCanvas(self.fig)
self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.canvas.mpl_connect('button_press_event',
self.presenter.plot_clicked)
self.ax = self.fig.add_subplot(111, projection='mantid')
layout_right.addWidget(self.canvas)
# Sample stats
self.create_stats_widgets()
layout_stats = QFormLayout()
layout_stats.addRow('', QLabel("Log Statistics"))
layout_stats.addRow('Min:', self.stats_widgets["minimum"])
layout_stats.addRow('Max:', self.stats_widgets["maximum"])
layout_stats.addRow('Mean:', self.stats_widgets["mean"])
layout_stats.addRow('Median:', self.stats_widgets["median"])
layout_stats.addRow('Std Dev:',
self.stats_widgets["standard_deviation"])
layout_stats.addRow('Time Avg:', self.stats_widgets["time_mean"])
layout_stats.addRow('Time Std Dev:',
self.stats_widgets["time_standard_deviation"])
layout_stats.addRow('Duration:', self.stats_widgets["duration"])
layout_right.addLayout(layout_stats)
frame_right.setLayout(layout_right)
self.addWidget(frame_right)
self.setStretchFactor(0, 1)
self.resize(1200, 800)
self.show()
def run(self, data):
print('processing ', data['regime name'])
# dict for calculated values
output = {}
# reset counter
self.counter = 0
# calculate data-sets
t = data['results']['simTime']
y = data['results']['model_output.0']
traj = data['results']['trajectory_output.0']
yd = data['results']['trajectory_output.0'][-1]
self.posLabel = np.arange(
np.min(y) + 0.1 * yd, yd, (yd - np.min(y)) / 4)
# create plot
fig = Figure()
axes = fig.add_subplot(111)
axes.set_title(
r'\textbf{Vergleich Signalverlaeufe (Systemantwort und Trajektorie)}'
)
axes.plot(t, traj, c='b', ls='-', label='w(t)')
# create t_desired line
# search time value for t_desired
t_desired = t[traj.index(yd)]
self.createTimeLine(axes, t, traj, t_desired, r'$T_{des}$')
# add real t_desired to dict output
output.update({'t_desired': data['modules']['trajectory']['delta t']})
# plot y(t)
axes.plot(t, y, c='k', ls='-', label='y(t)')
# axes scaling
axes.set_xlim(left=0, right=t[-1])
y_min = np.min(y)
y_max = np.max(y)
if (np.max(y) == 0):
axes.set_ylim(np.min(traj), np.max(traj) + np.max(traj) * 0.1)
else:
axes.set_ylim(y_min, y_max + y_max * 0.1)
axes.set_xlabel(r'\textit{Zeit [s]}')
axes.set_ylabel(r'\textit{Ballposition r(t) [m]}')
axes.legend(loc=4)
# create desired line
desiredLine = Line2D([0, t[-1]], [yd, yd],
lw=1,
ls=self.line_style,
c='k')
axes.add_line(desiredLine)
# calc damping-time (Beruhigungszeit)
eps = self.epsPercent * yd / 100
enterIdx = -1
for idx, val in enumerate(y):
if enterIdx == -1:
if abs(val - yd) < eps:
enterIdx = idx
else:
if abs(val - yd) >= eps:
enterIdx = -1
if enterIdx == -1:
# print 'DampingLine is not defined'
output.update({'td': None})
else:
td = t[enterIdx]
# create and add line
self.createTimeLine(axes, t, y, td, r'$T_{\epsilon}$')
output.update({'td': td})
# create epsilon tube
upperBoundLine = Line2D([0, t[-1]], [yd + eps, yd + eps],
ls='--',
c=self.line_color)
axes.add_line(upperBoundLine)
lowerBoundLine = Line2D([0, t[-1]], [yd - eps, yd - eps],
ls='--',
c=self.line_color)
axes.add_line(lowerBoundLine)
# calc control deviation
control_deviation = y[-1] - yd
output.update({'control_deviation': control_deviation})
self.calcMetrics(data, output)
# check for sim sucess
if not data['results']['finished']:
for key in output.keys():
output[key] = None
# add settings and metrics to dictionary results
results = {}
results.update({'metrics': output})
results.update({'modules': data['modules']})
canvas = FigureCanvas(fig)
self.writeOutputFiles(self.name, data['regime name'], fig, results)
return {'name': '_'.join([data['regime name'], self.name]), \
'figure': canvas}
def widgets(self):
self.close_btn = QPushButton(self) # 创建一个按钮
self.close_btn.setCheckable(True)
# self.close_btn.setText('X') # 按钮显示显示文本
# self.close_btn.resize(20, 20)
self.close_btn.setMaximumSize(12, 12)
self.close_btn.setStyleSheet(
"background-color: rgb(255, 12, 12); border-radius: 6;")
self.close_btn.move(12, 10)
self.max_btn = QPushButton(self)
# self.max_btn.setText('口')
# self.max_btn.resize(20, 20)
self.max_btn.setMaximumSize(12, 12)
self.max_btn.setStyleSheet(
"background-color: rgb(28, 255, 3); border-radius: 6;")
self.max_btn.move(24, 10)
self.min_btn = QPushButton(self)
# self.min_btn.setText('一')
# self.min_btn.resize(20, 20)
self.min_btn.setMaximumSize(12, 12)
self.min_btn.setStyleSheet(
"background-color: rgb(255, 243, 75); border-radius: 6;")
self.min_btn.move(36, 10)
self.titlelabel = QLabel('音乐音频处理')
self.titlelabel.setStyle(QStyleFactory.create('Fusion'))
self.titlelabel.setFont(QtGui.QFont("Arial", 16))
self.setCentralWidget(self.titlelabel)
self.placeholder = QLabel()
autoplaceholder = int(self.geometry().x() / 2)
self.placeholder.setMaximumSize(autoplaceholder - 200, 20)
# --播放时间
self.label1 = QLabel('00:00')
self.label1.setStyle(QStyleFactory.create('Fusion'))
self.label2 = QLabel('00:00')
self.label2.setStyle(QStyleFactory.create('Fusion'))
self.label1.setFont(QtGui.QFont("Arial", 18))
self.label2.setFont(QtGui.QFont("Arial", 18))
# --滑动条
self.slider = QtWidgets.QSlider(QtCore.Qt.Horizontal)
self.slider.setStyleSheet('background-color: rgba(0,0,0,0)')
# --播放按钮
self.play_button = QPushButton('播放', self)
self.play_button.setStyle(QStyleFactory.create('Fusion'))
# --静音按钮
self.mute_button = QPushButton('静音', self)
self.mute_button.setStyle(QStyleFactory.create('Fusion'))
self.choose_button = QPushButton('选择', self)
self.choose_button.setStyle(QStyleFactory.create('Fusion'))
# --上一首按钮
self.preview_button = QPushButton('上一首', self)
self.preview_button.setStyle(QStyleFactory.create('Fusion'))
# --下一首按钮
self.next_button = QPushButton('下一首', self)
self.next_button.setStyle(QStyleFactory.create('Fusion'))
# --打开文件夹按钮
self.open_button = QPushButton('打开文件夹', self)
self.open_button.setStyle(QStyleFactory.create('Fusion'))
# --显示音乐列表
self.qlist = QListWidget()
self.qlist.setStyle(QStyleFactory.create('Fusion'))
self.qlist.setHorizontalScrollBarPolicy(1)
self.qlist.setFont(QtGui.QFont("Arial", 18))
self.qlist.setMinimumSize(200, 200)
# --如果有初始化setting, 导入setting
self.loadSetting()
# --播放模式
self.cmb = QComboBox()
self.cmb.setStyle(QStyleFactory.create('Fusion'))
self.cmb.setStyleSheet('color: white;')
self.cmb.addItem('顺序播放')
self.cmb.addItem('单曲循环')
self.cmb.addItem('随机播放')
# --计时器
self.timer = QTimer(self)
self.timer.start(1000)
self.timer.timeout.connect(self.playByMode)
plt.style.use('dark_background')
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.canvas.setMinimumSize(200, 200)
class PowerAtRadar(QMainWindow, Ui_MainWindow):
def __init__(self):
super(self.__class__, self).__init__()
self.setupUi(self)
# Connect to the input boxes, when the user presses enter the form updates
self.target_min_range.returnPressed.connect(self._update_canvas)
self.target_max_range.returnPressed.connect(self._update_canvas)
self.peak_power.returnPressed.connect(self._update_canvas)
self.antenna_gain.returnPressed.connect(self._update_canvas)
self.frequency.returnPressed.connect(self._update_canvas)
self.target_rcs.returnPressed.connect(self._update_canvas)
# Set up a figure for the plotting canvas
fig = Figure()
self.axes1 = fig.add_subplot(111)
self.my_canvas = FigureCanvas(fig)
# Add the canvas to the vertical layout
self.verticalLayout.addWidget(self.my_canvas)
self.addToolBar(QtCore.Qt.TopToolBarArea,
NavigationToolbar(self.my_canvas, self))
# Update the canvas for the first display
self._update_canvas()
def _update_canvas(self):
"""
Update the figure when the user changes an input value.
:return:
"""
# Get the range from the form
target_min_range = float(self.target_min_range.text())
target_max_range = float(self.target_max_range.text())
# Set up the range array
target_range = linspace(target_min_range, target_max_range, 2000)
# Convert the antenna gain and target rcs to linear units
antenna_gain = 10.0**(float(self.antenna_gain.text()) / 10.0)
target_rcs = 10.0**(float(self.target_rcs.text()) / 10.0)
# Set up the input args
kwargs = {
'target_range': target_range,
'peak_power': float(self.peak_power.text()),
'antenna_gain': antenna_gain,
'frequency': float(self.frequency.text()),
'target_rcs': target_rcs
}
# Calculate the power at the radar
power_at_radar = radar_range.power_at_radar(**kwargs)
# Clear the axes for the updated plot
self.axes1.clear()
# Display the results
self.axes1.plot(target_range / 1.0e3, power_at_radar, '')
# Set the plot title and labels
self.axes1.set_title('Power at the Radar', size=14)
self.axes1.set_xlabel('Target Range (km)', size=12)
self.axes1.set_ylabel('Power at Radar (W)', size=12)
# Set the tick label size
self.axes1.tick_params(labelsize=12)
# Turn on the grid
self.axes1.grid(linestyle=':', linewidth=0.5)
# Update the canvas
self.my_canvas.draw()
class Plot3D(QWidget):
"""
Class to plot agent's trajectories.
"""
def __init__(self):
super().__init__()
# 3D Plot settings
self.window = None
self.fig = plt.figure(figsize=(3, 6))
self.ax = self.fig.add_subplot(111, projection='3d')
self.canvas = FigureCanvas(self.fig)
# Agent trajactories storage
self.x_traj = []
self.y_traj = []
self.z_traj = []
# Target storage
self.tgt_x = []
self.tgt_y = []
self.tgt_z = []
# Manage layout
vbox = QVBoxLayout()
vbox.addWidget(self.canvas)
self.setLayout(vbox)
def add_trajectories(self, x, y, z):
"""
Add trajectories
:param x: x value to be added
:param y: y value to be added
:param z: z value to be added
"""
self.x_traj.append(x)
self.y_traj.append(y)
self.z_traj.append(z)
def add_target(self, target):
"""
Add target coordinates.
:param target: array of targets
"""
if target is not None:
self.tgt_x.append(target[0])
self.tgt_y.append(target[1])
self.tgt_z.append(target[2])
def clear_3d(self):
"""
Used to clear 3d trajectories
"""
self.x_traj = []
self.y_traj = []
self.z_traj = []
self.tgt_x = []
self.tgt_y = []
self.tgt_z = []
width = self.window.widget.width
height = self.window.widget.height
height_x = self.window.widget.height_x
self.ax.clear()
self.set_3d_axes(self.ax, width, height, height_x)
self.canvas.draw()
def set_3d_axes(self, ax, x_lim, y_lim, z_lim):
"""
Sets the axis labels and limits.
"""
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
ax.set_xlim(0, x_lim)
ax.set_ylim(0, y_lim)
ax.set_zlim(0, z_lim)
def draw(self):
"""
Draw plots
"""
width = self.window.widget.width
height = self.window.widget.height
height_x = self.window.widget.height_x
self.ax.plot(self.x_traj,
self.y_traj,
self.z_traj,
c="#0091D4",
linewidth=1.5)
self.ax.plot(self.tgt_x,
self.tgt_y,
self.tgt_z,
marker='x',
c='green',
linewidth=1.5)
self.set_3d_axes(self.ax, width, height, height_x)
self.canvas.draw()
def setup(self, MainWindow):
'''
Creates Qt interactor
'''
#if called as a script, then treat as a mainwindow, otherwise treat as a generic widget
if hasattr(MainWindow,'setCentralWidget'):
MainWindow.setCentralWidget(self.centralWidget)
else:
self.centralWidget=MainWindow
MainWindow.setWindowTitle("OpenRS - model viewer v%s" %__version__)
#create new layout to hold both VTK and Qt interactors
mainlayout=QtWidgets.QHBoxLayout(self.centralWidget)
#create VTK widget
self.vtkWidget = QVTKRenderWindowInteractor(self.centralWidget)
#create Qt layout to contain interactions
load_model_box = QtWidgets.QGridLayout()
#create VTK widget
self.vtkWidget = QVTKRenderWindowInteractor(self.centralWidget)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.MinimumExpanding)
sizePolicy.setHorizontalStretch(100)
sizePolicy.setVerticalStretch(100)
self.vtkWidget.setSizePolicy(sizePolicy)
self.vtkWidget.setMinimumSize(QtCore.QSize(800, 600))
#set fonts
head_font=QtGui.QFont("Helvetica [Cronyx]",weight=QtGui.QFont.Bold)
io_font = QtGui.QFont("Helvetica")
#make display layout
display_box = QtWidgets.QGroupBox('Display')
#buttons
self.load_button = QtWidgets.QPushButton('Load')
self.load_label = QtWidgets.QLabel("Nothing loaded.")
self.load_label.setWordWrap(True)
self.load_label.setFont(io_font)
self.load_label.setToolTip('Load results file')
#make combo box for components
self.component_cb = QtWidgets.QComboBox()
self.component_cb.setToolTip('Change stress component displayed')
# self.component_cb.addItems(['\u03C311', '\u03C322', '\u03C333'])
self.component_cb.setEnabled(False)
self.mesh_display=QtWidgets.QPushButton("Edges off")
self.mesh_display.setToolTip('Turn mesh/edges on and off')
self.mesh_display.setCheckable(True)
self.mesh_display.setChecked(False)
self.mesh_display.setEnabled(False)
self.extract_boundaries_button = QtWidgets.QPushButton('Extract boundary')
self.extract_boundaries_button.setEnabled(False)
self.extract_boundaries_button.setToolTip('Extract boundary of model')
self.export_STL_button = QtWidgets.QRadioButton("Write STL")
self.export_STL_button.setChecked(False)
self.export_STL_button.setEnabled(False)
#make contour layout
contour_layout = QtWidgets.QGridLayout()
contour_box = QtWidgets.QGroupBox('Contours')
min_contour_label = QtWidgets.QLabel("Min:")
self.min_contour = QtWidgets.QDoubleSpinBox()
self.min_contour.setMinimum(-100000)
self.min_contour.setMaximum(100000)
max_contour_label = QtWidgets.QLabel("Max:")
self.max_contour = QtWidgets.QDoubleSpinBox()
self.max_contour.setMinimum(-100000)
self.max_contour.setMaximum(100000)
num_contour_label = QtWidgets.QLabel("Interval:")
self.num_contour = QtWidgets.QSpinBox()
self.num_contour.setToolTip('Number of entries shown on colorbar')
self.num_contour.setMinimum(3)
self.num_contour.setMaximum(20)
self.num_contour.setValue(5)
self.update_contours_button = QtWidgets.QPushButton('Update')
self.update_contours_button.setToolTip('Update the contour limits and interval')
self.update_contours_button.setEnabled(False)
contour_layout.addWidget(min_contour_label,1,0,1,1)
contour_layout.addWidget(self.min_contour,1,1,1,1)
contour_layout.addWidget(max_contour_label,1,2,1,1)
contour_layout.addWidget(self.max_contour,1,3,1,1)
contour_layout.addWidget(num_contour_label,1,4,1,1)
contour_layout.addWidget(self.num_contour,1,5,1,1)
contour_layout.addWidget(self.update_contours_button,1,6,1,1)
# line extraction from surface
extract_layout = QtWidgets.QGridLayout()
extract_box = QtWidgets.QGroupBox('Extract')
# labels for axes
x_label = QtWidgets.QLabel("x")
y_label = QtWidgets.QLabel("y")
z_label = QtWidgets.QLabel("z")
# x, y, z of first point
start_label = QtWidgets.QLabel("Start")
start_label.setToolTip('Start coordinate of line trace')
self.point1_x_coord = QtWidgets.QDoubleSpinBox()
self.point1_x_coord.setMinimum(-100000)
self.point1_x_coord.setMaximum(100000)
self.point1_y_coord = QtWidgets.QDoubleSpinBox()
self.point1_y_coord.setMinimum(-100000)
self.point1_y_coord.setMaximum(100000)
self.point1_z_coord = QtWidgets.QDoubleSpinBox()
self.point1_z_coord.setMinimum(-100000)
self.point1_z_coord.setMaximum(100000)
# x, y, z of second point
end_label = QtWidgets.QLabel("End")
end_label.setToolTip('End coordinate of line trace')
self.point2_x_coord = QtWidgets.QDoubleSpinBox()
self.point2_x_coord.setMinimum(-100000)
self.point2_x_coord.setMaximum(100000)
self.point2_y_coord = QtWidgets.QDoubleSpinBox()
self.point2_y_coord.setMinimum(-100000)
self.point2_y_coord.setMaximum(100000)
self.point2_z_coord = QtWidgets.QDoubleSpinBox()
self.point2_z_coord.setMinimum(-100000)
self.point2_z_coord.setMaximum(100000)
# x, y, z of clip point
clip_label = QtWidgets.QLabel("Clip")
clip_label.setToolTip('Tertiary coordinate to specify clipping plane')
self.clip_x_coord = QtWidgets.QDoubleSpinBox()
self.clip_x_coord.setMinimum(-100000)
self.clip_x_coord.setMaximum(100000)
self.clip_y_coord = QtWidgets.QDoubleSpinBox()
self.clip_y_coord.setMinimum(-100000)
self.clip_y_coord.setMaximum(100000)
self.clip_z_coord = QtWidgets.QDoubleSpinBox()
self.clip_z_coord.setMinimum(-100000)
self.clip_z_coord.setMaximum(100000)
#clip settings
self.clip_active_button=QtWidgets.QPushButton("Update clip")
self.clip_active_button.setToolTip('Show/update clipped model')
self.clip_active_button.setEnabled(False)
interval_label=QtWidgets.QLabel("Line interval:")
self.extract_interval=QtWidgets.QSpinBox()
self.extract_interval.setToolTip('Number of points to extract along line trace')
self.extract_interval.setValue(50)
self.extract_interval.setMinimum(3)
self.extract_interval.setMaximum(1000)
self.extract_button = QtWidgets.QPushButton('Update line')
self.extract_button.setToolTip('Show/update line trace')
self.extract_button.setEnabled(False)
self.export_line_button = QtWidgets.QPushButton('Export line')
self.export_line_button.setEnabled(False)
self.export_line_button.setToolTip('Export line trace to file')
#create figure canvas etc
#initialize plot
self.figure = plt.figure(figsize=(4,4))
plt.text(0.5, 0.5, "'Update line' for plot", ha='center', style='italic', fontweight = 'bold', color='lightgray', size= 18)
plt.axis('off')
#changes the background of the plot, otherwise white
# self.figure.patch.set_facecolor((242/255,242/255,242/255))
self.canvas = FigureCanvas(self.figure)
self.canvas.setMinimumSize(QtCore.QSize(400, 500))
#add everything to the extract layout
extract_layout.addWidget(x_label,1,1,1,1)
extract_layout.addWidget(y_label,1,2,1,1)
extract_layout.addWidget(z_label,1,3,1,1)
extract_layout.addWidget(start_label,2,0,1,1)
extract_layout.addWidget(self.point1_x_coord,2,1,1,1)
extract_layout.addWidget(self.point1_y_coord,2,2,1,1)
extract_layout.addWidget(self.point1_z_coord,2,3,1,1)
extract_layout.addWidget(end_label,3,0,1,1)
extract_layout.addWidget(self.point2_x_coord,3,1,1,1)
extract_layout.addWidget(self.point2_y_coord,3,2,1,1)
extract_layout.addWidget(self.point2_z_coord,3,3,1,1)
extract_layout.addWidget(clip_label,4,0,1,1)
extract_layout.addWidget(self.clip_x_coord,4,1,1,1)
extract_layout.addWidget(self.clip_y_coord,4,2,1,1)
extract_layout.addWidget(self.clip_z_coord,4,3,1,1)
extract_layout.addWidget(self.extract_button,5,2,1,1)
extract_layout.addWidget(self.clip_active_button,5,3,1,1)
extract_layout.addWidget(self.canvas,6,0,1,4)
load_model_box.addWidget(self.load_button,0,0,1,1)
load_model_box.addWidget(self.component_cb,0,1,1,1)
load_model_box.addWidget(self.mesh_display,0,2,1,1)
load_model_box.addWidget(self.load_label,1,0,1,3)
load_model_box.addWidget(self.extract_boundaries_button,2,1,1,1)
load_model_box.addWidget(self.export_STL_button,2,2,1,1)
#add layouts to boxes
display_box.setLayout(load_model_box)
contour_box.setLayout(contour_layout)
evlayout=QtWidgets.QVBoxLayout()
evbutton_layout = QtWidgets.QHBoxLayout()
evbutton_layout.addWidget(interval_label)
evbutton_layout.addWidget(self.extract_interval)
verticalSpacer = QtWidgets.QSpacerItem(200, 20, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding)
evbutton_layout.addItem(verticalSpacer)
evbutton_layout.addWidget(self.export_line_button)
evlayout.addLayout(extract_layout)
evlayout.addLayout(evbutton_layout)
extract_box.setLayout(evlayout)
lvlayout=QtWidgets.QVBoxLayout()
lvlayout.addWidget(display_box)
lvlayout.addWidget(contour_box)
lvlayout.addWidget(extract_box)
lvlayout.addStretch(1)
mainlayout.addWidget(self.vtkWidget)
mainlayout.addStretch(1)
mainlayout.addLayout(lvlayout)
def initialize(self):
self.vtkWidget.start()
class RainAttenuation(QMainWindow, Ui_MainWindow):
def __init__(self):
super(self.__class__, self).__init__()
self.setupUi(self)
# Connect to the input boxes, when the user presses enter the form updates
self.frequencyStartGHz.returnPressed.connect(self._update_canvas)
self.frequencyEndGHz.returnPressed.connect(self._update_canvas)
self.rain_rate.returnPressed.connect(self._update_canvas)
self.elevation_angle.returnPressed.connect(self._update_canvas)
self.polarization_tilt_angle.returnPressed.connect(self._update_canvas)
# Set up a figure for the plotting canvas
fig = Figure()
self.axes1 = fig.add_subplot(111)
self.my_canvas = FigureCanvas(fig)
# Add the canvas to the vertical layout
self.verticalLayout.addWidget(self.my_canvas)
self.addToolBar(QtCore.Qt.TopToolBarArea, NavigationToolbar(self.my_canvas, self))
# Update the canvas for the first display
self._update_canvas()
def _update_canvas(self):
"""
Update the figure when the user changes an input value.
:return:
"""
# Get the frequencies from the form
frequency_start = float(self.frequencyStartGHz.text())
frequency_end = float(self.frequencyEndGHz.text())
# Set up the frequency array
frequency = linspace(frequency_start, frequency_end, 2000)
# Set up the input args
kwargs = {'frequency': frequency,
'rain_rate': float(self.rain_rate.text()),
'elevation_angle': radians(float(self.elevation_angle.text())),
'polarization_tilt_angle': radians(float(self.polarization_tilt_angle.text()))}
# Calculate the rain attenuation
gamma = rain.attenuation(**kwargs)
# Clear the axes for the updated plot
self.axes1.clear()
# Display the results
self.axes1.plot(frequency, gamma)
# Set the plot title and labels
self.axes1.set_title('Rain Attenuation', size=14)
self.axes1.set_xlabel('Frequency (GHz)', size=12)
self.axes1.set_ylabel('Specific Attenuation (dB/km)', size=12)
# Set the tick label size
self.axes1.tick_params(labelsize=12)
# Turn on the grid
self.axes1.grid(linestyle=':', linewidth=0.5)
# Update the canvas
self.my_canvas.draw()
def add_plot(self, plot, event_source):
canvas = FigureCanvas(plot.fig)
layout = QtWidgets.QHBoxLayout(self.centralwidget)
layout.addWidget(canvas)
ani = DataAnimation(plot, event_source, blit=True)
canvas.draw()
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.center()
self.initUI()
self.figure = plt.figure()
ax1 = self.figure.add_subplot(311)
ax1.grid(True)
ax1.set_title("Numerical methods", fontweight="bold", size=13)
ax2 = self.figure.add_subplot(312)
ax2.grid(True)
ax2.set_title("Exact solution", fontweight="bold", size=13)
ax3 = self.figure.add_subplot(313)
ax3.grid(True)
ax3.set_title("Local errors", fontweight="bold", size=13)
self.figure.tight_layout()
grid = QGridLayout()
self.setLayout(grid)
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.button = QPushButton('Plot')
self.button.clicked.connect(self.plot)
self.sld = QtWidgets.QSlider(QtCore.Qt.Horizontal, self)
# self.x_sld = QtWidgets.QSlider(QtCore.Qt.Horizontal, self)
# self.y_sld = QtWidgets.QSlider(QtCore.Qt.Horizontal, self)
self.sld.setStyleSheet("""
QSlider{
background: #E3DEE2;
min-width:450px;
max-width:450px;
}
QSlider::groove:horizontal {
height: 10px;
margin: 0px;
border-radius: 5px;
background: #B0AEB1;
}
QSlider::handle:horizontal {
background: #fff;
border: 1px solid #E3DEE2;
width: 17px;
margin: -5px 0px;
border-radius: 8px;
}
QSlider::sub-page:qlineargradient {
background: #3B99FC;
border-radius: 5px;
}
""")
self.sld.setMinimum(2)
self.sld.setMaximum(100)
# optimal approximation
self.NUMBERS = 25
self.sld.setValue(self.NUMBERS)
self.X_STEP = 1
self.Y_STEP = 1
# self.x_sld.valueChanged.connect(self.x_change, self.x_sld.value())
# self.y_sld.valueChanged.connect(self.y_change, self.y_sld.value())
self.sld.valueChanged.connect(self.value_change, self.sld.value())
self.function_label = QLabel("Function: ")
self.function_le = QTextEdit()
self.function_le.setFixedSize(self.q.width() / 8.5,
self.q.height() / 41.2)
self.function_le.setText("y'=sin(x)+y")
self.label = QLabel("Number of points: " + str(self.sld.value()))
# self.x_label = QLabel("Grid x step: " + str(self.x_sld.value() / 100))
# self.y_label = QLabel("Grid y step: " + str(self.y_sld.value() / 100))
self.x0_label = QLabel("x0: ")
self.y0_label = QLabel("y0:")
self.X_label = QLabel("X: ")
self.N0_label = QLabel("Initial number of points (N0): ")
self.NF_label = QLabel("Final number of points (NF): ")
grid.setSpacing(25)
self.x0_le = QTextEdit()
self.x0_le.setFixedSize(self.q.width() / 8.5, self.q.height() / 41.2)
self.x0_le.setText(str(0))
self.y0_le = QTextEdit()
self.y0_le.setFixedSize(self.q.width() / 8.5, self.q.height() / 41.2)
self.y0_le.setText(str(1))
self.X_le = QTextEdit()
self.X_le.setFixedSize(self.q.width() / 8.5, self.q.height() / 41.2)
self.X_le.setText(str(12 / 5))
self.N0_le = QTextEdit()
self.N0_le.setFixedSize(self.q.width() / 8.5, self.q.height() / 41.2)
self.N0_le.setText(str(2))
self.NF_le = QTextEdit()
self.NF_le.setFixedSize(self.q.width() / 8.5, self.q.height() / 41.2)
self.NF_le.setText(str(10))
self.radio1 = QRadioButton("&Yes")
self.radio2 = QRadioButton("&No")
self.radio1.setChecked(True)
self.radio1.toggled.connect(
lambda: self.show_total_approximation_error(self.radio1))
self.radio2.toggled.connect(
lambda: self.show_total_approximation_error(self.radio2))
self.hbox = QHBoxLayout()
self.hbox.addWidget(self.radio1)
self.hbox.addWidget(self.radio2)
self.box = QGroupBox("&Show total approximation errors?")
self.box.setLayout(self.hbox)
self.mradio1 = QRadioButton("&Yes")
self.mradio2 = QRadioButton("&No")
self.mradio1.setChecked(True)
self.mbox = QHBoxLayout()
self.mbox.addWidget(self.mradio1)
self.mbox.addWidget(self.mradio2)
self.mGroupBox = QGroupBox("&Mark dots?")
self.mGroupBox.setLayout(self.mbox)
grid.addWidget(self.toolbar, 0, 0, 1, 25)
grid.addWidget(self.canvas, 1, 0, 25, 25)
grid.addWidget(self.function_label, 1, 25)
grid.addWidget(self.function_le, 2, 25)
grid.addWidget(self.label, 3, 25)
grid.addWidget(self.sld, 4, 25)
# grid.addWidget(self.x_label, 10, 25)
# grid.addWidget(self.x_sld, 11, 25)
# grid.addWidget(self.y_label, 12, 25)
# grid.addWidget(self.y_sld, 13, 25)
grid.addWidget(self.x0_label, 5, 25)
grid.addWidget(self.x0_le, 6, 25)
grid.addWidget(self.y0_label, 7, 25)
grid.addWidget(self.y0_le, 8, 25)
grid.addWidget(self.X_label, 9, 25)
grid.addWidget(self.X_le, 10, 25)
grid.addWidget(self.box, 11, 25)
grid.addWidget(self.N0_label, 12, 25)
grid.addWidget(self.N0_le, 13, 25)
grid.addWidget(self.NF_label, 14, 25)
grid.addWidget(self.NF_le, 15, 25)
grid.addWidget(self.mGroupBox, 16, 25)
grid.addWidget(self.button, 25, 25)
class DelayLine(QMainWindow, Ui_MainWindow):
def __init__(self):
super(self.__class__, self).__init__()
self.setupUi(self)
# Connect to the input boxes, when the user presses enter the form updates
self.prf_stagger.returnPressed.connect(self._update_canvas)
self.prf_type.currentIndexChanged.connect(self._update_canvas)
# Set up a figure for the plotting canvas
fig = Figure()
self.fig = fig
self.axes1 = fig.add_subplot(111)
self.my_canvas = FigureCanvas(fig)
# Add the canvas to the vertical layout
self.verticalLayout.addWidget(self.my_canvas)
self.addToolBar(QtCore.Qt.TopToolBarArea,
NavigationToolbar(self.my_canvas, self))
# Update the canvas for the first display
self._update_canvas()
def _update_canvas(self):
"""
Update the figure when the user changes and input value.
:return:
"""
# Get the parameters from the form
prf_stagger = float(self.prf_stagger.text())
# Get the PRF type
prf_type = self.prf_type.currentText()
# Set up the normalized frequency space
frequency = linspace(0, 4, 1000)
# Clear the axes for the updated plot
self.axes1.clear()
# Calculate response based on PRF type
if prf_type == 'Single':
response = countermeasures.delay_line(frequency) / 4.0
# Display the results
self.axes1.plot(frequency, 10 * log10(response + finfo(float).eps),
'')
elif prf_type == 'Stagger':
response_prf1 = countermeasures.delay_line(frequency) / 4.0
response_prf2 = countermeasures.delay_line(
prf_stagger * frequency) / 4.0
response = 0.5 * (response_prf1 + response_prf2)
# Display the results
self.axes1.plot(frequency,
10 * log10(response_prf1 + finfo(float).eps),
'',
label='PRF 1')
self.axes1.plot(frequency,
10 * log10(response_prf2 + finfo(float).eps),
'--',
label='PRF 2')
self.axes1.plot(frequency,
10 * log10(response + finfo(float).eps),
':',
label='PRF Staggered')
# Place the legend
self.axes1.legend(loc='lower left', prop={'size': 10})
# Set the plot title and labels
self.axes1.set_title('Delay Line Response', size=14)
self.axes1.set_xlabel('Normalized Frequency (f / PRF)', size=12)
self.axes1.set_ylabel('Amplitude (dB)', size=12)
# Set the y-axis lim
self.axes1.set_ylim([-30, 1])
# Turn on the grid
self.axes1.grid(linestyle=':', linewidth=0.5)
# Set the tick label size
self.axes1.tick_params(labelsize=12)
# Update the canvas
self.my_canvas.draw()
def UI_setup(self):
self.figure = Figure()
self.canvas = FigureCanvas(self.figure)
self.button = QtWidgets.QPushButton("Plot", self)
self.button.clicked.connect(self.plot)
self.button.resize(self.button.minimumSizeHint())
self.button.move(100, 100)
VLabel = QtWidgets.QLabel("y(x) = ax^2 + bx + c", self)
LLabel = QtWidgets.QLabel("Line Color", self)
RLabel = QtWidgets.QLabel("Root Color", self)
LcomboBox = QtWidgets.QComboBox(self)
RcomboBox = QtWidgets.QComboBox(self)
LcomboBox.addItem("Blue")
LcomboBox.addItem("Green")
LcomboBox.addItem("Red")
LcomboBox.addItem("Cyan")
LcomboBox.addItem("Magenta")
LcomboBox.addItem("Yellow")
LcomboBox.addItem("Black")
LcomboBox.addItem("White")
RcomboBox.addItem("Blue")
RcomboBox.addItem("Green")
RcomboBox.addItem("Red")
RcomboBox.addItem("Cyan")
RcomboBox.addItem("Magenta")
RcomboBox.addItem("Yellow")
RcomboBox.addItem("Black")
RcomboBox.addItem("White")
LcomboBox.activated[str].connect(self.set_color)
RcomboBox.activated[str].connect(self.set_root_color)
hbox1 = QtWidgets.QHBoxLayout()
hbox2 = QtWidgets.QHBoxLayout()
hbox3 = QtWidgets.QHBoxLayout()
hbox1.addStretch(1)
hbox2.addStretch(1)
hbox3.addStretch(1)
hbox1.addWidget(self.button)
hbox1.addWidget(self.canvas)
hbox3.addWidget(LLabel)
hbox3.addWidget(LcomboBox)
hbox3.addWidget(RLabel)
hbox3.addWidget(RcomboBox)
validator = QtGui.QDoubleValidator()
ALabel = QtWidgets.QLabel("a", self)
ALineEdit = QtWidgets.QLineEdit("0", self)
ALineEdit.setValidator(validator)
ALineEdit.textChanged[str].connect(self.set_quadratic_a)
BLabel = QtWidgets.QLabel("b", self)
BLineEdit = QtWidgets.QLineEdit("0", self)
BLineEdit.setValidator(validator)
BLineEdit.textChanged[str].connect(self.set_quadratic_b)
CLabel = QtWidgets.QLabel("c", self)
CLineEdit = QtWidgets.QLineEdit("0", self)
CLineEdit.setValidator(validator)
CLineEdit.textChanged[str].connect(self.set_quadratic_c)
hbox2.addWidget(ALabel)
hbox2.addWidget(ALineEdit)
hbox2.addWidget(BLabel)
hbox2.addWidget(BLineEdit)
hbox2.addWidget(CLabel)
hbox2.addWidget(CLineEdit)
vbox = QtWidgets.QVBoxLayout()
vbox.addStretch(1)
vbox.addLayout(hbox1)
vbox.addWidget(VLabel, alignment=QtCore.Qt.AlignCenter)
vbox.addLayout(hbox2)
vbox.addLayout(hbox3)
self.CenWidget.setLayout(vbox)
self.setGeometry(50, 50, 600, 600)
self.setWindowTitle("Quadratic Function Plotter")
def showUI(self):
# Central widget and layout
wid = QWidget()
self.setCentralWidget(wid)
grid = QGridLayout()
wid.setLayout(grid)
grid.setSpacing(5)
# Creamos las cuatro cajas que vamos a usar
Caja1 = QGroupBox('Dimensión de los datos del entrenamiento')
Caja2 = QGroupBox('Área de la representación del error')
Caja3 = QGroupBox('Parámetros de la red neuronal')
Caja4 = QGroupBox('Zona de resultados')
Caja5 = QGroupBox('Zona de botones')
Caja1.setObjectName('PrimeraCaja')
# Creamos los cuatro layouts. Son 4 Grids, al fin y al cabo.
Caja1Layout = QGridLayout()
Caja2Layout = QGridLayout()
Caja3Layout = QGridLayout()
Caja4Layout = QGridLayout()
Caja5Layout = QGridLayout()
Caja1.setLayout(Caja1Layout)
Caja2.setLayout(Caja2Layout)
Caja3.setLayout(Caja3Layout)
Caja4.setLayout(Caja4Layout)
Caja5.setLayout(Caja5Layout)
grid.addWidget(Caja1, 0, 0, 1, 2) # 1 Fila - 2 Columnas
grid.addWidget(Caja2, 1, 0, 1, 4) # 1 Fila - 4 Columnas
grid.addWidget(Caja3, 2, 0, 1, 4) # 1 Fila - 2 Columnas
grid.addWidget(Caja4, 0, 4, 2, 1) # 2 Filas - 1 Columna
grid.addWidget(Caja5, 3, 0, 3, 4) # 3 Filas - 4 Columnas
grid.setColumnStretch(0, 2)
Caja1.setSizePolicy(
QSizePolicy.Maximum, QSizePolicy.Maximum
) # Con esto se consigue dejar pequeña la mierda esa
Caja3.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
# Objects
# Plot object
self.figure = plt.figure(tight_layout=True)
self.canvas = FigureCanvas(self.figure)
self.canvas.setMinimumSize(
200, 200) # Esto hace que no se pueda hacer el widget to pequeño
ax = self.figure.add_subplot(111)
plt.xlabel('Iteración')
plt.ylabel('Error')
plt.title('Error vs Iteración')
self.canvas.draw()
# Labels for the functions
label1 = QLabel('Input - H1')
label2 = QLabel('H1 - H(-1)')
label3 = QLabel('H(-1) - Output')
label4 = QLabel('Error')
label5 = QLabel('Layers')
label6 = QLabel('Neurons')
label7 = QLabel('Learning rate')
label8 = QLabel('Regularization')
label9 = QLabel('Resultados:')
label10 = QLabel('Dimensión de inputs')
label11 = QLabel('Dimensión de outputs')
# Selectors for the functions
self.combo1 = QComboBox(self)
self.combo1.addItem('Sigmoid')
self.combo1.addItem('ReLu')
self.combo1.addItem('Linear')
self.combo1.addItem('SoftMax')
self.combo2 = QComboBox(self)
self.combo2.addItem('Sigmoid')
self.combo2.addItem('ReLu')
self.combo2.addItem('Linear')
self.combo2.addItem('SoftMax')
self.combo3 = QComboBox(self)
self.combo3.addItem('Sigmoid')
self.combo3.addItem('ReLu')
self.combo3.addItem('Linear')
self.combo3.addItem('SoftMax')
self.combo4 = QComboBox(self)
self.combo4.addItem('Quadratic Error')
self.combo4.addItem('Cross-Entropy function')
# Botones
btn = QPushButton('Cargar parámetros')
btn.clicked.connect(self.checkParameters)
btn2 = QPushButton('Crear Redes Neuronales')
btn2.clicked.connect(self.initNetwork)
btn3 = QPushButton('Resolver red')
btn3.clicked.connect(self.solveNetwork)
btn3.setStyleSheet(
"font: bold; background-color: cyan; font-size: 26px; border-width: 100px; border-color: black"
)
btn3.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
btn4 = QPushButton('Cargar Inputs y Outputs')
btn4.clicked.connect(self.readInputs)
# Edit Texts
self.ed1 = QLineEdit(' ')
self.ed2 = QLineEdit(' ')
self.ed3 = QLineEdit(' ')
self.ed4 = QLineEdit(' ')
self.ed1.setText('1')
self.ed2.setText('1')
self.ed3.setText('1')
self.ed4.setText('1')
self.ed5 = QLineEdit('1')
self.ed6 = QLineEdit('1')
self.ed5.setMaximumWidth(30)
self.ed6.setMaximumWidth(30)
# Bloque de texto
self.block = QTextEdit('Status:')
self.block.moveCursor(QTextCursor.End)
self.block.insertPlainText('\n' + 'Run for results')
self.block.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
# Colocamos los objetos
# Labels
Caja1Layout.addWidget(label10, 0, 0)
Caja1Layout.addWidget(label11, 1, 0)
Caja1Layout.addWidget(self.ed5, 0, 1)
Caja1Layout.addWidget(self.ed6, 1, 1)
Caja1Layout.setColumnStretch(1, 3)
# Plot
Caja2Layout.addWidget(self.canvas, 0, 0) # 1 fila, 4 columnas
# Parametros a introducir
Caja3Layout.addWidget(label1, 0, 0)
Caja3Layout.addWidget(self.combo1, 0, 1)
Caja3Layout.addWidget(label2, 1, 0)
Caja3Layout.addWidget(self.combo2, 1, 1)
Caja3Layout.addWidget(label3, 2, 0)
Caja3Layout.addWidget(self.combo3, 2, 1)
Caja3Layout.addWidget(label4, 3, 0)
Caja3Layout.addWidget(self.combo4, 3, 1)
Caja3Layout.addWidget(label5, 0, 2)
Caja3Layout.addWidget(self.ed1, 0, 3)
Caja3Layout.addWidget(label6, 1, 2)
Caja3Layout.addWidget(self.ed2, 1, 3)
Caja3Layout.addWidget(label7, 2, 2)
Caja3Layout.addWidget(self.ed3, 2, 3)
Caja3Layout.addWidget(label8, 3, 2)
Caja3Layout.addWidget(self.ed4, 3, 3)
# Bloque de texto
Caja4Layout.addWidget(label9, 0, 0, 1, 1)
Caja4Layout.addWidget(self.block, 1, 0, 1, 1)
# Botones
Caja5Layout.addWidget(btn, 0, 0)
Caja5Layout.addWidget(btn2, 2, 0)
Caja5Layout.addWidget(btn3, 0, 1, 3, 3)
Caja5Layout.addWidget(btn4, 1, 0)
class SampleLogsView(QSplitter):
"""Sample Logs View
This contains a table of the logs, a plot of the currently
selected logs, and the statistics of the selected log.
"""
def __init__(self, presenter, parent = None, name = '', isMD=False, noExp = 0):
super(SampleLogsView, self).__init__(parent)
self.presenter = presenter
self.setWindowTitle("{} sample logs".format(name))
self.setWindowFlags(Qt.Window)
# Create sample log table
self.table = QTableView()
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.clicked.connect(self.presenter.clicked)
self.table.doubleClicked.connect(self.presenter.doubleClicked)
self.table.contextMenuEvent = self.tableMenu
self.addWidget(self.table)
frame_right = QFrame()
layout_right = QVBoxLayout()
#Add full_time and experimentinfo options
layout_options = QHBoxLayout()
if isMD:
layout_options.addWidget(QLabel("Experiment Info #"))
self.experimentInfo = QSpinBox()
self.experimentInfo.setMaximum(noExp-1)
self.experimentInfo.valueChanged.connect(self.presenter.changeExpInfo)
layout_options.addWidget(self.experimentInfo)
self.full_time = QCheckBox("Relative Time")
self.full_time.setChecked(True)
self.full_time.stateChanged.connect(self.presenter.plot_logs)
layout_options.addWidget(self.full_time)
layout_right.addLayout(layout_options)
# Sample log plot
self.fig = Figure()
self.canvas = FigureCanvas(self.fig)
self.canvas.setSizePolicy(QSizePolicy.Expanding,QSizePolicy.Expanding)
self.canvas.mpl_connect('button_press_event', self.presenter.plot_clicked)
self.ax = self.fig.add_subplot(111, projection='mantid')
layout_right.addWidget(self.canvas)
# Sample stats
self.create_stats_widgets()
layout_stats = QFormLayout()
layout_stats.addRow('', QLabel("Log Statistics"))
layout_stats.addRow('Min:', self.stats_widgets["minimum"])
layout_stats.addRow('Max:', self.stats_widgets["maximum"])
layout_stats.addRow('Mean:', self.stats_widgets["mean"])
layout_stats.addRow('Median:', self.stats_widgets["median"])
layout_stats.addRow('Std Dev:', self.stats_widgets["standard_deviation"])
layout_stats.addRow('Time Avg:', self.stats_widgets["time_mean"])
layout_stats.addRow('Time Std Dev:', self.stats_widgets["time_standard_deviation"])
layout_stats.addRow('Duration:', self.stats_widgets["duration"])
layout_right.addLayout(layout_stats)
frame_right.setLayout(layout_right)
self.addWidget(frame_right)
self.setStretchFactor(0,1)
self.resize(1200,800)
self.show()
def tableMenu(self, event):
"""Right click menu for table, can plot or print selected logs"""
menu = QMenu(self)
plotAction = menu.addAction("Plot selected")
plotAction.triggered.connect(self.presenter.new_plot_logs)
plotAction = menu.addAction("Print selected")
plotAction.triggered.connect(self.presenter.print_selected_logs)
menu.exec_(event.globalPos())
def set_model(self, model):
"""Set the model onto the table"""
self.model = model
self.table.setModel(self.model)
self.table.resizeColumnsToContents()
self.table.horizontalHeader().setSectionResizeMode(2, QHeaderView.Stretch)
def plot_selected_logs(self, ws, exp, rows):
"""Update the plot with the selected rows"""
self.ax.clear()
self.create_ax_by_rows(self.ax, ws, exp, rows)
self.fig.canvas.draw()
def new_plot_selected_logs(self, ws, exp, rows):
"""Create a new plot, in a separate window for selected rows"""
fig, ax = plt.subplots(subplot_kw={'projection': 'mantid'})
self.create_ax_by_rows(ax, ws, exp, rows)
fig.show()
def create_ax_by_rows(self, ax, ws, exp, rows):
"""Creates the plots for given rows onto axis ax"""
for row in rows:
log_text = self.get_row_log_name(row)
ax.plot(ws,
LogName=log_text,
label=log_text,
marker='.',
FullTime=not self.full_time.isChecked(),
ExperimentInfo=exp)
ax.set_ylabel('')
if ax.get_legend_handles_labels()[0]:
ax.legend()
def get_row_log_name(self, i):
"""Returns the log name of particular row"""
return str(self.model.item(i, 0).text())
def get_exp(self):
"""Get set experiment info number"""
return self.experimentInfo.value()
def get_selected_row_indexes(self):
"""Return a list of selected row from table"""
return [row.row() for row in self.table.selectionModel().selectedRows()]
def set_selected_rows(self, rows):
"""Set seleceted rows in table"""
mode = QItemSelectionModel.Select | QItemSelectionModel.Rows
for row in rows:
self.table.selectionModel().select(self.model.index(row, 0), mode)
def create_stats_widgets(self):
"""Creates the statistics widgets"""
self.stats_widgets = {"minimum": QLineEdit(),
"maximum": QLineEdit(),
"mean": QLineEdit(),
"median": QLineEdit(),
"standard_deviation": QLineEdit(),
"time_mean": QLineEdit(),
"time_standard_deviation": QLineEdit(),
"duration": QLineEdit()}
for widget in self.stats_widgets.values():
widget.setReadOnly(True)
def set_statistics(self, stats):
"""Updates the statistics widgets from stats dictionary"""
for param in self.stats_widgets.keys():
self.stats_widgets[param].setText('{:.6}'.format(getattr(stats, param)))
def clear_statistics(self):
"""Clears the values in statistics widgets"""
for widget in self.stats_widgets.values():
widget.clear()
def __init__(self):
## Initialize the application
self.app = QApplication(sys.argv)
super().__init__(None)
self.setWindowTitle("SV2TTS toolbox")
## Main layouts
# Root
root_layout = QGridLayout()
self.setLayout(root_layout)
# Browser
browser_layout = QGridLayout()
root_layout.addLayout(browser_layout, 0, 1)
# Visualizations
vis_layout = QVBoxLayout()
root_layout.addLayout(vis_layout, 1, 1, 2, 3)
# Generation
gen_layout = QVBoxLayout()
root_layout.addLayout(gen_layout, 0, 2)
# Projections
self.projections_layout = QVBoxLayout()
root_layout.addLayout(self.projections_layout, 1, 0)
## Projections
# UMap
fig, self.umap_ax = plt.subplots(figsize=(4, 4), facecolor="#F0F0F0")
fig.subplots_adjust(left=0.02, bottom=0.02, right=0.98, top=0.98)
self.projections_layout.addWidget(FigureCanvas(fig))
self.umap_hot = False
self.clear_button = QPushButton("Clear")
self.projections_layout.addWidget(self.clear_button)
## Browser
# Dataset, speaker and utterance selection
i = 0
self.dataset_box = QComboBox()
browser_layout.addWidget(QLabel("<b>Dataset</b>"), i, 0)
browser_layout.addWidget(self.dataset_box, i + 1, 0)
self.speaker_box = QComboBox()
browser_layout.addWidget(QLabel("<b>Speaker</b>"), i, 1)
browser_layout.addWidget(self.speaker_box, i + 1, 1)
self.utterance_box = QComboBox()
browser_layout.addWidget(QLabel("<b>Audio</b>"), i, 2)
browser_layout.addWidget(self.utterance_box, i + 1, 2)
self.browser_browse_button = QPushButton("Browse")
browser_layout.addWidget(self.browser_browse_button, i, 3)
self.browser_load_button = QPushButton("Load")
browser_layout.addWidget(self.browser_load_button, i + 1, 3)
i += 2
# Random buttons
self.random_dataset_button = QPushButton("Random Text")
browser_layout.addWidget(self.random_dataset_button, i, 0)
self.random_speaker_button = QPushButton("Random Speaker")
browser_layout.addWidget(self.random_speaker_button, i, 1)
self.random_utterance_button = QPushButton("Random Audio")
browser_layout.addWidget(self.random_utterance_button, i, 2)
self.auto_next_checkbox = QCheckBox("Auto select next")
self.auto_next_checkbox.setChecked(True)
browser_layout.addWidget(self.auto_next_checkbox, i, 3)
i += 1
# Utterance box
browser_layout.addWidget(QLabel("<b>Use embedding from:</b>"), i, 0)
i += 1
# Random & next utterance buttons
self.utterance_history = QComboBox()
browser_layout.addWidget(self.utterance_history, i, 0, 1, 3)
i += 1
# Random & next utterance buttons
self.take_generated_button = QPushButton("Preprocess")
browser_layout.addWidget(self.take_generated_button, i, 0)
self.record_button = QPushButton("Record")
browser_layout.addWidget(self.record_button, i, 1)
self.play_button = QPushButton("Play")
browser_layout.addWidget(self.play_button, i, 2)
self.stop_button = QPushButton("Stop")
browser_layout.addWidget(self.stop_button, i, 3)
i += 2
# Model selection
self.encoder_box = QComboBox()
browser_layout.addWidget(QLabel("<b>Encoder</b>"), i, 0)
browser_layout.addWidget(self.encoder_box, i + 1, 0)
self.synthesizer_box = QComboBox()
browser_layout.addWidget(QLabel("<b>Synthesizer</b>"), i, 1)
browser_layout.addWidget(self.synthesizer_box, i + 1, 1)
self.vocoder_box = QComboBox()
browser_layout.addWidget(QLabel("<b>Vocoder</b>"), i, 2)
browser_layout.addWidget(self.vocoder_box, i + 1, 2)
i += 2
## Embed & spectrograms
vis_layout.addStretch()
gridspec_kw_current = {"width_ratios": [1, 2, 2]} # embed,spectrogram
fig, self.current_ax = plt.subplots(1,
3,
figsize=(10, 2.25),
facecolor="#F0F0F0",
gridspec_kw=gridspec_kw_current)
fig.subplots_adjust(left=0, bottom=0.1, right=1, top=0.8)
vis_layout.addWidget(FigureCanvas(fig))
gridspec_kw_gen = {
"width_ratios": [1, 2, 2]
} # embed,alignment,spectrogram
fig, self.gen_ax = plt.subplots(1,
3,
figsize=(10, 2.25),
facecolor="#F0F0F0",
gridspec_kw=gridspec_kw_gen)
fig.subplots_adjust(left=0, bottom=0.1, right=1, top=0.8)
vis_layout.addWidget(FigureCanvas(fig))
for ax in self.current_ax.tolist() + self.gen_ax.tolist():
ax.set_facecolor("#F0F0F0")
for side in ["top", "right", "bottom", "left"]:
ax.spines[side].set_visible(False)
## Generation
self.text_prompt = QPlainTextEdit(default_text)
gen_layout.addWidget(self.text_prompt, stretch=1)
layout = QHBoxLayout() # 改为两部分
self.generate_button = QPushButton("Synthesize and vocode")
layout.addWidget(self.generate_button)
self.compare_button = QPushButton("Compare")
layout.addWidget(self.compare_button)
gen_layout.addLayout(layout)
layout = QHBoxLayout()
self.synthesize_button = QPushButton("Synthesize only")
layout.addWidget(self.synthesize_button)
self.vocode_button = QPushButton("Vocode only")
layout.addWidget(self.vocode_button)
gen_layout.addLayout(layout)
self.loading_bar = QProgressBar()
gen_layout.addWidget(self.loading_bar)
self.log_window = QLabel()
self.log_window.setAlignment(Qt.AlignBottom | Qt.AlignLeft)
gen_layout.addWidget(self.log_window)
self.logs = []
gen_layout.addStretch()
## Set the size of the window and of the elements
max_size = QDesktopWidget().availableGeometry(self).size() * 0.8
self.resize(max_size)
## Finalize the display
self.reset_interface()
self.show()
def __init__(self, parent=None):
fig = Figure()
self.axes = fig.add_subplot(111)
self.parent = parent
FigureCanvas.__init__(self, fig)
def loadTabs(self):
self.tabs = QTabWidget()
self.tab1 = QWidget()
self.tab2 = QWidget()
self.tab3 = QWidget()
self.tab4 = QWidget()
self.tab5 = QWidget()
# self.tab6 = QWidget()
self.tabs.resize(300, 200)
# self.tabs.addTab(self.tabG1,"Grafo Barabaási-Albert")
# self.tabs.addTab(self.tabG2, "Grafo Erdos-Rényi")
# self.tabs.addTab(self.tabG3,"Grafo Watts y Strogatz")
# self.tabs.addTab(self.tabG4,"Grafo Facebook")
self.tabs.addTab(self.tab1, "Simulacion")
self.tabs.addTab(self.tab2, "Barabási–Albert")
self.tabs.addTab(self.tab3, "Erdös–Rényi")
self.tabs.addTab(self.tab4, "Watts y Strogatz")
self.tabs.addTab(self.tab5, "Facebook")
# self.tabs.addTab(self.tab6,"Mapa de calor")
self.tab1.layout = QVBoxLayout(self)
self.pushButton1 = QPushButton("INICIAR SIMULACIÓN")
self.tab1.layout.addWidget(self.pushButton1)
self.tab1.setLayout(self.tab1.layout)
# Graficsa para Fig 1
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
self.pushButton1.clicked.connect(self.graficas)
self.tab2.layout = QVBoxLayout(self)
self.tab2.layout.addWidget(self.toolbar)
self.tab2.layout.addWidget(self.canvas)
self.tab2.setLayout(self.tab2.layout)
# Graficsa para Fig 2
self.figure2 = plt.figure()
self.canvas2 = FigureCanvas(self.figure2)
self.toolbar2 = NavigationToolbar(self.canvas2, self)
self.tab3.layout = QVBoxLayout(self)
self.tab3.layout.addWidget(self.toolbar2)
self.tab3.layout.addWidget(self.canvas2)
self.tab3.setLayout(self.tab3.layout)
# # Graficsa para Fig 3
self.figure3 = plt.figure()
self.canvas3 = FigureCanvas(self.figure3)
self.toolbar3 = NavigationToolbar(self.canvas3, self)
self.tab4.layout = QVBoxLayout(self)
self.tab4.layout.addWidget(self.toolbar3)
self.tab4.layout.addWidget(self.canvas3)
self.tab4.setLayout(self.tab4.layout)
# # Graficsa para Facebook
self.figure4 = plt.figure()
self.canvas4 = FigureCanvas(self.figure4)
self.toolbar4 = NavigationToolbar(self.canvas4, self)
self.tab5.layout = QVBoxLayout(self)
self.tab5.layout.addWidget(self.toolbar4)
self.tab5.layout.addWidget(self.canvas4)
self.tab5.setLayout(self.tab5.layout)
self.AddGraphs()
self.layout.addWidget(self.tabs)
self.setLayout(self.layout)
def _init_ui(self):
vbox = QtWidgets.QVBoxLayout(self)
self.fig = Figure(figsize=(6, 6))
self.fig.subplots_adjust(left=0.05, right=0.99, top=0.9, bottom=0.05)
self.canvas = FigureCanvas(self.fig)
self.navbar = MyNavigationToolbar(self.canvas, self)
self.canvas.mpl_connect('button_press_event', self._frame_focus)
vbox.addWidget(self.navbar)
vbox.addWidget(self.canvas)
hbox = QtWidgets.QHBoxLayout()
vbox.addLayout(hbox)
if not self.do_powder:
label = QtWidgets.QLabel('Frame number: ', self)
hbox.addWidget(label)
self.numstr = QtWidgets.QLineEdit('0', self)
self.numstr.setFixedWidth(64)
hbox.addWidget(self.numstr)
label = QtWidgets.QLabel('/%d'%self.emc_reader.num_frames, self)
hbox.addWidget(label)
hbox.addStretch(1)
if not self.do_powder and self.do_compare:
self.compare_flag = QtWidgets.QCheckBox('Compare', self)
self.compare_flag.clicked.connect(self._compare_flag_changed)
self.compare_flag.setChecked(False)
hbox.addWidget(self.compare_flag)
label = QtWidgets.QLabel('CMap:', self)
hbox.addWidget(label)
self.slicerange = QtWidgets.QLineEdit('10', self)
self.slicerange.setFixedWidth(30)
hbox.addWidget(self.slicerange)
label = QtWidgets.QLabel('^', self)
hbox.addWidget(label)
self.exponent = QtWidgets.QLineEdit('1.0', self)
self.exponent.setFixedWidth(30)
hbox.addWidget(self.exponent)
hbox.addStretch(1)
label = QtWidgets.QLabel('PlotMax:', self)
hbox.addWidget(label)
self.rangestr = QtWidgets.QLineEdit('10', self)
self.rangestr.setFixedWidth(48)
hbox.addWidget(self.rangestr)
hbox = QtWidgets.QHBoxLayout()
vbox.addLayout(hbox)
button = QtWidgets.QPushButton('Plot', self)
button.clicked.connect(self.plot_frame)
hbox.addWidget(button)
if self.do_powder:
button = QtWidgets.QPushButton('Save', self)
button.clicked.connect(self._save_powder)
hbox.addWidget(button)
else:
gui_utils.add_scroll_hbox(self, hbox)
hbox.addStretch(1)
button = QtWidgets.QPushButton('Quit', self)
button.clicked.connect(self.parent.close)
hbox.addWidget(button)
self.show()
#if not self.do_compare:
self.plot_frame()
class SampleLogsView(QSplitter):
"""Sample Logs View
This contains a table of the logs, a plot of the currently
selected logs, and the statistics of the selected log.
"""
def __init__(self, presenter, parent=None, name='', isMD=False, noExp=0):
super(SampleLogsView, self).__init__(parent)
self.presenter = presenter
self.setWindowTitle("{} sample logs".format(name))
self.setWindowFlags(Qt.Window)
self.setAttribute(Qt.WA_DeleteOnClose, True)
# Create sample log table
self.table = QTableView()
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.clicked.connect(self.presenter.clicked)
self.table.doubleClicked.connect(self.presenter.doubleClicked)
self.table.contextMenuEvent = self.tableMenu
self.addWidget(self.table)
frame_right = QFrame()
layout_right = QVBoxLayout()
#Add full_time and experimentinfo options
layout_options = QHBoxLayout()
if isMD:
layout_options.addWidget(QLabel("Experiment Info #"))
self.experimentInfo = QSpinBox()
self.experimentInfo.setMaximum(noExp - 1)
self.experimentInfo.valueChanged.connect(
self.presenter.changeExpInfo)
layout_options.addWidget(self.experimentInfo)
self.full_time = QCheckBox("Relative Time")
self.full_time.setChecked(True)
self.full_time.stateChanged.connect(self.presenter.plot_logs)
layout_options.addWidget(self.full_time)
layout_right.addLayout(layout_options)
# Sample log plot
self.fig = Figure()
self.canvas = FigureCanvas(self.fig)
self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.canvas.mpl_connect('button_press_event',
self.presenter.plot_clicked)
self.ax = self.fig.add_subplot(111, projection='mantid')
layout_right.addWidget(self.canvas)
# Sample stats
self.create_stats_widgets()
layout_stats = QFormLayout()
layout_stats.addRow('', QLabel("Log Statistics"))
layout_stats.addRow('Min:', self.stats_widgets["minimum"])
layout_stats.addRow('Max:', self.stats_widgets["maximum"])
layout_stats.addRow('Mean:', self.stats_widgets["mean"])
layout_stats.addRow('Median:', self.stats_widgets["median"])
layout_stats.addRow('Std Dev:',
self.stats_widgets["standard_deviation"])
layout_stats.addRow('Time Avg:', self.stats_widgets["time_mean"])
layout_stats.addRow('Time Std Dev:',
self.stats_widgets["time_standard_deviation"])
layout_stats.addRow('Duration:', self.stats_widgets["duration"])
layout_right.addLayout(layout_stats)
frame_right.setLayout(layout_right)
self.addWidget(frame_right)
self.setStretchFactor(0, 1)
self.resize(1200, 800)
self.show()
def closeEvent(self, event):
self.deleteLater()
super(SampleLogsView, self).closeEvent(event)
def tableMenu(self, event):
"""Right click menu for table, can plot or print selected logs"""
menu = QMenu(self)
plotAction = menu.addAction("Plot selected")
plotAction.triggered.connect(self.presenter.new_plot_logs)
plotAction = menu.addAction("Print selected")
plotAction.triggered.connect(self.presenter.print_selected_logs)
menu.exec_(event.globalPos())
def set_model(self, model):
"""Set the model onto the table"""
self.model = model
self.table.setModel(self.model)
self.table.resizeColumnsToContents()
self.table.horizontalHeader().setSectionResizeMode(
2, QHeaderView.Stretch)
def plot_selected_logs(self, ws, exp, rows):
"""Update the plot with the selected rows"""
self.ax.clear()
self.create_ax_by_rows(self.ax, ws, exp, rows)
self.fig.canvas.draw()
def new_plot_selected_logs(self, ws, exp, rows):
"""Create a new plot, in a separate window for selected rows"""
fig, ax = plt.subplots(subplot_kw={'projection': 'mantid'})
self.create_ax_by_rows(ax, ws, exp, rows)
fig.show()
def create_ax_by_rows(self, ax, ws, exp, rows):
"""Creates the plots for given rows onto axis ax"""
for row in rows:
log_text = self.get_row_log_name(row)
ax.plot(ws,
LogName=log_text,
label=log_text,
FullTime=not self.full_time.isChecked(),
ExperimentInfo=exp)
ax.set_ylabel('')
if ax.get_legend_handles_labels()[0]:
ax.legend()
def get_row_log_name(self, i):
"""Returns the log name of particular row"""
return str(self.model.item(i, 0).text())
def get_exp(self):
"""Get set experiment info number"""
return self.experimentInfo.value()
def get_selected_row_indexes(self):
"""Return a list of selected row from table"""
return [
row.row() for row in self.table.selectionModel().selectedRows()
]
def set_selected_rows(self, rows):
"""Set seleceted rows in table"""
mode = QItemSelectionModel.Select | QItemSelectionModel.Rows
for row in rows:
self.table.selectionModel().select(self.model.index(row, 0), mode)
def create_stats_widgets(self):
"""Creates the statistics widgets"""
self.stats_widgets = {
"minimum": QLineEdit(),
"maximum": QLineEdit(),
"mean": QLineEdit(),
"median": QLineEdit(),
"standard_deviation": QLineEdit(),
"time_mean": QLineEdit(),
"time_standard_deviation": QLineEdit(),
"duration": QLineEdit()
}
for widget in self.stats_widgets.values():
widget.setReadOnly(True)
def set_statistics(self, stats):
"""Updates the statistics widgets from stats dictionary"""
for param in self.stats_widgets.keys():
self.stats_widgets[param].setText('{:.6}'.format(
getattr(stats, param)))
def clear_statistics(self):
"""Clears the values in statistics widgets"""
for widget in self.stats_widgets.values():
widget.clear()
def initUI(self):
has_type = []
frame_left = {}
vbox_left = {}
label_left = {}
topic_type_dict = bag_reader.read_bag(sys.argv[1])
for msg_type in topic_type_dict.values():
if bag_reader.msg_types.count(
msg_type) and not has_type.count(msg_type):
has_type.append(msg_type)
splitter_left = QtWidgets.QSplitter(QtCore.Qt.Vertical)
# Separates the variables to different categories in order to populate the screen
for msg_type in has_type:
frame_left[msg_type] = QtWidgets.QFrame(self)
frame_left[msg_type].setFrameShape(QtWidgets.QFrame.StyledPanel)
vbox_left[msg_type] = QtWidgets.QVBoxLayout(self)
label_left[msg_type] = QtWidgets.QLabel(self)
label_left[msg_type].setText(msg_type)
label_left[msg_type].adjustSize()
vbox_left[msg_type].addWidget(label_left[msg_type])
for topic in topic_type_dict.keys():
if topic_type_dict[topic] == msg_type:
cb = QtWidgets.QCheckBox(topic, self)
cb.stateChanged.connect(self.addTopic)
vbox_left[msg_type].addWidget(cb)
vbox_left[msg_type].addStretch(1)
frame_left[msg_type].setLayout(vbox_left[msg_type])
splitter_left.addWidget(frame_left[msg_type])
vbox_left_var = QtWidgets.QVBoxLayout(self)
label_left_var = QtWidgets.QLabel(self)
label_left_var.setText('Variables')
label_left_var.adjustSize()
vbox_left_var.addWidget(label_left_var)
frame_left_var = QtWidgets.QFrame(self)
frame_left_var.setFrameShape(QtWidgets.QFrame.StyledPanel)
for var in bag_reader.var_types:
cb = QtWidgets.QCheckBox(var, self)
cb.stateChanged.connect(self.addVar)
vbox_left_var.addWidget(cb)
vbox_left_var.addStretch(0)
frame_left_var.setLayout(vbox_left_var)
splitter_left.addWidget(frame_left_var)
frame_left_control = QtWidgets.QFrame(self)
frame_left_control.setFrameShape(QtWidgets.QFrame.StyledPanel)
vbox_left_control = QtWidgets.QVBoxLayout(self)
load_btn = QtWidgets.QPushButton('Load', self)
clear_btn = QtWidgets.QPushButton('Clear', self)
save_btn = QtWidgets.QPushButton('Save Figure', self)
load_btn.clicked.connect(self.buttonClicked)
clear_btn.clicked.connect(self.buttonClearClicked)
save_btn.clicked.connect(self.buttonSaveClicked)
vbox_left_control.addWidget(load_btn)
vbox_left_control.addWidget(clear_btn)
vbox_left_control.addWidget(save_btn)
vbox_left_control.addStretch(1)
frame_left_control.setLayout(vbox_left_control)
splitter_left.addWidget(frame_left_control)
frame_right = QtWidgets.QFrame(self)
frame_right.setFrameShape(QtWidgets.QFrame.StyledPanel)
splitter_v = QtWidgets.QSplitter(QtCore.Qt.Horizontal)
splitter_v.addWidget(splitter_left)
splitter_v.addWidget(frame_right)
hbox = QtWidgets.QHBoxLayout(self)
hbox.addWidget(splitter_v)
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
vbox_right = QtWidgets.QVBoxLayout(self)
vbox_right.addWidget(self.canvas)
frame_right.setLayout(vbox_right)
self.setLayout(hbox)
self.resize(1000, 800)
self.center()
self.show()
class GAF_Widget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.parent = None
self.fig = Figure()
self.canvas = FigureCanvas(self.fig)
self.navi_toolbar = NavigationToolbar(self.canvas, self)
vertical_layout = QVBoxLayout()
vertical_layout.addWidget(self.canvas)
vertical_layout.addWidget(self.navi_toolbar)
# self.canvas.ax_img = self.canvas.figure.add_subplot(121)
# self.canvas.ax_profile = self.canvas.figure.add_subplot(322)
# self.canvas.ax_ctr = self.canvas.figure.add_subplot(324)
# self.canvas.ax_pot = self.canvas.figure.add_subplot(326)
#self.canvas.axes = self.canvas.figure.add_subplot(111)
self.setLayout(vertical_layout)
self.gaf = 0
def update_canvas(self, fig_size):
self.canvas = FigureCanvas(Figure(fig_size))
self.navi_toolbar = NavigationToolbar(self.canvas, self)
vertical_layout = QVBoxLayout()
vertical_layout.addWidget(self.canvas)
vertical_layout.addWidget(self.navi_toolbar)
# self.canvas.ax_profile = self.canvas.figure.add_subplot(322)
# self.canvas.ax_ctr = self.canvas.figure.add_subplot(324)
# self.canvas.ax_pot = self.canvas.figure.add_subplot(326)
#self.canvas.axes = self.canvas.figure.add_subplot(111)
self.setLayout(vertical_layout)
def reset(self):
self.canvas.figure.clear()
self.canvas.draw()
self.data = {}
self.ax_handle_ed = None
self.ax_handles_ctr = None
def clear_plot(self):
self.canvas.figure.clear()
self.canvas.draw()
def make_gaf_data(self, serie_data=np.cos(np.arange(0, 100))):
return compute_GAF(serie_data)
def create_plots(self,
serie_data=np.cos(np.arange(0, 100)),
plot_type='GAF diagram',
relative=False):
gaf, phi, r, scaled_time_serie = self.make_gaf_data(serie_data)
if relative:
gaf_ = gaf - self.gaf
self.gaf, self.phi, self.r, self.scaled_time_serie = gaf, phi, r, scaled_time_serie
# self.update_canvas(eval(self.parent.lineEdit_fig_size.text()))
self.canvas.figure.clear()
if plot_type == 'polar encoding':
self.ax = self.canvas.figure.add_subplot(polar=True)
self.ax.plot(phi, r)
self.ax.set_title("Polar Encoding")
self.ax.set_rticks([0, 1])
self.ax.set_rlabel_position(-22.5)
self.ax.grid(True)
elif plot_type == 'GAF diagram':
self.ax = self.canvas.figure.add_subplot()
if relative:
self.ax.matshow(gaf_)
else:
self.ax.matshow(gaf)
self.ax.set_title("Gramian Angular Field")
self.ax.set_yticklabels([])
self.ax.set_xticklabels([])
elif plot_type == 'CTR series':
self.ax = self.canvas.figure.add_subplot()
self.ax.plot(range(len(scaled_time_serie)), scaled_time_serie)
self.ax.set_title("Scaled CTR Serie")
self.canvas.draw()
