GLViewWidget#

class pyqtgraph.opengl.GLViewWidget(
*args,
devicePixelRatio=None,
**kwargs,
)[source]#

Bases: GLViewMixin, QOpenGLWidget

__init__(
*args,
devicePixelRatio=None,
**kwargs,
)[source]#
Basic widget for displaying 3D data

  • Rotation/scale controls

  • Axis/grid display

  • Export options

Arguments:

parent

(QObject, optional): Parent QObject. Defaults to None.

devicePixelRatio

No longer in use. High-DPI displays should automatically detect the correct resolution.

rotationMethod

(str): Mechanism to drive the rotation method, options are ‘euler’ and ‘quaternion’. Defaults to ‘euler’.
class RenderFlags#
class RenderFlags(
f: RenderFlags | QWidget.RenderFlag,
)
class RenderFlags(
a0: RenderFlags,
)

Bases: simplewrapper

acceptDrops(
self,
) → bool#
accessibleDescription(
self,
) → str#
accessibleName(
self,
) → str#
actionEvent(
self,
a0: QActionEvent | None,
)#
actions(
self,
) → list[QAction]#
activateWindow(
self,
)#
addAction(
self,
action: QAction | None,
)#
addActions(
self,
actions: Iterable[QAction],
)#
adjustSize(
self,
)#
autoFillBackground(
self,
) → bool#
backgroundRole(
self,
) → QPalette.ColorRole#
baseSize(
self,
) → QSize#
blockSignals(
self,
b: bool,
) → bool#
cameraPosition()#

Return current position of camera based on center, dist, elevation, and azimuth

changeEvent(
self,
a0: QEvent | None,
)#
childAt(
self,
p: QPoint,
) → QWidget | None#
childAt(
self,
ax: int,
ay: int,
) → QWidget | None
childEvent(
self,
a0: QChildEvent | None,
)#
children(
self,
) → list[QObject]#
childrenRect(
self,
) → QRect#
childrenRegion(
self,
) → QRegion#
clear()#

Remove all items from the scene.

