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)