prsctrl_gui.ui.widgets.plot.Plot#

class Plot(max_data_points=1000)[source]#

Bases: GraphicsLayoutWidget

pyqtgraph plot widget for showing voltage and LED vs time

To maintain performance, only a fixed number of data points is stored. Whenever this buffer size is reached, half of the data points are removed and some new data points are skipped to maintain a constant interval.

This means that accuracy is lost when zooming in!

Arguments:
parent	Optional parent widget
useOpenGL	If True, the GraphicsView will use OpenGL to do all of its rendering. This can improve performance on some systems, but may also introduce bugs (the combination of QGraphicsView and QOpenGLWidget is still an ‘experimental’ feature of Qt)
background	Set the background color of the GraphicsView. Accepts any single argument accepted by `mkColor`. By default, the background color is determined using the ‘backgroundColor’ configuration option (see `setConfigOptions`).

Methods

`acceptDrops`
`accessibleDescription`
`accessibleIdentifier`
`accessibleName`
`actionEvent`
`actions`
`activateWindow`
`addAction`
`addActions`
`addItem`
`addScrollBarWidget`
`adjustSize`
`alignment`
`autoFillBackground`
`backgroundBrush`
`backgroundRole`
`baseSize`
`blockSignals`
`cacheMode`
`centerOn`
`changeEvent`
`childAt`
`childEvent`
`children`
`childrenRect`
`childrenRegion`
`clearFocus`
`clearMask`
`clearMouse`
`clear_data`	Clear the lines and data
`close`
`closeEvent`
`colorCount`
`connectNotify`
`contentsMargins`
`contentsRect`
`contextMenuEvent`
`contextMenuPolicy`
`cornerWidget`
`create`
`createWindowContainer`
`cursor`
`customEvent`
`deleteLater`
`depth`
`destroy`
`devType`
`devicePixelRatio`
`devicePixelRatioF`
`devicePixelRatioFScale`
`disconnect`
`disconnectNotify`
`dragEnterEvent`
`dragLeaveEvent`
`dragMode`
`dragMoveEvent`
`drawBackground`
`drawForeground`
`drawFrame`
`dropEvent`
`dumpObjectInfo`
`dumpObjectTree`
`dynamicPropertyNames`
`effectiveWinId`
`enableMouse`
`ensurePolished`
`ensureVisible`
`enterEvent`
`event`
`eventFilter`
`find`
`findChild`
`findChildren`
`fitInView`
`focusInEvent`
`focusNextChild`
`focusNextPrevChild`
`focusOutEvent`
`focusPolicy`
`focusPreviousChild`
`focusProxy`
`focusWidget`
`font`
`fontInfo`
`fontMetrics`
`foregroundBrush`
`foregroundRole`
`frameGeometry`
`frameRect`
`frameShadow`
`frameShape`
`frameSize`
`frameStyle`
`frameWidth`
`geometry`
`grab`
`grabGesture`
`grabKeyboard`
`grabMouse`
`grabShortcut`
`graphicsEffect`
`graphicsProxyWidget`
`hasFocus`
`hasHeightForWidth`
`hasMouseTracking`
`hasTabletTracking`
`height`
`heightForWidth`
`heightMM`
`hide`
`hideEvent`
`horizontalScrollBar`
`horizontalScrollBarPolicy`
`inherits`
`initPainter`
`initStyleOption`
`inputMethodEvent`
`inputMethodHints`
`inputMethodQuery`
`insertAction`
`insertActions`
`installEventFilter`
`invalidateScene`
`isActiveWindow`
`isAncestorOf`
`isEnabled`
`isEnabledTo`
`isFullScreen`
`isHidden`
`isInteractive`
`isLeftToRight`
`isMaximized`
`isMinimized`
`isModal`
`isQuickItemType`
`isRightToLeft`
`isSignalConnected`
`isTransformed`
`isVisible`
`isVisibleTo`
`isWidgetType`
`isWindow`
`isWindowModified`
`isWindowType`
`itemAt`
`items`
`keyPressEvent`
`keyReleaseEvent`
`keyboardGrabber`
`killTimer`
`layout`
`layoutDirection`
`leaveEvent`
`lineWidth`
`locale`
`lockXRange`
`logicalDpiX`
`logicalDpiY`
`lower`
`mapFrom`
`mapFromGlobal`
`mapFromParent`
`mapFromScene`
`mapTo`
`mapToGlobal`
`mapToParent`
`mapToScene`
`mask`
`maximumHeight`
`maximumSize`
`maximumViewportSize`
`maximumWidth`
`metaObject`
`metric`
`midLineWidth`
`minimumHeight`
`minimumSize`
`minimumSizeHint`
`minimumWidth`
`mouseDoubleClickEvent`
`mouseGrabber`
`mouseMoveEvent`
`mousePressEvent`
`mouseReleaseEvent`
`move`
`moveEvent`
`moveToThread`
`nativeEvent`
`nativeParentWidget`
`nextInFocusChain`
`normalGeometry`
`objectName`
`optimizationFlags`
`overrideWindowFlags`
`overrideWindowState`
`paintEngine`
`paintEvent`
`paintingActive`
`palette`
`parent`
`parentWidget`
`physicalDpiX`
`physicalDpiY`
`pixelSize`	Return vector with the length and width of one view pixel in scene coordinates
`pos`
`previousInFocusChain`
`property`
`pyqtConfigure`	Each keyword argument is either the name of a Qt property or a Qt signal.
`raise_`
`receivers`
`rect`
`releaseKeyboard`
`releaseMouse`
`releaseShortcut`
`removeAction`
`removeEventFilter`
`removeItem`
`render`
`renderHints`
`repaint`
`resetCachedContent`
`resetTransform`
`resize`
`resizeAnchor`
`resizeEvent`
`restoreGeometry`
`rotate`
`rubberBandRect`
`rubberBandSelectionMode`
`saveGeometry`
`scale`
`scaleToImage`	Scales such that pixels in image are the same size as screen pixels.
`scene`
`sceneRect`
`screen`
`scroll`
`scrollBarWidgets`
`scrollContentsBy`
`sender`
`senderSignalIndex`
`setAcceptDrops`
`setAccessibleDescription`
`setAccessibleIdentifier`
`setAccessibleName`
`setAlignment`
`setAntialiasing`	Enable or disable default antialiasing.
`setAspectLocked`
`setAttribute`
`setAutoFillBackground`
`setBackground`	Set the background color of the GraphicsView.
`setBackgroundBrush`
`setBackgroundRole`
`setBaseSize`
`setCacheMode`
`setCentralItem`
`setCentralWidget`	Sets a QGraphicsWidget to automatically fill the entire view (the item will be automatically resize whenever the GraphicsView is resized).
`setContentsMargins`
`setContextMenuPolicy`
`setCornerWidget`
`setCursor`
`setDisabled`
`setDragMode`
`setEnabled`
`setFixedHeight`
`setFixedSize`
`setFixedWidth`
`setFocus`
`setFocusPolicy`
`setFocusProxy`
`setFont`
`setForegroundBrush`
`setForegroundRole`
`setFrameRect`
`setFrameShadow`
`setFrameShape`
`setFrameStyle`
`setGeometry`
`setGraphicsEffect`
`setHidden`
`setHorizontalScrollBar`
`setHorizontalScrollBarPolicy`
`setInputMethodHints`
`setInteractive`
`setLayout`
`setLayoutDirection`
`setLineWidth`
`setLocale`
`setMask`
`setMaximumHeight`
`setMaximumSize`
`setMaximumWidth`
`setMidLineWidth`
`setMinimumHeight`
`setMinimumSize`
`setMinimumWidth`
`setMouseTracking`
`setObjectName`
`setOptimizationFlag`
`setOptimizationFlags`
`setPalette`
`setParent`
`setProperty`
`setRange`
`setRenderHint`
`setRenderHints`
`setResizeAnchor`
`setRubberBandSelectionMode`
`setScene`
`setSceneRect`
`setScreen`
`setShortcutAutoRepeat`
`setShortcutEnabled`
`setSizeAdjustPolicy`
`setSizeIncrement`
`setSizePolicy`
`setStatusTip`
`setStyle`
`setStyleSheet`
`setTabOrder`
`setTabletTracking`
`setToolTip`
`setToolTipDuration`
`setTransform`
`setTransformationAnchor`
`setUpdatesEnabled`
`setVerticalScrollBar`
`setVerticalScrollBarPolicy`
`setViewport`
`setViewportMargins`
`setViewportUpdateMode`
`setVisible`
`setWhatsThis`
`setWindowFilePath`
`setWindowFlag`
`setWindowFlags`
`setWindowIcon`
`setWindowIconText`
`setWindowModality`
`setWindowModified`
`setWindowOpacity`
`setWindowRole`
`setWindowState`
`setWindowTitle`
`setXRange`
`setYRange`
`set_data`	Set the data to be plotted, without updating the internal arrays
`setupViewport`
`sharedPainter`
`shear`
`show`
`showEvent`
`showFullScreen`
`showMaximized`
`showMinimized`
`showNormal`
`signalsBlocked`
`size`
`sizeAdjustPolicy`
`sizeHint`
`sizeIncrement`
`sizePolicy`
`stackUnder`
`startTimer`
`statusTip`
`style`
`styleSheet`
`tabletEvent`
`testAttribute`
`thread`
`timerEvent`
`toolTip`
`toolTipDuration`
`tr`
`transform`
`transformationAnchor`
`translate`
`underMouse`
`ungrabGesture`
`unsetCursor`
`unsetLayoutDirection`
`unsetLocale`
`update`
`updateGeometry`
`updateMatrix`
`updateMicroFocus`
`updateScene`
`updateSceneRect`
`update_plot`	Add new data points to the plot Parameters ---------- time voltage led
`update_views`	Make sure the linked view boxes have the correct size (called after resizing of the plot)
`updatesEnabled`
`useOpenGL`
`verticalScrollBar`
`verticalScrollBarPolicy`
`viewRect`	Return the boundaries of the view in scene coordinates
`viewport`
`viewportEvent`
`viewportMargins`
`viewportSizeHint`
`viewportTransform`
`viewportUpdateMode`
`visibleRange`
`visibleRegion`
`whatsThis`
`wheelEvent`
`width`
`widthMM`
`winId`
`window`
`windowFilePath`
`windowFlags`
`windowHandle`
`windowIcon`
`windowIconText`
`windowModality`
`windowOpacity`
`windowRole`
`windowState`
`windowTitle`
`windowType`
`x`
`y`