clearFocus(
self,
)#
clearMask(
self,
)#
close(
self,
) → bool#
closeEvent(
self,
a0: QCloseEvent | None,
)#
colorCount(
self,
) → int#
connectNotify(
self,
signal: QMetaMethod,
)#
contentsMargins(
self,
) → QMargins#
contentsRect(
self,
) → QRect#
contextMenuEvent(
self,
a0: QContextMenuEvent | None,
)#
contextMenuPolicy(
self,
) → Qt.ContextMenuPolicy#
create(
self,
window: PyQt5.sip.voidptr = None,
initializeWindow: bool = True,
destroyOldWindow: bool = True,
)#
createWindowContainer(
window: QWindow | None,
parent: QWidget | None = None,
flags: Qt.WindowFlags | Qt.WindowType = 0,
) → QWidget#
cursor(
self,
) → QCursor#
customEvent(
self,
a0: QEvent | None,
)#
deleteLater(
self,
)#
depth(
self,
) → int#
destroy(
self,
destroyWindow: bool = True,
destroySubWindows: bool = True,
)#
devType(
self,
) → int#
devicePixelRatio(
self,
) → int#
devicePixelRatioF(
self,
) → float#
devicePixelRatioFScale() → float#
disconnect(
a0: QMetaObject.Connection,
) → bool#
disconnect(
self,
) → None
disconnectNotify(
self,
signal: QMetaMethod,
)#
dragEnterEvent(
self,
a0: QDragEnterEvent | None,
)#
dragLeaveEvent(
self,
a0: QDragLeaveEvent | None,
)#
dragMoveEvent(
self,
a0: QDragMoveEvent | None,
)#
dropEvent(
self,
a0: QDropEvent | None,
)#
dumpObjectInfo(
self,
)#
dumpObjectTree(
self,
)#
dynamicPropertyNames(
self,
) → list[QByteArray]#
effectiveWinId(
self,
) → PyQt5.sip.voidptr#
ensurePolished(
self,
)#
enterEvent(
self,
a0: QEvent | None,
)#
eventFilter(
self,
a0: QObject | None,
a1: QEvent | None,
) → bool#
find(
a0: PyQt5.sip.voidptr,
) → QWidget | None#
findChild(
self,
type: type[QObjectT],
name: str | None = '',
options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively,
) → QObjectT#
findChild(
self,
types: tuple[type[QObjectT], ...],
name: str | None = '',
options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively,
) → QObjectT
findChildren(
self,
type: type[QObjectT],
name: str | None = '',
options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively,
) → list[QObjectT]#
findChildren(
self,
types: tuple[type[QObjectT], ...],
name: str | None = '',
options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively,
) → list[QObjectT]
findChildren(
self,
type: type[QObjectT],
regExp: QRegExp,
options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively,
) → list[QObjectT]
findChildren(
self,
types: tuple[type[QObjectT], ...],
regExp: QRegExp,
options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively,
) → list[QObjectT]
findChildren(
self,
type: type[QObjectT],
re: QRegularExpression,
options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively,
) → list[QObjectT]
findChildren(
self,
types: tuple[type[QObjectT], ...],
re: QRegularExpression,
options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively,
) → list[QObjectT]
focusInEvent(
self,
a0: QFocusEvent | None,
)#
focusNextChild(
self,
) → bool#
focusNextPrevChild(
self,
next: bool,
) → bool#
focusOutEvent(
self,
a0: QFocusEvent | None,
)#
focusPolicy(
self,
) → Qt.FocusPolicy#
focusPreviousChild(
self,
) → bool#
focusProxy(
self,
) → QWidget | None#
focusWidget(
self,
) → QWidget | None#
font(
self,
) → QFont#
fontInfo(
self,
) → QFontInfo#
fontMetrics(
self,
) → QFontMetrics#
foregroundRole(
self,
) → QPalette.ColorRole#
frameGeometry(
self,
) → QRect#
frameSize(
self,
) → QSize#
geometry(
self,
) → QRect#
getContentsMargins(
self,
)#
grab(
self,
rectangle: QRect = QRect(QPoint(0, 0), QSize(-1, -1)),
) → QPixmap#
grabGesture(
self,
type: Qt.GestureType,
flags: Qt.GestureFlags | Qt.GestureFlag = Qt.GestureFlags(),
)#
grabKeyboard(
self,
)#
grabMouse(
self,
)#
grabMouse(
self,
a0: QCursor | Qt.CursorShape,
) → None
grabShortcut(
self,
key: QKeySequence | QKeySequence.StandardKey | str | None | int,
context: Qt.ShortcutContext = Qt.WindowShortcut,
) → int#
graphicsEffect(
self,
) → QGraphicsEffect | None#
graphicsProxyWidget(
self,
) → QGraphicsProxyWidget | None#
hasFocus(
self,
) → bool#
hasHeightForWidth(
self,
) → bool#
hasMouseTracking(
self,
) → bool#
hasTabletTracking(
self,
) → bool#
height(
self,
) → int#
heightForWidth(
self,
a0: int,
) → int#
heightMM(
self,
) → int#
hide(
self,
)#
hideEvent(
self,
a0: QHideEvent | None,
)#
inherits(
self,
classname: str | None,
) → bool#
initPainter(
self,
painter: QPainter | None,
)#
initializeGL()#

Initialize items that were not initialized during addItem().

inputMethodEvent(
self,
a0: QInputMethodEvent | None,
)#
inputMethodHints(
self,
) → Qt.InputMethodHints#
inputMethodQuery(
self,
a0: Qt.InputMethodQuery,
) → Any#
insertAction(
self,
before: QAction | None,
action: QAction | None,
)#
insertActions(
self,
before: QAction | None,
actions: Iterable[QAction],
)#
installEventFilter(
self,
a0: QObject | None,
)#
isActiveWindow(
self,
) → bool#
isAncestorOf(
self,
child: QWidget | None,
) → bool#
isEnabled(
self,
) → bool#
isEnabledTo(
self,
a0: QWidget | None,
) → bool#
isFullScreen(
self,
) → bool#
isHidden(
self,
) → bool#
isLeftToRight(
self,
) → bool#
isMaximized(
self,
) → bool#
isMinimized(
self,
) → bool#
isModal(
self,
) → bool#
isRightToLeft(
self,
) → bool#
isSignalConnected(
self,
signal: QMetaMethod,
) → bool#
isVisible(
self,
) → bool#
isVisibleTo(
self,
a0: QWidget | None,
) → bool#
isWidgetType(
self,
) → bool#
isWindow(
self,
) → bool#
isWindowModified(
self,
) → bool#
isWindowType(
self,
) → bool#
itemsAt(
region=None,
)#

Return a list of the items displayed in the region (x, y, w, h) relative to the widget.

