def __init__(self,
image=None,
fillHistogram=True,
rgbHistogram=False,
levelMode='mono'):
pg.GraphicsWidget.__init__(self)
self.lut = None
self.imageItem = lambda: None # fake a dead weakref
self.levelMode = levelMode
self.rgbHistogram = rgbHistogram
self.layout = QtGui.QGraphicsGridLayout()
self.setLayout(self.layout)
self.layout.setContentsMargins(1, 1, 1, 1)
self.layout.setSpacing(0)
self.vb = pg.ViewBox(parent=self)
self.vb.setMaximumHeight(20)
self.vb.setMinimumHeight(20)
self.vb.setMouseEnabled(x=False, y=True)
self.gradient = pg.GradientEditorItem()
self.gradient.setOrientation('top')
self.gradient.loadPreset('viridis')
self.gradient.setFlag(self.gradient.ItemStacksBehindParent)
self.vb.setFlag(self.gradient.ItemStacksBehindParent)
self.layout.addItem(self.gradient, 0, 0)
self.layout.addItem(self.vb, 1, 0)
self.axis = pg.AxisItem('bottom',
linkView=self.vb,
maxTickLength=-10,
parent=self)
self.layout.addItem(self.axis, 2, 0)
self.regions = [
pg.LinearRegionItem([0, 1], 'vertical', swapMode='block'),
#we dont need those here
#pg.LinearRegionItem([0, 1], 'vertical', swapMode='block', pen='r',brush=fn.mkBrush((255, 50, 50, 50)), span=(0., 1/3.)),
#pg.LinearRegionItem([0, 1], 'vertical', swapMode='block', pen='g',brush=fn.mkBrush((50, 255, 50, 50)), span=(1/3., 2/3.)),
#pg.LinearRegionItem([0, 1], 'vertical', swapMode='block', pen='b',brush=fn.mkBrush((50, 50, 255, 80)), span=(2/3., 1.)),
#pg.LinearRegionItem([0, 1], 'vertical', swapMode='block', pen='w',brush=fn.mkBrush((255, 255, 255, 50)), span=(2/3., 1.))
]
for region in self.regions:
region.setZValue(1000)
self.vb.addItem(region)
region.lines[0].addMarker('<|', 0.5)
region.lines[1].addMarker('|>', 0.5)
region.sigRegionChanged.connect(self.regionChanging)
region.sigRegionChangeFinished.connect(self.regionChanged)
self.region = self.regions[0]
add = QtGui.QPainter.CompositionMode_Plus
self.plots = [
pg.PlotCurveItem(pen=(200, 200, 200, 100)), # mono
pg.PlotCurveItem(pen=(255, 0, 0, 100), compositionMode=add), # r
pg.PlotCurveItem(pen=(0, 255, 0, 100), compositionMode=add), # g
pg.PlotCurveItem(pen=(0, 0, 255, 100), compositionMode=add), # b
pg.PlotCurveItem(pen=(200, 200, 200, 100),
compositionMode=add), # a
]
self.plot = self.plots[0]
for plot in self.plots:
self.vb.addItem(plot)
self.fillHistogram(fillHistogram)
self.range = None
self.gradient.sigGradientChanged.connect(self.gradientChanged)
self.vb.sigRangeChanged.connect(self.viewRangeChanged)
def __init__(self, host, port, timeout, siglist, selected_driver=None):
"""
Initializes an instance of class WindowMain.
host - IcePAP system address.
port - IcePAP system port number.
timeout - Socket timeout.
siglist - List of predefined signals.
Element Syntax: <driver>:<signal name>:<Y-axis>
Example: ["1:PosAxis:1", "1:MeasI:2", "1:MeasVm:3"]
selected_driver - The driver to display in combobox at startup.
"""
QtGui.QMainWindow.__init__(self, None)
self.ui = Ui_WindowMain()
self.setAttribute(Qt.WA_DeleteOnClose, True)
self.ui.setupUi(self)
self.setWindowTitle('Oscilloscope | ' + host)
try:
self.collector = Collector(host,
port,
timeout,
self.callback_collect)
except Exception as e:
msg = 'Failed to create main window.\n{}'.format(e)
print(msg)
QtGui.QMessageBox.critical(None, 'Create Main Window', msg)
return
self.subscriptions = {}
self.curve_items = []
self._paused = False
self.settings = Settings(self, self.collector)
# Set up the plot area.
self.plot_widget = pg.PlotWidget()
self._plot_item = self.plot_widget.getPlotItem()
self.view_boxes = [self.plot_widget.getViewBox(),
pg.ViewBox(),
pg.ViewBox()]
self.ui.vloCurves.setDirection(QtGui.QBoxLayout.BottomToTop)
self.ui.vloCurves.addWidget(self.plot_widget)
# Set up the X-axis.
self._plot_item.getAxis('bottom').hide() # Hide the original X-axis.
self._axisTime = AxisTime(orientation='bottom') # Create new X-axis.
self._axisTime.linkToView(self.view_boxes[0])
self._plot_item.layout.removeItem(self._plot_item.getAxis('bottom'))
self._plot_item.layout.addItem(self._axisTime, 3, 1)
self.now = self.collector.get_current_time()
self.view_boxes[0].disableAutoRange(axis=self.view_boxes[0].XAxis)
self.view_boxes[1].disableAutoRange(axis=self.view_boxes[1].XAxis)
self.view_boxes[2].disableAutoRange(axis=self.view_boxes[2].XAxis)
self._reset_x()
# Set up the three Y-axes.
self._plot_item.showAxis('right')
self._plot_item.scene().addItem(self.view_boxes[1])
self._plot_item.scene().addItem(self.view_boxes[2])
ax3 = pg.AxisItem(orientation='right', linkView=self.view_boxes[2])
self.axes = [self._plot_item.getAxis('left'),
self._plot_item.getAxis('right'), ax3]
self.axes[1].linkToView(self.view_boxes[1])
self.view_boxes[1].setXLink(self.view_boxes[0])
self.view_boxes[2].setXLink(self.view_boxes[0])
self._plot_item.layout.addItem(self.axes[2], 2, 3)
self._plot_item.hideButtons()
self._enable_auto_range_y()
# Set up the crosshair vertical line.
self.vertical_line = pg.InfiniteLine(angle=90, movable=False)
self.view_boxes[0].addItem(self.vertical_line, ignoreBounds=True)
# Initialize comboboxes and buttons.
self._fill_combo_box_driver_ids(selected_driver)
self._fill_combo_box_signals()
self._select_axis_1()
self._update_button_status()
# Set up signalling connections.
self._connect_signals()
self.proxy = pg.SignalProxy(self.plot_widget.scene().sigMouseMoved,
rateLimit=60,
slot=self._mouse_moved)
# Add any predefined signals.
for sig in siglist:
lst = sig.split(':')
if len(lst) != 3:
msg = 'Bad format of predefined signal "{}".\n' \
'It should be: ' \
'<driver>:<signal name>:<Y-axis>'.format(sig)
print(msg)
QtGui.QMessageBox.critical(None, 'Bad Signal Syntax', msg)
return
self._add_signal(int(lst[0]), lst[1], int(lst[2]))
import sys
import time
from pyqtgraph.Qt import QtCore, QtGui
import numpy as np
import pyqtgraph as pg
from skimage import data
app = QtGui.QApplication([])
w = pg.GraphicsView()
w.show()
w.resize(600, 600)
w.setWindowTitle('pyqtgraph example: Draw')
view = pg.ViewBox(enableMouse=True)
w.setCentralItem(view)
## lock the aspect ratio
view.setAspectLocked(True)
view.invertY()
## Create image item
imgitem = pg.ImageItem(axisOrder='row-major')
view.addItem(imgitem)
labelitem = pg.LabelItem()
view.addItem(labelitem)
img = data.astronaut()
# img = np.rot90(data.astronaut(), k=-1, axes=(0,1))
print('img is', img.shape)
parser = argparse.ArgumentParser()
parser.add_argument('--host', type=str, default='127.0.0.1')
args = parser.parse_args()
host = args.host # Advanced function for debug and advanced usage
app = QtGui.QApplication([])
lw = pg.LayoutWidget()
lw.setWindowTitle('Camera Viewer')
view = pg.GraphicsView()
lw.addWidget(view, col=0)
lg = pg.GraphicsLayout()
view.setCentralItem(lg)
view.show()
#vb = lg.addViewBox(lockAspect=True, invertY=True)
vb = pg.ViewBox(lockAspect=True, invertY=True)
data = np.random.normal(size=(1024, 1024)) # Random data
img = pg.ImageItem(data)
vb.addItem(img)
lg.addItem(vb)
# Create histogram and lut in graphics layout
lut = pg.HistogramLUTItem()
lut.setImageItem(img)
lut.setHistogramRange(0, 50000)
lg.addItem(lut)
li = pg.LayoutWidget()
lw.addWidget(li, row=1)
# Checkbox
auto_checkbox = QtGui.QCheckBox("Auto Level")
def on_activate(self):
""" Definition and initialisation of the GUI plus staring the measurement.
"""
self._pid_logic = self.pidlogic()
#####################
# Configuring the dock widgets
# Use the inherited class 'CounterMainWindow' to create the GUI window
self._mw = PIDMainWindow()
# Setup dock widgets
self._mw.centralwidget.hide()
self._mw.setDockNestingEnabled(True)
# Plot labels.
self._pw = self._mw.trace_PlotWidget
self.plot1 = self._pw.plotItem
self.plot1.setLabel(
'left',
'<font color={0}>Process Value</font> and <font color={1}>Setpoint</font>'.format(
palette.c1.name(),
palette.c2.name()),
units='unit')
self.plot1.setLabel('bottom', 'Time', units='s')
self.plot1.showAxis('right')
self.plot1.getAxis('right').setLabel(
'Control Value',
units='unit',
color=palette.c3.name())
self.plot2 = pg.ViewBox()
self.plot1.scene().addItem(self.plot2)
self.plot1.getAxis('right').linkToView(self.plot2)
self.plot2.setXLink(self.plot1)
## Create an empty plot curve to be filled later, set its pen
self._curve1 = pg.PlotDataItem(pen=pg.mkPen(palette.c1),#, style=QtCore.Qt.DotLine),
symbol=None
#symbol='o',
#symbolPen=palette.c1,
#symbolBrush=palette.c1,
#symbolSize=3
)
self._curve3 = pg.PlotDataItem(pen=pg.mkPen(palette.c2),
symbol=None
)
self._curve2 = pg.PlotDataItem(pen=pg.mkPen(palette.c3),#, style=QtCore.Qt.DotLine),
symbol=None
#symbol='o',
#symbolPen=palette.c3,
#symbolBrush=palette.c3,
#symbolSize=3
)
# self._curve1 = pg.PlotCurveItem()
# self._curve1.setPen(palette.c1)
# self._curve3 = pg.PlotCurveItem()
# self._curve3.setPen(palette.c2)
# self._curve2 = pg.PlotCurveItem()
# self._curve2.setPen(palette.c3)
self.plot1.addItem(self._curve1)
self.plot1.addItem(self._curve3)
self.plot2.addItem(self._curve2)
self.updateViews()
self.plot1.vb.sigResized.connect(self.updateViews)
# setting the x axis length correctly
self._pw.setXRange(0, self._pid_logic.getBufferLength() * self._pid_logic.timestep)
#####################
# Setting default parameters
self._mw.P_DoubleSpinBox.setValue(self._pid_logic.get_kp())
self._mw.I_DoubleSpinBox.setValue(self._pid_logic.get_ki())
self._mw.D_DoubleSpinBox.setValue(self._pid_logic.get_kd())
self._mw.setpointDoubleSpinBox.setValue(self._pid_logic.get_setpoint())
self._mw.manualDoubleSpinBox.setValue(self._pid_logic.get_manual_value())
self._mw.pidEnabledCheckBox.setChecked(self._pid_logic._controller.get_enabled())
# make correct button state
self._mw.start_control_Action.setChecked(self._pid_logic.get_enabled())
#####################
# Connecting user interactions
self._mw.start_control_Action.triggered.connect(self.start_clicked)
self._mw.record_control_Action.triggered.connect(self.save_clicked)
self._mw.P_DoubleSpinBox.valueChanged.connect(self.kpChanged)
self._mw.I_DoubleSpinBox.valueChanged.connect(self.kiChanged)
self._mw.D_DoubleSpinBox.valueChanged.connect(self.kdChanged)
self._mw.setpointDoubleSpinBox.valueChanged.connect(self.setpointChanged)
self._mw.manualDoubleSpinBox.valueChanged.connect(self.manualValueChanged)
self._mw.pidEnabledCheckBox.toggled.connect(self.pidEnabledChanged)
# Connect the default view action
self._mw.restore_default_view_Action.triggered.connect(self.restore_default_view)
#####################
# starting the physical measurement
self.sigStart.connect(self._pid_logic.startLoop)
self.sigStop.connect(self._pid_logic.stopLoop)
self._pid_logic.sigUpdateDisplay.connect(self.updateData)
def on_activate(self):
""" Definition and initialisation of the GUI plus staring the measurement.
"""
self._laser_logic = self.get_connector('laserlogic')
#####################
# Configuring the dock widgets
# Use the inherited class 'CounterMainWindow' to create the GUI window
self._mw = LaserWindow()
# Setup dock widgets
self._mw.setDockNestingEnabled(True)
self._mw.actionReset_View.triggered.connect(self.restoreDefaultView)
# set up plot
self._mw.plotWidget = pg.PlotWidget(
axisItems={'bottom': TimeAxisItem(orientation='bottom')})
self._mw.pwContainer.layout().addWidget(self._mw.plotWidget)
plot1 = self._mw.plotWidget.getPlotItem()
plot1.setLabel('left', 'power', units='W', color=palette.c1.name())
plot1.setLabel('bottom', 'Time', units=None)
plot1.setLabel('right',
'Temperature',
units='°C',
color=palette.c3.name())
plot2 = pg.ViewBox()
plot1.scene().addItem(plot2)
plot1.getAxis('right').linkToView(plot2)
plot2.setXLink(plot1)
self.curves = {}
colorlist = (palette.c2, palette.c3, palette.c4, palette.c5,
palette.c6)
i = 0
for name in self._laser_logic.data:
if name != 'time':
curve = pg.PlotDataItem()
if name == 'power':
curve.setPen(palette.c1)
plot1.addItem(curve)
else:
curve.setPen(colorlist[(2 * i) % len(colorlist)])
plot2.addItem(curve)
self.curves[name] = curve
i += 1
self.plot1 = plot1
self.plot2 = plot2
self.updateViews()
self.plot1.vb.sigResized.connect(self.updateViews)
self.updateButtonsEnabled()
self._mw.laserButton.clicked.connect(self.changeLaserState)
self._mw.shutterButton.clicked.connect(self.changeShutterState)
self.sigLaser.connect(self._laser_logic.set_laser_state)
self.sigShutter.connect(self._laser_logic.set_shutter_state)
self.sigCurrent.connect(self._laser_logic.set_current)
self.sigPower.connect(self._laser_logic.set_power)
self.sigCtrlMode.connect(self._laser_logic.set_control_mode)
self._mw.controlModeButtonGroup.buttonClicked.connect(
self.changeControlMode)
self.sliderProxy = pg.SignalProxy(
self._mw.setValueVerticalSlider.valueChanged, 0.1, 5,
self.updateFromSlider)
self._mw.setValueDoubleSpinBox.editingFinished.connect(
self.updateFromSpinBox)
self._laser_logic.sigUpdate.connect(self.updateGui)
def test_ImageItem(transpose=False):
w = pg.GraphicsLayoutWidget()
w.show()
view = pg.ViewBox()
w.setCentralWidget(view)
w.resize(200, 200)
img = TransposedImageItem(border=0.5, transpose=transpose)
view.addItem(img)
# test mono float
np.random.seed(0)
data = np.random.normal(size=(20, 20))
dmax = data.max()
data[:10, 1] = dmax + 10
data[1, :10] = dmax + 12
data[3, :10] = dmax + 13
img.setImage(data)
QtTest.QTest.qWaitForWindowExposed(w)
time.sleep(0.1)
app.processEvents()
assertImageApproved(w, 'imageitem/init', 'Init image item. View is auto-scaled, image axis 0 marked by 1 line, axis 1 is marked by 2 lines. Origin in bottom-left.')
# ..with colormap
cmap = pg.ColorMap([0, 0.25, 0.75, 1], [[0, 0, 0, 255], [255, 0, 0, 255], [255, 255, 0, 255], [255, 255, 255, 255]])
img.setLookupTable(cmap.getLookupTable())
assertImageApproved(w, 'imageitem/lut', 'Set image LUT.')
# ..and different levels
img.setLevels([dmax+9, dmax+13])
assertImageApproved(w, 'imageitem/levels1', 'Levels show only axis lines.')
img.setLookupTable(None)
# test mono int
data = np.fromfunction(lambda x,y: x+y*10, (129, 128)).astype(np.int16)
img.setImage(data)
assertImageApproved(w, 'imageitem/gradient_mono_int', 'Mono int gradient.')
img.setLevels([640, 641])
assertImageApproved(w, 'imageitem/gradient_mono_int_levels', 'Mono int gradient w/ levels to isolate diagonal.')
# test mono byte
data = np.fromfunction(lambda x,y: x+y, (129, 128)).astype(np.ubyte)
img.setImage(data)
assertImageApproved(w, 'imageitem/gradient_mono_byte', 'Mono byte gradient.')
img.setLevels([127, 128])
assertImageApproved(w, 'imageitem/gradient_mono_byte_levels', 'Mono byte gradient w/ levels to isolate diagonal.')
# test monochrome image
data = np.zeros((10, 10), dtype='uint8')
data[:5,:5] = 1
data[5:,5:] = 1
img.setImage(data)
assertImageApproved(w, 'imageitem/monochrome', 'Ubyte image with only 0,1 values.')
# test bool
data = data.astype(bool)
img.setImage(data)
assertImageApproved(w, 'imageitem/bool', 'Boolean mask.')
# test RGBA byte
data = np.zeros((100, 100, 4), dtype='ubyte')
data[..., 0] = np.linspace(0, 255, 100).reshape(100, 1)
data[..., 1] = np.linspace(0, 255, 100).reshape(1, 100)
data[..., 3] = 255
img.setImage(data)
assertImageApproved(w, 'imageitem/gradient_rgba_byte', 'RGBA byte gradient.')
img.setLevels([[128, 129], [128, 255], [0, 1], [0, 255]])
assertImageApproved(w, 'imageitem/gradient_rgba_byte_levels', 'RGBA byte gradient. Levels set to show x=128 and y>128.')
# test RGBA float
data = data.astype(float)
img.setImage(data / 1e9)
assertImageApproved(w, 'imageitem/gradient_rgba_float', 'RGBA float gradient.')
# checkerboard to test alpha
img2 = TransposedImageItem(transpose=transpose)
img2.setImage(np.fromfunction(lambda x,y: (x+y)%2, (10, 10)), levels=[-1,2])
view.addItem(img2)
img2.setScale(10)
img2.setZValue(-10)
data[..., 0] *= 1e-9
data[..., 1] *= 1e9
data[..., 3] = np.fromfunction(lambda x,y: np.sin(0.1 * (x+y)), (100, 100))
img.setImage(data, levels=[[0, 128e-9],[0, 128e9],[0, 1],[-1, 1]])
assertImageApproved(w, 'imageitem/gradient_rgba_float_alpha', 'RGBA float gradient with alpha.')
# test composition mode
img.setCompositionMode(QtGui.QPainter.CompositionMode.CompositionMode_Plus)
assertImageApproved(w, 'imageitem/gradient_rgba_float_additive', 'RGBA float gradient with alpha and additive composition mode.')
img2.hide()
img.setCompositionMode(QtGui.QPainter.CompositionMode.CompositionMode_SourceOver)
# test downsampling
data = np.fromfunction(lambda x,y: np.cos(0.002 * x**2), (800, 100))
img.setImage(data, levels=[-1, 1])
assertImageApproved(w, 'imageitem/resolution_without_downsampling', 'Resolution test without downsampling.')
img.setAutoDownsample(True)
assertImageApproved(w, 'imageitem/resolution_with_downsampling_x', 'Resolution test with downsampling axross x axis.')
assert img._lastDownsample == (4, 1)
img.setImage(data.T, levels=[-1, 1])
assertImageApproved(w, 'imageitem/resolution_with_downsampling_y', 'Resolution test with downsampling across y axis.')
assert img._lastDownsample == (1, 4)
w.hide()
def test_PolyLineROI():
rois = [(pg.PolyLineROI([[0, 0], [10, 0], [0, 15]], closed=True,
pen=0.3), 'closed'),
(pg.PolyLineROI([[0, 0], [10, 0], [0, 15]], closed=False,
pen=0.3), 'open')]
#plt = pg.plot()
plt = pg.GraphicsView()
plt.show()
plt.resize(200, 200)
vb = pg.ViewBox()
plt.scene().addItem(vb)
vb.resize(200, 200)
#plt.plotItem = pg.PlotItem()
#plt.scene().addItem(plt.plotItem)
#plt.plotItem.resize(200, 200)
plt.scene().minDragTime = 0 # let us simulate mouse drags very quickly.
# seemingly arbitrary requirements; might need longer wait time for some platforms..
QtTest.QTest.qWaitForWindowShown(plt)
QtTest.QTest.qWait(100)
for r, name in rois:
vb.clear()
vb.addItem(r)
vb.autoRange()
app.processEvents()
assertImageApproved(plt, 'roi/polylineroi/' + name + '_init',
'Init %s polyline.' % name)
initState = r.getState()
assert len(r.getState()['points']) == 3
# hover over center
center = r.mapToScene(pg.Point(3, 3))
mouseMove(plt, center)
assertImageApproved(plt, 'roi/polylineroi/' + name + '_hover_roi',
'Hover mouse over center of ROI.')
# drag ROI
mouseDrag(plt, center, center + pg.Point(10, -10),
QtCore.Qt.LeftButton)
assertImageApproved(plt, 'roi/polylineroi/' + name + '_drag_roi',
'Drag mouse over center of ROI.')
# hover over handle
pt = r.mapToScene(pg.Point(r.getState()['points'][2]))
mouseMove(plt, pt)
assertImageApproved(plt, 'roi/polylineroi/' + name + '_hover_handle',
'Hover mouse over handle.')
# drag handle
mouseDrag(plt, pt, pt + pg.Point(5, 20), QtCore.Qt.LeftButton)
assertImageApproved(plt, 'roi/polylineroi/' + name + '_drag_handle',
'Drag mouse over handle.')
# hover over segment
pt = r.mapToScene((pg.Point(r.getState()['points'][2]) +
pg.Point(r.getState()['points'][1])) * 0.5)
mouseMove(plt, pt + pg.Point(0, 2))
assertImageApproved(plt, 'roi/polylineroi/' + name + '_hover_segment',
'Hover mouse over diagonal segment.')
# click segment
mouseClick(plt, pt, QtCore.Qt.LeftButton)
assertImageApproved(plt, 'roi/polylineroi/' + name + '_click_segment',
'Click mouse over segment.')
r.clearPoints()
assertImageApproved(plt, 'roi/polylineroi/' + name + '_clear',
'All points cleared.')
assert len(r.getState()['points']) == 0
r.setPoints(initState['points'])
assertImageApproved(plt, 'roi/polylineroi/' + name + '_setpoints',
'Reset points to initial state.')
assert len(r.getState()['points']) == 3
r.setState(initState)
assertImageApproved(plt, 'roi/polylineroi/' + name + '_setstate',
'Reset ROI to initial state.')
assert len(r.getState()['points']) == 3
def check_getArrayRegion(roi, name, testResize=True, transpose=False):
initState = roi.getState()
#win = pg.GraphicsLayoutWidget()
win = pg.GraphicsView()
win.show()
win.resize(200, 400)
# Don't use Qt's layouts for testing--these generate unpredictable results.
#vb1 = win.addViewBox()
#win.nextRow()
#vb2 = win.addViewBox()
# Instead, place the viewboxes manually
vb1 = pg.ViewBox()
win.scene().addItem(vb1)
vb1.setPos(6, 6)
vb1.resize(188, 191)
vb2 = pg.ViewBox()
win.scene().addItem(vb2)
vb2.setPos(6, 203)
vb2.resize(188, 191)
img1 = pg.ImageItem(border='w')
img2 = pg.ImageItem(border='w')
vb1.addItem(img1)
vb2.addItem(img2)
np.random.seed(0)
data = np.random.normal(size=(7, 30, 31, 5))
data[0, :, :, :] += 10
data[:, 1, :, :] += 10
data[:, :, 2, :] += 10
data[:, :, :, 3] += 10
if transpose:
data = data.transpose(0, 2, 1, 3)
img1.setImage(data[0, ..., 0])
vb1.setAspectLocked()
vb1.enableAutoRange(True, True)
roi.setZValue(10)
vb1.addItem(roi)
if isinstance(roi, pg.RectROI):
if transpose:
assert roi.getAffineSliceParams(data, img1, axes=(1, 2)) == ([
28.0, 27.0
], ((1.0, 0.0), (0.0, 1.0)), (1.0, 1.0))
else:
assert roi.getAffineSliceParams(data, img1, axes=(1, 2)) == ([
27.0, 28.0
], ((1.0, 0.0), (0.0, 1.0)), (1.0, 1.0))
rgn = roi.getArrayRegion(data, img1, axes=(1, 2))
#assert np.all((rgn == data[:, 1:-2, 1:-2, :]) | (rgn == 0))
img2.setImage(rgn[0, ..., 0])
vb2.setAspectLocked()
vb2.enableAutoRange(True, True)
app.processEvents()
assertImageApproved(win, name + '/roi_getarrayregion',
'Simple ROI region selection.')
with pytest.raises(TypeError):
roi.setPos(0, False)
roi.setPos([0.5, 1.5])
rgn = roi.getArrayRegion(data, img1, axes=(1, 2))
img2.setImage(rgn[0, ..., 0])
app.processEvents()
assertImageApproved(win, name + '/roi_getarrayregion_halfpx',
'Simple ROI region selection, 0.5 pixel shift.')
roi.setAngle(45)
roi.setPos([3, 0])
rgn = roi.getArrayRegion(data, img1, axes=(1, 2))
img2.setImage(rgn[0, ..., 0])
app.processEvents()
assertImageApproved(win, name + '/roi_getarrayregion_rotate',
'Simple ROI region selection, rotation.')
if testResize:
roi.setSize([60, 60])
rgn = roi.getArrayRegion(data, img1, axes=(1, 2))
img2.setImage(rgn[0, ..., 0])
app.processEvents()
assertImageApproved(win, name + '/roi_getarrayregion_resize',
'Simple ROI region selection, resized.')
img1.scale(1, -1)
img1.setPos(0, img1.height())
img1.rotate(20)
rgn = roi.getArrayRegion(data, img1, axes=(1, 2))
img2.setImage(rgn[0, ..., 0])
app.processEvents()
assertImageApproved(win, name + '/roi_getarrayregion_img_trans',
'Simple ROI region selection, image transformed.')
vb1.invertY()
rgn = roi.getArrayRegion(data, img1, axes=(1, 2))
img2.setImage(rgn[0, ..., 0])
app.processEvents()
assertImageApproved(win, name + '/roi_getarrayregion_inverty',
'Simple ROI region selection, view inverted.')
roi.setState(initState)
img1.resetTransform()
img1.setPos(0, 0)
img1.scale(1, 0.5)
rgn = roi.getArrayRegion(data, img1, axes=(1, 2))
img2.setImage(rgn[0, ..., 0])
app.processEvents()
assertImageApproved(
win, name + '/roi_getarrayregion_anisotropic',
'Simple ROI region selection, image scaled anisotropically.')
# allow the roi to be re-used
roi.scene().removeItem(roi)
def __init__(self, source, axis = None, scale = None, title = None, invertY = False, minMax = None, screen = None, parent = None, *args):
### Images soures
self.initializeSources(source, axis = axis, scale = scale)
#print('init')
### Gui Construction
pg.QtGui.QWidget.__init__(self, parent, *args);
#print('gui')
if title is None:
if isinstance(source, str):
title = source;
elif isinstance(source, io.src.Source):
title = source.location;
if title is None:
title = 'DataViewer';
self.setWindowTitle(title);
self.resize(1600,1200)
#print('title')
self.layout = pg.QtGui.QGridLayout(self);
self.layout.setContentsMargins(0,0,0,0)
#print('layout')
# image pane
self.view = pg.ViewBox();
self.view.setAspectLocked(True);
self.view.invertY(invertY)
self.graphicsView = pg.GraphicsView()
self.graphicsView.setObjectName("GraphicsView")
self.graphicsView.setCentralItem(self.view)
splitter = pg.QtGui.QSplitter();
splitter.setOrientation(pg.QtCore.Qt.Horizontal)
splitter.setSizes([self.width() - 10, 10]);
self.layout.addWidget(splitter);
image_splitter = pg.QtGui.QSplitter();
image_splitter.setOrientation(pg.QtCore.Qt.Vertical)
image_splitter.setSizePolicy(pg.QtGui.QSizePolicy.Expanding, pg.QtGui.QSizePolicy.Expanding)
splitter.addWidget(image_splitter);
#print('image')
# Image plots
image_options = dict(clipToView = True, autoDownsample = True, autoLevels = False, useOpenGL = None);
self.image_items = [pg.ImageItem(s[self.source_slice[:s.ndim]], **image_options) for s in self.sources];
for i in self.image_items:
i.setRect(pg.QtCore.QRect(0, 0, self.source_range_x, self.source_range_y))
i.setCompositionMode(pg.QtGui.QPainter.CompositionMode_Plus);
self.view.addItem(i);
self.view.setXRange(0, self.source_range_x);
self.view.setYRange(0, self.source_range_y);
#print('plots')
# Slice Selector
self.slicePlot = pg.PlotWidget()
sizePolicy = pg.QtGui.QSizePolicy(pg.QtGui.QSizePolicy.Preferred, pg.QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.slicePlot.sizePolicy().hasHeightForWidth())
self.slicePlot.setSizePolicy(sizePolicy)
self.slicePlot.setMinimumSize(pg.QtCore.QSize(0, 40))
self.slicePlot.setObjectName("roiPlot");
#self.sliceCurve = self.slicePlot.plot()
self.sliceLine = pg.InfiniteLine(0, movable=True)
self.sliceLine.setPen((255, 255, 255, 200))
self.sliceLine.setZValue(1)
self.slicePlot.addItem(self.sliceLine)
self.slicePlot.hideAxis('left')
self.updateSlicer();
self.sliceLine.sigPositionChanged.connect(self.updateSlice)
#print('slice')
# Axis Tools
axis_tools_layout = pg.QtGui.QGridLayout()
self.axis_buttons = [];
axesnames = ['x', 'y', 'z'];
for d in range(3):
button = pg.QtGui.QRadioButton(axesnames[d]);
button.setMaximumWidth(50);
axis_tools_layout.addWidget(button,0,d);
button.clicked.connect(ft.partial(self.setSliceAxis, d));
self.axis_buttons.append(button);
self.axis_buttons[self.source_axis].setChecked(True);
axis_tools_widget = pg.QtGui.QWidget();
axis_tools_widget.setLayout(axis_tools_layout);
#print('axis')
# coordinate label
self.source_pointer = [0,0,0];
self.source_label = pg.QtGui.QLabel("");
axis_tools_layout.addWidget(self.source_label,0,3);
self.graphicsView.scene().sigMouseMoved.connect(self.updateLabelFromMouseMove);
#print('coords')
#compose the image viewer
image_splitter.addWidget(self.graphicsView);
image_splitter.addWidget(self.slicePlot)
image_splitter.addWidget(axis_tools_widget);
image_splitter.setSizes([self.height()-35-20, 35, 20])
#print('viewer')
# lut widgets
if self.nsources == 1:
cols = ['flame'];
elif self.nsources == 2:
cols = ['purple', 'green'];
else:
cols = np.array(['white', 'green','red', 'blue', 'purple'] * self.nsources)[:self.nsources];
self.luts = [LUT(image = i, color = c) for i,c in zip(self.image_items, cols)];
lut_layout = pg.QtGui.QGridLayout();
lut_layout.setContentsMargins(0,0,0,0);
for d,l in enumerate(self.luts):
lut_layout.addWidget(l,0,d);
lut_widget = pg.QtGui.QWidget();
lut_widget.setLayout(lut_layout);
lut_widget.setContentsMargins(0,0,0,0);
#lut_widget.setSizePolicy(pg.QtGui.QSizePolicy.Maximum, pg.QtGui.QSizePolicy.Expanding)
lut_widget.setSizePolicy(pg.QtGui.QSizePolicy.Preferred, pg.QtGui.QSizePolicy.Expanding)
splitter.addWidget(lut_widget);
splitter.setStretchFactor(0, 1);
splitter.setStretchFactor(1, 0);
#self.source_levelMin = [];
#self.source_levelMax = [];
#for i,s in enumerate(self.sources):
# lmin, lmax = list(map(float, self.quickMinMax(s[self.source_slice])));
# self.levelMin.append(lmin);
# self.levelMax.append(lmax);
#print('lut')
# update scale
for l in self.luts:
l.range_buttons[1][2].click();
if minMax is not None:
self.setMinMax(minMax);
self.show();
image_item.updateImage(rgb.transpose(1, 0, 2)[:, ::-1])
SHOW_PLOT = True
# SHOW_PLOT = False
if not os.getenv('DISPLAY'):
# But not if there is no x server:
SHOW_PLOT = False
if SHOW_PLOT:
import pyqtgraph as pg
qapplication = QtGui.QApplication([])
graphics_view = pg.GraphicsView()
graphics_view.setAttribute(QtCore.Qt.WA_ShowWithoutActivating)
graphics_view.setWindowTitle('MPI task %d' % simulator.MPI_rank)
view_box = pg.ViewBox()
graphics_view.setCentralItem(view_box)
view_box.setAspectLocked(True)
image_item = None
def initial_guess(x, y):
sigma_x = 0.5 * R
sigma_y = 0.5 * R
f = np.sqrt(np.exp(-x**2 / (2 * sigma_x**2) - y**2 / (2 * sigma_y**2)))
return f
def run_sims():
try:
psi = simulator.elements.make_vector(initial_guess)
def keyPressEvent(self, event):
key = event.key()
modifier = event.modifiers()
if key in self.disabled_keys:
super().keyPressEvent(event)
else:
if key == Qt.Key_C:
if self.cursor1 is None:
start, stop = self.viewbox.viewRange()[0]
self.cursor1 = Cursor(pos=0, angle=90, movable=True)
self.plotItem.addItem(self.cursor1, ignoreBounds=True)
self.cursor1.sigPositionChanged.connect(self.cursor_moved.emit)
self.cursor1.sigPositionChangeFinished.connect(
self.cursor_move_finished.emit
)
self.cursor1.setPos((start + stop) / 2)
self.cursor_move_finished.emit()
else:
self.plotItem.removeItem(self.cursor1)
self.cursor1.setParent(None)
self.cursor1 = None
self.cursor_removed.emit()
elif key == Qt.Key_F:
for viewbox, signal in zip(self.view_boxes, self.signals):
if len(signal.plot_samples):
min_, max_ = (
np.amin(signal.plot_samples),
np.amax(signal.plot_samples),
)
viewbox.setYRange(min_, max_, padding=0)
if self.cursor1:
self.cursor_moved.emit()
elif key == Qt.Key_G:
if self.plotItem.ctrl.yGridCheck.isChecked():
self.showGrid(x=True, y=False)
else:
self.showGrid(x=True, y=True)
for axis in self.axes:
if axis.grid is False:
axis.setGrid(80)
else:
axis.setGrid(False)
elif key in (Qt.Key_I, Qt.Key_O):
x_range, _ = self.viewbox.viewRange()
delta = x_range[1] - x_range[0]
step = delta * 0.05
if key == Qt.Key_I:
step = -step
if self.cursor1:
pos = self.cursor1.value()
x_range = pos - delta / 2, pos + delta / 2
self.viewbox.setXRange(
x_range[0] - step, x_range[1] + step, padding=0
)
elif key == Qt.Key_R:
if self.region is None:
self.region = pg.LinearRegionItem((0, 0))
self.region.setZValue(-10)
self.plotItem.addItem(self.region)
self.region.sigRegionChanged.connect(self.range_modified.emit)
self.region.sigRegionChangeFinished.connect(
self.range_modified_finished.emit
)
start, stop = self.viewbox.viewRange()[0]
start, stop = (
start + 0.1 * (stop - start),
stop - 0.1 * (stop - start),
)
self.region.setRegion((start, stop))
else:
self.region.setParent(None)
self.region.hide()
self.region = None
self.range_removed.emit()
elif key == Qt.Key_S and modifier == Qt.ControlModifier:
file_name, _ = QFileDialog.getSaveFileName(
self,
"Select output measurement file", "",
"MDF version 4 files (*.mf4)",
)
if file_name:
mdf = MDF()
mdf.append(self.signals)
mdf.save(file_name, overwrite=True)
elif key == Qt.Key_S:
count = len(
[
sig
for (sig, curve) in zip(self.signals, self.curves)
if not sig.empty and curve.isVisible()
]
)
if count:
position = 0
for signal, viewbox, curve in zip(
reversed(self.signals),
reversed(self.view_boxes),
reversed(self.curves),
):
if not signal.empty and curve.isVisible():
min_ = signal.min
max_ = signal.max
if min_ == max_:
min_, max_ = min_ - 1, max_ + 1
dim = (max_ - min_) * 1.1
max_ = min_ + dim * count
min_, max_ = (
min_ - dim * position,
max_ - dim * position,
)
viewbox.setYRange(min_, max_, padding=0)
position += 1
else:
xrange, _ = self.viewbox.viewRange()
self.viewbox.autoRange(padding=0)
self.viewbox.setXRange(*xrange, padding=0)
self.viewbox.disableAutoRange()
if self.cursor1:
self.cursor_moved.emit()
elif key == Qt.Key_H and modifier == Qt.ControlModifier:
for axis, signal in zip(self.axes, self.signals):
if axis.isVisible() and signal.samples.dtype.kind in "ui":
axis.format = "hex"
signal.format = "hex"
axis.hide()
axis.show()
if (
self.axis.isVisible()
and self.signals[self.singleton].samples.dtype.kind in "ui"
):
self.axis.format = "hex"
self.signals[self.singleton].format = "hex"
self.axis.hide()
self.axis.show()
if self.cursor1:
self.cursor_moved.emit()
elif key == Qt.Key_B and modifier == Qt.ControlModifier:
for axis, signal in zip(self.axes, self.signals):
if axis.isVisible() and signal.samples.dtype.kind in "ui":
axis.format = "bin"
signal.format = "bin"
axis.hide()
axis.show()
if (
self.axis.isVisible()
and self.signals[self.singleton].samples.dtype.kind in "ui"
):
self.axis.format = "bin"
self.signals[self.singleton].format = "bin"
self.axis.hide()
self.axis.show()
if self.cursor1:
self.cursor_moved.emit()
elif key == Qt.Key_P and modifier == Qt.ControlModifier:
for axis, signal in zip(self.axes, self.signals):
if axis.isVisible() and signal.samples.dtype.kind in "ui":
axis.format = "phys"
signal.format = "phys"
axis.hide()
axis.show()
if (
self.axis.isVisible()
and self.signals[self.singleton].samples.dtype.kind in "ui"
):
self.axis.format = "phys"
self.signals[self.singleton].format = "phys"
self.axis.hide()
self.axis.show()
if self.cursor1:
self.cursor_moved.emit()
elif key in (Qt.Key_Left, Qt.Key_Right):
if self.cursor1:
prev_pos = pos = self.cursor1.value()
dim = len(self.timebase)
if dim:
pos = np.searchsorted(self.timebase, pos)
if key == Qt.Key_Right:
pos += 1
else:
pos -= 1
pos = np.clip(pos, 0, dim - 1)
pos = self.timebase[pos]
else:
if key == Qt.Key_Right:
pos += 1
else:
pos -= 1
(left_side, right_side), _ = self.viewbox.viewRange()
if pos >= right_side:
delta = abs(pos - prev_pos)
self.viewbox.setXRange(
left_side + delta, right_side + delta, padding=0
)
elif pos <= left_side:
delta = abs(pos - prev_pos)
self.viewbox.setXRange(
left_side - delta, right_side - delta, padding=0
)
else:
delta = 0
self.cursor1.setValue(pos)
elif key == Qt.Key_H:
start_ts = [
sig.timestamps[0]
for sig in self.signals
if len(sig.timestamps)
]
stop_ts = [
sig.timestamps[-1]
for sig in self.signals
if len(sig.timestamps)
]
if start_ts:
start_t, stop_t = min(start_ts), max(stop_ts)
self.viewbox.setXRange(start_t, stop_t)
self.viewbox.autoRange(padding=0)
self.viewbox.disableAutoRange()
if self.cursor1:
self.cursor_moved.emit()
elif key == Qt.Key_Insert:
dlg = DefineChannel(self.signals, self.all_timebase, self)
dlg.setModal(True)
dlg.exec_()
sig = dlg.result
if sig is not None:
index = len(self.signals)
self.signals.append(sig)
if sig.samples.dtype.kind == "f":
sig.format = "{:.6f}"
sig.plot_texts = None
else:
sig.format = "phys"
if sig.samples.dtype.kind in "SV":
sig.plot_texts = sig.texts = sig.samples
sig.samples = np.zeros(len(sig.samples))
else:
sig.plot_texts = None
sig.enable = True
if sig.conversion:
vals = sig.conversion.convert(sig.samples)
if vals.dtype.kind != 'S':
nans = np.isnan(vals)
samples = np.where(
nans,
sig.samples,
vals,
)
sig.samples = samples
sig.plot_samples = sig.samples
sig.plot_timestamps = sig.timestamps
sig._stats = {
"range": (0, -1),
"range_stats": {},
"visible": (0, -1),
"visible_stats": {},
}
color = COLORS[index % 10]
sig.color = color
if len(sig.samples):
sig.min = np.amin(sig.samples)
sig.max = np.amax(sig.samples)
sig.empty = False
else:
sig.empty = True
axis = FormatedAxis("right", pen=color)
if sig.conversion and hasattr(sig.conversion, "text_0"):
axis.text_conversion = sig.conversion
view_box = pg.ViewBox(enableMenu=False)
axis.linkToView(view_box)
axis.labelText = sig.name
axis.labelUnits = sig.unit
axis.labelStyle = {"color": color}
axis.hide()
self.layout.addItem(axis, 2, index + 2)
self.scene_.addItem(view_box)
t = sig.plot_timestamps
curve = self.curvetype(
t,
sig.plot_samples,
pen=color,
symbolBrush=color,
symbolPen=color,
symbol="o",
symbolSize=4,
)
view_box.addItem(curve)
view_box.setXLink(self.viewbox)
self.view_boxes.append(view_box)
self.curves.append(curve)
self.axes.append(axis)
view_box.setYRange(sig.min, sig.max, padding=0, update=True)
(start, stop), _ = self.viewbox.viewRange()
view_box.setXRange(start, stop, padding=0, update=True)
axis.showLabel()
axis.show()
QApplication.processEvents()
self.computation_channel_inserted.emit()
else:
super().keyPressEvent(event)
def __init__(self, signals, with_dots, *args, **kwargs):
super().__init__(*args, **kwargs)
self.xrange_changed.connect(self.xrange_changed_handle)
self.with_dots = with_dots
if self.with_dots:
self.curvetype = pg.PlotDataItem
else:
self.curvetype = pg.PlotCurveItem
self.info = None
self.standalone = kwargs.get("standalone", False)
self.singleton = None
self.region = None
self.cursor1 = None
self.cursor2 = None
self.signals = signals
self.common_axis_items = set()
self.disabled_keys = set()
for sig in self.signals:
if sig.samples.dtype.kind == "f":
sig.format = "{:.6f}"
sig.plot_texts = None
else:
sig.format = "phys"
if sig.samples.dtype.kind in "SV":
sig.plot_texts = sig.texts = sig.samples
sig.samples = np.zeros(len(sig.samples))
else:
sig.plot_texts = None
sig.enable = True
if sig.conversion:
vals = sig.conversion.convert(sig.samples)
if vals.dtype.kind not in 'SV':
nans = np.isnan(vals)
samples = np.where(
nans,
sig.samples,
vals,
)
sig.samples = samples
sig.plot_samples = sig.samples
sig.plot_timestamps = sig.timestamps
sig._stats = {
"range": (0, -1),
"range_stats": {},
"visible": (0, -1),
"visible_stats": {},
}
if self.signals:
self.all_timebase = self.timebase = reduce(
np.union1d, (sig.timestamps for sig in self.signals)
)
else:
self.all_timebase = self.timebase = None
self.showGrid(x=True, y=True)
self.plot_item = self.plotItem
self.plot_item.hideAxis("left")
self.layout = self.plot_item.layout
self.scene_ = self.plot_item.scene()
self.viewbox = self.plot_item.vb
self.viewbox.sigXRangeChanged.connect(self.xrange_changed.emit)
self.curve = self.curvetype([], [])
axis = self.layout.itemAt(2, 0)
axis.setParent(None)
self.axis = FormatedAxis("left")
self.layout.removeItem(axis)
self.layout.addItem(self.axis, 2, 0)
self.axis.linkToView(axis.linkedView())
self.plot_item.axes["left"]["item"] = self.axis
self.plot_item.hideAxis("left")
self.viewbox.addItem(self.curve)
self.cursor_hint = pg.PlotDataItem(
[],
[],
pen="#000000",
symbolBrush="#000000",
symbolPen="w",
symbol="s",
symbolSize=8,
)
self.viewbox.addItem(self.cursor_hint)
self.view_boxes = []
self.curves = []
self.axes = []
for i, sig in enumerate(self.signals):
color = COLORS[i % 10]
sig.color = color
if len(sig.samples):
if sig.samples.dtype.kind not in 'SV':
sig.min = np.amin(sig.samples)
sig.max = np.amax(sig.samples)
else:
sig.min = 'n.a.'
sig.max = 'n.a.'
sig.empty = False
else:
sig.empty = True
axis = FormatedAxis("right", pen=color)
if sig.conversion and hasattr(sig.conversion, "text_0"):
axis.text_conversion = sig.conversion
view_box = pg.ViewBox(enableMenu=False)
axis.linkToView(view_box)
if len(sig.name) <= 32:
axis.labelText = sig.name
else:
axis.labelText = f"{sig.name[:29]}..."
axis.labelUnits = sig.unit
axis.labelStyle = {"color": color}
self.layout.addItem(axis, 2, i + 2)
self.scene_.addItem(view_box)
curve = self.curvetype(
sig.plot_timestamps,
sig.plot_samples,
pen=color,
symbolBrush=color,
symbolPen=color,
symbol="o",
symbolSize=4,
)
view_box.addItem(curve)
view_box.setXLink(self.viewbox)
self.view_boxes.append(view_box)
self.curves.append(curve)
self.axes.append(axis)
axis.hide()
if len(signals) == 1:
self.setSignalEnable(0, 1)
# self.update_views()
self.viewbox.sigResized.connect(self.update_views)
# self.viewbox.enableAutoRange(axis=pg.ViewBox.XYAxes, enable=True)
self.keyPressEvent(QKeyEvent(QEvent.KeyPress, Qt.Key_H, Qt.NoModifier))
self.resizeEvent = self._resizeEvent
from pyqtgraph.Qt import QtGui, QtCore
import pyqtgraph as pg
app = QtGui.QApplication([])
mw = QtGui.QMainWindow()
mw.setWindowTitle('pyqtgraph example: ViewBox')
mw.show()
mw.resize(800, 600)
gv = pg.GraphicsView()
mw.setCentralWidget(gv)
l = QtGui.QGraphicsGridLayout()
l.setHorizontalSpacing(0)
l.setVerticalSpacing(0)
vb = pg.ViewBox(border='r')
p1 = pg.PlotDataItem(np.random.normal(size=100))
vb.addItem(p1)
## Just something to play with inside the ViewBox
class movableRect(QtGui.QGraphicsRectItem):
def __init__(self, *args):
QtGui.QGraphicsRectItem.__init__(self, *args)
self.setAcceptHoverEvents(True)
def hoverEnterEvent(self, ev):
self.savedPen = self.pen()
self.setPen(pg.mkPen(255, 255, 255))
ev.ignore()
def init_figures(self):
"""
Create all figures that will be added to the GUI
"""
# Figures to show ephys data
# 2D scatter/ image plot
self.fig_img = pg.PlotItem()
self.fig_img.setYRange(min=self.probe_tip - self.probe_extra, max=self.probe_top +
self.probe_extra, padding=self.pad)
self.fig_img.addLine(y=self.probe_tip, pen=self.kpen_dot, z=50)
self.fig_img.addLine(y=self.probe_top, pen=self.kpen_dot, z=50)
self.set_axis(self.fig_img, 'bottom')
self.fig_data_ax = self.set_axis(self.fig_img, 'left',
label='Distance from probe tip (uV)')
self.fig_img_cb = pg.PlotItem()
self.fig_img_cb.setMaximumHeight(70)
self.fig_img_cb.setMouseEnabled(x=False, y=False)
self.set_axis(self.fig_img_cb, 'bottom', show=False)
self.set_axis(self.fig_img_cb, 'left', pen='w')
self.set_axis(self.fig_img_cb, 'top', pen='w')
# 1D line plot
self.fig_line = pg.PlotItem()
self.fig_line.setMouseEnabled(x=False, y=False)
self.fig_line.setYRange(min=self.probe_tip - self.probe_extra, max=self.probe_top +
self.probe_extra, padding=self.pad)
self.fig_line.addLine(y=self.probe_tip, pen=self.kpen_dot, z=50)
self.fig_line.addLine(y=self.probe_top, pen=self.kpen_dot, z=50)
self.set_axis(self.fig_line, 'bottom')
self.set_axis(self.fig_line, 'left', show=False)
# 2D probe plot
self.fig_probe = pg.PlotItem()
self.fig_probe.setMouseEnabled(x=False, y=False)
self.fig_probe.setMaximumWidth(50)
self.fig_probe.setYRange(min=self.probe_tip - self.probe_extra, max=self.probe_top +
self.probe_extra, padding=self.pad)
self.fig_probe.addLine(y=self.probe_tip, pen=self.kpen_dot, z=50)
self.fig_probe.addLine(y=self.probe_top, pen=self.kpen_dot, z=50)
self.set_axis(self.fig_probe, 'bottom', pen='w')
self.set_axis(self.fig_probe, 'left', show=False)
self.fig_probe_cb = pg.PlotItem()
self.fig_probe_cb.setMouseEnabled(x=False, y=False)
self.fig_probe_cb.setMaximumHeight(70)
self.set_axis(self.fig_probe_cb, 'bottom', show=False)
self.set_axis(self.fig_probe_cb, 'left', show=False)
self.set_axis(self.fig_probe_cb, 'top', pen='w')
# Add img plot, line plot, probe plot, img colourbar and probe colourbar to a graphics
# layout widget so plots can be arranged and moved easily
self.fig_data_area = pg.GraphicsLayoutWidget()
self.fig_data_area.scene().sigMouseClicked.connect(self.on_mouse_double_clicked)
self.fig_data_area.scene().sigMouseHover.connect(self.on_mouse_hover)
self.fig_data_layout = pg.GraphicsLayout()
self.fig_data_layout.addItem(self.fig_img_cb, 0, 0)
self.fig_data_layout.addItem(self.fig_probe_cb, 0, 1, 1, 2)
self.fig_data_layout.addItem(self.fig_img, 1, 0)
self.fig_data_layout.addItem(self.fig_line, 1, 1)
self.fig_data_layout.addItem(self.fig_probe, 1, 2)
self.fig_data_layout.layout.setColumnStretchFactor(0, 6)
self.fig_data_layout.layout.setColumnStretchFactor(1, 2)
self.fig_data_layout.layout.setColumnStretchFactor(2, 1)
self.fig_data_layout.layout.setRowStretchFactor(0, 1)
self.fig_data_layout.layout.setRowStretchFactor(1, 10)
self.fig_data_area.addItem(self.fig_data_layout)
# Figures to show histology data
# Histology figure that will be updated with user input
self.fig_hist = pg.PlotItem()
self.fig_hist.setContentsMargins(0, 0, 0, 0)
self.fig_hist.setMouseEnabled(x=False)
self.fig_hist.setYRange(min=self.probe_tip - self.probe_extra, max=self.probe_top +
self.probe_extra, padding=self.pad)
self.set_axis(self.fig_hist, 'bottom', pen='w', ticks=False)
self.ax_hist = self.set_axis(self.fig_hist, 'left', pen=None)
self.ax_hist.setWidth(0)
self.ax_hist.setStyle(tickTextOffset=-70)
self.fig_scale = pg.PlotItem()
self.fig_scale.setMaximumWidth(50)
self.fig_scale.setMouseEnabled(x=False)
self.scale_label = pg.LabelItem(color='k')
self.set_axis(self.fig_scale, 'bottom', pen='w', ticks=False)
self.set_axis(self.fig_scale, 'left', show=False)
(self.fig_scale).setYLink(self.fig_hist)
# Figure that will show scale factor of histology boundaries
self.fig_scale_cb = pg.PlotItem()
self.fig_scale_cb.setMouseEnabled(x=False, y=False)
self.fig_scale_cb.setMaximumHeight(70)
self.set_axis(self.fig_scale_cb, 'bottom', show=False)
self.set_axis(self.fig_scale_cb, 'left', show=False)
self.fig_scale_ax = self.set_axis(self.fig_scale_cb, 'top', pen='w')
self.set_axis(self.fig_scale_cb, 'right', show=False)
# Histology figure that will remain at initial state for reference
self.fig_hist_ref = pg.PlotItem()
self.fig_hist_ref.setMouseEnabled(x=False)
self.fig_hist_ref.setYRange(min=self.probe_tip - self.probe_extra, max=self.probe_top +
self.probe_extra, padding=self.pad)
self.set_axis(self.fig_hist_ref, 'bottom', pen='w')
self.set_axis(self.fig_hist_ref, 'left', show=False)
self.ax_hist_ref = self.set_axis(self.fig_hist_ref, 'right', pen=None)
self.ax_hist_ref.setWidth(0)
self.ax_hist_ref.setStyle(tickTextOffset=-70)
self.fig_hist_area = pg.GraphicsLayoutWidget()
self.fig_hist_area.setMouseTracking(True)
self.fig_hist_area.scene().sigMouseClicked.connect(self.on_mouse_double_clicked)
self.fig_hist_area.scene().sigMouseHover.connect(self.on_mouse_hover)
self.fig_hist_extra_yaxis = pg.PlotItem()
self.fig_hist_extra_yaxis.setMouseEnabled(x=False, y=False)
self.fig_hist_extra_yaxis.setMaximumWidth(2)
self.fig_hist_extra_yaxis.setYRange(min=self.probe_tip - self.probe_extra,
max=self.probe_top + self.probe_extra,
padding=self.pad)
self.set_axis(self.fig_hist_extra_yaxis, 'bottom', pen='w')
self.ax_hist2 = self.set_axis(self.fig_hist_extra_yaxis, 'left', pen=None)
self.ax_hist2.setWidth(10)
self.fig_hist_layout = pg.GraphicsLayout()
self.fig_hist_layout.addItem(self.fig_scale_cb, 0, 0, 1, 4)
self.fig_hist_layout.addItem(self.fig_hist_extra_yaxis, 1, 0)
self.fig_hist_layout.addItem(self.fig_hist, 1, 1)
self.fig_hist_layout.addItem(self.fig_scale, 1, 2)
self.fig_hist_layout.addItem(self.fig_hist_ref, 1, 3)
self.fig_hist_layout.layout.setColumnStretchFactor(0, 1)
self.fig_hist_layout.layout.setColumnStretchFactor(1, 4)
self.fig_hist_layout.layout.setColumnStretchFactor(2, 1)
self.fig_hist_layout.layout.setColumnStretchFactor(3, 4)
self.fig_hist_layout.layout.setRowStretchFactor(0, 1)
self.fig_hist_layout.layout.setRowStretchFactor(1, 10)
self.fig_hist_area.addItem(self.fig_hist_layout)
# Figure to show coronal slice through the brain
self.fig_slice_area = pg.GraphicsLayoutWidget()
self.fig_slice_layout = pg.GraphicsLayout()
self.fig_slice_hist_alt = pg.ViewBox()
self.fig_slice = pg.ViewBox()
self.fig_slice_layout.addItem(self.fig_slice, 0, 0)
self.fig_slice_layout.addItem(self.fig_slice_hist_alt, 0, 1)
self.fig_slice_layout.layout.setColumnStretchFactor(0, 3)
self.fig_slice_layout.layout.setColumnStretchFactor(1, 1)
self.fig_slice_area.addItem(self.fig_slice_layout)
self.slice_item = self.fig_slice_hist_alt
# Figure to show fit and offset applied by user
self.fig_fit = pg.PlotWidget(background='w')
self.fig_fit.setMouseEnabled(x=False, y=False)
self.fig_fit_exporter = pg.exporters.ImageExporter(self.fig_fit.plotItem)
self.fig_fit.sigDeviceRangeChanged.connect(self.on_fig_size_changed)
self.fig_fit.setXRange(min=self.view_total[0], max=self.view_total[1])
self.fig_fit.setYRange(min=self.view_total[0], max=self.view_total[1])
self.set_axis(self.fig_fit, 'bottom', label='Original coordinates (um)')
self.set_axis(self.fig_fit, 'left', label='New coordinates (um)')
plot = pg.PlotCurveItem()
plot.setData(x=self.depth, y=self.depth, pen=self.kpen_dot)
self.fit_plot = pg.PlotCurveItem(pen=self.bpen_solid)
self.fit_scatter = pg.ScatterPlotItem(size=7, symbol='o', brush='w', pen='b')
self.fit_plot_lin = pg.PlotCurveItem(pen=self.rpen_dot)
self.fig_fit.addItem(plot)
self.fig_fit.addItem(self.fit_plot)
self.fig_fit.addItem(self.fit_plot_lin)
self.fig_fit.addItem(self.fit_scatter)
self.lin_fit_option = QtGui.QCheckBox('Linear fit', self.fig_fit)
self.lin_fit_option.setChecked(True)
self.lin_fit_option.stateChanged.connect(self.lin_fit_option_changed)
self.on_fig_size_changed()
def setupUi(self, MainWindow):
# Exemple de liste d'actions
self.nomsActions = ["Entreprise 1", "Entreprise 2", "Entreprise 3"]
# Matrice de covariance
self.Sigma = np.array([[20, -13, 0], [-13, 25, 0], [0, 0, 23]])
self.Sigma = self.Sigma.astype('d')
# Retours sur l'investissement moyens
self.Mu = np.array([1.5, -0.2, 1.3])
self.Mu = self.Mu.astype('d')
# Nombre d'assets
self.nbActions = len(self.nomsActions)
# Nombre de périodes
self.nbPer = 400
# Prix initiaux
self.init = np.array([40, 40, 40])
# Risk-free rate
self.Rf = 0.5
# Coefficient multiplicatif reliant alpha et 1/lambda
uns = np.ones(self.nbActions)
self.coeff_de_prop = np.dot(
uns, np.dot(np.linalg.inv(self.Sigma), self.Mu)
) # Coefficient de proportionalité entre gamma et 1/alpha
MainWindow.setObjectName("Théorie du Portefeuille de Markovitz")
MainWindow.resize(1600, 950)
self.centralWidget = QtWidgets.QWidget(MainWindow)
self.centralWidget.setObjectName("centralWidget")
## Premier onglet:
self.tabWidget = QtWidgets.QTabWidget(self.centralWidget)
self.tabWidget.setGeometry(QtCore.QRect(0, 10, 1600, 900))
self.tabWidget.setObjectName("tabWidget")
self.tab = QtWidgets.QWidget()
self.tab.setObjectName("tab")
# On crée une VBox à gauche
self.VBoxGWidget = QtWidgets.QWidget(self.tab)
self.VBoxGWidget.setGeometry(QtCore.QRect(30, 10, 300, 600))
self.VBoxGWidget.setObjectName("VBoxGWidget")
self.VBoxG = QtWidgets.QVBoxLayout(self.VBoxGWidget)
self.VBoxG.setContentsMargins(11, 11, 11, 11)
self.VBoxG.setSpacing(3)
self.VBoxG.setObjectName("VBoxG")
# On lui ajoute un label qui servira à guider l'utilisateur
self.indic_label = QtWidgets.QLabel(self.VBoxGWidget)
self.indic_label.setMinimumSize(QtCore.QSize(300, 80))
self.indic_label.setMaximumSize(QtCore.QSize(300, 80))
self.indic_label.setObjectName("indic_label")
self.VBoxG.addWidget(self.indic_label)
# On ajoute les champs des actions à la VBox, un bouton "Valider" et un bouton "Retour"
self.addChamps(self.nbActions)
self.validerBouton = QtWidgets.QPushButton(self.tab)
self.validerBouton.setGeometry(QtCore.QRect(130, 600, 88, 34))
self.validerBouton.setObjectName("validerBouton")
self.validerBouton.raise_()
self.retourBouton = QtWidgets.QPushButton(self.tab)
self.retourBouton.setGeometry(QtCore.QRect(130, 600, 88, 34))
self.retourBouton.setObjectName("retourBouton")
self.retourBouton.raise_()
self.VBoxGWidget.raise_()
# On rajoute les n graphiques des actifs
self.horizontalLayoutWidget = QtWidgets.QWidget(self.tab)
self.horizontalLayoutWidget.setGeometry(QtCore.QRect(
600, 50, 800, 700))
self.horizontalLayoutWidget.setObjectName("horizontalLayoutWidget")
self.horizontalLayout = QtWidgets.QHBoxLayout(
self.horizontalLayoutWidget)
self.horizontalLayout.setContentsMargins(11, 11, 11, 11)
self.horizontalLayout.setSpacing(40)
self.horizontalLayout.setObjectName("horizontalLayout")
self.verticalLayout = QtWidgets.QVBoxLayout()
self.verticalLayout.setSpacing(6)
self.verticalLayout.setObjectName("verticalLayout")
self.add_N_Graphiques(self.nbActions)
# On rajoute le repère sur lequel on va représenter les courbes des n actifs
self.horizontalLayout.addLayout(self.verticalLayout)
self.graphicsView_n_graphiques = PlotWidget(
self.horizontalLayoutWidget)
self.graphicsView_n_graphiques.setObjectName(
"graphicsView_n_graphiques")
self.horizontalLayout.addWidget(self.graphicsView_n_graphiques)
# On fait de même avec le repère où l'on va tracer la frontière de Markovitz
self.graphicsView_frontiere = PlotWidget(self.horizontalLayoutWidget)
self.graphicsView_frontiere.setObjectName("graphicsView_frontiere")
self.horizontalLayout.addWidget(self.graphicsView_frontiere)
self.tabWidget.addTab(self.tab, "")
## Deuxième onglet
self.tab_2 = QtWidgets.QWidget()
self.tab_2.setObjectName("tab_2")
# On crée une VBox à gauche
self.VBoxGWidget_2 = QtWidgets.QWidget(self.tab_2)
self.VBoxGWidget_2.setGeometry(QtCore.QRect(30, 10, 300, 600))
self.VBoxGWidget_2.setObjectName("VBoxGWidget_2")
self.VBoxG_2 = QtWidgets.QVBoxLayout(self.VBoxGWidget_2)
self.VBoxG_2.setContentsMargins(11, 11, 11, 11)
self.VBoxG_2.setSpacing(3)
self.VBoxG_2.setObjectName("VBoxG_2")
# On lui ajoute un label qui servira à guider l'utilisateur
self.indic_label_2 = QtWidgets.QLabel(self.VBoxGWidget_2)
self.indic_label_2.setMinimumSize(QtCore.QSize(300, 80))
self.indic_label_2.setMaximumSize(QtCore.QSize(300, 80))
self.indic_label_2.setObjectName("indic_label_2")
self.VBoxG_2.addWidget(self.indic_label_2)
# On ajoute les champs des actions à la VBox, un bouton "Valider" et un bouton "Retour"
self.addChamps_2(self.nbActions)
self.validerBouton_2 = QtWidgets.QPushButton(self.tab_2)
self.validerBouton_2.setGeometry(QtCore.QRect(130, 600, 88, 34))
self.validerBouton_2.setObjectName("validerBouton_2")
self.validerBouton_2.raise_()
self.retourBouton_2 = QtWidgets.QPushButton(self.tab_2)
self.retourBouton_2.setGeometry(QtCore.QRect(130, 600, 88, 34))
self.retourBouton_2.setObjectName("retourBouton_2")
self.retourBouton_2.raise_()
self.VBoxGWidget_2.raise_()
# On rajoute les n graphiques des actifs
self.horizontalLayoutWidget_2 = QtWidgets.QWidget(self.tab_2)
self.horizontalLayoutWidget_2.setGeometry(
QtCore.QRect(400, 50, 821, 651))
self.horizontalLayoutWidget_2.setObjectName("horizontalLayoutWidget_2")
self.horizontalLayout_2 = QtWidgets.QHBoxLayout(
self.horizontalLayoutWidget_2)
self.horizontalLayout_2.setContentsMargins(11, 11, 11, 11)
self.horizontalLayout_2.setSpacing(6)
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.verticalLayout_2 = QtWidgets.QVBoxLayout()
self.verticalLayout_2.setSpacing(6)
self.verticalLayout_2.setObjectName("verticalLayout_2")
self.add_N_Graphiques_2(self.nbActions)
# On rajoute le repère sur lequel on va représenter les courbes des n actifs
self.horizontalLayout_2.addLayout(self.verticalLayout_2)
self.graphicsView_n_graphiques_2 = PlotWidget(
self.horizontalLayoutWidget_2)
self.graphicsView_n_graphiques_2.setObjectName(
"graphicsView_n_graphiques_2")
self.horizontalLayout_2.addWidget(self.graphicsView_n_graphiques_2)
# On fait de même avec le repère où l'on va tracer la frontière de Markovitz
self.graphicsView_frontiere_2 = PlotWidget(
self.horizontalLayoutWidget_2)
self.graphicsView_frontiere_2.setObjectName("graphicsView_frontiere_2")
self.horizontalLayout_2.addWidget(self.graphicsView_frontiere_2)
self.tabWidget.addTab(self.tab_2, "")
# Troisième onglet: paramètres
self.tab_3 = QtWidgets.QWidget()
self.tab_3.setObjectName("tab_3")
# Code pour l'onglet "Paramètres"
# Liste des paramètres modifiables:
self.params = [
{
'name':
'Paramètres principaux',
'type':
'group',
'children': [
{
'name': "Nombre d'actifs considérés",
'type': 'int',
'value': 3
},
{
'name': "Nombre de périodes",
'type': 'int',
'value': 400
},
{
'name': "Taux d'intérêt de l'actif sans risque",
'type': 'float',
'value': 0.5,
'step': 0.1
},
{
'name': "Secteurs considérés",
'type': 'list',
'values':
["Tous", "Banque", "Automobile", "High Tech"],
'value': 2
},
{
'name': 'Numéro de poste',
'type': 'int',
'value': 1
},
{
'name': 'Aversion au risque imposée',
'type': 'bool',
'value': False,
'tip': "Aversion au risque imposée"
},
{
'name': 'Modifier la matrice de covariance',
'type': 'action'
},
]
},
{
'name':
'Sauvegarder paramètres/Annuler modifications actuelles',
'type':
'group',
'children': [
{
'name': 'Sauvegarder',
'type': 'action'
},
{
'name': 'Annuler modifications actuelles',
'type': 'action'
},
]
},
#{'name': 'Aversion au risque imposée', 'type': 'float', 'value': 1.2e6, 'siPrefix': True, 'suffix': 'Unités', 'readonly': True},
ComplexParameter(
self.coeff_de_prop,
name=
'Aversion au risque et proportion du portefeuille de marché')
]
# On crée un arbre de paramètres:
self.p = Parameter.create(name='params',
type='group',
children=self.params)
self.p.sigTreeStateChanged.connect(self.change)
# On connecte chaque champ de paramètre à la fonction valueChanging, qui gère
# ce qui se passe quand on modifie le champ
for child in self.p.children():
child.sigValueChanging.connect(self.valueChanging)
for ch2 in child.children():
ch2.sigValueChanging.connect(self.valueChanging)
self.p.param('Sauvegarder paramètres/Annuler modifications actuelles',
'Sauvegarder').sigActivated.connect(self.save)
self.p.param('Sauvegarder paramètres/Annuler modifications actuelles',
'Annuler modifications actuelles').sigActivated.connect(
self.restore)
self.p.param('Paramètres principaux',
'Modifier la matrice de covariance').sigActivated.connect(
self.matrice_de_cov)
# On crée le widget associé à l'arbre de paramètres
self.t = ParameterTree()
self.t.setParameters(self.p, showTop=False)
self.t.setWindowTitle('Arbre de paramètres')
self.layout = QtGui.QGridLayout()
self.tab_3.setLayout(self.layout)
self.layout.addWidget(self.t, 1, 0, 1, 1)
# test sauvegarder/rétablir
self.s = self.p.saveState()
self.p.restoreState(self.s)
if parametres == True:
self.tabWidget.addTab(self.tab_3, "")
# Quatrième onglet: mesurer l'aversion au risque
self.tab_4 = QtWidgets.QWidget()
self.tab_4.setObjectName("tab_4")
if aversion_au_risque == True:
self.tabWidget.addTab(self.tab_4, "")
#######################################CHANTIER#########################################
vb = pg.ViewBox()
vb.setAspectLocked(True)
img = pg.ImageItem(np.zeros((200, 200)))
vb.addItem(img)
vb.setRange(QtCore.QRectF(0, 0, 200, 200))
# Coefficient multiplicatif reliant alpha et 1/lambda
uns = np.ones(self.nbActions)
self.coeff_de_prop = np.dot(
uns, np.dot(np.linalg.inv(self.Sigma), self.Mu)
) # Coefficient de proportionalité entre gamma et 1/alpha
## start drawing with 3x3 brush
kern = np.array([[0.0, 10, 0.0], [10, 10.0, 10], [0.0, 10, 0.0]])
img.setDrawKernel(kern, mask=kern, center=(1, 1), mode='add')
img.setLevels([0, 10])
## yScale = pg.AxisItem(orientation='left', linkView=vb)
if chantier:
pg.show()
# xScale = pg.AxisItem(orientation='bottom', linkView=vb)
## l.addItem(xScale, 1, 1)
## l.addItem(yScale, 0, 0)
# pw = pg.PlotWidget(self.tab_4,viewBox=vb, axisItems={'bottom': xScale}, enableMenu=False, title="PlotItem with custom axis and ViewBox<br>Menu disabled, mouse behavior changed: left-drag to zoom, right-click to reset zoom")
# pw.show()
# pw = pg.PlotWidget(self.tab_4,viewBox=vb, axisItems={'bottom': xScale}, enableMenu=False, title="PlotItem with custom axis and ViewBox<br>Menu disabled, mouse behavior changed: left-drag to zoom, right-click to reset zoom")
# pw.show()
## On crée une fenêtre avec un Widget GraphicsView
# self.w = pg.GraphicsView(self.tab_4)
# self.w.show()
# self.w.resize(800,800)
# self.w.setWindowTitle('pyqtgraph example: Draw')
#
# self.view = pg.ViewBox()
# self.w.setCentralItem(self.view)
#
# ## lock the aspect ratio
# self.view.setAspectLocked(True)
#
# ## Create image item
# self.img = pg.ImageItem(np.zeros((200,200)))
# self.view.addItem(self.img)
#
#
#
# ## Set initial view bounds
# self.view.setRange(QtCore.QRectF(0, 0, 200, 200))
#
# ## start drawing with 3x3 brush
# kern = np.array([
# [0.0, 10, 0.0],
# [10, 10.0, 10],
# [0.0, 10, 0.0]
# ])
# self.img.setDrawKernel(kern, mask=kern, center=(1,1), mode='add')
# self.img.setLevels([0, 10])
#
# self.view.setMouseEnabled(False,False)
## self.layout_gamma = QtGui.QGridLayout()
## self.tab_4.setLayout(self.layout_gamma)
## self.layout_gamma.addWidget(self.w, 1, 0, 1, 1)
#####FINCHANTIER
# Autres
MainWindow.setCentralWidget(self.centralWidget)
self.menuBar = QtWidgets.QMenuBar(MainWindow)
self.menuBar.setGeometry(QtCore.QRect(0, 0, 1212, 26))
self.menuBar.setObjectName("menuBar")
MainWindow.setMenuBar(self.menuBar)
self.mainToolBar = QtWidgets.QToolBar(MainWindow)
self.mainToolBar.setObjectName("mainToolBar")
MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.mainToolBar)
self.statusBar = QtWidgets.QStatusBar(MainWindow)
self.statusBar.setObjectName("statusBar")
MainWindow.setStatusBar(self.statusBar)
self.retranslateUi(MainWindow)
self.tabWidget.setCurrentIndex(0)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def __init__(self):
super().__init__()
self.matrix = None
self._tree = None
self._ordered_tree = None
self._sorted_matrix = None
self._sort_indices = None
self._selection = None
self.sorting_cb = gui.comboBox(
self.controlArea,
self,
"sorting",
box="Element sorting",
items=["None", "Clustering", "Clustering with ordered leaves"],
callback=self._invalidate_ordering)
box = gui.vBox(self.controlArea, "Colors")
self.colormap_cb = gui.comboBox(box,
self,
"colormap",
callback=self._update_color)
self.colormap_cb.setIconSize(QSize(64, 16))
self.palettes = list(_color_palettes)
init_color_combo(self.colormap_cb, self.palettes, QSize(64, 16))
self.colormap_cb.setCurrentIndex(self.colormap)
form = QFormLayout(formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
# form.addRow(
# "Gamma",
# gui.hSlider(box, self, "color_gamma", minValue=0.0, maxValue=1.0,
# step=0.05, ticks=True, intOnly=False,
# createLabel=False, callback=self._update_color)
# )
form.addRow(
"Low",
gui.hSlider(box,
self,
"color_low",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self._update_color))
form.addRow(
"High",
gui.hSlider(box,
self,
"color_high",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self._update_color))
box.layout().addLayout(form)
self.annot_combo = gui.comboBox(self.controlArea,
self,
"annotation_idx",
box="Annotations",
callback=self._invalidate_annotations,
contentsLength=12)
self.annot_combo.setModel(itemmodels.VariableListModel())
self.annot_combo.model()[:] = ["None", "Enumeration"]
self.controlArea.layout().addStretch()
gui.auto_commit(self.controlArea, self, "autocommit", "Send data",
"Auto send is on")
self.view = pg.GraphicsView(background="w")
self.mainArea.layout().addWidget(self.view)
self.grid_widget = pg.GraphicsWidget()
self.grid = QGraphicsGridLayout()
self.grid_widget.setLayout(self.grid)
self.viewbox = pg.ViewBox(enableMouse=False, enableMenu=False)
self.viewbox.setAcceptedMouseButtons(Qt.NoButton)
self.viewbox.setAcceptHoverEvents(False)
self.grid.addItem(self.viewbox, 1, 1)
self.left_dendrogram = DendrogramWidget(
self.grid_widget,
orientation=DendrogramWidget.Left,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False)
self.left_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.left_dendrogram.setAcceptHoverEvents(False)
self.top_dendrogram = DendrogramWidget(
self.grid_widget,
orientation=DendrogramWidget.Top,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False)
self.top_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.top_dendrogram.setAcceptHoverEvents(False)
self.grid.addItem(self.left_dendrogram, 1, 0)
self.grid.addItem(self.top_dendrogram, 0, 1)
self.right_labels = TextList(alignment=Qt.AlignLeft)
self.bottom_labels = TextList(orientation=Qt.Horizontal,
alignment=Qt.AlignRight)
self.grid.addItem(self.right_labels, 1, 2)
self.grid.addItem(self.bottom_labels, 2, 1)
self.view.setCentralItem(self.grid_widget)
self.left_dendrogram.hide()
self.top_dendrogram.hide()
self.right_labels.hide()
self.bottom_labels.hide()
self.matrix_item = None
self.dendrogram = None
self.grid_widget.scene().installEventFilter(self)
########################## # Create the main window # ########################## # This should be pretty self-explanatory if you have worked with Qt/PyQt # before. If not, consider reading a tutorial or a book. app = QtGui.QApplication([]) win = QtGui.QWidget() lay = QtGui.QGridLayout() win.setLayout(lay) # Create a the first GraphicsView, which will contain a ViewBox for easier # image zoom/pan/rotate operations, which will in turn contain the ImageItem # responsible for displaying the image. pg1 = pg.GraphicsView() vb1 = pg.ViewBox() im1 = pg.ImageItem() vb1.addItem(im1) vb1.setAspectLocked(True) # No aspect distortions pg1.setBackground(None) # Transparent background outside of the image pg1.setCentralWidget(vb1) # Autoscale the image when the window is rescaled # Do the same for the second GraphicsView pg2 = pg.GraphicsView() vb2 = pg.ViewBox() im2 = pg.ImageItem() vb2.addItem(im2) vb2.setAspectLocked(True) pg2.setBackground(None) pg2.setCentralWidget(vb2)
def __init__(self,
imageItem=None,
label=None,
showHistogram=True,
subsampleStep='auto',
histHeightPercentile=99.0,
maxTickLength=10):
""" Constructor.
:param imageItem pg.ImageItem: PyQtGraph ImageItem to which this legen will be linked
:param Optonal[str] label: text to show next to the axis
:param bool showHistogram: if True (the default), a histogram of image values is drawn
:param float histHeightPercentile: Only use this percentil when scaling the histogram
height. Often an image has one color that occurs very often and this then will
completely dominate the histogram. By discarding this color when scaling the
histogram the other color occurrences will become visible. By default we use the
99 percentile, meaning the 1% of the bins with the highest values will be discarded.
:param subsampleStep:The step size that is used to subsample the array when calculating
the histogram. Can be a scalar, a tuple with two elements, or 'auto'.
:param int maxTickLength: Maximum tick length of the color axis. Default = 10
"""
pg.GraphicsWidget.__init__(self)
if COL_PROFILING:
# Profiler that measures the drawing of the inspectors.
self._profFileName = "col_legend.prof"
logger.warning(
"Profiling is on for {}. This may cost a bit of CPU time.")
self._profiler = cProfile.Profile()
self.histHeightPercentile = histHeightPercentile
self._histogramIsVisible = showHistogram
self.histogramWidth = 50
self._imageItem = None
# List of mouse buttons that reset the color range when clicked.
# You can safely modify this list.
self.resetRangeMouseButtons = [pg.QtCore.Qt.MiddleButton]
self._subsampleStep = subsampleStep
# Histogram
self.histViewBox = pg.ViewBox(enableMenu=False)
self.histViewBox.disableAutoRange(BOTH_AXES)
self.histViewBox.setMouseEnabled(x=False, y=True)
self.histViewBox.setFixedWidth(self.histogramWidth)
self.histPlotDataItem = pg.PlotDataItem()
self.histPlotDataItem.rotate(90)
self.histViewBox.addItem(self.histPlotDataItem)
self.fillHistogram()
# Color scale
self.colorScaleViewBox = pg.ViewBox(enableMenu=False, border=None)
self.colorScaleViewBox.disableAutoRange(pg.ViewBox.XYAxes)
self.colorScaleViewBox.setMouseEnabled(x=False, y=False)
self.colorScaleViewBox.setMinimumWidth(10)
self.colorScaleViewBox.setMaximumWidth(25)
self.colorScaleImageItem = pg.ImageItem(
) # image data will be set in setLut
self.colorScaleViewBox.addItem(self.colorScaleImageItem)
self.colorScaleViewBox.setZValue(10)
# Overlay viewbox that will have alway have the same geometry as the colorScaleViewBox
self.overlayViewBox = pg.ViewBox(enableMenu=False,
border=pg.mkPen(
pg.getConfigOption('foreground'),
width=1))
self.overlayViewBox.setZValue(100)
self.axisItem = pg.AxisItem(orientation='right',
linkView=self.overlayViewBox,
showValues=True,
maxTickLength=maxTickLength,
parent=self)
self.histViewBox.linkView(pg.ViewBox.YAxis, self.overlayViewBox)
# Overall layout
self.mainLayout = pg.QtWidgets.QGraphicsGridLayout()
self.setLayout(self.mainLayout)
self.mainLayout.setContentsMargins(1, 1, 1, 1)
self.mainLayout.setSpacing(0)
self.mainLayout.addItem(self.histViewBox, 0, 0)
self.mainLayout.addItem(self.colorScaleViewBox, 0, 1)
self.mainLayout.addItem(self.axisItem, 0, 2)
self.overlayViewBox.setParentItem(self.colorScaleViewBox.parentItem())
# Connect signals
self.colorScaleViewBox.geometryChanged.connect(self._updateOverlay)
# It might also trigger an update when the axis is resized (but can't reproduce it
# anymore). If needed we could test if the range has changed substantially before updating
# image levels.
self.overlayViewBox.sigYRangeChanged.connect(self._updateImageLevels)
self.setLabel(label)
self.showHistogram(showHistogram)
self.setLut(lut)
def _initalize_image_widgets(file_date, band, dtype):
"""Set up the various QT widgets used to display the plot"""
# Set up display widgets
try:
QApplication(sys.argv + ['-platform', 'offscreen']) # So we can make widgets :)
except RuntimeError as err:
if "singleton" not in str(err):
raise
pg.setConfigOptions(background='#EEE', foreground='k')
scale_font = QFont("Arial", 10)
disp_widget = QWidget()
disp_widget.setStyleSheet('background-color:rgba(0,255,0,255);padding:0px;margin:0px;')
v_layout = QVBoxLayout()
v_layout.setContentsMargins(0, 0, 0, 0)
v_layout.setSpacing(0)
view_box = pg.ViewBox(border={'width': 0},)
plot_widget = pg.PlotWidget(disp_widget,
viewBox=view_box)
scale_widget = GradientWidget()
scale_widget.setOrientation("Horizontal")
scale_widget.setFont(scale_font)
scale_widget.setStyleSheet("background-color:white;")
scale_widget.setFixedWidth(950)
date_label = QLabel()
if band is None:
band = "Cloud"
date_label.setText(f"{file_date.strftime('%Y-%m-%d %H:%M:%S')} UTC {dtype} {band}")
date_label.setStyleSheet('color:#eee; background-color:rgba(0, 0, 0, 0.4); padding:2px 7px;')
date_label_font = date_label.font()
date_label_font.setPointSize(9)
date_label.setFont(date_label_font)
date_label.adjustSize()
v_layout.addWidget(plot_widget)
disp_widget.setLayout(v_layout)
plot_item = plot_widget.getPlotItem()
plot_item.hideAxis('left')
plot_item.hideAxis('bottom')
plot_item.hideButtons()
img_width = 1000
img_height = 800
view_size = QSize(img_width, img_height)
view_widget = plot_item.getViewWidget()
view_widget.parent().setFixedSize(view_size)
view_widget.adjustSize()
return (plot_item, scale_widget, disp_widget, date_label)
def setup_figure(self):
"""
Runs once during App initialization, after setup()
This is the place to make all graphical interface initializations,
build plots, etc.
"""
# connect ui widgets to measurement/hardware settings or functions
self.settings.save_video.connect_to_widget(self.ui.save_video_checkBox)
self.settings.track_ant.connect_to_widget(self.ui.track_ant_checkBox)
self.ui.start_pushButton.clicked.connect(self.start)
self.ui.interrupt_pushButton.clicked.connect(self.interrupt)
self.ui.up_pushButton.clicked.connect(self.daqmotor.operations['up'])
self.ui.down_pushButton.clicked.connect(
self.daqmotor.operations['down'])
self.ui.left_pushButton.clicked.connect(
self.daqmotor.operations['left'])
self.ui.right_pushButton.clicked.connect(
self.daqmotor.operations['right'])
self.daqmotor.settings.manual.connect_to_widget(
self.ui.manual_checkBox)
self.daqmotor.settings.manual_steps.connect_to_widget(
self.ui.manual_steps_doubleSpinBox)
self.daqmotor.settings.x.connect_to_widget(self.ui.x_doubleSpinBox)
self.daqmotor.settings.y.connect_to_widget(self.ui.y_doubleSpinBox)
self.daqmotor.settings.move_to_x.connect_to_widget(
self.ui.move_to_x_doubleSpinBox)
self.daqmotor.settings.move_to_y.connect_to_widget(
self.ui.move_to_y_doubleSpinBox)
self.ui.move_to_pushButton.clicked.connect(
self.daqmotor.operations['move_to'])
self.ui.zero_pushButton.clicked.connect(
self.daqmotor.operations['zero'])
self.ui.home_pushButton.clicked.connect(
self.daqmotor.operations['home'])
# Set up pyqtgraph graph_layout in the UI
self.wide_cam_layout = pg.GraphicsLayoutWidget()
self.track_cam_layout = pg.GraphicsLayoutWidget()
self.tracker_layout = pg.GraphicsLayoutWidget()
self.ui.wide_cam_groupBox.layout().addWidget(self.wide_cam_layout)
self.ui.track_cam_groupBox.layout().addWidget(self.track_cam_layout)
self.ui.tracker_groupBox.layout().addWidget(self.tracker_layout)
#create camera image graphs
self.wide_cam_view = pg.ViewBox()
self.wide_cam_layout.addItem(self.wide_cam_view)
self.wide_cam_image = pg.ImageItem()
self.wide_cam_view.addItem(self.wide_cam_image)
self.track_cam_view = pg.ViewBox()
self.track_cam_layout.addItem(self.track_cam_view)
self.track_cam_image = pg.ImageItem()
self.track_cam_view.addItem(self.track_cam_image)
self.tracker_view = pg.ViewBox()
self.tracker_layout.addItem(self.tracker_view)
self.tracker_image = pg.ImageItem()
self.tracker_view.addItem(self.tracker_image)
# initiate tracker buffer
self.tracker_data = np.zeros((64, 64), dtype=np.uint8)
#counter used for reducing refresh rate
self.wide_disp_counter = 0
self.track_disp_counter = 0
def __init__(self, tvar_name, show_xaxis=False, mouse_function=None):
self.tvar_name = tvar_name
self.show_xaxis = show_xaxis
self.crosshair = pytplot.tplot_opt_glob['crosshair']
# Sets up the layout of the Tplot Object
pg.GraphicsLayout.__init__(self)
self.layout.setHorizontalSpacing(50)
self.layout.setContentsMargins(0, 0, 0, 0)
# Set up the x axis
self.xaxis = pg.AxisItem(orientation='bottom')
self.xaxis.setHeight(35)
self.xaxis.enableAutoSIPrefix(enable=False)
# Set up the y axis
self.yaxis = AxisItem("left")
self.yaxis.setWidth(100)
vb = NoPaddingPlot()
self.plotwindow = self.addPlot(row=0,
col=0,
axisItems={
'bottom': self.xaxis,
'left': self.yaxis
},
viewBox=vb)
# Set up the view box needed for the legends
self.legendvb = pg.ViewBox(enableMouse=False)
self.legendvb.setMaximumWidth(100)
self.legendvb.setXRange(0, 1, padding=0)
self.legendvb.setYRange(0, 1, padding=0)
self.addItem(self.legendvb, 0, 1)
self.curves = []
self.colors = self._setcolors()
self.colormap = self._setcolormap()
if pytplot.tplot_opt_glob['black_background']:
self.labelStyle = {
'font-size':
str(pytplot.data_quants[self.tvar_name].attrs['plot_options']
['extras']['char_size']) + 'pt',
'color':
'#FFF'
}
else:
self.labelStyle = {
'font-size':
str(pytplot.data_quants[self.tvar_name].attrs['plot_options']
['extras']['char_size']) + 'pt',
'color':
'#000'
}
if show_xaxis:
self.plotwindow.showAxis('bottom')
else:
self.plotwindow.hideAxis('bottom')
self._mouseMovedFunction = mouse_function
self.vLine = pg.InfiniteLine(angle=90,
movable=False,
pen=pg.mkPen('k'))
self.hLine = pg.InfiniteLine(angle=0, movable=False, pen=pg.mkPen('k'))
self.plotwindow.addItem(self.vLine, ignoreBounds=True)
self.plotwindow.addItem(self.hLine, ignoreBounds=True)
self.vLine.setVisible(False)
self.hLine.setVisible(False)
self.label = pg.LabelItem(justify='left')
self.addItem(self.label, row=1, col=0)
# Set legend options
self.hoverlegend = CustomLegendItem(offset=(0, 0))
# Allow the user to set x-axis(time) and y-axis data names in crosshairs
self.hoverlegend.setItem(
pytplot.data_quants[self.tvar_name].attrs['plot_options']
['xaxis_opt']['crosshair'] + ':', "0")
self.hoverlegend.setItem(
pytplot.data_quants[self.tvar_name].attrs['plot_options']
['yaxis_opt']['crosshair'] + ':', "0")
self.hoverlegend.setVisible(False)
self.hoverlegend.setParentItem(self.plotwindow.vb)
def setupUi(self):
serialport = QLabel("USB port", self)
self.serialportEdit = QLineEdit(self.a34972aport, self)
self.runstopButton = QPushButton("START", self)
self.clearButton = QPushButton("Clear", self)
schroll_lbl = QLabel("Schroll elapsed time [pts] ", self)
self.combo0 = QComboBox(self)
mylist0 = ["100", "200", "400", "600", "800", "1000", "1500", "2000"]
self.combo0.addItems(mylist0)
self.combo0.setCurrentIndex(mylist0.index(str(self.schroll_pts)))
##############################################
g0_1 = QGridLayout()
g0_1.addWidget(serialport, 0, 0)
g0_1.addWidget(self.serialportEdit, 0, 1)
g0_2 = QGridLayout()
g0_2.addWidget(schroll_lbl, 0, 0)
g0_2.addWidget(self.combo0, 0, 1)
g0_2.addWidget(self.runstopButton, 0, 2)
g0_2.addWidget(self.clearButton, 0, 3)
g0_3 = QVBoxLayout()
g0_3.addLayout(g0_1)
g0_3.addLayout(g0_2)
##############################################
# set graph and toolbar to a new vertical group vcan
self.pw1 = pg.PlotWidget()
self.pw1.setFixedWidth(600)
##############################################
# create table
self.tableWidget = self.createTable()
##############################################
# SET ALL VERTICAL COLUMNS TOGETHER
vbox = QVBoxLayout()
vbox.addLayout(g0_3)
vbox.addWidget(self.pw1)
hbox = QHBoxLayout()
hbox.addLayout(vbox)
hbox.addWidget(self.tableWidget)
self.threadpool = QThreadPool()
print(
"Multithreading in the Agilent 34972A dialog with maximum %d threads"
% self.threadpool.maxThreadCount())
self.isRunning = False
self.setLayout(hbox)
self.setWindowTitle("Test Agilent 34972A")
# PLOT 2 settings
# create plot and add it to the figure canvas
self.p1 = self.pw1.plotItem
self.curve1 = self.p1.plot(pen='w')
# create plot and add it to the figure
self.p0_1 = pg.ViewBox()
self.curve2 = pg.PlotCurveItem(pen='r')
self.p0_1.addItem(self.curve2)
# connect respective axes to the plot
#self.p1.showAxis('left')
self.p1.getAxis('left').setLabel("Voltage", units="V", color='yellow')
self.p1.showAxis('right')
self.p1.getAxis('right').setLabel("Arb unit, 1023=1.1V",
units="",
color='red')
self.p1.scene().addItem(self.p0_1)
self.p1.getAxis('right').linkToView(self.p0_1)
self.p0_1.setXLink(self.p1)
self.p1.getAxis('bottom').setLabel("Points", units="", color='yellow')
# Use automatic downsampling and clipping to reduce the drawing load
self.pw1.setDownsampling(mode='peak')
self.pw1.setClipToView(True)
# Initialize and set titles and axis names for both plots
self.clear_vars_graphs()
self.combo0.activated[str].connect(self.onActivated0)
# run or cancel the main script
self.runstopButton.clicked.connect(self.runstop)
self.clearButton.clicked.connect(self.set_clear)
self.clearButton.setEnabled(False)
def __init__(self, parent=None):
super(BinaryPlayer, self).__init__(parent)
pg.setConfigOptions(imageAxisOrder='row-major')
self.setGeometry(70, 70, 1070, 1070)
self.setWindowTitle('View registered binary')
self.cwidget = QtGui.QWidget(self)
self.setCentralWidget(self.cwidget)
self.l0 = QtGui.QGridLayout()
#layout = QtGui.QFormLayout()
self.cwidget.setLayout(self.l0)
#self.p0 = pg.ViewBox(lockAspect=False,name='plot1',border=[100,100,100],invertY=True)
self.win = pg.GraphicsLayoutWidget()
# --- cells image
self.win = pg.GraphicsLayoutWidget()
self.win.move(600, 0)
self.win.resize(1000, 500)
self.l0.addWidget(self.win, 1, 2, 13, 14)
layout = self.win.ci.layout
self.loaded = False
self.zloaded = False
# A plot area (ViewBox + axes) for displaying the image
self.vmain = pg.ViewBox(lockAspect=True, invertY=True, name="plot1")
self.win.addItem(self.vmain, row=0, col=0)
self.vmain.setMenuEnabled(False)
self.imain = pg.ImageItem()
self.vmain.addItem(self.imain)
self.cellscatter = pg.ScatterPlotItem()
self.vmain.addItem(self.cellscatter)
self.maskmain = pg.ImageItem()
# side box
self.vside = pg.ViewBox(lockAspect=True, invertY=True)
self.vside.setMenuEnabled(False)
self.iside = pg.ImageItem()
self.vside.addItem(self.iside)
self.cellscatter_side = pg.ScatterPlotItem()
self.vside.addItem(self.cellscatter_side)
self.maskside = pg.ImageItem()
# view red channel
self.redbox = QtGui.QCheckBox("view red channel")
self.redbox.setStyleSheet("color: white;")
self.redbox.setEnabled(False)
self.redbox.toggled.connect(self.add_red)
self.l0.addWidget(self.redbox, 0, 5, 1, 1)
# view masks
self.maskbox = QtGui.QCheckBox("view masks")
self.maskbox.setStyleSheet("color: white;")
self.maskbox.setEnabled(False)
self.maskbox.toggled.connect(self.add_masks)
self.l0.addWidget(self.maskbox, 0, 6, 1, 1)
# view raw binary
self.rawbox = QtGui.QCheckBox("view raw binary")
self.rawbox.setStyleSheet("color: white;")
self.rawbox.setEnabled(False)
self.rawbox.toggled.connect(self.add_raw)
self.l0.addWidget(self.rawbox, 0, 7, 1, 1)
# view zstack
self.zbox = QtGui.QCheckBox("view z-stack")
self.zbox.setStyleSheet("color: white;")
self.zbox.setEnabled(False)
self.zbox.toggled.connect(self.add_zstack)
self.l0.addWidget(self.zbox, 0, 8, 1, 1)
zlabel = QtGui.QLabel('Z-plane:')
zlabel.setStyleSheet("color: white;")
self.l0.addWidget(zlabel, 0, 9, 1, 1)
self.Zedit = QtGui.QLineEdit(self)
self.Zedit.setValidator(QtGui.QIntValidator(0, 0))
self.Zedit.setText('0')
self.Zedit.setFixedWidth(30)
self.Zedit.setAlignment(QtCore.Qt.AlignRight)
self.l0.addWidget(self.Zedit, 0, 10, 1, 1)
self.p1 = self.win.addPlot(name='plot_shift', row=1, col=0, colspan=2)
self.p1.setMouseEnabled(x=True, y=False)
self.p1.setMenuEnabled(False)
self.scatter1 = pg.ScatterPlotItem()
self.scatter1.setData([0, 0], [0, 0])
self.p1.addItem(self.scatter1)
self.p2 = self.win.addPlot(name='plot_F', row=2, col=0, colspan=2)
self.p2.setMouseEnabled(x=True, y=False)
self.p2.setMenuEnabled(False)
self.scatter2 = pg.ScatterPlotItem()
self.p2.setXLink('plot_shift')
self.p3 = self.win.addPlot(name='plot_Z', row=3, col=0, colspan=2)
self.p3.setMouseEnabled(x=True, y=False)
self.p3.setMenuEnabled(False)
self.scatter3 = pg.ScatterPlotItem()
self.p3.setXLink('plot_shift')
#self.p2.autoRange(padding=0.01)
self.win.ci.layout.setRowStretchFactor(0, 12)
self.movieLabel = QtGui.QLabel("No ops chosen")
self.movieLabel.setStyleSheet("color: white;")
self.movieLabel.setAlignment(QtCore.Qt.AlignCenter)
self.nframes = 0
self.cframe = 0
self.createButtons()
# create ROI chooser
self.l0.addWidget(QtGui.QLabel(''), 6, 0, 1, 2)
qlabel = QtGui.QLabel(self)
qlabel.setText("<font color='white'>Selected ROI:</font>")
self.l0.addWidget(qlabel, 7, 0, 1, 2)
self.ROIedit = QtGui.QLineEdit(self)
self.ROIedit.setValidator(QtGui.QIntValidator(0, 10000))
self.ROIedit.setText('0')
self.ROIedit.setFixedWidth(45)
self.ROIedit.setAlignment(QtCore.Qt.AlignRight)
self.ROIedit.returnPressed.connect(self.number_chosen)
self.l0.addWidget(self.ROIedit, 8, 0, 1, 1)
# create frame slider
self.frameLabel = QtGui.QLabel("Current frame:")
self.frameLabel.setStyleSheet("color: white;")
self.frameNumber = QtGui.QLabel("0")
self.frameNumber.setStyleSheet("color: white;")
self.frameSlider = QtGui.QSlider(QtCore.Qt.Horizontal)
#self.frameSlider.setTickPosition(QtGui.QSlider.TicksBelow)
self.frameSlider.setTickInterval(5)
self.frameSlider.setTracking(False)
self.frameDelta = 10
self.l0.addWidget(QtGui.QLabel(''), 12, 0, 1, 1)
self.l0.setRowStretch(12, 1)
self.l0.addWidget(self.frameLabel, 13, 0, 1, 2)
self.l0.addWidget(self.frameNumber, 14, 0, 1, 2)
self.l0.addWidget(self.frameSlider, 13, 2, 14, 13)
self.l0.addWidget(QtGui.QLabel(''), 14, 1, 1, 1)
ll = QtGui.QLabel(
'(when paused, left/right arrow keys can move slider)')
ll.setStyleSheet("color: white;")
self.l0.addWidget(ll, 16, 0, 1, 3)
#speedLabel = QtGui.QLabel("Speed:")
#self.speedSpinBox = QtGui.QSpinBox()
#self.speedSpinBox.setRange(1, 9999)
#self.speedSpinBox.setValue(100)
#self.speedSpinBox.setSuffix("%")
self.frameSlider.valueChanged.connect(self.go_to_frame)
self.l0.addWidget(self.movieLabel, 0, 0, 1, 5)
self.updateFrameSlider()
self.updateButtons()
self.updateTimer = QtCore.QTimer()
self.updateTimer.timeout.connect(self.next_frame)
self.cframe = 0
self.loaded = False
self.Floaded = False
self.raw_on = False
self.red_on = False
self.z_on = False
self.wraw = False
self.wred = False
self.wraw_wred = False
self.win.scene().sigMouseClicked.connect(self.plot_clicked)
# if not a combined recording, automatically open binary
if hasattr(parent, 'ops'):
if parent.ops['save_path'][-8:] != 'combined':
filename = os.path.abspath(
os.path.join(parent.basename, 'ops.npy'))
print(filename)
self.Fcell = parent.Fcell
self.stat = parent.stat
self.iscell = parent.iscell
self.Floaded = True
self.openFile(filename, True)
def __init__(self, experiment=None, camera=None):
"""
:param experiment: experiment to which this belongs
(:class:Experiment <stytra.Experiment> object)
"""
super().__init__()
self.experiment = experiment
if experiment is not None:
self.camera = experiment.camera
experiment.gui_timer.timeout.connect(self.update_image)
else:
self.camera = camera
self.gui_timer = QTimer()
self.gui_timer.setSingleShot(False)
self.control_params = CameraControlParameters()
# Create the layout for the camera view:
self.camera_display_widget = pg.GraphicsLayoutWidget()
# Display area for showing the camera image:
self.display_area = pg.ViewBox(lockAspect=1, invertY=False)
self.display_area.setRange(
QRectF(0, 0, 640, 640), update=True, disableAutoRange=True
)
# Image to which the frame will be set, initially black:
self.image_item = pg.ImageItem()
self.image_item.setImage(np.zeros((640, 480), dtype=np.uint8))
self.display_area.addItem(self.image_item)
self.camera_display_widget.addItem(self.display_area)
# Queue of frames coming from the camera
if hasattr(experiment, "frame_dispatcher"):
self.frame_queue = self.experiment.frame_dispatcher.gui_queue
else:
self.frame_queue = self.camera.frame_queue
# Queue of control parameters for the camera:
self.control_queue = self.camera.control_queue
self.camera_rotation = self.camera.rotation
self.camera_params_tree = ParameterTree(showHeader=False)
# Connect changes in the camera parameters:
for c in self.control_params.params.children():
c.sigValueChanged.connect(self.update_controls)
self.layout = QVBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.camera_display_widget)
self.layout_control = QHBoxLayout()
if self.control_queue is not None:
self.params_button = QPushButton("Camera params")
self.params_button.clicked.connect(self.show_params_gui)
self.layout_control.addWidget(self.params_button)
self.captureButton = QPushButton("Capture frame")
self.captureButton.clicked.connect(self.save_image)
self.layout_control.addWidget(self.captureButton)
self.layout.addLayout(self.layout_control)
self.current_image = None
self.setLayout(self.layout)
from pyqtgraph.Qt import QtGui, QtCore
import pyqtgraph as pg
pg.mkQApp()
# Axis
a2 = pg.AxisItem("left")
a3 = pg.AxisItem("left")
a4 = pg.AxisItem("left")
a5 = pg.AxisItem("left")
a6 = pg.AxisItem("left")
# ViewBoxes
v2 = pg.ViewBox()
v3 = pg.ViewBox()
v4 = pg.ViewBox()
v5 = pg.ViewBox()
v6 = pg.ViewBox()
# main view
pw = pg.GraphicsView()
pw.setWindowTitle('pyqtgraph example: multiple y-axis')
pw.show()
# layout
l = pg.GraphicsLayout()
pw.setCentralWidget(l)
# add axis to layout
## watch the col parameter here for the position
l.addItem(a2, row=2, col=5, rowspan=1, colspan=1)
import initExample ## Add path to library (just for examples; you do not need this)
from pyqtgraph.Qt import QtCore, QtGui
import numpy as np
import pyqtgraph as pg
app = QtGui.QApplication([])
## Create window with GraphicsView widget
w = pg.GraphicsView()
w.show()
w.resize(800, 800)
w.setWindowTitle('pyqtgraph example: Draw')
view = pg.ViewBox()
w.setCentralItem(view)
## lock the aspect ratio
view.setAspectLocked(True)
## Create image item
img = pg.ImageItem(np.zeros((200, 200)))
view.addItem(img)
## Set initial view bounds
view.setRange(QtCore.QRectF(0, 0, 200, 200))
## start drawing with 3x3 brush
kern = np.array([[0.0, 0.5, 0.0], [0.5, 1.0, 0.5], [0.0, 0.5, 0.0]])
img.setDrawKernel(kern, mask=kern, center=(1, 1), mode='add')
##import initExample ## Add path to library (just for examples; you do not need this)
import pyqtgraph as pg
from pyqtgraph.Qt import QtCore, QtGui
import numpy as np
pg.mkQApp()
pw = pg.PlotWidget()
pw.show()
pw.setWindowTitle('pyqtgraph example: MultiplePlotAxes')
p1 = pw.plotItem
p1.setLabels(left='axis 1')
## create a new ViewBox, link the right axis to its coordinate system
p2 = pg.ViewBox()
p1.showAxis('right')
p1.scene().addItem(p2)
p1.getAxis('right').linkToView(p2)
p2.setXLink(p1)
p1.getAxis('right').setLabel('axis2', color='#0000ff')
#### create third ViewBox.
#### this time we need to create a new axis as well.
##p3 = pg.ViewBox()
##ax3 = pg.AxisItem('right')
##p1.layout.addItem(ax3, 2, 3)
##p1.scene().addItem(p3)
##ax3.linkToView(p3)
##p3.setXLink(p1)
##ax3.setZValue(-10000)
return QtCore.QRectF(0, 0, 20, 20)
def mouseClickEvent(self, ev):
if ev.double():
print("double click")
else:
print("click")
ev.accept()
#def mouseDragEvent(self, ev):
#print "drag"
#ev.accept()
#self.setPos(self.pos() + ev.pos()-ev.lastPos())
vb = pg.ViewBox()
win.setCentralItem(vb)
obj = Obj()
vb.addItem(obj)
obj2 = Obj()
win.addItem(obj2)
def clicked():
print("button click")
btn = QtGui.QPushButton("BTN")
btn.clicked.connect(clicked)
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.subset_data = None
self._subset_mask = None
self._selection_mask = None
self._item = None
self.__selection_item = None
self.__replot_requested = False
box = gui.widgetBox(self.controlArea, "Axes")
box1 = gui.widgetBox(box, "Displayed", margin=0)
box1.setFlat(True)
self.active_view = view = QListView(
sizePolicy=QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Ignored),
selectionMode=QListView.ExtendedSelection,
dragEnabled=True,
defaultDropAction=Qt.MoveAction,
dragDropOverwriteMode=False,
dragDropMode=QListView.DragDrop,
showDropIndicator=True,
minimumHeight=50,
)
view.viewport().setAcceptDrops(True)
movedown = QAction(
"Move down", view,
shortcut=QKeySequence(Qt.AltModifier | Qt.Key_Down),
triggered=self.__deactivate_selection
)
view.addAction(movedown)
self.varmodel_selected = model = DnDVariableListModel(
parent=self)
model.rowsInserted.connect(self._invalidate_plot)
model.rowsRemoved.connect(self._invalidate_plot)
model.rowsMoved.connect(self._invalidate_plot)
view.setModel(model)
box1.layout().addWidget(view)
box1 = gui.widgetBox(box, "Other", margin=0)
box1.setFlat(True)
self.other_view = view = QListView(
sizePolicy=QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Ignored),
selectionMode=QListView.ExtendedSelection,
dragEnabled=True,
defaultDropAction=Qt.MoveAction,
dragDropOverwriteMode=False,
dragDropMode=QListView.DragDrop,
showDropIndicator=True,
minimumHeight=50
)
view.viewport().setAcceptDrops(True)
moveup = QtGui.QAction(
"Move up", view,
shortcut=QKeySequence(Qt.AltModifier | Qt.Key_Up),
triggered=self.__activate_selection
)
view.addAction(moveup)
self.varmodel_other = model = DnDVariableListModel(parent=self)
view.setModel(model)
box1.layout().addWidget(view)
box = gui.widgetBox(self.controlArea, "Jittering")
gui.comboBox(box, self, "jitter_value",
items=["None", "0.01%", "0.1%", "0.5%", "1%", "2%"],
callback=self._invalidate_plot)
box.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
box = gui.widgetBox(self.controlArea, "Points")
box.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum)
self.colorvar_model = itemmodels.VariableListModel(parent=self)
self.shapevar_model = itemmodels.VariableListModel(parent=self)
self.sizevar_model = itemmodels.VariableListModel(parent=self)
self.labelvar_model = itemmodels.VariableListModel(parent=self)
form = QtGui.QFormLayout(
formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow,
spacing=8
)
box.layout().addLayout(form)
cb = gui.comboBox(box, self, "color_index",
callback=self._on_color_change)
cb.setModel(self.colorvar_model)
form.addRow("Colors", cb)
alpha_slider = QSlider(
Qt.Horizontal, minimum=10, maximum=255, pageStep=25,
tickPosition=QSlider.TicksBelow, value=self.alpha_value)
alpha_slider.valueChanged.connect(self._set_alpha)
form.addRow("Opacity", alpha_slider)
cb = gui.comboBox(box, self, "shape_index",
callback=self._on_shape_change)
cb.setModel(self.shapevar_model)
form.addRow("Shape", cb)
cb = gui.comboBox(box, self, "size_index",
callback=self._on_size_change)
cb.setModel(self.sizevar_model)
form.addRow("Size", cb)
size_slider = QSlider(
Qt.Horizontal, minimum=3, maximum=30, value=self.point_size,
pageStep=3,
tickPosition=QSlider.TicksBelow)
size_slider.valueChanged.connect(self._set_size)
form.addRow("", size_slider)
toolbox = gui.widgetBox(self.controlArea, "Zoom/Select")
toollayout = QtGui.QHBoxLayout()
toolbox.layout().addLayout(toollayout)
gui.auto_commit(self.controlArea, self, "auto_commit", "Commit")
# Main area plot
self.view = pg.GraphicsView(background="w")
self.view.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.view.setFrameStyle(QtGui.QFrame.StyledPanel)
self.viewbox = pg.ViewBox(enableMouse=True, enableMenu=False)
self.viewbox.grabGesture(Qt.PinchGesture)
self.view.setCentralItem(self.viewbox)
self.mainArea.layout().addWidget(self.view)
self.selection = PlotSelectionTool(
self, selectionMode=PlotSelectionTool.Lasso)
self.selection.setViewBox(self.viewbox)
self.selection.selectionFinished.connect(self._selection_finish)
self.zoomtool = PlotZoomTool(self)
self.pantool = PlotPanTool(self)
self.pinchtool = PlotPinchZoomTool(self)
self.pinchtool.setViewBox(self.viewbox)
self.continuous_palette = colorpalette.ContinuousPaletteGenerator(
QtGui.QColor(220, 220, 220),
QtGui.QColor(0, 0, 0),
False
)
self.discrete_palette = colorpalette.ColorPaletteGenerator(13)
def icon(name):
path = "icons/Dlg_{}.png".format(name)
path = pkg_resources.resource_filename(widget.__name__, path)
return QtGui.QIcon(path)
actions = namespace(
zoomtofit=QAction(
"Zoom to fit", self, icon=icon("zoom_reset"),
shortcut=QKeySequence(Qt.ControlModifier | Qt.Key_0),
triggered=lambda:
self.viewbox.setRange(QRectF(-1.05, -1.05, 2.1, 2.1))),
zoomin=QAction(
"Zoom in", self,
shortcut=QKeySequence(QKeySequence.ZoomIn),
triggered=lambda: self.viewbox.scaleBy((1 / 1.25, 1 / 1.25))),
zoomout=QAction(
"Zoom out", self,
shortcut=QKeySequence(QKeySequence.ZoomOut),
triggered=lambda: self.viewbox.scaleBy((1.25, 1.25))),
select=QAction(
"Select", self, checkable=True, icon=icon("arrow"),
shortcut=QKeySequence(Qt.ControlModifier + Qt.Key_1)),
zoom=QAction(
"Zoom", self, checkable=True, icon=icon("zoom"),
shortcut=QKeySequence(Qt.ControlModifier + Qt.Key_2)),
pan=QAction(
"Pan", self, checkable=True, icon=icon("pan_hand"),
shortcut=QKeySequence(Qt.ControlModifier + Qt.Key_3)),
)
self.addActions([actions.zoomtofit, actions.zoomin, actions.zoomout])
group = QtGui.QActionGroup(self, exclusive=True)
group.addAction(actions.select)
group.addAction(actions.zoom)
group.addAction(actions.pan)
actions.select.setChecked(True)
currenttool = self.selection
def activated(action):
nonlocal currenttool
if action is actions.select:
tool, cursor = self.selection, Qt.ArrowCursor
elif action is actions.zoom:
tool, cursor = self.zoomtool, Qt.ArrowCursor
elif action is actions.pan:
tool, cursor = self.pantool, Qt.OpenHandCursor
else:
assert False
currenttool.setViewBox(None)
tool.setViewBox(self.viewbox)
self.viewbox.setCursor(QtGui.QCursor(cursor))
currenttool = tool
group.triggered[QAction].connect(activated)
def button(action):
b = QtGui.QToolButton()
b.setDefaultAction(action)
return b
toollayout.addWidget(button(actions.select))
toollayout.addWidget(button(actions.zoom))
toollayout.addWidget(button(actions.pan))
toollayout.addSpacing(4)
toollayout.addWidget(button(actions.zoomtofit))
toollayout.addStretch()
toolbox.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum)
