class matplotlibWidget(QWidget):
def __init__(self, parent = None):
QWidget.__init__(self, parent)
self.canvas = MplCanvas()
self.gl = QGridLayout()
alignment = Qt.Alignment()
self.gl.addWidget(self.canvas,0,0,-1,-1,alignment)
self.toolbar = NavigationToolbar(self.canvas, self)
self.toolbar.hide()
# Just some button
self.button1 = QPushButton('Zoom')
self.button1.clicked.connect(self.zoom)
self.button2 = QPushButton('Pan')
self.button2.clicked.connect(self.pan)
self.button3 = QPushButton('Home')
self.button3.clicked.connect(self.home)
self.gl.addWidget(self.toolbar,1,0,alignment)
self.gl.addWidget(self.button1,1,1,alignment)
self.gl.addWidget(self.button2,1,2,alignment)
self.gl.addWidget(self.button3,1,3,alignment)
self.setLayout(self.gl)
def home(self):
self.toolbar.home()
def zoom(self):
self.toolbar.zoom()
def pan(self):
self.toolbar.pan()
def release_zoom(self, event):
"""
override zoom released method
"""
self.canvas_zoom_released.emit()
NavigationToolbar2QT.release_zoom(self, event)
class MyMplCanvas(FigureCanvas):
"""Ultimately, this is a QWidget (as well as a FigureCanvasAgg, etc.)."""
def __init__(self, parent=None, width=5, height=4, dpi=100):
fig = Figure(figsize=(width, height), dpi=dpi)
self.axes = fig.add_subplot(111)
# We want the axes cleared every time plot() is called
self.axes.hold(False)
self.compute_initial_figure()
#
FigureCanvas.__init__(self, fig)
self.setParent(parent)
self.setStyleSheet("{background-color:transparent;border:none;}")
"""FigureCanvas.setSizePolicy(self,
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)"""
FigureCanvas.updateGeometry(self)
self.tootlbar = NavigationToolbar(self, parent)
self.tootlbar.hide()
self.fid = 0
self.data = []
self.index = []
def compute_initial_figure(self):
pass
def press_zoom(self, event):
"""
Method that is used to limit zoom to the x axis. Based on
http://stackoverflow.com/a/16709952/5215507
"""
event.key = 'x'
NavigationToolbar.press_zoom(self, event)
def draw(self):
"""
Canvas is drawn called by pan(), zoom()
:return:
"""
NavigationToolbar2QT.draw(self)
self._myParent.evt_view_updated()
def _update_view(self):
"""
view update called by home(), back() and forward()
:return:
"""
NavigationToolbar2QT._update_view(self)
self._myParent.evt_view_updated()
def __init__(self, *args, **kwargs): NavigationToolbar2QT.__init__(self, *args, **kwargs) self.init_buttons() self.panAction.setCheckable(True) self.zoomAction.setCheckable(True) # remove the subplots action self.removeAction( self.subplotsAction )
def __init__(self, canvas_, parent_):
# backend.figureoptions = None # Monkey patched to kill the figure options button on matplotlib toolbar
# self.toolitems = (
# ('Home', 'Reset original view', 'home', 'home'),
# ('Back', 'Back to previous view', 'back', 'back'),
# ('Forward', 'Forward to next view', 'forward', 'forward'),
# (None, None, None, None),
# ('Pan', 'Pan axes with left mouse, zoom with right', 'move', 'pan'),
# ('Zoom', 'Zoom to rectangle', 'zoom_to_rect', 'zoom'),
# (None, None, None, None),
# ('Save', 'Save the current image', 'filesave', 'save_figure'),
# )
NavigationToolbar2QT.__init__(self, canvas_, parent_)
def zoom(self, *args):
"""
Turn on/off zoom (zoom button)
:param args:
:return:
"""
NavigationToolbar2QT.zoom(self, args)
if self._myMode == NAVIGATION_MODE_ZOOM:
# out of zoom mode
self._myMode = NAVIGATION_MODE_NONE
else:
# into zoom mode
self._myMode = NAVIGATION_MODE_ZOOM
def __init__(self, parent, canvas):
""" Initialization
built-in methods
- drag_zoom(self, event): triggered during holding the mouse and moving
"""
NavigationToolbar2QT.__init__(self, canvas, canvas)
# parent
self._myParent = parent
# tool bar mode
self._myMode = NAVIGATION_MODE_NONE
# connect the events to parent
self.home_button_pressed.connect(self._myParent.evt_toolbar_home)
self.canvas_zoom_released.connect(self._myParent.evt_zoom_released)
def __init__(self, parent=None):
super(Widgetmain, self).__init__(parent)
self.figure = Figure()
# plt.subplots_adjust(left=0.031, right=0.999, top=0.99, bottom=0.03)
# plt.subplots_adjust(left=0.001, right=0.999, top=0.999, bottom=0.001)
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
# uncomment for disabling plot toolbar, not recommended
self.toolbar.hide()
# set the layout
self.layout = QtWidgets.QVBoxLayout()
self.layout.addWidget(self.toolbar)
self.layout.addWidget(self.canvas)
self.setLayout(self.layout)
# set the plot class handlers
self.wzoom = plot_tools.WheellZoom()
self.adapt = plot_tools.WindowResize() # keep tight layout
self.cursor = plot_tools.SnaptoCursor()
self.selector = plot_tools.Select()
self.selection = plot_tools.Selection()
self.dataplot = None
def pan(self, *args):
"""
:param args:
:return:
"""
NavigationToolbar2QT.pan(self, args)
if self._myMode == NAVIGATION_MODE_PAN:
# out of pan mode
self._myMode = NAVIGATION_MODE_NONE
else:
# into pan mode
self._myMode = NAVIGATION_MODE_PAN
print('PANNED')
def addmpl(self, fig):
self.canvas = FigureCanvas(fig)
self.canvas.mpl_connect('button_press_event',self.on_click)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas,self.mplwindow,coordinates=True)
self.mplvl.addWidget(self.toolbar)
def addmpl(self):
# add plot to anvas
self.rmmpl()
self.canvas = FigureCanvas(self.fig)
self.mplvl.addWidget(self.canvas)
self.canvas.draw()
self.toolbar = NavigationToolbar(self.canvas, self.mplwindow)
self.mplvl.addWidget(self.toolbar)
def __init__(self, parent, settingsdict1={}, obsid=''):
utils.start_waiting_cursor()#show the user this may take a long time...
self.obsid = obsid
self.log_pos = None
self.y_pos = None
self.meas_ts = None
self.head_ts = None
self.head_ts_for_plot = None
self.level_masl_ts = None
self.loggerpos_masl_or_offset_state = 1
self.settingsdict = settingsdict1
qgis.PyQt.QtWidgets.QDialog.__init__(self, parent)
self.setAttribute(qgis.PyQt.QtCore.Qt.WA_DeleteOnClose)
self.setupUi(self) # Required by Qt4 to initialize the UI
self.setWindowTitle(ru(QCoreApplication.translate('Calibrlogger', "Calculate water level from logger"))) # Set the title for the dialog
self.INFO.setText(ru(QCoreApplication.translate('Calibrlogger', "Select the observation point with logger data to be adjusted.")))
self.log_calc_manual.setText("<a href=\"https://github.com/jkall/qgis-midvatten-plugin/wiki/4.-Edit-data\">Midvatten manual</a>")
# Create a plot window with one single subplot
self.calibrplotfigure = plt.figure()
self.axes = self.calibrplotfigure.add_subplot( 111 )
self.canvas = FigureCanvas( self.calibrplotfigure )
self.mpltoolbar = NavigationToolbar( self.canvas, self.widgetPlot )
self.layoutplot.addWidget( self.canvas )
self.layoutplot.addWidget( self.mpltoolbar )
self.show()
self.cid =[]
self.pushButtonSet.clicked.connect(lambda x: self.set_logger_pos())
self.pushButtonAdd.clicked.connect(lambda x: self.add_to_level_masl())
self.pushButtonFrom.clicked.connect(lambda x: self.set_from_date_from_x())
self.pushButtonTo.clicked.connect(lambda x: self.set_to_date_from_x())
self.L1_button.clicked.connect(lambda x: self.set_adjust_data('L1_date', 'L1_level'))
self.L2_button.clicked.connect(lambda x: self.set_adjust_data('L2_date', 'L2_level'))
self.M1_button.clicked.connect(lambda x: self.set_adjust_data('M1_date', 'M1_level'))
self.M2_button.clicked.connect(lambda x: self.set_adjust_data('M2_date', 'M2_level'))
self.pushButton_from_extent.clicked.connect(lambda: self.FromDateTime.setDateTime(num2date(self.axes.get_xbound()[0])))
self.pushButton_to_extent.clicked.connect(lambda: self.ToDateTime.setDateTime(num2date(self.axes.get_xbound()[1])))
self.pushButtonupdateplot.clicked.connect(lambda x: self.update_plot())
self.pushButtonLpos.clicked.connect(lambda x: self.catch_old_level())
self.pushButtonMpos.clicked.connect(lambda x: self.catch_new_level())
self.pushButtonMpos.setEnabled(False)
self.pushButtonCalcBestFit.clicked.connect(lambda x: self.logger_pos_best_fit())
self.pushButtonCalcBestFit.setToolTip(ru(QCoreApplication.translate('Calibrlogger', 'This will calibrate all values inside the chosen period\nusing the mean difference between head_cm and w_levels measurements.\n\nThe search radius is the maximum time distance allowed\n between a logger measurement and a w_level measurement.')))
self.pushButtonCalcBestFit2.clicked.connect(lambda x: self.level_masl_best_fit())
self.pushButtonCalcBestFit2.setToolTip(ru(QCoreApplication.translate('Calibrlogger', 'This will calibrate all values inside the chosen period\nusing the mean difference between level_masl and w_levels measurements.\n\nThe search radius is the maximum time distance allowed\n between a logger measurement and a w_level measurement.')))
self.pushButton_delete_logger.clicked.connect(lambda: self.delete_selected_range('w_levels_logger'))
self.adjust_trend_button.clicked.connect(lambda x: self.adjust_trend_func())
self.get_search_radius()
# Populate combobox with obsid from table w_levels_logger
self.load_obsid_from_db()
utils.stop_waiting_cursor()#now this long process is done and the cursor is back as normal
def __init__(self):
super(Scanner, self).__init__()
self.setupUi(self)
# IP address validator
rx = QRegExp('^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$')
self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue))
# state variable
self.idle = True
# number of samples to show on the plot
self.size = 512 * 512
self.freq = 143.0
# buffer and offset for the incoming samples
self.buffer = bytearray(8 * self.size)
self.offset = 0
self.data = np.frombuffer(self.buffer, np.int32)
# create figure
figure = Figure()
figure.set_facecolor('none')
self.axes = figure.add_subplot(111)
self.canvas = FigureCanvas(figure)
self.plotLayout.addWidget(self.canvas)
self.axes.axis((0.0, 512.0, 0.0, 512.0))
x, y = np.meshgrid(np.linspace(0.0, 512.0, 513), np.linspace(0.0, 512.0, 513))
z = x / 512.0 + y * 0.0
self.mesh = self.axes.pcolormesh(x, y, z, cmap = cm.plasma)
# create navigation toolbar
self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False)
# remove subplots action
actions = self.toolbar.actions()
if int(matplotlib.__version__[0]) < 2:
self.toolbar.removeAction(actions[7])
else:
self.toolbar.removeAction(actions[6])
self.plotLayout.addWidget(self.toolbar)
# create TCP socket
self.socket = QTcpSocket(self)
self.socket.connected.connect(self.connected)
self.socket.readyRead.connect(self.read_data)
self.socket.error.connect(self.display_error)
# connect signals from buttons and boxes
self.connectButton.clicked.connect(self.start)
self.scanButton.clicked.connect(self.scan)
self.periodValue.valueChanged.connect(self.set_period)
self.trgtimeValue.valueChanged.connect(self.set_trgtime)
self.trginvCheck.stateChanged.connect(self.set_trginv)
self.shdelayValue.valueChanged.connect(self.set_shdelay)
self.shtimeValue.valueChanged.connect(self.set_shtime)
self.shinvCheck.stateChanged.connect(self.set_shinv)
self.acqdelayValue.valueChanged.connect(self.set_acqdelay)
self.samplesValue.valueChanged.connect(self.set_samples)
self.pulsesValue.valueChanged.connect(self.set_pulses)
# create timers
self.startTimer = QTimer(self)
self.startTimer.timeout.connect(self.timeout)
self.meshTimer = QTimer(self)
self.meshTimer.timeout.connect(self.update_mesh)
# set default values
self.periodValue.setValue(200.0)
class MatplotlibWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.frame = QWidget()
self.canvas = MplCanvas()
self.canvas.setParent(self.frame)
self.mpltoolbar = Navigationtoolbar(self.canvas, self.frame)
self.vbl = QVBoxLayout()
self.vbl.addWidget(self.canvas)
self.vbl.addWidget(self.mpltoolbar)
self.setLayout(self.vbl)
self.mpltoolbar.toggleViewAction()
def setTitle(self, text):
"""
Sets the figure title
"""
self.canvas.setTitle(text)
def get_axis(self):
return self.canvas.ax
def get_figure(self):
return self.canvas.fig
def clear(self, force=False):
if force:
self.canvas.fig.clear()
self.canvas.ax = self.canvas.fig.add_subplot(111)
# self.canvas.ax.clear()
# self.canvas = MplCanvas()
else:
self.canvas.ax.clear()
def redraw(self):
self.canvas.ax.figure.canvas.draw()
def plot(self, x, y, title='', xlabel='', ylabel=''):
self.setTitle(title)
self.canvas.ax.plot(x, y)
self.redraw()
def _initGui(self):
"""setup the user interface"""
self.ui = Ui_elevationDlg()
self.ui.setupUi(self)
#get settings
self.s = QSettings()
self.loadSettings()
self.gh = geometryHelper( self.iface )
self.eh = elevationHelper( self.iface, self.startDir)
#setup a message bar
self.bar = QgsMessageBar()
self.bar.setSizePolicy( QSizePolicy.Minimum, QSizePolicy.Fixed )
self.ui.verticalLayout.addWidget(self.bar)
self.ui.buttonBox.addButton(QPushButton("Sluiten"), QDialogButtonBox.RejectRole )
for btn in self.ui.buttonBox.buttons():
btn.setAutoDefault(0)
##graph global vars
self.Rubberline = None
self.profile = None
self.pt = None
self.ax = None
self.ano = None
self.anoLbl = None
self.counter = 0
self.xscaleUnit = (1, "m")
# a figure instance to plot on
self.figure = Figure()
#create the Canvas widget and toolbar and set graphWgt as parent
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
###
#self.ui.toolbar.layout().insertWidget(0, self.toolbar)
self.ui.graphWgt.layout().addWidget(self.canvas)
self.createCanvasToolbar()
#events
self.ui.drawBtn.clicked.connect(self.drawBtnClicked)
self.figure.canvas.mpl_connect('motion_notify_event', self.showGraphMotion)
self.ui.saveLineBtn.clicked.connect(self.saveLineClicked)
self.ui.savePntBtn.clicked.connect(self.savePntClicked)
self.ui.addDHMbtn.clicked.connect(self.addDHMasWMS)
self.ui.refreshBtn.clicked.connect( self.onRefresh )
self.ui.buttonBox.helpRequested.connect(self.openHelp)
self.rejected.connect(self.clean )
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.frame = QWidget()
self.canvas = MplCanvas()
self.canvas.setParent(self.frame)
self.mpltoolbar = Navigationtoolbar(self.canvas, self.frame)
self.vbl = QVBoxLayout()
self.vbl.addWidget(self.canvas)
self.vbl.addWidget(self.mpltoolbar)
self.setLayout(self.vbl)
self.mpltoolbar.toggleViewAction()
def __init__(self, parent = None):
# initialization of Qt MainWindow widget
QtWidgets.QWidget.__init__(self, parent)
# set the canvas to the Matplotlib widget
self.canvas = MplCanvas()
self.ntb = NavigationToolbar(self.canvas, self)
#self.ntb.removeAction(self.ntb.buttons[0])
self.ntb.clear()
program_folder = os.path.join(os.path.dirname(__file__), "ims")
a = self.ntb.addAction(self.ntb._icon(os.path.join(program_folder, "world.png")), 'Home', self.zoom2fullextent)
a.setToolTip('Reset original view')
a = self.ntb.addAction(self.ntb._icon(os.path.join(program_folder, "arrow_left.png")), 'Back', self.ntb.back)
a.setToolTip('Back to previous view')
a = self.ntb.addAction(self.ntb._icon(os.path.join(program_folder, "arrow_right.png")), 'Forward', self.ntb.forward)
a.setToolTip('Forward to next view')
a = self.ntb.addAction(self.ntb._icon(os.path.join(program_folder, "arrow_out.png")), 'Pan', self.ntb.pan)
a.setToolTip('Pan axes with left mouse, zoom with right')
a = self.ntb.addAction(self.ntb._icon(os.path.join(program_folder, "zoom.png")), 'Zoom', self.ntb.zoom)
a.setToolTip('Zoom to rectangle')
action_SetSrcPt = self.ntb.addAction(self.ntb._icon(os.path.join(program_folder, "bullet_red.png")), 'Source point', self.pt_map)
action_SetSrcPt.setToolTip('Set source point in map')
a = self.ntb.addAction(self.ntb._icon(os.path.join(program_folder, "camera.png")), 'Save',
self.ntb.save_figure)
a.setToolTip('Save map as image')
a = self.ntb.addAction(self.ntb._icon(os.path.join(program_folder, "help.png")), 'Help',
self.openHelp)
a.setToolTip('Help')
a = self.ntb.addAction(self.ntb._icon(os.path.join(program_folder, "information.png")), 'About',
self.helpAbout)
a.setToolTip('About')
# create a vertical box layout
self.vbl = QtWidgets.QVBoxLayout()
# add widgets to the vertical box
self.vbl.addWidget(self.canvas)
self.vbl.addWidget(self.ntb)
# set the layout to the vertical box
self.setLayout(self.vbl)
def initUI(self):
self.setWindowTitle('NyqLab: Scope')
# Figure
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
toolbar = NavigationToolbar(self.canvas, self)
# Eye diagram toolbar button
action_eye = QtWidgets.QAction(QtGui.QIcon('media/eye'), 'Scope', self)
action_eye.triggered.connect(self.onEyeClick)
toolbar.addAction(action_eye)
# Axis
self.ax_t = self.figure.add_subplot(2, 1, 1)
self.ax_t.grid(True, which='major', linestyle='--')
self.ax_t.set_xlabel('$t / T_\mathrm{b}$')
self.ax_t.axis(self.ax_t_lim_free)
self.ax_t.xaxis.set_major_locator(ticker.MultipleLocator(1.0))
self.ax_t.yaxis.set_major_locator(ticker.MultipleLocator(0.5))
self.ax_f = self.figure.add_subplot(2, 1, 2)
self.ax_f.axis(self.ax_f_lim)
self.ax_f.grid(True, which='major', linestyle='--')
self.ax_f.set_xlabel('$f / R_\mathrm{b}$')
self.ax_f.xaxis.set_major_locator(ticker.MultipleLocator(0.5))
self.ax_f.yaxis.set_major_locator(ticker.MultipleLocator(10.0))
layout = QtWidgets.QVBoxLayout()
layout.addWidget(toolbar)
layout.addWidget(self.canvas)
widget = QtWidgets.QWidget(self)
self.setCentralWidget(widget)
widget.setLayout(layout)
self.resize(800, 500)
def __init__(self):
super(PulsedNMR, self).__init__()
self.setupUi(self)
self.rateValue.addItems(['25', '50', '250', '500', '2500'])
# IP address validator
rx = QRegExp('^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$')
self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue))
# state variable
self.idle = True
# number of samples to show on the plot
self.size = 50000
# buffer and offset for the incoming samples
self.buffer = bytearray(8 * self.size)
self.offset = 0
self.data = np.frombuffer(self.buffer, np.complex64)
# create figure
figure = Figure()
figure.set_facecolor('none')
self.axes = figure.add_subplot(111)
self.canvas = FigureCanvas(figure)
self.plotLayout.addWidget(self.canvas)
# create navigation toolbar
self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False)
# remove subplots action
actions = self.toolbar.actions()
self.toolbar.removeAction(actions[7])
self.plotLayout.addWidget(self.toolbar)
# create TCP socket
self.socket = QTcpSocket(self)
self.socket.connected.connect(self.connected)
self.socket.readyRead.connect(self.read_data)
self.socket.error.connect(self.display_error)
# connect signals from buttons and boxes
self.startButton.clicked.connect(self.start)
self.freqValue.valueChanged.connect(self.set_freq)
self.awidthValue.valueChanged.connect(self.set_awidth)
self.deltaValue.valueChanged.connect(self.set_delta)
self.rateValue.currentIndexChanged.connect(self.set_rate)
# set rate
self.rateValue.setCurrentIndex(2)
# create timer for the repetitions
self.timer = QTimer(self)
self.timer.timeout.connect(self.fire)
def __init__(self, parent=None, dpi=100):
# Create figure and axes, the axes should cover the entire figure size
figure = Figure(dpi=dpi, frameon=False)
self.axes = figure.add_axes((0, 0, 1, 1), facecolor='black')
# Hide the x and y axis, we just want to see the image
self.axes.get_xaxis().set_visible(False)
self.axes.get_yaxis().set_visible(False)
# Initialize the parent FigureCanvas
FigureCanvas.__init__(self, figure)
self.setParent(parent)
# Set background of the widget to be close to black
# The color is not made actually black so that the user can distinguish the image bounds from the figure bounds
self.setStyleSheet('background-color: #222222;')
# Set widget to have strong focus to receive key press events
self.setFocusPolicy(Qt.StrongFocus)
# Create navigation toolbar and hide it
# We don't want the user to see the toolbar but we are making our own in the user interface that will call
# functions from the toolbar
self.toolbar = NavigationToolbar(self, self)
self.toolbar.hide()
# Update size policy and geometry
FigureCanvas.setSizePolicy(self, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
self.isLPS = False
self.isLAS = False
self.image = None
self.sliceNumber = 0
self.diaphragmAxial = None
self.umbilicisInferior = None
self.umbilicisSuperior = None
self.umbilicisLeft = None
self.umbilicisRight = None
self.umbilicisCoronal = None
self.CATLine = None
self.leftArmBounds = None
self.rightArmBounds = None
def __init__(self, layout, vna):
# create figure
self.figure = Figure()
if sys.platform != 'win32':
self.figure.set_facecolor('none')
self.canvas = FigureCanvas(self.figure)
layout.addWidget(self.canvas)
# create navigation toolbar
self.toolbar = NavigationToolbar(self.canvas, None, False)
self.toolbar.layout().setSpacing(6)
# remove subplots action
actions = self.toolbar.actions()
if int(matplotlib.__version__[0]) < 2:
self.toolbar.removeAction(actions[7])
else:
self.toolbar.removeAction(actions[6])
self.toolbar.addSeparator()
self.cursorLabels = {}
self.cursorValues = {}
self.cursorMarkers = {}
self.cursorPressed = {}
for i in range(len(self.cursors)):
self.cursorMarkers[i] = None
self.cursorPressed[i] = False
self.cursorLabels[i] = QLabel('Cursor %d, kHz' % (i + 1))
self.cursorLabels[i].setStyleSheet('color: %s' % self.colors[i])
self.cursorValues[i] = QSpinBox()
self.cursorValues[i].setMinimumSize(90, 0)
self.cursorValues[i].setSingleStep(10)
self.cursorValues[i].setAlignment(Qt.AlignRight | Qt.AlignTrailing | Qt.AlignVCenter)
self.toolbar.addWidget(self.cursorLabels[i])
self.toolbar.addWidget(self.cursorValues[i])
self.cursorValues[i].valueChanged.connect(partial(self.set_cursor, i))
self.canvas.mpl_connect('button_press_event', partial(self.press_marker, i))
self.canvas.mpl_connect('motion_notify_event', partial(self.move_marker, i))
self.canvas.mpl_connect('button_release_event', partial(self.release_marker, i))
self.toolbar.addSeparator()
self.plotButton = QPushButton('Rescale')
self.toolbar.addWidget(self.plotButton)
layout.addWidget(self.toolbar)
self.plotButton.clicked.connect(self.plot)
self.mode = None
self.vna = vna
def __init__(self, parent = None):
QWidget.__init__(self, parent)
self.canvas = FigureCanvas(Figure())
vertical_layout = QVBoxLayout()
vertical_layout.addWidget(self.canvas)
self.canvas.axes = self.canvas.figure.add_subplot(111)
self.setLayout(vertical_layout)
self.toolbar = NavigationToolbar2QT(self.canvas,self,coordinates=True)
vertical_layout.addWidget(self.toolbar)
img = plt.imread('map.png',0)
print(self.points_for_ride([5,5],[20,20], 2, 5))
self.canvas.axes.imshow(img)
def __init__(self,
parent: QWidget,
row: int = 1,
col: int = 1,
polar: bool = False):
"""Input title and two axises, QChart class has no parent."""
super(DataChart, self).__init__(parent)
layout = QVBoxLayout(self)
figure = Figure()
canvas = FigureCanvasQTAgg(figure)
layout.addWidget(NavigationToolbar2QT(canvas, self))
layout.addWidget(canvas)
self._ax: List[Axes] = []
for i in range(1, row * col + 1):
self._ax.append(figure.add_subplot(row, col, i, polar=polar))
def set_margin(m: float) -> None:
figure.tight_layout(pad=m)
self.set_margin = set_margin
def __init__(self, parent=None, flags=QtCore.Qt.WindowFlags()):
super().__init__(parent=parent, flags=flags)
self.setWindowTitle("Visualización de distribución")
# Main widget to be displayed
self.content = QWidget()
self.layout = QVBoxLayout()
# Canvas is the object that holds the graph
self.canvas = MplCanvas()
self.toolbox = NavigationToolbar2QT(self.canvas, self.content)
# Add the widgets to a vertical layout
self.layout.addWidget(self.toolbox)
self.layout.addWidget(self.canvas)
# Set the content as the central widget
self.content.setLayout(self.layout)
self.setCentralWidget(self.content)
def __init__(self, parent=None, width=5, height=4, dpi=100):
fig = Figure(figsize=(width, height), dpi=dpi)
self.axes = fig.add_subplot(111)
# We want the axes cleared every time plot() is called
self.axes.hold(False)
self.compute_initial_figure()
#
FigureCanvas.__init__(self, fig)
self.setParent(parent)
'''FigureCanvas.setSizePolicy(self,
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)'''
FigureCanvas.updateGeometry(self)
self.tootlbar=NavigationToolbar(self,parent)
self.tootlbar.hide()
def populate(self):
self.setWindowTitle('Live plotter')
self.canvas = MplCanvas()
self.nav = NavigationToolbar(self.canvas, self)
'''Changed nav toolbar'''
self.nav.addAction('Reset optimizer', self.reset_opt)
self.layout = QGridLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.nav)
self.layout.addWidget(self.canvas)
self.setLayout(self.layout)
#self.canvas.ax.set_ylim((0, 5e-5))
#self.canvas.ax.set_xlim((0, .04))
width = self.canvas.width()
height = self.nav.height() + self.canvas.height() + 20
self.setFixedSize(width, height)
def init_commandlayout(self) -> None:
self.commandLayout = QVBoxLayout()
fig = Figure(figsize=(4, 3), dpi=100)
self.contrast_fc = FigureCanvas(fig)
self.contrast_ax = self.contrast_fc.figure.add_subplot(111)
self.contrast_fc.draw()
nav = NavigationToolbar2QT(self.contrast_fc, self)
nav.setStyleSheet("QToolBar { border: 0px }")
self.commandLayout.addWidget(self.contrast_fc)
self.commandLayout.addWidget(nav)
self.contrastTable = QTableWidget()
self.contrastTable.setSelectionBehavior(QTableView.SelectRows)
self.contrastTable.horizontalHeader().setDefaultSectionSize(90)
self.contrastTable.verticalHeader().setDefaultSectionSize(30)
self.commandLayout.addWidget(self.contrastTable)
self.mainlayout.addLayout(self.commandLayout)
def __init__(self, parent=None):
super(MplGraphQt5Widget, self).__init__(parent)
self.width = 3
self.height = 3
self.dpi = 100
self._dataY = np.array([])
self._dataX = np.array([])
self._spCols = 1
self._spRows = 1
self.all_sp_axes = []
self.fig = Figure(figsize=(self.width, self.height), dpi=self.dpi)
self.all_sp_axes.append(self.fig.add_subplot(self._spCols, self._spRows, 1))
self.fig.set_frameon(False)
self.fig.set_tight_layout(True)
self.canvas = Canvas(self.fig)
self._navBarOn = False
self.mpl_toolbar = NavigationToolbar(self.canvas, parent)
self.mpl_toolbar.dynamic_update()
self.canvas.mpl_connect('key_press_event', self.on_key_press)
self.canvas.mpl_connect('button_press_event', self.on_button_press)
self.canvas.mpl_connect('motion_notify_event', self.on_mouse_move)
self.canvas.setFocusPolicy(Qt.ClickFocus)
self.canvas.setFocus()
self.canvas.setParent(parent)
self.canvas.clearMask()
self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.canvas.updateGeometry()
vbox = QVBoxLayout()
vbox.addWidget(self.canvas)
vbox.addWidget(self.mpl_toolbar)
if not self._navBarOn:
self.mpl_toolbar.hide()
self.setLayout(vbox)
def create_main_frame(self):
self.main_frame = QtWidgets.QWidget()
# Create the mpl Figure and FigCanvas objects
self.dpi = 100
self.fig = Figure((10.0, 10.0), dpi=self.dpi, facecolor='White')
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
# Create the navigation toolbar, tied to the canvas
self.mpl_toolbar = NavigationToolbar(self.canvas, self.main_frame)
save_button = QtWidgets.QPushButton()
save_button.clicked.connect(self.save_production_data)
save_button.setIcon(QtGui.QIcon(":save.png"))
save_button.setToolTip("Save production data")
save_button.setStatusTip("Save production data")
show_button = QtWidgets.QPushButton()
show_button.clicked.connect(self.plot_settings_view)
show_button.setIcon(QtGui.QIcon(":gear.png"))
show_button.setToolTip("Edit settings")
show_button.setStatusTip("Edit settings")
buttonbox0 = QtWidgets.QDialogButtonBox()
buttonbox0.addButton(save_button, QtWidgets.QDialogButtonBox.ActionRole)
buttonbox0.addButton(show_button, QtWidgets.QDialogButtonBox.ActionRole)
self.mpl_toolbar.addWidget(buttonbox0)
vbox = QtWidgets.QVBoxLayout()
vbox.addWidget(self.mpl_toolbar)
vbox.addWidget(self.canvas)
self.main_frame.setLayout(vbox)
self.setCentralWidget(self.main_frame)
self.status_text = QtWidgets.QLabel("")
self.statusBar().addWidget(self.status_text,1)
def __init__(self, figures, fig_no=0):
super().__init__()
self.setWindowTitle("Plot")
self.figures = figures
self.fig_no = fig_no
self.left_v_widget = QWidget(self)
self.left_v_box = QtWidgets.QVBoxLayout(self.left_v_widget)
self.left_v_box.setContentsMargins(0, 0, 0, 0)
self.right_v_widget = QWidget(self)
self.right_v_box = QtWidgets.QVBoxLayout(self.right_v_widget)
self.right_v_box.setContentsMargins(4, 0, 10, 0)
self.canvas = Canvas(self.left_v_widget, figures[fig_no])
self.nav = NavigationToolbar2QT(self.canvas, self.left_v_widget)
self.left_v_box.addWidget(self.nav)
self.left_v_box.addWidget(self.canvas)
self.button_time = QtWidgets.QPushButton(self.right_v_widget)
self.button_time.setText("Time Domain")
self.button_time.clicked.connect(self.change_to_time)
self.button_frequency = QtWidgets.QPushButton(self.right_v_widget)
self.button_frequency.setText("Frequency Domain")
self.button_frequency.clicked.connect(self.change_to_frequency)
self.right_v_box.addStretch()
self.right_v_box.addWidget(self.button_time)
self.right_v_box.addStretch()
self.right_v_box.addWidget(self.button_frequency)
self.right_v_box.addStretch()
self.layout = QtWidgets.QHBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.left_v_widget)
self.layout.addWidget(self.right_v_widget)
self.setLayout(self.layout)
self.setMinimumSize(self.width(), self.height())
def populate(self):
self.setWindowTitle(self.name)
self.canvas = MplCanvas()
self.nav = NavigationToolbar(self.canvas, self)
#select_cam = self.nav.addAction('&Select camera')
#select_cam.addAction('horizontal mot')
#select_cam.addAction('vertical mot (cavity)')
self.nav.addAction('Launch live plotter', self.launch_plotter)
self.layout = QGridLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.nav)
self.layout.addWidget(self.canvas)
self.setLayout(self.layout)
width = self.canvas.width()
height = self.nav.height() + self.canvas.height()
self.setFixedSize(width, height)
def __init__(self):
super(MatplotlibPopupWindow, self).__init__()
self.main_widget = QtWidgets.QWidget()
self.setCentralWidget(self.main_widget)
# Init the matplotlib canvas
self.canvas = FigureCanvas(Figure(facecolor='#efebe7'))
self.canvas.axes = self.canvas.figure.add_subplot(111)
# Create toolbar, passing canvas as first parament, parent (self, the MainWindow) as second.
toolbar = NavigationToolbar2QT(self.canvas, self)
# Compose elements into layout
layout = QVBoxLayout(self.main_widget)
layout.addWidget(toolbar)
layout.addWidget(self.canvas)
def populate(self):
self.setWindowTitle("Clock + cavity gui")
self.canvas = MplCanvas()
self.nav = NavigationToolbar(self.canvas, self)
#self.nav.addAction('Select analysis method')
#self.nav.addAction('Launch live plotter', self.launch_plotter)
self.layout = QGridLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.nav)
self.layout.addWidget(self.canvas)
self.setLayout(self.layout)
width = self.canvas.width()
height = self.nav.height() + self.canvas.height()
self.setFixedSize(width, height)
self.add_subplot_buttons()
def __init__(self):
super().__init__()
self.observable_net = self.grad_displays = \
self.weight_displays = self.weights = self.gradients = self.displays = None
self.l1_from = self.l1_to = self.l2_from = self.l2_to = self.step = self.adjust_value = \
self.grad_vectors = self.weight_vectors = None
self.layer = 0
self.epochs = 10
self.delete_x = 0
self.delete_y = 0
self.initialize_observable_net()
self.ad_value = None
self.vis = 'gradient'
self.figure = Figure()
self.canvas = FigureCanvasQTAgg(self.figure)
self.toolbar = NavigationToolbar2QT(self.canvas, self)
self.init_ui()
self.update_texts()
def __createFigure(self): ##创建绘图系统
self.__fig = mpl.figure.Figure(figsize=(8, 5)) #单位英寸
figCanvas = FigureCanvas(self.__fig) #创建FigureCanvas对象，必须传递一个Figure对象
self.__naviBar = NavigationToolbar(figCanvas,
self) #创建NavigationToolbar工具栏
actList = self.__naviBar.actions() #关联的Action列表
for act in actList: #获得每个Action的标题和tooltip，可注释掉
print("text=%s,\ttoolTip=%s" % (act.text(), act.toolTip()))
self.__changeActionLanguage() #改工具栏的语言为汉语
##工具栏改造
actList[6].setVisible(False) #隐藏Subplots 按钮
actList[7].setVisible(False) #隐藏Customize按钮
act8 = actList[8] #分隔条
self.__naviBar.insertAction(act8, self.ui.actTightLayout) #"紧凑布局"按钮
self.__naviBar.insertAction(act8, self.ui.actSetCursor) #"十字光标"按钮
count = len(actList) #Action的个数
lastAction = actList[count - 1] #最后一个Action
self.__naviBar.insertAction(lastAction,
self.ui.actScatterAgain) #"重绘散点"按钮
lastAction.setVisible(False) #隐藏其原有的坐标提示
self.__naviBar.addSeparator()
self.__naviBar.addAction(self.ui.actQuit) #"退出"按钮
self.__naviBar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon) #显示方式
self.addToolBar(self.__naviBar) #添加作为主窗口工具栏
self.setCentralWidget(figCanvas)
figCanvas.setCursor(Qt.CrossCursor)
## 必须保留变量cid，否则可能被垃圾回收
self._cid1 = figCanvas.mpl_connect("motion_notify_event",
self.do_canvas_mouseMove)
self._cid2 = figCanvas.mpl_connect("axes_enter_event",
self.do_axes_mouseEnter)
self._cid3 = figCanvas.mpl_connect("axes_leave_event",
self.do_axes_mouseLeave)
self._cid4 = figCanvas.mpl_connect("pick_event", self.do_series_pick)
self._cid5 = figCanvas.mpl_connect("scroll_event", self.do_scrollZoom)
def __init__(self, parent):
super().__init__(parent)
self.parent = parent
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.setWindowTitle('Graph Window')
vbl = QtWidgets.QVBoxLayout(self) # self is where layout is assigned
hbl = QtWidgets.QHBoxLayout()
self.mmc = MyMplCanvas(self)
mpl_toolbar = NavigationToolbar2QT(self.mmc, self.parent)
self.combobox1 = QtWidgets.QComboBox()
self.combobox2 = QtWidgets.QComboBox()
self.spinbox = QtWidgets.QSpinBox()
self.label1 = QtWidgets.QLabel('Bands:')
self.label2 = QtWidgets.QLabel('Bands:')
self.label3 = QtWidgets.QLabel('Value:')
self.checkbox = QtWidgets.QCheckBox('Option:')
self.checkbox.hide()
hbl.addWidget(self.label1)
hbl.addWidget(self.combobox1)
hbl.addWidget(self.label2)
hbl.addWidget(self.combobox2)
hbl.addWidget(self.label3)
hbl.addWidget(self.spinbox)
vbl.addWidget(self.mmc)
vbl.addWidget(mpl_toolbar)
vbl.addWidget(self.checkbox)
vbl.addLayout(hbl)
self.setFocus()
self.combobox1.currentIndexChanged.connect(self.change_band)
self.combobox2.currentIndexChanged.connect(self.change_band)
self.spinbox.valueChanged.connect(self.change_band)
self.checkbox.stateChanged.connect(self.change_band)
def __init__(self):
QMainWindow.__init__(self)
menubar = self.menuBar()
filemenu = menubar.addMenu("File")
file_loader_widget = FileLoaderWidget(self)
file_loader_presenter = file_loader_widget.get_presenter()
filemenu.addAction(file_loader_widget)
preview_widget = PreviewWidget()
preview_presenter = preview_widget.get_presenter()
plot_widget = PlotWidget()
plot_presenter = plot_widget.get_presenter()
self.toolbar = NavigationToolbar(plot_widget, self)
self.addToolBar(self.toolbar)
MainViewPresenter(self, file_loader_presenter, preview_presenter,
plot_presenter)
# Action for exiting the program
exitAct = QAction("Exit", self)
exitAct.triggered.connect(self.close)
filemenu.addAction(exitAct)
self.statusBar()
centralWidget = QWidget()
self.setCentralWidget(centralWidget)
gridLayout = QGridLayout()
centralWidget.setLayout(gridLayout)
gridLayout.addWidget(preview_widget, 0, 0)
gridLayout.addWidget(plot_widget, 0, 1)
self.setWindowTitle("Dataset Viewer")
self.show()
def setupui(self):
""" Setup UI """
hbl_all = QtWidgets.QHBoxLayout(self)
mpl_toolbar = NavigationToolbar2QT(self.mmc, self)
vbl_raster = QtWidgets.QVBoxLayout()
label2 = QtWidgets.QLabel()
label3 = QtWidgets.QLabel()
self.dsb_dist.setDecimals(4)
self.dsb_dist.setMinimum(0.0001)
self.dsb_dist.setSingleStep(0.0001)
self.dsb_dist.setProperty("value", 0.001)
self.radio_geog.setChecked(True)
spacer = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.setWindowTitle("Fault Plane Solution (FPS)")
label2.setText('FPS Algorithm:')
label3.setText('Width Scale Factor:')
self.btn_saveshp.setText('Save Shapefile')
vbl_raster.addWidget(label2)
vbl_raster.addWidget(self.cbox_alg)
vbl_raster.addWidget(label3)
vbl_raster.addWidget(self.dsb_dist)
vbl_raster.addWidget(self.radio_geog)
vbl_raster.addWidget(self.radio_proj)
vbl_raster.addItem(spacer)
vbl_raster.addWidget(self.btn_saveshp)
vbl_right = QtWidgets.QVBoxLayout()
vbl_right.addWidget(self.mmc)
vbl_right.addWidget(mpl_toolbar)
hbl_all.addLayout(vbl_raster)
hbl_all.addLayout(vbl_right)
self.btn_saveshp.clicked.connect(self.save_shp)
self.dsb_dist.valueChanged.connect(self.change_alg)
self.radio_geog.toggled.connect(self.change_alg)
def create_widget_plot(self):
self.widget_plot = QWidget(self)
self.vbox_plot = QVBoxLayout()
self.hbox_plot = QHBoxLayout()
self.fig_plot = Figure(figsize=(9, 6), dpi=65)
self.fig_plot.patch.set_color('w')
self.ax_plot = self.fig_plot.add_axes([0, 0, 1, 1],
axisbg=(0.6, 0.7, 0.8))
self.canvas_plot = FigureCanvas(self.fig_plot)
self.canvas_plot.setParent(self.widget_plot)
self.canvas_plot.show()
self.mpl_toolbar = NavigationToolbar(self.canvas_plot,
self.widget_plot)
self.mpl_toolbar.setStyleSheet("border:none;background-color:#efefef")
self.ch_color = ['y', 'b', 'r', 'g']
self.ch1_label = QLabel('CH1')
self.ch2_label = QLabel('CH2')
self.ch3_label = QLabel('CH3')
self.ch4_label = QLabel('CH4')
self.ch_label_group = [
self.ch1_label, self.ch2_label, self.ch3_label, self.ch4_label
]
for i in self.ch_label_group:
i.setStyleSheet(
"color:rgb(100,100,100,250);font-size:15px;font-weight:bold;border:2px solid red;"
)
self.hbox_plot.addWidget(self.ch1_label)
self.hbox_plot.addStretch(1)
self.hbox_plot.addWidget(self.ch2_label)
self.hbox_plot.addStretch(1)
self.hbox_plot.addWidget(self.ch3_label)
self.hbox_plot.addStretch(1)
self.hbox_plot.addWidget(self.ch4_label)
self.vbox_plot.addWidget(self.canvas_plot)
self.vbox_plot.addWidget(self.mpl_toolbar)
self.vbox_plot.addLayout(self.hbox_plot)
self.widget_plot.setLayout(self.vbox_plot)
def __init__(self, ):
super(PlotWidget, self).__init__()
self.setupUi(self)
self.fig_dict = {}
# store copies of call backs, so that they are not garbage collected
self.on_wheel_cpy = self.on_wheel
self.on_db_click_cpy = self.on_db_click
# set figure and background to transparent
self.plotAreaWidget.fig = Figure(facecolor="white")
self.plotAreaWidget.fig.set_tight_layout(True)
# set some properties for canvas
self.plotAreaWidget.canvas = FigureCanvas(self.plotAreaWidget.fig)
self.splitter.setSizes([680, 50])
self.ax = self.plotAreaWidget.fig.add_subplot(111)
self.ax.grid(True)
# connect scroll and double click event to canvas
self.plotAreaWidget.canvas.mpl_connect('scroll_event',
self.on_wheel_cpy)
self.plotAreaWidget.canvas.mpl_connect('button_press_event',
self.on_db_click_cpy)
self.verticalLayout_3.addWidget(self.plotAreaWidget.canvas)
# add the toolbar for the plot
self.toolbar = NavigationToolbar(self.plotAreaWidget.canvas,
self.plotAreaWidget,
coordinates=True)
self.toolbar.pan()
self.verticalLayout_3.addWidget(self.toolbar)
self.label_warning.hide()
# Anchor identifier for ci plots
self.anchor_identifier = ''
self.ci_mode = 'average'
def stack1UI(self): #THE PLOTTING CAPABILITY
#figure painting from matplot
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
#toolbar addition
self.toolbar = NavigationToolbar(self.canvas, self)
self.toolbar.show()
#some buttons for functionality
self.button = QtWidgets.QPushButton('ReadPlot')
self.button.clicked.connect(self.readplot)
self.button2 = QtWidgets.QPushButton('ClearPlot')
self.button2.clicked.connect(self.clearplot)
layout = QtWidgets.QVBoxLayout()
layout.addWidget(self.toolbar)
layout.addWidget(self.canvas)
layout.addWidget(self.button)
layout.addWidget(self.button2)
self.stack1.setLayout(layout)
def __init__(self, parent, plot_name):
super().__init__(parent)
self.plot_name = plot_name
self.plot_manager = PlotManager.instance
self.plot_thread = None
self.figure = Figure(figsize=(18, 12))
# self.figure.subplots_adjust(left=0.1, right=0.9,
# bottom=0.1, top=0.9,
# hspace=0.3, wspace=0.3)
self.canvas = FigureCanvas(self.figure)
self.toolbar = NavigationToolbar(self.canvas, self)
main_layout = QtWidgets.QVBoxLayout(self)
main_layout.setAlignment(QtCore.Qt.AlignTop | QtCore.Qt.AlignLeft)
main_layout.setContentsMargins(0, 0, 0, 0)
main_layout.setSpacing(0)
main_layout.addWidget(self.toolbar)
main_layout.addWidget(self.canvas)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.fig_pdynamic = Figure()
self.fig_pdynamic.set_facecolor('#ffffff')
self.canvas_pdynamic = FigureCanvas(self.fig_pdynamic)
vertical_layout = QVBoxLayout()
vertical_layout.addWidget(self.canvas_pdynamic)
self.canvas_pdynamic.axes_pdynamic = self.canvas_pdynamic.figure.add_subplot(
111)
self.setLayout(vertical_layout)
self.canvas_pdynamic.axes_pdynamic.set_xticks([])
self.canvas_pdynamic.axes_pdynamic.set_yticks([])
self.canvas_pdynamic.axes_pdynamic.axis('off')
self.fig_pdynamic.subplots_adjust(left=0.12,
bottom=0.15,
right=0.985,
top=0.95)
self.toolbar = NavigationToolbar(self.canvas_pdynamic, self)
self.toolbar.setFixedHeight(25)
vertical_layout.addWidget(self.toolbar)
def __init__(self, figure, identifier, filepath):
self.identifier = identifier
loader = UiLoader()
self.ui = loader.load(os.path.join(LYSE_DIR, 'plot_window.ui'),
PlotWindow())
# Tell Windows how to handle our windows in the the taskbar, making pinning work properly and stuff:
if os.name == 'nt':
self.ui.newWindow.connect(set_win_appusermodel)
self.set_window_title(identifier, filepath)
# figure.tight_layout()
self.figure = figure
self.canvas = figure.canvas
self.navigation_toolbar = NavigationToolbar(self.canvas, self.ui)
self.lock_action = self.navigation_toolbar.addAction(
QtGui.QIcon(':qtutils/fugue/lock-unlock'), 'Lock axes',
self.on_lock_axes_triggered)
self.lock_action.setCheckable(True)
self.lock_action.setToolTip('Lock axes')
self.copy_to_clipboard_action = self.navigation_toolbar.addAction(
QtGui.QIcon(':qtutils/fugue/clipboard--arrow'),
'Copy to clipboard', self.on_copy_to_clipboard_triggered)
self.copy_to_clipboard_action.setToolTip('Copy to clipboard')
self.copy_to_clipboard_action.setShortcut(QtGui.QKeySequence.Copy)
self.ui.verticalLayout_canvas.addWidget(self.canvas)
self.ui.verticalLayout_navigation_toolbar.addWidget(
self.navigation_toolbar)
self.lock_axes = False
self.axis_limits = None
self.update_window_size()
self.ui.show()
def __init__(self, parent=None):
QtWidgets.QDialog.__init__(self, parent=None)
self.parent = parent
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.setWindowTitle("Graph Window")
vbl = QtWidgets.QVBoxLayout(self) # self is where layout is assigned
self.hbl = QtWidgets.QHBoxLayout()
self.mmc = MyMplCanvas(self)
mpl_toolbar = NavigationToolbar2QT(self.mmc, self.parent)
self.combobox1 = QtWidgets.QComboBox()
self.combobox2 = QtWidgets.QComboBox()
self.spinbox = QtWidgets.QSpinBox()
self.label1 = QtWidgets.QLabel()
self.label2 = QtWidgets.QLabel()
self.label3 = QtWidgets.QLabel()
self.label1.setText('Bands:')
self.label2.setText('Bands:')
self.label3.setText('Value:')
self.hbl.addWidget(self.label1)
self.hbl.addWidget(self.combobox1)
self.hbl.addWidget(self.label2)
self.hbl.addWidget(self.combobox2)
self.hbl.addWidget(self.label3)
self.hbl.addWidget(self.spinbox)
vbl.addWidget(self.mmc)
vbl.addWidget(mpl_toolbar)
vbl.addLayout(self.hbl)
self.setFocus()
self.combobox1.currentIndexChanged.connect(self.change_band)
self.combobox2.currentIndexChanged.connect(self.change_band)
self.spinbox.valueChanged.connect(self.change_band)
def __init__(self, parent=None):
super().__init__(parent)
self.settings = QSettings()
self.settings.beginGroup("plot_display")
# initialise canvas/figure/axes according to
# https://matplotlib.org/examples/user_interfaces/embedding_in_qt5.html
self.fig = Figure(figsize=(10, 10),
facecolor=(1, 1, 1),
edgecolor=(0, 0, 0))
self.ax = self.fig.add_axes((0, 0, 1, 1))
self.ax.tick_params(pad=-5)
self.canvas = FigureCanvas(self.fig)
self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.canvas.updateGeometry()
self.toolbar = NavigationToolbar(self.canvas, self)
# plot params
self._vector_data = vpype.VectorData()
self._page_format = (100, 100) # in pixels
self._init_lims = True
self._layers = {}
# settings
self._unit: str = self.settings.value("unit", "cm")
self._colorful: bool = self.settings.value("colorful", False)
self._show_points: bool = self.settings.value("show_points", False)
self._show_pen_up: bool = self.settings.value("show_pen_up", False)
self._show_axes: bool = self.settings.value("show_axes", False)
self._show_grid: bool = self.settings.value("show_grid", False)
# setup layout
layout = QVBoxLayout()
layout.setMargin(0)
layout.setSpacing(0)
layout.addWidget(self.canvas)
layout.addWidget(self.toolbar)
self.setLayout(layout)
def create_main_frame(self, two_axes=False):
self.main_frame = QtWidgets.QWidget()
# Create the mpl Figure and FigCanvas objects
self.dpi = 100
self.fig = Figure((10.0, 10.0), dpi=self.dpi, facecolor='White')
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
self.axes = self.fig.add_subplot(111, facecolor='White')
if two_axes:
self.axes2 = self.axes.twinx()
# Create the navigation toolbar, tied to the canvas
self.mpl_toolbar = NavigationToolbar(self.canvas, self.main_frame)
# Other GUI controls
show_button = QtWidgets.QPushButton()
show_button.clicked.connect(self.plot_settings_view)
show_button.setIcon(QtGui.QIcon(":gear.png"))
show_button.setToolTip(self.tr("Plot settings"))
show_button.setStatusTip(self.tr("Plot settings"))
buttonbox0 = QtWidgets.QDialogButtonBox()
buttonbox0.addButton(show_button,
QtWidgets.QDialogButtonBox.ActionRole)
self.mpl_toolbar.addWidget(show_button)
vbox = QtWidgets.QVBoxLayout()
vbox.addWidget(self.mpl_toolbar)
vbox.addWidget(self.canvas)
self.main_frame.setLayout(vbox)
self.setCentralWidget(self.main_frame)
self.status_text = QtWidgets.QLabel("")
self.statusBar().addWidget(self.status_text, 1)
def __init__(self, redraw):
super(PlotCanvas, self).__init__()
layout = QtWidgets.QGridLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
self.setLayout(layout)
figure = Figure()
canvas = FigureCanvasQTAgg(figure)
canvas.setContentsMargins(0, 0, 0, 0)
layout.addWidget(canvas, 1, 1, 1, 1)
self._canvas = canvas
toolbar = NavigationToolbar2QT(canvas, self)
layout.addWidget(toolbar, 2, 1, 1, 1)
plot = figure.add_subplot(111, projection='3d')
# plot.set_aspect('equal')
self._plot = plot
self._redraw.connect(redraw)
def create_main_frame(self,two_axes=False):
self.main_frame = QtWidgets.QWidget()
# Create the mpl Figure and FigCanvas objects
self.dpi = 100
self.fig = Figure((10.0, 10.0), dpi=self.dpi, facecolor='White')
self.canvas = FigureCanvas(self.fig)
self.canvas.setParent(self.main_frame)
self.axes = self.fig.add_subplot(111, facecolor='White')
if two_axes:
self.axes2 = self.axes.twinx()
# Create the navigation toolbar, tied to the canvas
self.mpl_toolbar = NavigationToolbar(self.canvas, self.main_frame)
# Other GUI controls
show_button = QtWidgets.QPushButton()
show_button.clicked.connect(self.plot_settings_view)
show_button.setIcon(QtGui.QIcon(":gear.png"))
show_button.setToolTip(self.tr("Plot settings"))
show_button.setStatusTip(self.tr("Plot settings"))
buttonbox0 = QtWidgets.QDialogButtonBox()
buttonbox0.addButton(show_button, QtWidgets.QDialogButtonBox.ActionRole)
self.mpl_toolbar.addWidget(show_button)
vbox = QtWidgets.QVBoxLayout()
vbox.addWidget(self.mpl_toolbar)
vbox.addWidget(self.canvas)
self.main_frame.setLayout(vbox)
self.setCentralWidget(self.main_frame)
self.status_text = QtWidgets.QLabel("")
self.statusBar().addWidget(self.status_text,1)
def __init__(self,
figure,
out_dir=None,
):
super().__init__()
#=======================================================================
# defauklts
#=======================================================================
if out_dir is None: out_dir = os.getcwd()
#update defaults
if not os.path.exists(out_dir):os.makedirs(out_dir)
matplotlib.rcParams['savefig.directory'] = out_dir
#styleize window
self.setWindowTitle('CanFlood %s'%(figure._suptitle.get_text()[:15]))
#=======================================================================
# setup window
#=======================================================================
#add the main widget
self._main = QtWidgets.QWidget()
self.setCentralWidget(self._main)
#build a la yout
layout = QtWidgets.QVBoxLayout(self._main)
#build/add canvas to layout
canvas = FigureCanvas(figure)
layout.addWidget(canvas)
#build/add toolbar
self._toolbar = NavigationToolbar2QT(canvas, self)
self.addToolBar(self._toolbar)
def __init__(self, canvas: FigureCanvasQTAgg):
super().__init__()
self.layout = QVBoxLayout(self)
self.setLayout(self.layout)
self.canvas = canvas
self.canvas.setParent(self)
self.canvas.setFocusPolicy(Qt.StrongFocus)
self.canvas.setFocus()
self.layout.addWidget(self.canvas)
self.figure = canvas.figure # type: Figure
self.mpl_toolbar = NavigationToolbar(self.canvas, self)
self.layout.addWidget(self.mpl_toolbar)
def sizeHint():
size = super(NavigationToolbar, self.mpl_toolbar).sizeHint()
return size
self.mpl_toolbar.sizeHint = sizeHint
self.mpl_toolbar.layout().setContentsMargins(0, 0, 0, 0)
self.mpl_toolbar.setIconSize(QSize(16, 16))
self.mpl_toolbar.layout().setSpacing(2)
self.layout.setContentsMargins(0, 0, 0, 0)
# self.mpl_toolbar.setHeight(20)
self.canvas.mpl_connect('key_press_event', self.on_key_press)
self.canvas.mpl_connect('scroll_event', self.on_scroll)
self.canvas.mpl_connect('key_release_event', self.on_key_release)
self.mpl_toolbar.pan() # we usually want to pan with mouse, since zooming is on the scroll
self.current_modifiers = set()
self.restored_axes = set()
self.axes_state_to_restore = []
self.figure.add_axobserver(lambda figure: self._restore_existing_axes())
self.setMinimumSize(200, 200)
def setupUi(self, Form):
Ui_gmx_extract_energy.setupUi(self, Form)
Form.fsmodel = QtWidgets.QFileSystemModel()
Form.treeViewOpenFile.setModel(Form.fsmodel)
Form.fsmodel.setNameFilters(['*.edr'])
Form.fsmodel.setRootPath('/')
Form.treeViewOpenFile.hideColumn(1)
Form.treeViewOpenFile.hideColumn(2)
Form.treeViewOpenFile.hideColumn(3)
Form.fsmodel.sort(0, QtCore.Qt.AscendingOrder)
Form.treeViewOpenFile.expand(Form.fsmodel.index(os.getcwd()))
Form.treeViewOpenFile.setCurrentIndex(Form.fsmodel.index(os.getcwd()))
Form.treeViewOpenFile.scrollTo(Form.fsmodel.index(os.getcwd()), QtWidgets.QAbstractItemView.PositionAtTop)
Form.treeViewOpenFile.activated.connect(Form.onFileSelected)
Form.figure = Figure()
Form.figureCanvas = FigureCanvasQTAgg(Form.figure)
Form.verticalLayoutFigure.addWidget(Form.figureCanvas)
Form.navigationToolBar = NavigationToolbar2QT(Form.figureCanvas, Form)
Form.verticalLayoutFigure.addWidget(Form.navigationToolBar)
Form.hideAllPushButton.clicked.connect(Form.hideAll)
Form.toolButtonGoFirst.clicked.connect(
lambda: Form.horizontalSliderCursor.triggerAction(Form.horizontalSliderCursor.SliderToMinimum))
Form.toolButtonGoLast.clicked.connect(
lambda: Form.horizontalSliderCursor.triggerAction(Form.horizontalSliderCursor.SliderToMaximum))
Form.toolButtonGoNext.clicked.connect(
lambda: Form.horizontalSliderCursor.triggerAction(Form.horizontalSliderCursor.SliderSingleStepAdd))
Form.toolButtonGoPrevious.clicked.connect(
lambda: Form.horizontalSliderCursor.triggerAction(Form.horizontalSliderCursor.SliderSingleStepSub))
Form.tminSlider.valueChanged.connect(Form.onTminSliderValueChanged)
Form.tmaxSlider.valueChanged.connect(Form.onTmaxSliderValueChanged)
Form.smoothingSlider.valueChanged.connect(Form.onSmoothingChanged)
index = 0
for i, w in enumerate(sorted(self.windowfunctions)):
Form.smoothingFunctionComboBox.addItem(self.windowfunctions[w])
if w == 'boxcar':
index = i
Form.smoothingFunctionComboBox.setCurrentIndex(index)
Form.smoothingFunctionComboBox.currentIndexChanged.connect(lambda *args: self.replot())
def __init__(self, parent: Any):
super(CreateFigure, self).__init__()
self.parent = parent
self.hbox = QHBoxLayout(self)
lwidget, lvbox = QWidget(), QVBoxLayout()
self.list_widget = QListWidget()
self.update_list()
self.list_widget.itemClicked.connect(self.plot_figure_clicked)
lvbox.addWidget(self.list_widget)
lwidget.setLayout(lvbox)
self.hbox.addWidget(lwidget)
self.figure = FigureCanvas(width=5, height=4, dpi=100)
toolbar = NavigationToolbar2QT(self.figure, self, coordinates=False)
rwidget, rvbox = QWidget(), QVBoxLayout()
rvbox.addWidget(toolbar)
rvbox.addWidget(self.figure)
rwidget.setLayout(rvbox)
self.hbox.addWidget(rwidget)
def __init__(self):
super().__init__()
self.left = 10
self.top = 10
self.title = 'XRD data processing'
self.width = 720
self.height = 540
self.button1 = QPushButton('Open file', self)
self.label1 = QLabel('', self)
self.label2 = QLabel('Specify theta', self)
self.kanal = QLineEdit('', self)
self.button2 = QPushButton('Next', self)
self.hboxLayout = QHBoxLayout(self)
self.m = PlotCanvas(self, width=6.9, height=4.5)
self.m.move(15, 40)
self.tools = NavigationToolbar(self.m, self)
self.tools.move(15, 500)
self.tools.resize(400, 30)
self.initUI()
def __init__(self):
super().__init__()
# set initial window shape
self.setWindowTitle("Function plotter")
self.setGeometry(300, 400, 600, 600)
# create initial figure and toolbar for the plotter
self.canvas = MplCanvas(self, 5, 4, 100)
self.toolbar = NavigationToolbar2QT(self.canvas, self)
self.createDataGroupBox() # container for the input data
# organize the layout of the main parts of the GUI
grid = QtWidgets.QGridLayout()
grid.addWidget(self.toolbar, 0, 0)
grid.addWidget(self.canvas, 1, 0)
grid.addWidget(self.dataGroupBox, 2, 0)
widget = QtWidgets.QWidget()
widget.setLayout(grid)
self.setCentralWidget(widget)
self.center()
# connect signals and slots
self.pushButton_plot.clicked.connect(self.plotFunction)
def __init__(self):
super(VNA, self).__init__()
self.setupUi(self)
# IP address validator
rx = QRegExp('^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$')
self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue))
# state variables
self.idle = True
self.reading = False
# sweep parameters
self.sweep_start = 100
self.sweep_stop = 60000
self.sweep_size = 600
self.xaxis, self.sweep_step = np.linspace(self.sweep_start, self.sweep_stop, self.sweep_size, retstep = True)
self.xaxis *= 1000
# buffer and offset for the incoming samples
self.buffer = bytearray(24 * VNA.max_size)
self.offset = 0
self.data = np.frombuffer(self.buffer, np.complex64)
self.adc1 = np.zeros(VNA.max_size, np.complex64)
self.adc2 = np.zeros(VNA.max_size, np.complex64)
self.dac1 = np.zeros(VNA.max_size, np.complex64)
self.open = np.zeros(VNA.max_size, np.complex64)
self.short = np.zeros(VNA.max_size, np.complex64)
self.load = np.zeros(VNA.max_size, np.complex64)
self.dut = np.zeros(VNA.max_size, np.complex64)
self.mode = 'dut'
# create figure
self.figure = Figure()
self.figure.set_facecolor('none')
self.canvas = FigureCanvas(self.figure)
self.plotLayout.addWidget(self.canvas)
# create navigation toolbar
self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False)
# initialize cursor
self.cursor = None
# remove subplots action
actions = self.toolbar.actions()
self.toolbar.removeAction(actions[7])
self.plotLayout.addWidget(self.toolbar)
# create TCP socket
self.socket = QTcpSocket(self)
self.socket.connected.connect(self.connected)
self.socket.readyRead.connect(self.read_data)
self.socket.error.connect(self.display_error)
# connect signals from buttons and boxes
self.sweepFrame.setEnabled(False)
self.dutSweep.setEnabled(False)
self.connectButton.clicked.connect(self.start)
self.writeButton.clicked.connect(self.write_cfg)
self.readButton.clicked.connect(self.read_cfg)
self.openSweep.clicked.connect(self.sweep_open)
self.shortSweep.clicked.connect(self.sweep_short)
self.loadSweep.clicked.connect(self.sweep_load)
self.dutSweep.clicked.connect(self.sweep_dut)
self.csvButton.clicked.connect(self.write_csv)
self.s1pButton.clicked.connect(self.write_s1p)
self.s2pButton.clicked.connect(self.write_s2p)
self.startValue.valueChanged.connect(self.set_start)
self.stopValue.valueChanged.connect(self.set_stop)
self.sizeValue.valueChanged.connect(self.set_size)
self.rateValue.addItems(['500', '100', '50', '10', '5', '1'])
self.rateValue.lineEdit().setReadOnly(True)
self.rateValue.lineEdit().setAlignment(Qt.AlignRight)
for i in range(0, self.rateValue.count()):
self.rateValue.setItemData(i, Qt.AlignRight, Qt.TextAlignmentRole)
self.rateValue.currentIndexChanged.connect(self.set_rate)
self.corrValue.valueChanged.connect(self.set_corr)
self.levelValue.valueChanged.connect(self.set_level)
self.openPlot.clicked.connect(self.plot_open)
self.shortPlot.clicked.connect(self.plot_short)
self.loadPlot.clicked.connect(self.plot_load)
self.dutPlot.clicked.connect(self.plot_dut)
self.smithPlot.clicked.connect(self.plot_smith)
self.impPlot.clicked.connect(self.plot_imp)
self.rcPlot.clicked.connect(self.plot_rc)
self.swrPlot.clicked.connect(self.plot_swr)
self.rlPlot.clicked.connect(self.plot_rl)
self.gainPlot.clicked.connect(self.plot_gain)
# create timer
self.startTimer = QTimer(self)
self.startTimer.timeout.connect(self.timeout)
class VNA(QMainWindow, Ui_VNA):
max_size = 16384
def __init__(self):
super(VNA, self).__init__()
self.setupUi(self)
# IP address validator
rx = QRegExp('^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$')
self.addrValue.setValidator(QRegExpValidator(rx, self.addrValue))
# state variables
self.idle = True
self.reading = False
# sweep parameters
self.sweep_start = 100
self.sweep_stop = 60000
self.sweep_size = 600
self.xaxis, self.sweep_step = np.linspace(self.sweep_start, self.sweep_stop, self.sweep_size, retstep = True)
self.xaxis *= 1000
# buffer and offset for the incoming samples
self.buffer = bytearray(24 * VNA.max_size)
self.offset = 0
self.data = np.frombuffer(self.buffer, np.complex64)
self.adc1 = np.zeros(VNA.max_size, np.complex64)
self.adc2 = np.zeros(VNA.max_size, np.complex64)
self.dac1 = np.zeros(VNA.max_size, np.complex64)
self.open = np.zeros(VNA.max_size, np.complex64)
self.short = np.zeros(VNA.max_size, np.complex64)
self.load = np.zeros(VNA.max_size, np.complex64)
self.dut = np.zeros(VNA.max_size, np.complex64)
self.mode = 'dut'
# create figure
self.figure = Figure()
self.figure.set_facecolor('none')
self.canvas = FigureCanvas(self.figure)
self.plotLayout.addWidget(self.canvas)
# create navigation toolbar
self.toolbar = NavigationToolbar(self.canvas, self.plotWidget, False)
# initialize cursor
self.cursor = None
# remove subplots action
actions = self.toolbar.actions()
self.toolbar.removeAction(actions[7])
self.plotLayout.addWidget(self.toolbar)
# create TCP socket
self.socket = QTcpSocket(self)
self.socket.connected.connect(self.connected)
self.socket.readyRead.connect(self.read_data)
self.socket.error.connect(self.display_error)
# connect signals from buttons and boxes
self.sweepFrame.setEnabled(False)
self.dutSweep.setEnabled(False)
self.connectButton.clicked.connect(self.start)
self.writeButton.clicked.connect(self.write_cfg)
self.readButton.clicked.connect(self.read_cfg)
self.openSweep.clicked.connect(self.sweep_open)
self.shortSweep.clicked.connect(self.sweep_short)
self.loadSweep.clicked.connect(self.sweep_load)
self.dutSweep.clicked.connect(self.sweep_dut)
self.csvButton.clicked.connect(self.write_csv)
self.s1pButton.clicked.connect(self.write_s1p)
self.s2pButton.clicked.connect(self.write_s2p)
self.startValue.valueChanged.connect(self.set_start)
self.stopValue.valueChanged.connect(self.set_stop)
self.sizeValue.valueChanged.connect(self.set_size)
self.rateValue.addItems(['500', '100', '50', '10', '5', '1'])
self.rateValue.lineEdit().setReadOnly(True)
self.rateValue.lineEdit().setAlignment(Qt.AlignRight)
for i in range(0, self.rateValue.count()):
self.rateValue.setItemData(i, Qt.AlignRight, Qt.TextAlignmentRole)
self.rateValue.currentIndexChanged.connect(self.set_rate)
self.corrValue.valueChanged.connect(self.set_corr)
self.levelValue.valueChanged.connect(self.set_level)
self.openPlot.clicked.connect(self.plot_open)
self.shortPlot.clicked.connect(self.plot_short)
self.loadPlot.clicked.connect(self.plot_load)
self.dutPlot.clicked.connect(self.plot_dut)
self.smithPlot.clicked.connect(self.plot_smith)
self.impPlot.clicked.connect(self.plot_imp)
self.rcPlot.clicked.connect(self.plot_rc)
self.swrPlot.clicked.connect(self.plot_swr)
self.rlPlot.clicked.connect(self.plot_rl)
self.gainPlot.clicked.connect(self.plot_gain)
# create timer
self.startTimer = QTimer(self)
self.startTimer.timeout.connect(self.timeout)
def start(self):
if self.idle:
self.connectButton.setEnabled(False)
self.socket.connectToHost(self.addrValue.text(), 1001)
self.startTimer.start(5000)
else:
self.stop()
def stop(self):
self.idle = True
self.socket.abort()
self.connectButton.setText('Connect')
self.connectButton.setEnabled(True)
self.sweepFrame.setEnabled(False)
self.selectFrame.setEnabled(True)
self.dutSweep.setEnabled(False)
def timeout(self):
self.display_error('timeout')
def connected(self):
self.startTimer.stop()
self.idle = False
self.set_start(self.startValue.value())
self.set_stop(self.stopValue.value())
self.set_size(self.sizeValue.value())
self.set_rate(self.rateValue.currentIndex())
self.set_corr(self.corrValue.value())
self.set_level(self.levelValue.value())
self.connectButton.setText('Disconnect')
self.connectButton.setEnabled(True)
self.sweepFrame.setEnabled(True)
self.dutSweep.setEnabled(True)
def read_data(self):
if not self.reading:
self.socket.readAll()
return
size = self.socket.bytesAvailable()
self.progress.setValue((self.offset + size) / 24)
limit = 24 * (self.sweep_size + 1)
if self.offset + size < limit:
self.buffer[self.offset:self.offset + size] = self.socket.read(size)
self.offset += size
else:
self.buffer[self.offset:limit] = self.socket.read(limit - self.offset)
self.adc1 = self.data[0::3]
self.adc2 = self.data[1::3]
self.dac1 = self.data[2::3]
getattr(self, self.mode)[0:self.sweep_size] = self.adc1[1:self.sweep_size + 1] / self.dac1[1:self.sweep_size + 1]
getattr(self, 'plot_%s' % self.mode)()
self.reading = False
self.sweepFrame.setEnabled(True)
self.selectFrame.setEnabled(True)
def display_error(self, socketError):
self.startTimer.stop()
if socketError == 'timeout':
QMessageBox.information(self, 'VNA', 'Error: connection timeout.')
else:
QMessageBox.information(self, 'VNA', 'Error: %s.' % self.socket.errorString())
self.stop()
def set_start(self, value):
self.sweep_start = value
self.xaxis, self.sweep_step = np.linspace(self.sweep_start, self.sweep_stop, self.sweep_size, retstep = True)
self.xaxis *= 1000
if self.idle: return
self.socket.write(struct.pack('<I', 0<<28 | int(value * 1000)))
def set_stop(self, value):
self.sweep_stop = value
self.xaxis, self.sweep_step = np.linspace(self.sweep_start, self.sweep_stop, self.sweep_size, retstep = True)
self.xaxis *= 1000
if self.idle: return
self.socket.write(struct.pack('<I', 1<<28 | int(value * 1000)))
def set_size(self, value):
self.sweep_size = value
self.xaxis, self.sweep_step = np.linspace(self.sweep_start, self.sweep_stop, self.sweep_size, retstep = True)
self.xaxis *= 1000
if self.idle: return
self.socket.write(struct.pack('<I', 2<<28 | int(value)))
def set_rate(self, value):
if self.idle: return
rate = [1, 5, 10, 50, 100, 500][value]
self.socket.write(struct.pack('<I', 3<<28 | int(rate)))
def set_corr(self, value):
if self.idle: return
self.socket.write(struct.pack('<I', 4<<28 | int(value)))
def set_level(self, value):
if self.idle: return
self.socket.write(struct.pack('<I', 5<<28 | int(32767 * np.power(10.0, value / 20.0))))
def sweep(self):
if self.idle: return
self.sweepFrame.setEnabled(False)
self.selectFrame.setEnabled(False)
self.socket.write(struct.pack('<I', 6<<28))
self.offset = 0
self.reading = True
self.progress = QProgressDialog('Sweep status', 'Cancel', 0, self.sweep_size + 1)
self.progress.setModal(True)
self.progress.setMinimumDuration(1000)
self.progress.canceled.connect(self.cancel)
def cancel(self):
self.offset = 0
self.reading = False
self.socket.write(struct.pack('<I', 7<<28))
self.sweepFrame.setEnabled(True)
self.selectFrame.setEnabled(True)
def sweep_open(self):
self.mode = 'open'
self.sweep()
def sweep_short(self):
self.mode = 'short'
self.sweep()
def sweep_load(self):
self.mode = 'load'
self.sweep()
def sweep_dut(self):
self.mode = 'dut'
self.sweep()
def gain(self):
size = self.sweep_size
return self.dut[0:size]/self.short[0:size]
def impedance(self):
size = self.sweep_size
return 50.0 * (self.open[0:size] - self.load[0:size]) * (self.dut[0:size] - self.short[0:size]) / ((self.load[0:size] - self.short[0:size]) * (self.open[0:size] - self.dut[0:size]))
def gamma(self):
z = self.impedance()
return (z - 50.0)/(z + 50.0)
def plot_gain(self):
if self.cursor is not None: self.cursor.hide().disable()
matplotlib.rcdefaults()
self.figure.clf()
self.figure.subplots_adjust(left = 0.12, bottom = 0.12, right = 0.88, top = 0.98)
axes1 = self.figure.add_subplot(111)
axes1.cla()
axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix))
axes1.yaxis.set_major_formatter(FuncFormatter(metric_prefix))
axes1.tick_params('y', color = 'blue', labelcolor = 'blue')
axes1.yaxis.label.set_color('blue')
gain = self.gain()
axes1.plot(self.xaxis, 20.0 * np.log10(np.absolute(gain)), color = 'blue', label = 'Gain')
axes2 = axes1.twinx()
axes2.spines['left'].set_color('blue')
axes2.spines['right'].set_color('red')
axes1.set_xlabel('Hz')
axes1.set_ylabel('Gain, dB')
axes2.set_ylabel('Phase angle')
axes2.tick_params('y', color = 'red', labelcolor = 'red')
axes2.yaxis.label.set_color('red')
axes2.plot(self.xaxis, np.angle(gain, deg = True), color = 'red', label = 'Phase angle')
self.cursor = datacursor(axes = self.figure.get_axes(), formatter = LabelFormatter(), display = 'multiple')
self.canvas.draw()
def plot_magphase(self, data):
if self.cursor is not None: self.cursor.hide().disable()
matplotlib.rcdefaults()
self.figure.clf()
self.figure.subplots_adjust(left = 0.12, bottom = 0.12, right = 0.88, top = 0.98)
axes1 = self.figure.add_subplot(111)
axes1.cla()
axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix))
axes1.yaxis.set_major_formatter(FuncFormatter(metric_prefix))
axes1.tick_params('y', color = 'blue', labelcolor = 'blue')
axes1.yaxis.label.set_color('blue')
axes1.plot(self.xaxis, np.absolute(data), color = 'blue', label = 'Magnitude')
axes2 = axes1.twinx()
axes2.spines['left'].set_color('blue')
axes2.spines['right'].set_color('red')
axes1.set_xlabel('Hz')
axes1.set_ylabel('Magnitude')
axes2.set_ylabel('Phase angle')
axes2.tick_params('y', color = 'red', labelcolor = 'red')
axes2.yaxis.label.set_color('red')
axes2.plot(self.xaxis, np.angle(data, deg = True), color = 'red', label = 'Phase angle')
self.cursor = datacursor(axes = self.figure.get_axes(), formatter = LabelFormatter(), display = 'multiple')
self.canvas.draw()
def plot_open(self):
self.plot_magphase(self.open[0:self.sweep_size])
def plot_short(self):
self.plot_magphase(self.short[0:self.sweep_size])
def plot_load(self):
self.plot_magphase(self.load[0:self.sweep_size])
def plot_dut(self):
self.plot_magphase(self.dut[0:self.sweep_size])
def plot_smith_grid(self, axes, color):
load = 50.0
ticks = np.array([0.0, 0.2, 0.5, 1.0, 2.0, 5.0])
for tick in ticks * load:
axis = np.logspace(-4, np.log10(1.0e3), 200) * load
z = tick + 1.0j * axis
gamma = (z - load)/(z + load)
axes.plot(gamma.real, gamma.imag, color = color, linewidth = 0.4, alpha = 0.3)
axes.plot(gamma.real, -gamma.imag, color = color, linewidth = 0.4, alpha = 0.3)
z = axis + 1.0j * tick
gamma = (z - load)/(z + load)
axes.plot(gamma.real, gamma.imag, color = color, linewidth = 0.4, alpha = 0.3)
axes.plot(gamma.real, -gamma.imag, color = color, linewidth = 0.4, alpha = 0.3)
if tick == 0.0:
axes.text(1.0, 0.0, u'\u221E', color = color, ha = 'left', va = 'center', clip_on = True, fontsize = 18.0)
axes.text(-1.0, 0.0, u'0\u03A9', color = color, ha = 'left', va = 'bottom', clip_on = True, fontsize = 12.0)
continue
lab = u'%d\u03A9' % tick
x = (tick - load) / (tick + load)
axes.text(x, 0.0, lab, color = color, ha = 'left', va = 'bottom', clip_on = True, fontsize = 12.0)
lab = u'j%d\u03A9' % tick
z = 1.0j * tick
gamma = (z - load)/(z + load) * 1.05
x = gamma.real
y = gamma.imag
angle = np.angle(gamma) * 180.0 / np.pi - 90.0
axes.text(x, y, lab, color = color, ha = 'center', va = 'center', clip_on = True, rotation = angle, fontsize = 12.0)
lab = u'-j%d\u03A9' % tick
axes.text(x, -y, lab, color = color, ha = 'center', va = 'center', clip_on = True, rotation = -angle, fontsize = 12.0)
def plot_smith(self):
if self.cursor is not None: self.cursor.hide().disable()
matplotlib.rcdefaults()
self.figure.clf()
self.figure.subplots_adjust(left = 0.0, bottom = 0.0, right = 1.0, top = 1.0)
axes1 = self.figure.add_subplot(111)
self.plot_smith_grid(axes1, 'blue')
gamma = self.gamma()
plot, = axes1.plot(gamma.real, gamma.imag, color = 'red')
axes1.axis('equal')
axes1.set_xlim(-1.12, 1.12)
axes1.set_ylim(-1.12, 1.12)
axes1.xaxis.set_visible(False)
axes1.yaxis.set_visible(False)
for loc, spine in axes1.spines.items():
spine.set_visible(False)
self.cursor = datacursor(plot, formatter = SmithFormatter(self.xaxis), display = 'multiple')
self.canvas.draw()
def plot_imp(self):
self.plot_magphase(self.impedance())
def plot_rc(self):
self.plot_magphase(self.gamma())
def plot_swr(self):
if self.cursor is not None: self.cursor.hide().disable()
matplotlib.rcdefaults()
self.figure.clf()
self.figure.subplots_adjust(left = 0.12, bottom = 0.12, right = 0.88, top = 0.98)
axes1 = self.figure.add_subplot(111)
axes1.cla()
axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix))
axes1.yaxis.set_major_formatter(FuncFormatter(metric_prefix))
axes1.set_xlabel('Hz')
axes1.set_ylabel('SWR')
magnitude = np.absolute(self.gamma())
swr = np.maximum(1.0, np.minimum(100.0, (1.0 + magnitude) / np.maximum(1.0e-20, 1.0 - magnitude)))
axes1.plot(self.xaxis, swr, color = 'blue', label = 'SWR')
self.cursor = datacursor(axes = self.figure.get_axes(), formatter = LabelFormatter(), display = 'multiple')
self.canvas.draw()
def plot_rl(self):
if self.cursor is not None: self.cursor.hide().disable()
matplotlib.rcdefaults()
self.figure.clf()
self.figure.subplots_adjust(left = 0.12, bottom = 0.12, right = 0.88, top = 0.98)
axes1 = self.figure.add_subplot(111)
axes1.cla()
axes1.xaxis.set_major_formatter(FuncFormatter(metric_prefix))
axes1.set_xlabel('Hz')
axes1.set_ylabel('Return loss, dB')
magnitude = np.absolute(self.gamma())
axes1.plot(self.xaxis, 20.0 * np.log10(magnitude), color = 'blue', label = 'Return loss')
self.cursor = datacursor(axes = self.figure.get_axes(), formatter = LabelFormatter(), display = 'multiple')
self.canvas.draw()
def write_cfg(self):
dialog = QFileDialog(self, 'Write configuration settings', '.', '*.ini')
dialog.setDefaultSuffix('ini')
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setOptions(QFileDialog.DontConfirmOverwrite)
if dialog.exec() == QDialog.Accepted:
name = dialog.selectedFiles()
settings = QSettings(name[0], QSettings.IniFormat)
self.write_cfg_settings(settings)
def read_cfg(self):
dialog = QFileDialog(self, 'Read configuration settings', '.', '*.ini')
dialog.setDefaultSuffix('ini')
dialog.setAcceptMode(QFileDialog.AcceptOpen)
if dialog.exec() == QDialog.Accepted:
name = dialog.selectedFiles()
settings = QSettings(name[0], QSettings.IniFormat)
self.read_cfg_settings(settings)
def write_cfg_settings(self, settings):
settings.setValue('addr', self.addrValue.text())
settings.setValue('start', self.startValue.value())
settings.setValue('stop', self.stopValue.value())
settings.setValue('rate', self.rateValue.currentIndex())
settings.setValue('corr', self.corrValue.value())
size = self.sizeValue.value()
settings.setValue('size', size)
for i in range(0, size):
settings.setValue('open_real_%d' % i, float(self.open.real[i]))
settings.setValue('open_imag_%d' % i, float(self.open.imag[i]))
for i in range(0, size):
settings.setValue('short_real_%d' % i, float(self.short.real[i]))
settings.setValue('short_imag_%d' % i, float(self.short.imag[i]))
for i in range(0, size):
settings.setValue('load_real_%d' % i, float(self.load.real[i]))
settings.setValue('load_imag_%d' % i, float(self.load.imag[i]))
for i in range(0, size):
settings.setValue('dut_real_%d' % i, float(self.dut.real[i]))
settings.setValue('dut_imag_%d' % i, float(self.dut.imag[i]))
def read_cfg_settings(self, settings):
self.addrValue.setText(settings.value('addr', '192.168.1.100'))
self.startValue.setValue(settings.value('start', 100, type = int))
self.stopValue.setValue(settings.value('stop', 60000, type = int))
self.rateValue.setCurrentIndex(settings.value('rate', 0, type = int))
self.corrValue.setValue(settings.value('corr', 0, type = int))
size = settings.value('size', 600, type = int)
self.sizeValue.setValue(size)
for i in range(0, size):
real = settings.value('open_real_%d' % i, 0.0, type = float)
imag = settings.value('open_imag_%d' % i, 0.0, type = float)
self.open[i] = real + 1.0j * imag
for i in range(0, size):
real = settings.value('short_real_%d' % i, 0.0, type = float)
imag = settings.value('short_imag_%d' % i, 0.0, type = float)
self.short[i] = real + 1.0j * imag
for i in range(0, size):
real = settings.value('load_real_%d' % i, 0.0, type = float)
imag = settings.value('load_imag_%d' % i, 0.0, type = float)
self.load[i] = real + 1.0j * imag
for i in range(0, size):
real = settings.value('dut_real_%d' % i, 0.0, type = float)
imag = settings.value('dut_imag_%d' % i, 0.0, type = float)
self.dut[i] = real + 1.0j * imag
def write_csv(self):
dialog = QFileDialog(self, 'Write csv file', '.', '*.csv')
dialog.setDefaultSuffix('csv')
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setOptions(QFileDialog.DontConfirmOverwrite)
if dialog.exec() == QDialog.Accepted:
name = dialog.selectedFiles()
fh = open(name[0], 'w')
gamma = self.gamma()
size = self.sizeValue.value()
fh.write('frequency;open.real;open.imag;short.real;short.imag;load.real;load.imag;dut.real;dut.imag\n')
for i in range(0, size):
fh.write('0.0%.8d;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f;%12.9f\n' % (self.xaxis[i], self.open.real[i], self.open.imag[i], self.short.real[i], self.short.imag[i], self.load.real[i], self.load.imag[i], self.dut.real[i], self.dut.imag[i]))
fh.close()
def write_s1p(self):
dialog = QFileDialog(self, 'Write s1p file', '.', '*.s1p')
dialog.setDefaultSuffix('s1p')
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setOptions(QFileDialog.DontConfirmOverwrite)
if dialog.exec() == QDialog.Accepted:
name = dialog.selectedFiles()
fh = open(name[0], 'w')
gamma = self.gamma()
size = self.sizeValue.value()
fh.write('# GHz S MA R 50\n')
for i in range(0, size):
fh.write('0.0%.8d %8.6f %7.2f\n' % (self.xaxis[i], np.absolute(gamma[i]), np.angle(gamma[i], deg = True)))
fh.close()
def write_s2p(self):
dialog = QFileDialog(self, 'Write s2p file', '.', '*.s2p')
dialog.setDefaultSuffix('s2p')
dialog.setAcceptMode(QFileDialog.AcceptSave)
dialog.setOptions(QFileDialog.DontConfirmOverwrite)
if dialog.exec() == QDialog.Accepted:
name = dialog.selectedFiles()
fh = open(name[0], 'w')
gain = self.gain()
gamma = self.gamma()
size = self.sizeValue.value()
fh.write('# GHz S MA R 50\n')
for i in range(0, size):
fh.write('0.0%.8d %8.6f %7.2f %8.6f %7.2f 0.000000 0.00 0.000000 0.00\n' % (self.xaxis[i], np.absolute(gamma[i]), np.angle(gamma[i], deg = True), np.absolute(gain[i]), np.angle(gain[i], deg = True)))
fh.close()