keyboardGrabber() → QWidget | None#
killTimer(
self,
id: int,
)#
layout(
self,
) → QLayout | None#
layoutDirection(
self,
) → Qt.LayoutDirection#
leaveEvent(
self,
a0: QEvent | None,
)#
locale(
self,
) → QLocale#
logicalDpiX(
self,
) → int#
logicalDpiY(
self,
) → int#
lower(
self,
)#
mapFrom(
self,
a0: QWidget | None,
a1: QPoint,
) → QPoint#
mapFromGlobal(
self,
a0: QPoint,
) → QPoint#
mapFromParent(
self,
a0: QPoint,
) → QPoint#
mapTo(
self,
a0: QWidget | None,
a1: QPoint,
) → QPoint#
mapToGlobal(
self,
a0: QPoint,
) → QPoint#
mapToParent(
self,
a0: QPoint,
) → QPoint#
mask(
self,
) → QRegion#
maximumHeight(
self,
) → int#
maximumSize(
self,
) → QSize#
maximumWidth(
self,
) → int#
metaObject(
self,
) → QMetaObject | None#
minimumHeight(
self,
) → int#
minimumSize(
self,
) → QSize#
minimumSizeHint(
self,
) → QSize#
minimumWidth(
self,
) → int#
mouseDoubleClickEvent(
self,
a0: QMouseEvent | None,
)#
mouseGrabber() → QWidget | None#
move(
self,
a0: QPoint,
)#
move(
self,
ax: int,
ay: int,
) → None
moveEvent(
self,
a0: QMoveEvent | None,
)#
moveToThread(
self,
thread: QThread | None,
)#
nativeEvent(
self,
eventType: QByteArray | bytes | bytearray,
message: PyQt5.sip.voidptr | None,
)#
nativeParentWidget(
self,
) → QWidget | None#
nextInFocusChain(
self,
) → QWidget | None#
normalGeometry(
self,
) → QRect#
objectName(
self,
) → str#
orbit(
azim,
elev,
)#

Orbits the camera around the center position. azim and elev are given in degrees.

overrideWindowFlags(
self,
type: Qt.WindowFlags | Qt.WindowType,
)#
overrideWindowState(
self,
state: Qt.WindowStates | Qt.WindowState,
)#
paint(
*,
region,
viewport,
useItemNames=False,
)#

It is caller’s responsibility to call glViewport prior to calling this method. region specifies the sub-region of viewport that should be rendered.

paintingActive(
self,
) → bool#
palette(
self,
) → QPalette#
pan(
dx,
dy,
dz,
relative='global',
)#

Moves the center (look-at) position while holding the camera in place.

Arguments:

dx

Distance to pan in x direction

dy

Distance to pan in y direction

dz

Distance to pan in z direction

relative

String that determines the direction of dx,dy,dz. If “global”, then the global coordinate system is used. If “view”, then the z axis is aligned with the view direction, and x and y axes are in the plane of the view: +x points right, +y points up. If “view-upright”, then x is in the global xy plane and points to the right side of the view, y is in the global xy plane and orthogonal to x, and z points in the global z direction.

Distances are scaled roughly such that a value of 1.0 moves by one pixel on screen.

parent(
self,
) → QObject | None#
parentWidget(
self,
) → QWidget | None#
physicalDpiX(
self,
) → int#
physicalDpiY(
self,
) → int#
pixelSize(
pos,
)#

Return the approximate size of a screen pixel at the location pos Pos may be a Vector or an (N,3) array of locations

pos(
self,
) → QPoint#
previousInFocusChain(
self,
) → QWidget | None#
property(
self,
name: str | None,
) → Any#
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.

raise_(
self,
)#
readQImage()#

Read the current buffer pixels out as a QImage.

receivers(
self,
signal: PYQT_SIGNAL,
) → int#
rect(
self,
) → QRect#
releaseKeyboard(
self,
)#
releaseMouse(
self,
)#
releaseShortcut(
self,
id: int,
)#
removeAction(
self,
action: QAction | None,
)#
removeEventFilter(
self,
a0: QObject | None,
)#
removeItem(
item,
)#

Remove the item from the scene.

render(
self,
target: QPaintDevice | None,
targetOffset: QPoint = QPoint(),
sourceRegion: QRegion = QRegion(),
flags: RenderFlags | QWidget.RenderFlag = QWidget.RenderFlags(QWidget.RenderFlag.DrawWindowBackground | QWidget.RenderFlag.DrawChildren),
)#
render(
self,
painter: QPainter | None,
targetOffset: QPoint = QPoint(),
sourceRegion: QRegion = QRegion(),
flags: RenderFlags | QWidget.RenderFlag = QWidget.RenderFlags(QWidget.RenderFlag.DrawWindowBackground | QWidget.RenderFlag.DrawChildren),
) → None
repaint(
self,
)#
repaint(
self,
x: int,
y: int,
w: int,
h: int,
) → None
repaint(
self,
a0: QRect,
) → None
repaint(
self,
a0: QRegion,
) → None
reset()#