Attributes

`customContextMenuRequested`	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`destroyed`	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`lastFileDir`
`objectNameChanged`	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`rubberBandChanged`	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`sigDeviceRangeChanged`	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`sigDeviceTransformChanged`	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`sigMouseReleased`	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`sigScaleChanged`	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`sigSceneMouseMoved`	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`staticMetaObject`
`windowIconChanged`	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`windowIconTextChanged`	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`windowTitleChanged`	pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL

class CacheModeFlag(*values)#: Bases: Flag

class DragMode(*values)#: Bases: Enum

class OptimizationFlag(*values)#: Bases: Flag

class PaintDeviceMetric(*values)#: Bases: Enum

class RenderFlag(*values)#: Bases: Flag

class Shadow(*values)#

Bases: IntEnum

__add__(value, /)#: Return self+value.

__mul__(value, /)#: Return self*value.

as_integer_ratio()#

Return a pair of integers, whose ratio is equal to the original int.

The ratio is in lowest terms and has a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

conjugate()#: Returns self, the complex conjugate of any int.

denominator#: the denominator of a rational number in lowest terms

classmethod from_bytes(bytes, byteorder='big', *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.
signed: Indicates whether two’s complement is used to represent the integer.

imag#: the imaginary part of a complex number

is_integer()#: Returns True. Exists for duck type compatibility with float.is_integer.

numerator#: the numerator of a rational number in lowest terms

real#: the real part of a complex number

to_bytes(length=1, byteorder='big', *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes. Default is length 1.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

class Shape(*values)#

Bases: IntEnum

__add__(value, /)#: Return self+value.

__mul__(value, /)#: Return self*value.

as_integer_ratio()#

Return a pair of integers, whose ratio is equal to the original int.

The ratio is in lowest terms and has a positive denominator.

>>> (10).as_integer_ratio()
(10, 1)
>>> (-10).as_integer_ratio()
(-10, 1)
>>> (0).as_integer_ratio()
(0, 1)

bit_count()#

Number of ones in the binary representation of the absolute value of self.

Also known as the population count.

>>> bin(13)
'0b1101'
>>> (13).bit_count()
3

bit_length()#

Number of bits necessary to represent self in binary.

>>> bin(37)
'0b100101'
>>> (37).bit_length()
6

conjugate()#: Returns self, the complex conjugate of any int.

denominator#: the denominator of a rational number in lowest terms

classmethod from_bytes(bytes, byteorder='big', *, signed=False)#

Return the integer represented by the given array of bytes.

bytes: Holds the array of bytes to convert. The argument must either support the buffer protocol or be an iterable object producing bytes. Bytes and bytearray are examples of built-in objects that support the buffer protocol.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.
signed: Indicates whether two’s complement is used to represent the integer.

imag#: the imaginary part of a complex number

is_integer()#: Returns True. Exists for duck type compatibility with float.is_integer.

numerator#: the numerator of a rational number in lowest terms

real#: the real part of a complex number

to_bytes(length=1, byteorder='big', *, signed=False)#

Return an array of bytes representing an integer.

length: Length of bytes object to use. An OverflowError is raised if the integer is not representable with the given number of bytes. Default is length 1.
byteorder: The byte order used to represent the integer. If byteorder is ‘big’, the most significant byte is at the beginning of the byte array. If byteorder is ‘little’, the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value. Default is to use ‘big’.
signed: Determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised.

class SizeAdjustPolicy(*values)#: Bases: Enum

class StyleMask(*values)#: Bases: Enum

class ViewportAnchor(*values)#: Bases: Enum

class ViewportUpdateMode(*values)#: Bases: Enum

classmethod acceptDrops(self) → bool#

classmethod accessibleDescription(self) → str#

classmethod accessibleIdentifier(self) → str#

classmethod accessibleName(self) → str#

classmethod actionEvent(self, a0: QActionEvent | None)#

classmethod actions(self) → list[QAction]#

classmethod activateWindow(self)#

classmethod addAction(self, icon: QIcon, text: str | None) → QAction | None#
classmethod addAction(self, icon: QIcon, text: str | None, slot: PYQT_SLOT, type: Qt.ConnectionType = Qt.AutoConnection) → QAction | None
classmethod addAction(self, icon: QIcon, text: str | None, shortcut: QKeySequence | QKeySequence.StandardKey | str | None | int) → QAction | None
classmethod addAction(self, icon: QIcon, text: str | None, shortcut: QKeySequence | QKeySequence.StandardKey | str | None | int, slot: PYQT_SLOT, type: Qt.ConnectionType = Qt.AutoConnection) → QAction | None
classmethod addAction(self, text: str | None) → QAction | None
classmethod addAction(self, text: str | None, shortcut: QKeySequence | QKeySequence.StandardKey | str | None | int) → QAction | None
classmethod addAction(self, text: str | None, slot: PYQT_SLOT, type: Qt.ConnectionType = Qt.AutoConnection) → QAction | None
classmethod addAction(self, text: str | None, shortcut: QKeySequence | QKeySequence.StandardKey | str | None | int, slot: PYQT_SLOT, type: Qt.ConnectionType = Qt.AutoConnection) → QAction | None
classmethod addAction(self, action: QAction | None)

classmethod addActions(self, actions: Iterable[QAction])#

classmethod addScrollBarWidget(self, widget: QWidget | None, alignment: Qt.AlignmentFlag)#

classmethod adjustSize(self)#

classmethod alignment(self) → Qt.AlignmentFlag#

classmethod autoFillBackground(self) → bool#

classmethod backgroundBrush(self) → QBrush#

classmethod backgroundRole(self) → QPalette.ColorRole#

classmethod baseSize(self) → QSize#

classmethod blockSignals(self, b: bool) → bool#

classmethod cacheMode(self) → QGraphicsView.CacheModeFlag#

classmethod centerOn(self, pos: QPointF)#
classmethod centerOn(self, item: QGraphicsItem | None)
classmethod centerOn(self, ax: float, ay: float)

classmethod changeEvent(self, a0: QEvent | None)#

classmethod childAt(self, p: QPoint) → QWidget | None#
classmethod childAt(self, p: QPointF) → QWidget | None
classmethod childAt(self, ax: int, ay: int) → QWidget | None

classmethod childEvent(self, a0: QChildEvent | None)#

classmethod children(self) → list[QObject]#

classmethod childrenRect(self) → QRect#

classmethod childrenRegion(self) → QRegion#

classmethod clearFocus(self)#

classmethod clearMask(self)#

clear_data()[source]#: Clear the lines and data

close(self) → bool#

classmethod closeEvent(self, a0: QCloseEvent | None)#

classmethod colorCount(self) → int#

classmethod connectNotify(self, signal: QMetaMethod)#

classmethod contentsMargins(self) → QMargins#

classmethod contentsRect(self) → QRect#

classmethod contextMenuEvent(self, event: QContextMenuEvent | None)#

classmethod contextMenuPolicy(self) → Qt.ContextMenuPolicy#

classmethod cornerWidget(self) → QWidget | None#

classmethod create(self, window: PyQt6.sip.voidptr = None, initializeWindow: bool = True, destroyOldWindow: bool = True)#

classmethod createWindowContainer(window: QWindow | None, parent: QWidget | None = None, flags: Qt.WindowType = Qt.WindowFlags()) → QWidget#

classmethod cursor(self) → QCursor#

classmethod customEvent(self, a0: QEvent | None)#

classmethod deleteLater(self)#

classmethod depth(self) → int#

classmethod destroy(self, destroyWindow: bool = True, destroySubWindows: bool = True)#

classmethod devType(self) → int#

classmethod devicePixelRatio(self) → float#

classmethod devicePixelRatioF(self) → float#

classmethod devicePixelRatioFScale() → float#

classmethod disconnect(a0: QMetaObject.Connection) → bool#
classmethod disconnect(self)

classmethod disconnectNotify(self, signal: QMetaMethod)#

dragEnterEvent(self, event: QDragEnterEvent | None)#

classmethod dragLeaveEvent(self, event: QDragLeaveEvent | None)#

classmethod dragMode(self) → QGraphicsView.DragMode#

classmethod dragMoveEvent(self, event: QDragMoveEvent | None)#

classmethod drawBackground(self, painter: QPainter | None, rect: QRectF)#

classmethod drawForeground(self, painter: QPainter | None, rect: QRectF)#

classmethod drawFrame(self, a0: QPainter | None)#

classmethod dropEvent(self, event: QDropEvent | None)#

classmethod dumpObjectInfo(self)#

classmethod dumpObjectTree(self)#

classmethod dynamicPropertyNames(self) → list[QByteArray]#

classmethod effectiveWinId(self) → PyQt6.sip.voidptr#

classmethod ensurePolished(self)#

classmethod ensureVisible(self, rect: QRectF, xMargin: int = 50, yMargin: int = 50)#
classmethod ensureVisible(self, item: QGraphicsItem | None, xMargin: int = 50, yMargin: int = 50)
classmethod ensureVisible(self, x: float, y: float, w: float, h: float, xMargin: int = 50, yMargin: int = 50)

classmethod enterEvent(self, event: QEnterEvent | None)#

classmethod event(self, event: QEvent | None) → bool#

classmethod eventFilter(self, a0: QObject | None, a1: QEvent | None) → bool#

classmethod find(a0: PyQt6.sip.voidptr) → QWidget | None#

classmethod findChild(self, type: type[QObjectT], name: str | None = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) → QObjectT#
classmethod findChild(self, types: tuple[type[QObjectT], ...], name: str | None = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) → QObjectT

classmethod findChildren(self, type: type[QObjectT], name: str | None = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) → list[QObjectT]#
classmethod findChildren(self, types: tuple[type[QObjectT], ...], name: str | None = '', options: Qt.FindChildOption = Qt.FindChildrenRecursively) → list[QObjectT]
classmethod findChildren(self, type: type[QObjectT], re: QRegularExpression, options: Qt.FindChildOption = Qt.FindChildrenRecursively) → list[QObjectT]
classmethod findChildren(self, types: tuple[type[QObjectT], ...], re: QRegularExpression, options: Qt.FindChildOption = Qt.FindChildrenRecursively) → list[QObjectT]

classmethod fitInView(self, rect: QRectF, mode: Qt.AspectRatioMode = Qt.IgnoreAspectRatio)#
classmethod fitInView(self, item: QGraphicsItem | None, mode: Qt.AspectRatioMode = Qt.IgnoreAspectRatio)
classmethod fitInView(self, x: float, y: float, w: float, h: float, mode: Qt.AspectRatioMode = Qt.IgnoreAspectRatio)

classmethod focusInEvent(self, event: QFocusEvent | None)#

classmethod focusNextChild(self) → bool#

classmethod focusNextPrevChild(self, next: bool) → bool#

classmethod focusOutEvent(self, event: QFocusEvent | None)#

classmethod focusPolicy(self) → Qt.FocusPolicy#

classmethod focusPreviousChild(self) → bool#

classmethod focusProxy(self) → QWidget | None#

classmethod focusWidget(self) → QWidget | None#

classmethod font(self) → QFont#

classmethod fontInfo(self) → QFontInfo#

classmethod fontMetrics(self) → QFontMetrics#

classmethod foregroundBrush(self) → QBrush#

classmethod foregroundRole(self) → QPalette.ColorRole#

classmethod frameGeometry(self) → QRect#

classmethod frameRect(self) → QRect#

classmethod frameShadow(self) → QFrame.Shadow#

classmethod frameShape(self) → QFrame.Shape#

classmethod frameSize(self) → QSize#

classmethod frameStyle(self) → int#

classmethod frameWidth(self) → int#

classmethod geometry(self) → QRect#

classmethod grab(self, rectangle: QRect = QRect(QPoint(0, 0), QSize(-1, -1))) → QPixmap#

classmethod grabGesture(self, type: Qt.GestureType, flags: Qt.GestureFlag = Qt.GestureFlags())#

classmethod grabKeyboard(self)#

classmethod grabMouse(self)#
classmethod grabMouse(self, a0: QCursor | Qt.CursorShape)

classmethod grabShortcut(self, key: QKeySequence | QKeySequence.StandardKey | str | None | int, context: Qt.ShortcutContext = Qt.WindowShortcut) → int#

classmethod graphicsEffect(self) → QGraphicsEffect | None#

classmethod graphicsProxyWidget(self) → QGraphicsProxyWidget | None#

classmethod hasFocus(self) → bool#

classmethod hasHeightForWidth(self) → bool#

classmethod hasMouseTracking(self) → bool#

classmethod hasTabletTracking(self) → bool#

classmethod height(self) → int#

classmethod heightForWidth(self, a0: int) → int#

classmethod heightMM(self) → int#

classmethod hide(self)#

classmethod hideEvent(self, a0: QHideEvent | None)#

classmethod horizontalScrollBar(self) → QScrollBar | None#

classmethod horizontalScrollBarPolicy(self) → Qt.ScrollBarPolicy#

classmethod inherits(self, classname: str | None) → bool#

classmethod initPainter(self, painter: QPainter | None)#

classmethod initStyleOption(self, option: QStyleOptionFrame | None)#

classmethod inputMethodEvent(self, event: QInputMethodEvent | None)#

classmethod inputMethodHints(self) → Qt.InputMethodHint#

classmethod inputMethodQuery(self, query: Qt.InputMethodQuery) → Any#

classmethod insertAction(self, before: QAction | None, action: QAction | None)#

classmethod insertActions(self, before: QAction | None, actions: Iterable[QAction])#

classmethod installEventFilter(self, a0: QObject | None)#

classmethod invalidateScene(self, rect: QRectF = QRectF(), layers: QGraphicsScene.SceneLayer = QGraphicsScene.AllLayers)#

classmethod isActiveWindow(self) → bool#

classmethod isAncestorOf(self, child: QWidget | None) → bool#

classmethod isEnabled(self) → bool#

classmethod isEnabledTo(self, a0: QWidget | None) → bool#

classmethod isFullScreen(self) → bool#

classmethod isHidden(self) → bool#

classmethod isInteractive(self) → bool#

classmethod isLeftToRight(self) → bool#

classmethod isMaximized(self) → bool#

classmethod isMinimized(self) → bool#

classmethod isModal(self) → bool#

classmethod isQuickItemType(self) → bool#

classmethod isRightToLeft(self) → bool#

classmethod isSignalConnected(self, signal: QMetaMethod) → bool#

classmethod isTransformed(self) → bool#

classmethod isVisible(self) → bool#

classmethod isVisibleTo(self, a0: QWidget | None) → bool#

classmethod isWidgetType(self) → bool#

classmethod isWindow(self) → bool#

classmethod isWindowModified(self) → bool#

classmethod isWindowType(self) → bool#

classmethod itemAt(self, pos: QPoint) → QGraphicsItem | None#
classmethod itemAt(self, ax: int, ay: int) → QGraphicsItem | None

classmethod items(self) → list[QGraphicsItem]#
classmethod items(self, pos: QPoint) → list[QGraphicsItem]
classmethod items(self, x: int, y: int) → list[QGraphicsItem]
classmethod items(self, x: int, y: int, w: int, h: int, mode: Qt.ItemSelectionMode = Qt.IntersectsItemShape) → list[QGraphicsItem]
classmethod items(self, rect: QRect, mode: Qt.ItemSelectionMode = Qt.IntersectsItemShape) → list[QGraphicsItem]
classmethod items(self, polygon: QPolygon, mode: Qt.ItemSelectionMode = Qt.IntersectsItemShape) → list[QGraphicsItem]
classmethod items(self, path: QPainterPath, mode: Qt.ItemSelectionMode = Qt.IntersectsItemShape) → list[QGraphicsItem]

keyPressEvent(self, event: QKeyEvent | None)#

classmethod keyReleaseEvent(self, event: QKeyEvent | None)#

classmethod keyboardGrabber() → QWidget | None#

classmethod killTimer(self, id: int)#

classmethod layout(self) → QLayout | None#

classmethod layoutDirection(self) → Qt.LayoutDirection#

leaveEvent(self, a0: QEvent | None)#

classmethod lineWidth(self) → int#

classmethod locale(self) → QLocale#

classmethod logicalDpiX(self) → int#

classmethod logicalDpiY(self) → int#

classmethod lower(self)#

classmethod mapFrom(self, a0: QWidget | None, a1: QPoint) → QPoint#
classmethod mapFrom(self, a0: QWidget | None, a1: QPointF) → QPointF

classmethod mapFromGlobal(self, a0: QPoint) → QPoint#
classmethod mapFromGlobal(self, a0: QPointF) → QPointF

classmethod mapFromParent(self, a0: QPoint) → QPoint#
classmethod mapFromParent(self, a0: QPointF) → QPointF

classmethod mapFromScene(self, point: QPointF) → QPoint#
classmethod mapFromScene(self, rect: QRectF) → QPolygon
classmethod mapFromScene(self, polygon: QPolygonF) → QPolygon
classmethod mapFromScene(self, path: QPainterPath) → QPainterPath
classmethod mapFromScene(self, ax: float, ay: float) → QPoint
classmethod mapFromScene(self, ax: float, ay: float, w: float, h: float) → QPolygon

classmethod mapTo(self, a0: QWidget | None, a1: QPoint) → QPoint#
classmethod mapTo(self, a0: QWidget | None, a1: QPointF) → QPointF

classmethod mapToGlobal(self, a0: QPoint) → QPoint#
classmethod mapToGlobal(self, a0: QPointF) → QPointF

classmethod mapToParent(self, a0: QPoint) → QPoint#
classmethod mapToParent(self, a0: QPointF) → QPointF

classmethod mapToScene(self, point: QPoint) → QPointF#
classmethod mapToScene(self, rect: QRect) → QPolygonF
classmethod mapToScene(self, polygon: QPolygon) → QPolygonF
classmethod mapToScene(self, path: QPainterPath) → QPainterPath
classmethod mapToScene(self, ax: int, ay: int) → QPointF
classmethod mapToScene(self, ax: int, ay: int, w: int, h: int) → QPolygonF

classmethod mask(self) → QRegion#

classmethod maximumHeight(self) → int#

classmethod maximumSize(self) → QSize#

classmethod maximumViewportSize(self) → QSize#

classmethod maximumWidth(self) → int#

classmethod metaObject(self) → QMetaObject | None#

classmethod metric(self, a0: QPaintDevice.PaintDeviceMetric) → int#

classmethod midLineWidth(self) → int#

classmethod minimumHeight(self) → int#

classmethod minimumSize(self) → QSize#

classmethod minimumSizeHint(self) → QSize#

classmethod minimumWidth(self) → int#

classmethod mouseDoubleClickEvent(self, event: QMouseEvent | None)#

classmethod mouseGrabber() → QWidget | None#

mouseMoveEvent(self, event: QMouseEvent | None)#

mousePressEvent(self, event: QMouseEvent | None)#

mouseReleaseEvent(self, event: QMouseEvent | None)#

classmethod move(self, a0: QPoint)#
classmethod move(self, ax: int, ay: int)

classmethod moveEvent(self, a0: QMoveEvent | None)#

classmethod moveToThread(self, thread: QThread | None)#

classmethod nativeEvent(self, eventType: QByteArray | bytes | bytearray | memoryview, message: PyQt6.sip.voidptr | None)#

classmethod nativeParentWidget(self) → QWidget | None#

classmethod nextInFocusChain(self) → QWidget | None#

classmethod normalGeometry(self) → QRect#

classmethod objectName(self) → str#

classmethod optimizationFlags(self) → QGraphicsView.OptimizationFlag#

classmethod overrideWindowFlags(self, type: Qt.WindowType)#

classmethod overrideWindowState(self, state: Qt.WindowState)#

classmethod paintEngine(self) → QPaintEngine | None#

paintEvent(self, event: QPaintEvent | None)#

classmethod paintingActive(self) → bool#

classmethod palette(self) → QPalette#

classmethod parent(self) → QObject | None#

classmethod parentWidget(self) → QWidget | None#

classmethod physicalDpiX(self) → int#

classmethod physicalDpiY(self) → int#

pixelSize()#: Return vector with the length and width of one view pixel in scene coordinates

classmethod pos(self) → QPoint#

classmethod previousInFocusChain(self) → QWidget | None#

classmethod property(self, name: str | None) → Any#

classmethod pyqtConfigure(...)#: Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

classmethod raise_(self)#

classmethod receivers(self, signal: PYQT_SIGNAL) → int#

classmethod rect(self) → QRect#

classmethod releaseKeyboard(self)#

classmethod releaseMouse(self)#

classmethod releaseShortcut(self, id: int)#

classmethod removeAction(self, action: QAction | None)#

classmethod removeEventFilter(self, a0: QObject | None)#

render(self, painter: QPainter | None, target: QRectF = QRectF(), source: QRect = QRect(), mode: Qt.AspectRatioMode = Qt.KeepAspectRatio)#

classmethod renderHints(self) → QPainter.RenderHint#

classmethod repaint(self)#
classmethod repaint(self, x: int, y: int, w: int, h: int)
classmethod repaint(self, a0: QRect)
classmethod repaint(self, a0: QRegion)

classmethod resetCachedContent(self)#

classmethod resetTransform(self)#

classmethod resize(self, a0: QSize)#
classmethod resize(self, w: int, h: int)

classmethod resizeAnchor(self) → QGraphicsView.ViewportAnchor#

resizeEvent(self, event: QResizeEvent | None)#

classmethod restoreGeometry(self, geometry: QByteArray | bytes | bytearray | memoryview) → bool#

classmethod rotate(self, angle: float)#

classmethod rubberBandRect(self) → QRect#

classmethod rubberBandSelectionMode(self) → Qt.ItemSelectionMode#

classmethod saveGeometry(self) → QByteArray#

scale(self, sx: float, sy: float)#

scaleToImage(image)#: Scales such that pixels in image are the same size as screen pixels. This may result in a significant performance increase.

classmethod scene(self) → QGraphicsScene | None#

classmethod sceneRect(self) → QRectF#

classmethod screen(self) → QScreen | None#

classmethod scroll(self, dx: int, dy: int)#
classmethod scroll(self, dx: int, dy: int, a2: QRect)

classmethod scrollBarWidgets(self, alignment: Qt.AlignmentFlag) → list[QWidget]#

classmethod scrollContentsBy(self, dx: int, dy: int)#

classmethod sender(self) → QObject | None#

classmethod senderSignalIndex(self) → int#

classmethod setAcceptDrops(self, on: bool)#

classmethod setAccessibleDescription(self, description: str | None)#

classmethod setAccessibleIdentifier(self, identifier: str | None)#

classmethod setAccessibleName(self, name: str | None)#

classmethod setAlignment(self, alignment: Qt.AlignmentFlag)#

setAntialiasing(aa)#: Enable or disable default antialiasing. Note that this will only affect items that do not specify their own antialiasing options.

classmethod setAttribute(self, attribute: Qt.WidgetAttribute, on: bool = True)#

classmethod setAutoFillBackground(self, enabled: bool)#

setBackground(background)#: Set the background color of the GraphicsView. To use the defaults specified py pyqtgraph.setConfigOption, use background=’default’. To make the background transparent, use background=None.

classmethod setBackgroundBrush(self, brush: QBrush | QColor | Qt.GlobalColor | int | QGradient)#

classmethod setBackgroundRole(self, a0: QPalette.ColorRole)#

classmethod setBaseSize(self, basew: int, baseh: int)#
classmethod setBaseSize(self, s: QSize)

classmethod setCacheMode(self, mode: QGraphicsView.CacheModeFlag)#

setCentralWidget(item)#: Sets a QGraphicsWidget to automatically fill the entire view (the item will be automatically resize whenever the GraphicsView is resized).

classmethod setContentsMargins(self, left: int, top: int, right: int, bottom: int)#
classmethod setContentsMargins(self, margins: QMargins)

classmethod setContextMenuPolicy(self, policy: Qt.ContextMenuPolicy)#

classmethod setCornerWidget(self, widget: QWidget | None)#

classmethod setCursor(self, a0: QCursor | Qt.CursorShape)#

classmethod setDisabled(self, a0: bool)#

classmethod setDragMode(self, mode: QGraphicsView.DragMode)#

classmethod setEnabled(self, a0: bool)#

classmethod setFixedHeight(self, h: int)#

classmethod setFixedSize(self, a0: QSize)#
classmethod setFixedSize(self, w: int, h: int)

classmethod setFixedWidth(self, w: int)#

classmethod setFocus(self)#
classmethod setFocus(self, reason: Qt.FocusReason)

classmethod setFocusPolicy(self, policy: Qt.FocusPolicy)#

classmethod setFocusProxy(self, a0: QWidget | None)#

classmethod setFont(self, a0: QFont)#

classmethod setForegroundBrush(self, brush: QBrush | QColor | Qt.GlobalColor | int | QGradient)#

classmethod setForegroundRole(self, a0: QPalette.ColorRole)#

classmethod setFrameRect(self, a0: QRect)#

classmethod setFrameShadow(self, a0: QFrame.Shadow)#

classmethod setFrameShape(self, a0: QFrame.Shape)#

classmethod setFrameStyle(self, a0: int)#

classmethod setGeometry(self, a0: QRect)#
classmethod setGeometry(self, ax: int, ay: int, aw: int, ah: int)

classmethod setGraphicsEffect(self, effect: QGraphicsEffect | None)#

classmethod setHidden(self, hidden: bool)#

classmethod setHorizontalScrollBar(self, scrollbar: QScrollBar | None)#

classmethod setHorizontalScrollBarPolicy(self, a0: Qt.ScrollBarPolicy)#

classmethod setInputMethodHints(self, hints: Qt.InputMethodHint)#

classmethod setInteractive(self, allowed: bool)#

classmethod setLayout(self, a0: QLayout | None)#

classmethod setLayoutDirection(self, direction: Qt.LayoutDirection)#

classmethod setLineWidth(self, a0: int)#

classmethod setLocale(self, locale: QLocale)#

classmethod setMask(self, a0: QBitmap)#
classmethod setMask(self, a0: QRegion)

classmethod setMaximumHeight(self, maxh: int)#

classmethod setMaximumSize(self, maxw: int, maxh: int)#
classmethod setMaximumSize(self, s: QSize)

classmethod setMaximumWidth(self, maxw: int)#

classmethod setMidLineWidth(self, a0: int)#

classmethod setMinimumHeight(self, minh: int)#

classmethod setMinimumSize(self, minw: int, minh: int)#
classmethod setMinimumSize(self, s: QSize)

classmethod setMinimumWidth(self, minw: int)#

classmethod setMouseTracking(self, enable: bool)#

classmethod setObjectName(self, name: QByteArray | bytes | bytearray | memoryview | str | None)#

classmethod setOptimizationFlag(self, flag: QGraphicsView.OptimizationFlag, enabled: bool = True)#

classmethod setOptimizationFlags(self, flags: QGraphicsView.OptimizationFlag)#

classmethod setPalette(self, a0: QPalette)#

classmethod setParent(self, parent: QWidget | None)#
classmethod setParent(self, parent: QWidget | None, f: Qt.WindowType)

classmethod setProperty(self, name: str | None, value: Any) → bool#

classmethod setRenderHint(self, hint: QPainter.RenderHint, on: bool = True)#

classmethod setRenderHints(self, hints: QPainter.RenderHint)#

classmethod setResizeAnchor(self, anchor: QGraphicsView.ViewportAnchor)#

classmethod setRubberBandSelectionMode(self, mode: Qt.ItemSelectionMode)#

classmethod setScene(self, scene: QGraphicsScene | None)#

classmethod setSceneRect(self, rect: QRectF)#
classmethod setSceneRect(self, ax: float, ay: float, aw: float, ah: float)

classmethod setScreen(self, a0: QScreen | None)#

classmethod setShortcutAutoRepeat(self, id: int, enabled: bool = True)#

classmethod setShortcutEnabled(self, id: int, enabled: bool = True)#

classmethod setSizeAdjustPolicy(self, policy: QAbstractScrollArea.SizeAdjustPolicy)#

classmethod setSizeIncrement(self, w: int, h: int)#
classmethod setSizeIncrement(self, s: QSize)

classmethod setSizePolicy(self, a0: QSizePolicy)#
classmethod setSizePolicy(self, hor: QSizePolicy.Policy, ver: QSizePolicy.Policy)

classmethod setStatusTip(self, a0: str | None)#

classmethod setStyle(self, a0: QStyle | None)#

classmethod setStyleSheet(self, styleSheet: str | None)#

classmethod setTabOrder(a0: QWidget | None, a1: QWidget | None)#

classmethod setTabletTracking(self, enable: bool)#

classmethod setToolTip(self, a0: str | None)#

classmethod setToolTipDuration(self, msec: int)#

classmethod setTransform(self, matrix: QTransform, combine: bool = False)#

classmethod setTransformationAnchor(self, anchor: QGraphicsView.ViewportAnchor)#

classmethod setUpdatesEnabled(self, enable: bool)#

classmethod setVerticalScrollBar(self, scrollbar: QScrollBar | None)#

classmethod setVerticalScrollBarPolicy(self, a0: Qt.ScrollBarPolicy)#

classmethod setViewport(self, widget: QWidget | None)#

classmethod setViewportMargins(self, left: int, top: int, right: int, bottom: int)#
classmethod setViewportMargins(self, margins: QMargins)

classmethod setViewportUpdateMode(self, mode: QGraphicsView.ViewportUpdateMode)#

classmethod setVisible(self, visible: bool)#

classmethod setWhatsThis(self, a0: str | None)#

classmethod setWindowFilePath(self, filePath: str | None)#

classmethod setWindowFlag(self, a0: Qt.WindowType, on: bool = True)#

classmethod setWindowFlags(self, type: Qt.WindowType)#

classmethod setWindowIcon(self, icon: QIcon)#

classmethod setWindowIconText(self, a0: str | None)#

classmethod setWindowModality(self, windowModality: Qt.WindowModality)#

classmethod setWindowModified(self, a0: bool)#

classmethod setWindowOpacity(self, level: float)#

classmethod setWindowRole(self, a0: str | None)#

classmethod setWindowState(self, state: Qt.WindowState)#

classmethod setWindowTitle(self, a0: str | None)#

set_data(data_t, data_v, data_l)[source]#: Set the data to be plotted, without updating the internal arrays

classmethod setupViewport(self, widget: QWidget | None)#

classmethod sharedPainter(self) → QPainter | None#

classmethod shear(self, sh: float, sv: float)#

classmethod show(self)#

classmethod showEvent(self, event: QShowEvent | None)#

classmethod showFullScreen(self)#

classmethod showMaximized(self)#

classmethod showMinimized(self)#

classmethod showNormal(self)#

classmethod signalsBlocked(self) → bool#

classmethod size(self) → QSize#

classmethod sizeAdjustPolicy(self) → QAbstractScrollArea.SizeAdjustPolicy#

classmethod sizeHint(self) → QSize#

classmethod sizeIncrement(self) → QSize#

classmethod sizePolicy(self) → QSizePolicy#

classmethod stackUnder(self, a0: QWidget | None)#

classmethod startTimer(self, interval: int, timerType: Qt.TimerType = Qt.CoarseTimer) → int#

classmethod statusTip(self) → str#

classmethod style(self) → QStyle | None#

classmethod styleSheet(self) → str#

classmethod tabletEvent(self, a0: QTabletEvent | None)#

classmethod testAttribute(self, attribute: Qt.WidgetAttribute) → bool#

classmethod thread(self) → QThread | None#

classmethod timerEvent(self, a0: QTimerEvent | None)#

classmethod toolTip(self) → str#

classmethod toolTipDuration(self) → int#

classmethod tr(sourceText: str | None, disambiguation: str | None = None, n: int = -1) → str#

classmethod transform(self) → QTransform#

classmethod transformationAnchor(self) → QGraphicsView.ViewportAnchor#

translate(self, dx: float, dy: float)#

classmethod underMouse(self) → bool#

classmethod ungrabGesture(self, type: Qt.GestureType)#

classmethod unsetCursor(self)#

classmethod unsetLayoutDirection(self)#

classmethod unsetLocale(self)#

classmethod update(self)#
classmethod update(self, a0: QRect)
classmethod update(self, a0: QRegion)
classmethod update(self, ax: int, ay: int, aw: int, ah: int)

classmethod updateGeometry(self)#

classmethod updateMicroFocus(self, query: Qt.InputMethodQuery = Qt.ImQueryAll)#

classmethod updateScene(self, rects: Iterable[QRectF])#

classmethod updateSceneRect(self, rect: QRectF)#

update_plot(time, voltage, led)[source]#: Add new data points to the plot Parameters ———- time voltage led

update_views()[source]#: Make sure the linked view boxes have the correct size (called after resizing of the plot)

classmethod updatesEnabled(self) → bool#

classmethod verticalScrollBar(self) → QScrollBar | None#

classmethod verticalScrollBarPolicy(self) → Qt.ScrollBarPolicy#

viewRect()#: Return the boundaries of the view in scene coordinates

classmethod viewport(self) → QWidget | None#

classmethod viewportEvent(self, event: QEvent | None) → bool#

classmethod viewportMargins(self) → QMargins#

classmethod viewportSizeHint(self) → QSize#

classmethod viewportTransform(self) → QTransform#

classmethod viewportUpdateMode(self) → QGraphicsView.ViewportUpdateMode#

classmethod visibleRegion(self) → QRegion#

classmethod whatsThis(self) → str#

wheelEvent(self, event: QWheelEvent | None)#

classmethod width(self) → int#

classmethod widthMM(self) → int#

classmethod winId(self) → PyQt6.sip.voidptr#

classmethod window(self) → QWidget | None#

classmethod windowFilePath(self) → str#

classmethod windowFlags(self) → Qt.WindowType#

classmethod windowHandle(self) → QWindow | None#

classmethod windowIcon(self) → QIcon#

classmethod windowIconText(self) → str#

classmethod windowModality(self) → Qt.WindowModality#

classmethod windowOpacity(self) → float#

classmethod windowRole(self) → str#

classmethod windowState(self) → Qt.WindowState#

classmethod windowTitle(self) → str#

classmethod windowType(self) → Qt.WindowType#

classmethod x(self) → int#

classmethod y(self) → int#