Initialize the widget state or reset the current state to the original state.

resize(
self,
a0: QSize,
)#
resize(
self,
w: int,
h: int,
) → None
restoreGeometry(
self,
geometry: QByteArray | bytes | bytearray,
) → bool#
saveGeometry(
self,
) → QByteArray#
screen(
self,
) → QScreen | None#
scroll(
self,
dx: int,
dy: int,
)#
scroll(
self,
dx: int,
dy: int,
a2: QRect,
) → None
sender(
self,
) → QObject | None#
senderSignalIndex(
self,
) → int#
setAcceptDrops(
self,
on: bool,
)#
setAccessibleDescription(
self,
description: str | None,
)#
setAccessibleName(
self,
name: str | None,
)#
setAttribute(
self,
attribute: Qt.WidgetAttribute,
on: bool = True,
)#
setAutoFillBackground(
self,
enabled: bool,
)#
setBackgroundColor(
*args,
**kwds,
)#

Set the background color of the widget. Accepts the same arguments as mkColor().

setBackgroundRole(
self,
a0: QPalette.ColorRole,
)#
setBaseSize(
self,
basew: int,
baseh: int,
)#
setBaseSize(
self,
s: QSize,
) → None
setContentsMargins(
self,
left: int,
top: int,
right: int,
bottom: int,
)#
setContentsMargins(
self,
margins: QMargins,
) → None
setContextMenuPolicy(
self,
policy: Qt.ContextMenuPolicy,
)#
setCursor(
self,
a0: QCursor | Qt.CursorShape,
)#
setDisabled(
self,
a0: bool,
)#
setEnabled(
self,
a0: bool,
)#
setFixedHeight(
self,
h: int,
)#
setFixedSize(
self,
a0: QSize,
)#
setFixedSize(
self,
w: int,
h: int,
) → None
setFixedWidth(
self,
w: int,
)#
setFocus(
self,
)#
setFocus(
self,
reason: Qt.FocusReason,
) → None
setFocusPolicy(
self,
policy: Qt.FocusPolicy,
)#
setFocusProxy(
self,
a0: QWidget | None,
)#
setFont(
self,
a0: QFont,
)#
setForegroundRole(
self,
a0: QPalette.ColorRole,
)#
setGeometry(
self,
a0: QRect,
)#
setGeometry(
self,
ax: int,
ay: int,
aw: int,
ah: int,
) → None
setGraphicsEffect(
self,
effect: QGraphicsEffect | None,
)#
setHidden(
self,
hidden: bool,
)#
setInputMethodHints(
self,
hints: Qt.InputMethodHints | Qt.InputMethodHint,
)#
setLayout(
self,
a0: QLayout | None,
)#
setLayoutDirection(
self,
direction: Qt.LayoutDirection,
)#
setLocale(
self,
locale: QLocale,
)#
setMask(
self,
a0: QBitmap,
)#
setMask(
self,
a0: QRegion,
) → None
setMaximumHeight(
self,
maxh: int,
)#
setMaximumSize(
self,
maxw: int,
maxh: int,
)#
setMaximumSize(
self,
s: QSize,
) → None
setMaximumWidth(
self,
maxw: int,
)#
setMinimumHeight(
self,
minh: int,
)#
setMinimumSize(
self,
minw: int,
minh: int,
)#
setMinimumSize(
self,
s: QSize,
) → None
setMinimumWidth(
self,
minw: int,
)#
setMouseTracking(
self,
enable: bool,
)#
setObjectName(
self,
name: str | None,
)#
setPalette(
self,
a0: QPalette,
)#
setParent(
self,
parent: QWidget | None,
)#
setParent(
self,
parent: QWidget | None,
f: Qt.WindowFlags | Qt.WindowType,
) → None
setProperty(
self,
name: str | None,
value: Any,
) → bool#
setShortcutAutoRepeat(
self,
id: int,
enabled: bool = True,
)#
setShortcutEnabled(
self,
id: int,
enabled: bool = True,
)#
setSizeIncrement(
self,
w: int,
h: int,
)#
setSizeIncrement(
self,
s: QSize,
) → None
setSizePolicy(
self,
a0: QSizePolicy,
)#
setSizePolicy(
self,
hor: QSizePolicy.Policy,
ver: QSizePolicy.Policy,
) → None
setStatusTip(
self,
a0: str | None,
)#
setStyle(
self,
a0: QStyle | None,
)#
setStyleSheet(
self,
styleSheet: str | None,
)#
setTabOrder(
a0: QWidget | None,
a1: QWidget | None,
)#
setTabletTracking(
self,
enable: bool,
)#
setToolTip(
self,
a0: str | None,
)#
setToolTipDuration(
self,
msec: int,
)#
setUpdatesEnabled(
self,
enable: bool,
)#
setVisible(
self,
visible: bool,
)#
setWhatsThis(
self,
a0: str | None,
)#
setWindowFilePath(
self,
filePath: str | None,
)#
setWindowFlag(
self,
a0: Qt.WindowType,
on: bool = True,
)#
setWindowFlags(
self,
type: Qt.WindowFlags | Qt.WindowType,
)#
setWindowIcon(
self,
icon: QIcon,
)#
setWindowIconText(
self,
a0: str | None,
)#
setWindowModality(
self,
windowModality: Qt.WindowModality,
)#
setWindowModified(
self,
a0: bool,
)#
setWindowOpacity(
self,
level: float,
)#
setWindowRole(
self,
a0: str | None,
)#
setWindowState(
self,
state: Qt.WindowStates | Qt.WindowState,
)#
setWindowTitle(
self,
a0: str | None,
)#
sharedPainter(
self,
) → QPainter | None#
show(
self,
)#
showEvent(
self,
a0: QShowEvent | None,
)#
showFullScreen(
self,
)#
showMaximized(
self,
)#
showMinimized(
self,
)#
showNormal(
self,
)#
signalsBlocked(
self,
) → bool#
size(
self,
) → QSize#
sizeHint(
self,
) → QSize#
sizeIncrement(
self,
) → QSize#
sizePolicy(
self,
) → QSizePolicy#
stackUnder(
self,
a0: QWidget | None,
)#
startTimer(
self,
interval: int,
timerType: Qt.TimerType = Qt.CoarseTimer,
) → int#
statusTip(
self,
) → str#
style(
self,
) → QStyle | None#
styleSheet(
self,
) → str#
tabletEvent(
self,
a0: QTabletEvent | None,
)#
testAttribute(
self,
attribute: Qt.WidgetAttribute,
) → bool#
thread(
self,
) → QThread | None#
timerEvent(
self,
a0: QTimerEvent | None,
)#
toolTip(
self,
) → str#
toolTipDuration(
self,
) → int#
tr(
self,
sourceText: str | None,
disambiguation: str | None = None,
n: int = -1,
) → str#
underMouse(
self,
) → bool#
ungrabGesture(
self,
type: Qt.GestureType,
)#
unsetCursor(
self,
)#
unsetLayoutDirection(
self,
)#
unsetLocale(
self,
)#
update(
self,
)#
update(
self,
a0: QRect,
) → None
update(
self,
a0: QRegion,
) → None
update(
self,
ax: int,
ay: int,
aw: int,
ah: int,
) → None
updateGeometry(
self,
)#
updateMicroFocus(
self,
)#
updatesEnabled(
self,
) → bool#
visibleRegion(
self,
) → QRegion#
whatsThis(
self,
) → str#
width(
self,
) → int#
widthMM(
self,
) → int#
winId(
self,
) → PyQt5.sip.voidptr#
window(
self,
) → QWidget | None#
windowFilePath(
self,
) → str#
windowFlags(
self,
) → Qt.WindowFlags#
windowHandle(
self,
) → QWindow | None#
windowIcon(
self,
) → QIcon#
windowIconText(
self,
) → str#
windowModality(
self,
) → Qt.WindowModality#
windowOpacity(
self,
) → float#
windowRole(
self,
) → str#
windowState(
self,
) → Qt.WindowStates#
windowTitle(
self,
) → str#
windowType(
self,
) → Qt.WindowType#
x(
self,
) → int#
y(
self,
) → int#
class pyqtgraph.opengl.GLViewWidget.GLViewMixin(
*args,
rotationMethod='euler',
**kwargs,
)[source]#

Warning

The intention of this class is to provide users who want to use QOpenGLWindow instead of QOpenGLWidget but retain the benefits of GLViewWidget. Usage of this class should be considered experimental for the time being as it may change without warning in future releases.

Members:

__init__(
*args,
rotationMethod='euler',
**kwargs,
)[source]#

Mixin class providing functionality for GLViewWidget

Arguments:

rotationMethod

(str): Mechanism to drive the rotation method, options are ‘euler’ and ‘quaternion’. Defaults to ‘euler’.
On this page