def mouseMoveEvent(self, event):
"""
Must reimplement mouseMoveEvent of QGraphicsView to allow
ScrollHandDrag due to the fact that events are intercepted
breaks this feature.
"""
if self._transform_enable == True:
if self.dragMode() == self._yes_drag:
# Add stuff to handle the pan event
posf = event.localPos()
xf = posf.x()
yf = posf.y()
factor = self.transform().m11()
transform = self.scene_root_item.transform()
transform.translate((xf - self._x0)/factor,\
(yf - self._y0)/factor)
self.scene_root_item.setTransform(transform)
self._x0 = xf
self._y0 = yf
elif self._dolly_zoom_enable == True:
self.dollyZoom(event)
# adding this allows events to be passed to items underneath
QGraphicsView.mouseMoveEvent(self, event)
def __init__(self, parent=None):
QGraphicsView.__init__(self, parent)
self.updateSecs = 0.5
# Border
self.setLineWidth(0)
self.setFrameShape(QtWidgets.QFrame.NoFrame)
# Size
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
sizePolicy.setHeightForWidth(True)
self.setSizePolicy(sizePolicy)
# No scrollbars
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
# Scene
self.scene = QGraphicsScene()
self.setScene(self.scene)
self.setBackgroundBrush(QColor("black"))
# Text of clock
self.textItem = QGraphicsTextItem()
self.textItem.color = QColor(QColor("black"))
self.textItem.setFont(QFont("Segoe UI", 80))
self.textItem.setDefaultTextColor(QColor("white"))
self.textItem.setHtml("")
self.textItem.setZValue(20)
self.scene.addItem(self.textItem)
# Start ticking
self.start()
def wheelEvent(self, event):
'''Handle wheel event.
Argument(s):
event (QWheelEvent): Wheel event
'''
# Only zoom/dezoom if CTRL is pressed
if event.modifiers() == Qt.ControlModifier:
zoomInFactor = 1.25
zoomOutFactor = 1 / zoomInFactor
# Save the scene pos
oldPos = self.mapToScene(event.pos())
# Zoom
if event.angleDelta().y() > 0:
zoomFactor = zoomInFactor
else:
zoomFactor = zoomOutFactor
self.scale(zoomFactor, zoomFactor)
# Get the new position
newPos = self.mapToScene(event.pos())
# Move scene to old position
delta = newPos - oldPos
self.translate(delta.x(), delta.y())
# Move scrollbar
else:
QGraphicsView.wheelEvent(self, event)
def mouseReleaseEvent(self, event):
"""If panning, stop. If handles were pressed, release them."""
if self._transform_enable == True:
# QMouseEvent.button() returns the button that triggered the event
which_button = event.button()
if which_button in [self._button_pan, self._button_pan_alt]:
self._panDisable()
elif which_button == self._button_zoom:
self._dolly_zoom_enable = False
else:
return QGraphicsView.mouseReleaseEvent(self, event)
# end if
else:
if len(self._press_list): # Notify any pressed items to release
event_pos = event.pos()
for item in self._press_list:
#try:
# print("item release", item)
item.customMouseRelease(event)
#except:
# item.mouseReleaseEvent(event)
#end for
self._press_list = []
# end if
if self._selection_lock:
self._selection_lock.processPendingToAddList()
return QGraphicsView.mouseReleaseEvent(self, event)
def __init__(self,winParent):
QGraphicsView.__init__(self)
self.winParent=winParent
self.viewUpdate.connect(self.updateView)
self.m_altitude = 0
self.m_pressure = 28
self.m_originalHeight = 240
self.m_originalWidth = 240
self.m_originalAltCtr = QPointF(120,120)
self.m_face1Z = -50
self.m_face2Z = -40
self.m_face3Z = -30
self.m_hand1Z = -20
self.m_hand2Z = -10
self.m_caseZ = 10
self.setStyleSheet("background: transparent; border: none")
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setInteractive(False)
self.setEnabled(False)
self.m_scene = QGraphicsScene(self)
self.setScene(self.m_scene)
self.init()
def inputGraphicsViewKeyPressEvent(self,event):
mousePosition = QCursor().pos()
mousePosition = self.inputGraphicsView.mapFromGlobal(mousePosition)
if event.type() == QtCore.QEvent.KeyPress:
key = event.key()
if key == QtCore.Qt.Key_Space:
self.videoPlaybackWidget.playButtonClicked()
elif key == QtCore.Qt.Key_A:
self.videoPlaybackWidget.movePrevButtonClicked()
elif key == QtCore.Qt.Key_D:
self.videoPlaybackWidget.moveNextButtonClicked()
elif key == QtCore.Qt.Key_Down:
self.inputGraphicsViewScaleDown()
elif key == QtCore.Qt.Key_Up:
self.inputGraphicsViewScaleUp()
pass
elif key == QtCore.Qt.Key_R:
self.graphicsViewResized()
elif key == QtCore.Qt.Key_P:
pass
#self.handInputSystem.nextDataFrame()
elif key == QtCore.Qt.Key_O:
pass
#self.handInputSystem.previousDataFrame()
elif key == QtCore.Qt.Key_J:
frameNo = self.handInputSystem.getLastInputedFrameIndex()
self.videoPlaybackWidget.moveToFrame(frameNo)
elif key == QtCore.Qt.Key_S:
self.handInputSystem.saveCSV("./a.csv")
QGraphicsView.keyPressEvent(self.inputGraphicsView, event)
def __init__(self, lang, areaType, statusBar):
QGraphicsView.__init__(self)
self.ocrscene = OcrScene(self, lang, areaType)
self.setScene(self.ocrscene)
self.setCacheMode(QGraphicsView.CacheBackground)
self.setRenderHint(QPainter.Antialiasing)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QGraphicsView.AnchorViewCenter)
self.setMinimumSize(200, 200)
self.language = lang
self.statusBar = statusBar
self.areaType = areaType
self.resizingArea = None
self.resizingAreaPos = None
self.resizingAreaRect = None
self.resizingEdge = None
self.resizingStartingPos = None
self.areaBorder = float()
self.areaTextSize = float()
self.setCursor(Qt.CrossCursor)
self.scene().isModified = False
self.bResizing = False
self.filename = None
Image.init()
def __init__(self, photoBaseDir, validPhotoFileExts, maxCols, maxRows, borders, xBetweenPics, yBetweenPics, animationSpeed, picChangeMs, parent=None):
QGraphicsView.__init__(self, parent)
# Vars
self.maxCols = maxCols
self.maxRows = maxRows
self.borders = borders
self.xBetweenPics = xBetweenPics
self.yBetweenPics = yBetweenPics
self.animationSpeed = animationSpeed
self.animationTimeoutMs = 15000
self.picChangeMs = picChangeMs
# Border
self.setLineWidth(0)
self.setFrameShape(QtWidgets.QFrame.NoFrame)
# Size
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.setSizePolicy(sizePolicy)
# Appearance
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
# Widget
self.scene = QGraphicsScene()
self.setScene(self.scene)
self.setBackgroundBrush(QColor("light green"))
# Calc layout
self.calcCellSize()
self.animTimeout = QTimer()
self.picManager = PicManager(self.scene, photoBaseDir, validPhotoFileExts, maxCols, maxRows, QSize(self.xCellSize, self.yCellSize), borders, xBetweenPics, yBetweenPics)
# Class vars
self.animationRunning = False
self.curAnimationGroup = 0
self.animationGroups = [None] * 2
self.picChgTimer = None
self.stepCount = 0
class CameraWidget(QWidget):
def __init__(self, background_color):
QWidget.__init__(self)
self.scene = QGraphicsScene(self)
self.scene.setBackgroundBrush(QBrush(background_color))
self.graphics_view = QGraphicsView(self.scene)
self.graphics_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setFrameStyle(0)
self.graphics_view.setStyleSheet("QGraphicsView {background: transparent; border: 3px; outline: none;}")
self.graphics_view.scale(-1, 1) # this make live video from camero mirror.
self.video_item = QGraphicsVideoItem()
self.scene.addItem(self.video_item)
self.layout = QVBoxLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.graphics_view)
self.available_cameras = QCameraInfo.availableCameras()
# Set the default camera.
self.select_camera(0)
def resizeEvent(self, event):
self.video_item.setSize(QSizeF(event.size().width(), event.size().height()))
QWidget.resizeEvent(self, event)
def select_camera(self, i):
self.camera = QCamera(self.available_cameras[i])
self.camera.setViewfinder(self.video_item)
self.camera.setCaptureMode(QCamera.CaptureStillImage)
self.camera.start()
def mousePressEvent(self, event):
# grabbing the position of the widget
sp = self.mapToScene(event.pos())
ret = self.scene().areaAt(sp)
edge = ret % 100
iArea = int(ret / 100) - 1
# resizing/moving the area if it exists
if edge:
self.bResizing = True
self.resizingEdge = edge
self.resizingArea = self.scene().areas[iArea]
self.resizingStartingPos = sp
self.resizingAreaRect = self.resizingArea.rect()
self.resizingAreaPos = self.resizingArea.pos()
self.resizingArea.setFlag(QGraphicsItem.ItemIsMovable, False)
# creation of a new area if there is an image
elif iArea == -1 and self.filename:
size = QSizeF(0, 0)
newArea = self.scene().createArea(sp,
size, self.areaType, self.areaBorder,
self.areaTextSize)
self.bResizing = True
self.resizingEdge = 10
self.resizingArea = newArea
self.resizingStartingPos = sp
self.resizingAreaRect = self.resizingArea.rect()
self.resizingAreaPos = self.resizingArea.pos()
self.resizingArea.setFlag(QGraphicsItem.ItemIsMovable, False)
QGraphicsView.mousePressEvent(self, event)
def __init__(self, pickerView):
scene = QGraphicsScene()
scene.addText("QGraphicsItem in QGraphicsView. Press mouse to mock pick, key to open dialog.")
QGraphicsView.__init__(self, scene)
# Accept touch on both this widget and viewport (abstract scroll area)
# Touch engenders LMB mouse press event since app attribute for that is set.
self.setAttribute(Qt.WA_AcceptTouchEvents)
self.viewport().setAttribute(Qt.WA_AcceptTouchEvents)
self.qmlMaster = QmlMaster()
"""
See the QML, created there?
" A Person model which is mock-picked"
self.model = Person()
"""
if pickerView is not None:
self.pickerView = pickerView
self.pickDelegate = self.qmlMaster.findComponent(
self.pickerView, className=model.person.Person, objectName="person"
)
self.dialogDelegate = self.qmlMaster.findComponent(
self.pickerView, className=model.qmlDelegate.QmlDelegate, objectName="dialogDelegate"
)
else:
self.pickDelegate = None
self.dialogDelegate = None
def keyPressEvent(self, event):
"""
Handle key presses for mouse-drag transforms and arrow-key panning.
"""
if not self._has_focus: # we don't have focus -> ignore keypress
return
if event.key() == self._key_mod:
self._transform_enable = True
QGraphicsView.keyPressEvent(self, event)
elif event.key() == Qt.Key_Left:
transform = self.scene_root_item.transform()
transform.translate(self.keyPanDeltaX(), 0)
self.scene_root_item.setTransform(transform)
elif event.key() == Qt.Key_Up:
transform = self.scene_root_item.transform()
transform.translate(0, self.keyPanDeltaY())
self.scene_root_item.setTransform(transform)
elif event.key() == Qt.Key_Right:
transform = self.scene_root_item.transform()
transform.translate(-self.keyPanDeltaX(), 0)
self.scene_root_item.setTransform(transform)
elif event.key() == Qt.Key_Down:
transform = self.scene_root_item.transform()
transform.translate(0, -self.keyPanDeltaY())
self.scene_root_item.setTransform(transform)
elif event.key() == Qt.Key_Plus:
self.zoomIn(0.3)
elif event.key() == Qt.Key_Minus:
self.zoomIn(0.03)
else:
return QGraphicsView.keyPressEvent(self, event)
def __init__(self):
QGraphicsView.__init__(self)
# Image is displayed as a QPixmap in a QGraphicsScene attached to this QGraphicsView.
self.scene = QGraphicsScene()
self.setScene(self.scene)
# Store a local handle to the scene's current image pixmap.
self._pixmapHandle = None
# Image aspect ratio mode.
# !!! ONLY applies to full image. Aspect ratio is always ignored when zooming.
# Qt.IgnoreAspectRatio: Scale image to fit viewport.
# Qt.KeepAspectRatio: Scale image to fit inside viewport, preserving aspect ratio.
# Qt.KeepAspectRatioByExpanding: Scale image to fill the viewport, preserving aspect ratio.
self.aspectRatioMode = Qt.KeepAspectRatio
# Scroll bar behaviour.
# Qt.ScrollBarAlwaysOff: Never shows a scroll bar.
# Qt.ScrollBarAlwaysOn: Always shows a scroll bar.
# Qt.ScrollBarAsNeeded: Shows a scroll bar only when zoomed.
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
# Stack of QRectF zoom boxes in scene coordinates.
self.zoomStack = []
# Flags for enabling/disabling mouse interaction.
self.canZoom = True
self.canPan = True
def __init__(self, *args):
super(Demo, self).__init__(*args)
loadUi('MainWindow.ui', self)
scene = QGraphicsScene()
rectItem = QGraphicsRectItem(QRectF(0, 0, 320, 240))
rectItem.setBrush(Qt.red)
#rectItem.setPen(Qt.NoPen)
rectItem.setFlag(QGraphicsItem.ItemIsMovable)
scene.addItem(rectItem)
ellipseItem = QGraphicsEllipseItem(QRectF(0, 0, 200, 200))
ellipseItem.setBrush(Qt.blue)
#ellipseItem.setPen(Qt.NoPen)
ellipseItem.setFlag(QGraphicsItem.ItemIsMovable)
scene.addItem(ellipseItem)
rectSizeGripItem = SizeGripItem(SimpleResizer(rectItem), rectItem)
ellipseSizeGripItem = SizeGripItem(SimpleResizer(ellipseItem), ellipseItem)
graphicsView = QGraphicsView(self)
graphicsView.setScene(scene)
self.setCentralWidget(graphicsView)
def mousePressEvent(self, event):
if event.button() == self.fMiddleButton:
self.fPanning = True
self.setDragMode(QGraphicsView.ScrollHandDrag)
event = QMouseEvent(event.type(), event.pos(), Qt.LeftButton, Qt.LeftButton, event.modifiers())
QGraphicsView.mousePressEvent(self, event)
def keyReleaseEvent(self, event):
if event.key() == Qt.Key_Delete:
item = self.scene().focusItem()
self.scene().removeArea(item)
#elif event.key() == Qt.Key_Escape:
# self.first = True
QGraphicsView.keyReleaseEvent(self, event)
def inputGraphicsViewMousePressEvent(self, event):
if event.modifiers() == QtCore.Qt.ShiftModifier:
# Comment out to permit the view for sending the event to the child scene.
QGraphicsView.mousePressEvent(self.inputGraphicsView, event)
else:
self.drawingFlag = True
if not self.videoPlaybackWidget.isPlaying():
self.videoPlaybackWidget.playButtonClicked()
def __init__(self, parent=None):
QGraphicsView.__init__(self, parent)
self.parent = parent
self.setContentsMargins(QMargins())
self.setStyleSheet("QGraphicsView {border:0px solid;margin:0px;}")
self.setResizeAnchor(QGraphicsView.AnchorViewCenter)
self.setScene(QGraphicsScene(self))
self.scene().addItem(QGraphicsPixmapItem(QPixmap(":/images/front.png")))
def __init__(self, clrs=colours, parent=None):
QGraphicsView.__init__(self, parent)
self.scene = QGraphicsScene(self)
self.scene.setSceneRect(QtCore.QRectF(0, 0, 440, 340))
self.setScene(self.scene)
self.setBackgroundBrush(QtGui.QBrush(QtGui.QColor(0, 0, 0, 0)))
self.setMinimumSize(100, 100)
self.colours = clrs
def keyReleaseEvent(self, event):
"""docstring for keyReleaseEvent"""
if event.key() == self._key_mod:
self._transform_enable = False
self._dolly_zoom_enable = False
self._panDisable()
# end if
else:
QGraphicsView.keyReleaseEvent(self, event)
def __init__(self, parent):
QGraphicsView.__init__(self, parent)
self.fPanning = False
try:
self.fMiddleButton = Qt.MiddleButton
except:
self.fMiddleButton = Qt.MidButton
def inputGraphicsViewMouseReleaseEvent(self, event):
if self.drawingFlag == True:
self.drawingFlag = False
self.videoPlaybackWidget.playButtonClicked()
self.handInputSystem.inputMouseReleaseEvent()
self.handInputSystem.setPoints()
# Comment out to permit the view for sending the event to the child scene.
QGraphicsView.mouseReleaseEvent(self.inputGraphicsView, event)
self.inputGraphicsView.viewport().setCursor(QtCore.Qt.ArrowCursor)
def inputGraphicsViewwheelEvent(self,event):
scaleFactor = 1.15
if event.delta() > 0:
# Zoom in
self.inputGraphicsView.scale(scaleFactor, scaleFactor)
else:
# Zooming out
self.inputGraphicsView.scale(1.0 / scaleFactor, 1.0 / scaleFactor)
QGraphicsView.wheelEvent(self.inputGraphicsView, event)
def mouseReleaseEvent(self, event):
QGraphicsView.mouseReleaseEvent(self, event)
if not self.fPanning:
return
self.fPanning = False
self.setDragMode(QGraphicsView.NoDrag)
self.setCursor(QCursor(Qt.ArrowCursor))
def __init__(self, parent=None):
QGraphicsView.__init__(self, parent)
self.go_prev_img = parent.go_prev_img
self.go_next_img = parent.go_next_img
pal = self.palette()
pal.setColor(self.backgroundRole(), Qt.black)
self.setPalette(pal)
self.setFrameShape(QFrame.NoFrame)
def mousePressEvent(self, event):
"""Go to the next / previous image, or be able to drag the image with a hand."""
if event.button() == Qt.LeftButton:
x = event.x()
if x < 100:
self.go_prev_img()
elif x > self.width() - 100:
self.go_next_img()
else:
self.setDragMode(QGraphicsView.ScrollHandDrag)
QGraphicsView.mousePressEvent(self, event)
def __init__(self, parent: QWidget = None):
"""
On initialization, we need to bind the Ctrl/command key to
enable manipulation of the view.
"""
QGraphicsView.__init__(self, parent)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setRubberBandSelectionMode(Qt.IntersectsItemShape)
self._no_drag = QGraphicsView.RubberBandDrag
self._yes_drag = QGraphicsView.ScrollHandDrag
# reset things that are state dependent
self.clearGraphicsView()
self._x0 = 0
self._y0 = 0
self._scale_size = 1.0
self._scale_limit_max = 16.0 # OLD 3.0
self._scale_limit_min = 0.21
self._scale_up_rate = 0.01
self._scale_down_rate = 0.01
self._scale_fit_factor = .5 # sets initial zoom level
self._show_details = True
self._last_scale_factor = 0.0
self.scene_root_item = None # the item to transform
# Keyboard panning
self._key_pan_delta_x = styles.PATH_BASE_WIDTH * 21
self._key_pan_delta_y = styles.PATH_HELIX_HEIGHT + styles.PATH_HELIX_PADDING/2
# Modifier keys and buttons
self._key_mod = Qt.Key_Control
self._button_pan: Qt.MouseButtons = Qt.LeftButton
self._button_pan_alt: Qt.MouseButtons = Qt.MidButton
self._button_zoom: Qt.MouseButtons = Qt.RightButton
self.toolbar = None # custom hack for the paint tool palette
self._name = None
# a ``SelectionItemGroup`` object when not ``None``
self._selection_lock = None
self.setContextMenuPolicy(Qt.CustomContextMenu)
if GL:
self.is_GL = True
# self.glwidget = QGLWidget(QGLFormat(QGL.SampleBuffers))
self.glwidget = QOpenGLWidget()
# self.setupGL()
self.gl = self.glwidget.context().versionFunctions()
self.setViewport(self.glwidget)
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
# self.resetGL()
else:
self.is_GL = False
self.setViewportUpdateMode(QGraphicsView.MinimalViewportUpdate)
class QNEMainWindow(QMainWindow):
def __init__(self, parent):
super(QNEMainWindow, self).__init__(parent)
quitAct = QAction("&Quit", self, shortcut="Ctrl+Q",
statusTip="Exit the application", triggered=self.close)
addAct = QAction("&Add", self, statusTip="Add a block", triggered=self.addBlock)
fileMenu = self.menuBar().addMenu("&File")
fileMenu.addAction(addAct)
fileMenu.addSeparator()
fileMenu.addAction(quitAct)
self.setWindowTitle("Node Editor")
self.scene = QGraphicsScene(self)
self.view = QGraphicsView(self)
self.view.setScene(self.scene)
self.view.setRenderHint(QPainter.Antialiasing)
self.setCentralWidget(self.view)
self.nodesEditor = QNodesEditor(self)
self.nodesEditor.install(self.scene)
block = QNEBlock(None)
self.scene.addItem(block)
block.addPort("test", 0, QNEPort.NamePort)
block.addPort("TestBlock", 0, QNEPort.TypePort)
block.addInputPort("in1");
block.addInputPort("in2");
block.addInputPort("in3");
block.addOutputPort("out1");
block.addOutputPort("out2");
block.addOutputPort("out3");
block = block.clone()
block.setPos(150,0)
block = block.clone()
block.setPos(150,150)
def addBlock(self):
import random
import math
block = QNEBlock(None)
self.scene.addItem(block)
names = ["Vin", "Voutsadfasdf", "Imin", "Imax", "mul", "add", "sub", "div", "Conv", "FFT"]
for i in range(0,math.floor(random.uniform(3,8))):
block.addPort(random.choice(names), random.random()>0.5)
block.setPos(self.view.sceneRect().center().toPoint())
def __init__(self, width=10, parent=None):
QGraphicsView.__init__(self, parent)
self._frame = None
self._instructions = None
self.setScene(QGraphicsScene(self))
self._items = self.scene().createItemGroup([])
self.setMouseTracking(True)
self.pen = QPen(Qt.black, width, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)
self.painting = False
self.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform)
self.viewport().setCursor(self.getCursor())
self.updateScene()
def __init__(self, parent=None):
super(VideoPlayerWidget, self).__init__(parent)
self.scene = QGraphicsScene(self)
self.scene.setBackgroundBrush(QBrush(QColor(0, 0, 0, 255)))
self.graphics_view = QGraphicsView(self.scene)
self.graphics_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setFrameStyle(0)
self.graphics_view.setStyleSheet(
"QGraphicsView {background: transparent; border: 3px; outline: none;}"
)
self.video_item = QGraphicsVideoItem()
self.scene.addItem(self.video_item)
self.layout = QVBoxLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.graphics_view)
self.media_player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.media_player.setVideoOutput(self.video_item)
self.video_need_replay = False
self.video_seek_durcation = 3000 # in milliseconds
def showImage(self):
if self.key:
self.img = QPixmap(self.key)
if self.img.isNull():
QMessageBox.information(self, "Magic Viewer",
"不能打开文件：%s！" % self.key)
return
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.setDragMode(QGraphicsView.ScrollHandDrag)
# self.view.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
# self.view.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
self.scene.clear()
self.view.resetTransform()
self.scene.addPixmap(self.img)
self.zoom = 1 # 缩放系数
self.rotate = 0 # 旋转系数
# 如果图片尺寸＞窗口尺寸，计算缩放系数进行缩放
if self.img.width() > self.width() or self.img.height(
) > self.height():
self.zoom = min(self.width() / self.img.width(),
self.height() / self.img.height()) * 0.995
width = self.img.width()
height = self.img.height()
# self.scene.setSceneRect(0, 0, width - 2, height - 2)
self.view.resize(width, height)
self.setCentralWidget(self.view)
self.updateView()
self.show()
def __init__(self, parent=None, width=800, height=600):
# super(self.__class__, self).__init__(parent) # or
super().__init__(parent) # ??
self.setWindowTitle('pyueye example')
self.image = None
self.graphics_view = QGraphicsView(self)
self.v_layout = QVBoxLayout(self)
self.h_layout = QHBoxLayout()
self.scene = QGraphicsScene()
self.graphics_view.setScene(self.scene)
self.v_layout.addWidget(self.graphics_view)
self.scene.drawBackground = self.draw_background
self.scene.setSceneRect(self.scene.itemsBoundingRect())
self.update_signal.connect(self.update_image)
self.processors = []
self.resize(width, height)
self.v_layout.addLayout(self.h_layout)
self.setLayout(self.v_layout)
def __init__(self):
QGraphicsView.__init__(self)
self.scene = QGraphicsScene(0, 0, self.WYSOKOSC_OKNA,
self.SZEROKOSC_OKNA)
for i in range(self.number_of_players):
self.players.append(Player(1 + i * 10, 1 + i * 10, i))
for i in range(self.number_of_bots):
self.bots.append(Bot(10 + (i + 1) * 6, 10 + (i + 1) * 6, i + 1))
self.score = 0
self.view = QGraphicsView(self.scene)
self.getBoard()
for bot in self.bots:
bot.set_board(self.boar)
bot.set_player_position(self.players)
bot.set_bombs(self.bombs)
#self.intro()
self.drawBoard()
self.setScene(self.scene)
# self.timer.timeout.connect(self.draw_intro)
# self.timer.start(10)
self.timer.timeout.connect(self.update)
self.timer.start(10)
self.timer_boty = QTimer()
self.timer_boty.timeout.connect(self.move_bot)
self.timer_boty.start(500)
self.textbox = QtWidgets.QGraphicsTextItem()
self.textbox.setPos(
QtCore.QPointF(self.rect_width * (self.map_height + 1.5),
self.rect_width * 3))
self.textbox.setPlainText("Score = " + str(self.score))
self.scene.addItem(self.textbox)
def mousePressEvent(self, event):
""" Start mouse pan or zoom mode.
"""
scenePos = self.mapToScene(event.pos())
if event.button() == Qt.LeftButton:
if self.canPan and self.helper_bool:
self.setDragMode(QGraphicsView.RubberBandDrag)
elif self.canPan and self.helper_bool2:
self.setDragMode(QGraphicsView.ScrollHandDrag)
self.start = scenePos
#QGraphicsView.mouseMoveEvent(self,event)
#self.setMouseTracking(True)
elif self.canPan and self.helper_bool3:
self.setDragMode(QGraphicsView.ScrollHandDrag)
self.start2 = scenePos
self.leftMouseButtonPressed.emit(scenePos.x(), scenePos.y())
# self.cursorStartPosition = self.leftMouseButtonPressed.emit(scenePos.x(), scenePos.y())
# self.start = QPoint(self.cursorStartPosition.x(),self.cursorStartPosition.y())
elif event.button() == Qt.RightButton:
if self.canZoom:
self.setDragMode(QGraphicsView.RubberBandDrag)
self.rightMouseButtonPressed.emit(scenePos.x(), scenePos.y())
QGraphicsView.mousePressEvent(self, event)
def __init__(self):
QGraphicsView.__init__(self)
# Image is displayed as a QPixmap in a QGraphicsScene attached to this QGraphicsView.
self.scene = QGraphicsScene()
self.setScene(self.scene)
self.rectgroup = QGraphicsItemGroup()
self.linegroup =QGraphicsItemGroup()
self.linegroup2 =QGraphicsItemGroup()
self._pixmapHandle = None
self.canZoom = True
self.canPan = True
self.zoomStack = []
self.aspectRatioMode = Qt.KeepAspectRatio
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.begin = QPoint()
self.end = QPoint()
self.helper_bool = False
self.helper_bool2 = False
self.helper_bool3 = False
self.rect =QGraphicsRectItem()
self.line = QGraphicsLineItem()
self.line2 = QGraphicsLineItem()
def createGraphicView(self):
self.scene = QGraphicsScene()
self.greenBrush = QBrush(Qt.green)
self.grayBrush = QBrush(Qt.gray)
self.pen = QtGui.QPen(QtGui.QColor(0, 0, 0))
self.pen.setWidth(3)
graphicView = QGraphicsView(self.scene, self)
graphicView.setGeometry(50, 150, 1000, 600)
# osobna scena zeby wyswietlic zdjecie korzystajac QGraphicsItem
self.scene_img = QGraphicsScene()
graphicView_img = QGraphicsView(self.scene_img, self)
graphicView_img.setGeometry(1000, 10, 120, 120)
self.shapes()
def main():
app = QApplication(sys.argv)
grview = QGraphicsView()
scene = QGraphicsScene()
scene.setSceneRect(0, 0, 680, 459)
scene.addPixmap(QPixmap('01.png'))
grview.setScene(scene)
item = GraphicsRectItem(0, 0, 300, 150)
scene.addItem(item)
grview.fitInView(scene.sceneRect(), Qt.KeepAspectRatio)
grview.show()
sys.exit(app.exec_())
def mousePressEvent(self, event):
""" Start mouse pan or zoom mode.
"""
self.activated.emit()
scenePos = self.mapToScene(event.pos())
mods = event.modifiers()
if event.button() == Qt.LeftButton:
(x, y) = self.clipScenePos(scenePos)
#used from area selection and pen drawing,
if (self.panEnabled and not (mods & Qt.ShiftModifier)) or (mods & Qt.ControlModifier):
self.setDragMode(QGraphicsView.ScrollHandDrag)
elif self.tools.tool == "MATCH":
self.tools.leftPressed(x, y, mods)
elif mods & Qt.ShiftModifier:
self.dragSelectionStart = [x, y]
self.logfile.info("[SELECTION][DRAG] Selection starts..")
else:
self.tools.leftPressed(x, y)
#self.leftMouseButtonPressed.emit(clippedCoords[0], clippedCoords[1])
# PANNING IS ALWAYS POSSIBLE WITH WHEEL BUTTON PRESSED (!)
# if event.button() == Qt.MiddleButton:
# self.setDragMode(QGraphicsView.ScrollHandDrag)
if event.button() == Qt.RightButton:
clippedCoords = self.clipScenePos(scenePos)
self.rightMouseButtonPressed.emit(clippedCoords[0], clippedCoords[1])
QGraphicsView.mousePressEvent(self, event)
def initUI(self):
self.setWindowTitle(self.tr("Game of Life"))
self.setLayout(QVBoxLayout())
self.layout().setSpacing(0)
self.layout().setContentsMargins(0, 0, 0, 0)
self.comboBox = QComboBox()
self.comboBox.addItems(self.games.keys())
self.comboBox.currentTextChanged.connect(self.gameEvent)
self.layout().addWidget(self.comboBox)
self.scene = QGraphicsScene()
self.item = None
self.view = QGraphicsView(self.scene)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setSizePolicy(
QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred))
self.view.setFrameShape(QFrame.NoFrame)
self.layout().addWidget(self.view)
self.tickEvent(QImage())
self.view.fitInView(self.item, Qt.KeepAspectRatioByExpanding)
self.comboBox.setCurrentText(random.choice(list(self.games.keys())))
class VideoPlayerWidget(QWidget):
def __init__(self, parent=None):
super(VideoPlayerWidget, self).__init__(parent)
self.scene = QGraphicsScene(self)
self.scene.setBackgroundBrush(QBrush(QColor(0, 0, 0, 255)))
self.graphics_view = QGraphicsView(self.scene)
self.graphics_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setFrameStyle(0)
self.graphics_view.setStyleSheet(
"QGraphicsView {background: transparent; border: 3px; outline: none;}"
)
self.video_item = QGraphicsVideoItem()
self.scene.addItem(self.video_item)
self.layout = QVBoxLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.graphics_view)
self.media_player = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.media_player.setVideoOutput(self.video_item)
self.video_need_replay = False
self.video_seek_durcation = 3000 # in milliseconds
def resizeEvent(self, event):
self.video_item.setSize(
QSizeF(event.size().width(),
event.size().height()))
QWidget.resizeEvent(self, event)
def play(self, url):
self.media_player.setMedia(QMediaContent(QUrl.fromLocalFile(url)))
self.media_player.play()
def seek_forward(self):
video_position = self.media_player.position()
self.media_player.setPosition(video_position +
self.video_seek_durcation)
def seek_backward(self):
video_position = self.media_player.position()
self.media_player.setPosition(
max(video_position - self.video_seek_durcation, 0))
class MyMainWindow(QMainWindow):
# call constructor of MyMainWindow
def __init__(self, parent=None):
# call constructor of QMainWindow
super(MyMainWindow, self).__init__(parent)
w = 1000
h = 800
self.scene = QGraphicsScene(-w/2, -h/2, w, h)
self.view = QGraphicsView()
# set QGraphicsView attributes
# self.view.setViewport(QOpenGLWidget())
self.view.setRenderHints(QtGui.QPainter.Antialiasing |
QPainter.HighQualityAntialiasing)
self.view.setViewportUpdateMode(QGraphicsView.FullViewportUpdate)
self.view.setScene(self.scene)
# set central widget for the application
self.setCentralWidget(self.view)
# add items to the scene
self.addGraphicsItem((0, 0, 250, 250), 8.0, (255, 0, 0), (0, 0, 255), 'My first item')
self.addGraphicsItem((-250, -250, 300, 200), 4.0, (0, 0, 0), (255, 0, 100), 'My 2nd item')
self.addGraphicsItem((200, -200, 200, 200), 10.0, (0, 0, 255), (0, 255, 100), 'My 3rd item')
def addGraphicsItem(self, rect, pw, pc, bc, tooltip):
pen = QtGui.QPen(QtCore.Qt.SolidLine)
pen.setColor(QtGui.QColor(pc[0], pc[1], pc[2], 255))
pen.setWidth(pw)
brush = QtGui.QBrush(QtGui.QColor(bc[0], bc[1], bc[2], 255))
item = GraphicsItem(rect, pen, brush, tooltip)
self.scene.addItem(item)
def mousePressEvent(self, event):
#print 'from MainWindow'
pass
def keyPressEvent(self, event: QtGui.QKeyEvent):
key = event.key()
if key == QtCore.Qt.Key_Escape:
sys.exit(QApplication.quit())
else:
self.view.keyPressEvent(event)
def __init_ui(self):
"""
Function initializes User Interface and Map view.
:return:
"""
self.scene = QGraphicsScene(0, 0, WINDOW_HEIGHT, WINDOW_WIDTH)
self.view = QGraphicsView(self.scene)
self.draw_board()
self.setScene(self.scene)
self.timer.timeout.connect(self.update)
self.timer.start(10)
self.timer_bots = QTimer()
self.timer_bots.timeout.connect(self.move_bot)
self.timer_bots.start(200)
self.items = self.scene.items()
class MainGUI(QMainWindow):
def __init__(self):
super(MainGUI, self).__init__()
self.initUI()
def initUI(self):
# right panel
rightLayout = QVBoxLayout()
gridLayout = QGridLayout()
rightPanel = QWidget()
rightPanel.setLayout(rightLayout)
# Add the panel to a dock for flexibility
rightDock = QDockWidget("Control Panel", self)
rightDock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
rightDock.setWidget(rightPanel)
self.addDockWidget(Qt.RightDockWidgetArea, rightDock)
# The main widget
self.view = QGraphicsView()
self.view.scale(1, -1)
self.view.centerOn(0, 0)
self.scene = InteractiveScene(self) # QGraphicsScene(self)
self.scene.setBackgroundBrush(QBrush(Qt.white, Qt.SolidPattern))
# Add the axes
self.scene.addLine(0, 0, 1000, 0)
self.scene.addLine(0, 0, 0, 1000)
test_geo = Spline([[0, 0], [100, 100], [0, 150], [50, 200]])
test_item = SplineItem(test_geo)
# test_item = PolylineItem([[0, 0], [100, 0], [100, 100], [0, 100]])
# test_item = RectItem(5, 5, 55, 55)
# test_item = CircleItem(200, 200, 50)
# test_item = RingItem(200, 200, 50, 100)
self.scene.addItem(test_item)
self.view.setScene(self.scene)
self.setCentralWidget(self.view)
# Menus, status bar, tool bar and stuff
exitAction = QAction(QtGui.QIcon.fromTheme('application-exit'), 'Exit',
self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.close)
self.statusBar().showMessage('Hi there!')
self.toolbar = self.addToolBar('Exit')
self.toolbar.addAction(exitAction)
self.setGeometry(0, 0, 1200, 800)
self.setWindowTitle('SimpleUI 1.0')
self.showMaximized()
def __init__(self, parent=None):
super(VideoPlayer, self).__init__(parent)
self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface)
self.videoItem = QGraphicsVideoItem()
self.videoItem.setSize(QSizeF(640, 480))
scene = QGraphicsScene(self)
graphicsView = QGraphicsView(scene)
scene.addItem(self.videoItem)
rotateSlider = QSlider(Qt.Horizontal)
rotateSlider.setRange(-180, 180)
rotateSlider.setValue(0)
rotateSlider.valueChanged.connect(self.rotateVideo)
openButton = QPushButton("Open...")
openButton.clicked.connect(self.openFile)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.positionSlider = QSlider(Qt.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
controlLayout.addWidget(openButton)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.positionSlider)
layout = QVBoxLayout()
layout.addWidget(graphicsView)
layout.addWidget(rotateSlider)
layout.addLayout(controlLayout)
self.setLayout(layout)
self.mediaPlayer.setVideoOutput(self.videoItem)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
class CameraWidget(QWidget):
def __init__(self, background_color):
QWidget.__init__(self)
self.scene = QGraphicsScene(self)
self.scene.setBackgroundBrush(QBrush(background_color))
self.graphics_view = QGraphicsView(self.scene)
self.graphics_view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.graphics_view.setFrameStyle(QFrame.NoFrame)
self.graphics_view.scale(-1, 1) # this make live video from camero mirror.
self.video_item = QGraphicsVideoItem()
self.scene.addItem(self.video_item)
self.layout = QVBoxLayout(self)
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.graphics_view)
self.available_cameras = QCameraInfo.availableCameras()
# Set the default camera.
self.select_camera(0)
def resizeEvent(self, event):
self.video_item.setSize(QSizeF(event.size().width(), event.size().height()))
QWidget.resizeEvent(self, event)
def select_camera(self, i):
self.camera = QCamera(self.available_cameras[i])
self.camera.setViewfinder(self.video_item)
self.camera.setCaptureMode(QCamera.CaptureStillImage)
self.camera.start()
def take_photo(self, camera_save_path):
image_capture = QCameraImageCapture(self.camera)
save_path = str(Path(os.path.expanduser(camera_save_path)))
photo_path = os.path.join(save_path, "EAF_Camera_Photo_" + time.strftime("%Y-%m-%d_%H:%M:%S", time.localtime(int(time.time()))))
image_capture.capture(photo_path)
self.message_to_emacs.emit("Captured Photo at " + photo_path)
def stop_camera(self):
self.camera.stop()
def __init__(self):
super().__init__()
self.title = "PyQt5 QGraphicView"
self.top = 200
self.left = 500
#self.width = 600
#self.height = 500
#self.setWindowIcon(QtGui.QIcon("icon.png"))
self.setWindowTitle(self.title)
self.scene = QGraphicsScene()
self.pen = QPen(Qt.red)
self.whiteBrush = QBrush(Qt.white)
graphicView = QGraphicsView(self.scene, self)
graphicView.setMouseTracking(True)
graphicView.viewport().installEventFilter(self)
self.setCentralWidget(graphicView)
img = Image.open('KarlaOnMyShoulder.jpg')
self.imgQ = ImageQt.ImageQt(img) # we need to hold reference to imgQ, or it will crash
pixMap = QPixmap.fromImage(self.imgQ)
#pixMapItem = Canvas(pixMap)
pixMapItem = pixArrayItem(self.imgQ)
w = pixMap.width()
h = pixMap.height()
graphicView.setGeometry(0,0,w +10,h +10)
#graphicView.scale(.75, .75)
self.width = w
self.height = h
#pixMap.scaled(w*.75,h*.75, Qt.KeepAspectRatio)
self.scene.addItem(pixMapItem)
#displayWindow = QRectF(self.top + 10, self.left + 10,
# self.width - 10, self.height - 10)
self.setGeometry(self.left, self.top, self.width + 100, self.height + 100)
self.show()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.clubinfo = QFormLayout()
# create widgets
self.name_field = QLabel(self)
self.members_field = QLabel(self)
self.president_field = QLabel(self)
self.balance_field = QLabel(self)
self.time_field = QLabel(self)
self.location_field = QLabel(self)
self.openbtn = QPushButton(self)
self.new_clubs_lbl = QLabel(self)
self.active_clubs_lbl = QLabel(self)
self.new_clubs_list = QListView(self)
self.active_clubs_list = QListView(self)
self.clubimage = QPixmapLabel(self)
self.presidentview = QGraphicsView(self)
# create layouts
self.clubinfo.addRow("Name", self.name_field)
self.clubinfo.addRow("Members", self.members_field)
self.clubinfo.addRow("Club President", self.president_field)
self.clubinfo.addRow("Weekly Balance", self.balance_field)
self.clubinfo.addRow("Time", self.time_field)
self.clubinfo.addRow("Location", self.location_field)
grid = QGridLayout(self)
grid.addWidget(self.new_clubs_lbl, 0, 0)
grid.addWidget(self.new_clubs_list, 1, 0, 10, 1)
grid.addWidget(self.clubimage, 12, 0, 10, 1)
grid.addWidget(self.openbtn, 10, 1)
grid.addLayout(self.clubinfo, 12, 1, 10, 1)
grid.addWidget(self.active_clubs_lbl, 0, 2)
grid.addWidget(self.active_clubs_list, 1, 2, 10, 1)
grid.addWidget(self.presidentview, 12, 2, 10, 1)
for row in range(12, 22):
grid.setRowStretch(row, 10)
grid.setColumnStretch(0, 2)
grid.setColumnStretch(1, 1)
grid.setColumnStretch(2, 2)
# configure widgets
self.retranslateUi()
class DenseWindow(QMainWindow):#define new class derivated from QMAinWindow class
def __init__(self):#initialisation function
super().__init__()#attributes QMainWindow properties to the object
screen = QApplication.desktop()
screen_size = screen.screenGeometry()
self.title="Dense Viewer"
self.left=50
self.top=50
self.width= screen_size.width()
self.height=screen_size.height()
self.zoom = 1
self.model = load_model('yacka_recsys_reg.h5')
self.initUI()
def initUI(self):
self.setGeometry(self.left,self.top,self.width,self.height)
#--------Graphic scene & view--------
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene, self)
self.painter = QPainter()
self.painter.begin(self.view)
self.view.setStyleSheet("background-color: rgb(250, 250, 250)")
self.view.setDragMode(QGraphicsView.RubberBandDrag)
self.setCentralWidget(self.view)
self.setWindowTitle(self.title)
self.showModel(self.model)
self.show()
def showModel(self, model):
weights = model.get_weights()
max_nb_of_node = max([len(layer) for layer in weights])
for x in range(1, len(weights), 2):
layer = weights[x]
for y, weight in enumerate(layer):
new_state = State(0, str(round(weight, 4)))
new_state.setPos(x*75, y*75 + (max_nb_of_node-len(layer))*75/2)
self.scene.addItem(new_state)
def wheelEvent(self, event):
'''Zoom In/Out with CTRL + mouse wheel'''
if event.modifiers() == Qt.ControlModifier:
self.zoom = math.pow(2.0, -event.angleDelta().y() / 240.0)
self.view.scale(self.zoom, self.zoom)
print("wheelEvent")
else:
return QGraphicsView.wheelEvent(self, event)
print("wheelEvent2")
def __init__(self, parent=None):
"""
It creates main window of the application. Kakuro model isn't initiali-
zed here, though.
"""
super(MainWindow, self).__init__(parent)
self.scene = QGraphicsScene(self)
self.view = QGraphicsView(self.scene)
self.setCentralWidget(self.view)
self.model = None
self.openAction \
= QAction(QIcon(':/icons/open.png'), 'Open file', self)
self.openAction.setShortcut(QKeySequence.Open)
self.openAction.triggered.connect(self._loadFromFile)
self.solveAction \
= QAction(QIcon(':/icons/solve.png'), 'Solve automatically', self)
self.solveAction.triggered.connect(self._solve)
self.solveAction.setEnabled(False)
self.rawHeuristicAction \
= QAction(QIcon(':/icons/1.png'), 'Raw heuristic', self)
self.rawHeuristicAction.triggered.connect(self._rawHeuristic)
self.rawHeuristicAction.setEnabled(False)
self.contextSolutionsHeuristicAction \
= QAction(QIcon(':/icons/2.png'), 'Context solutions heuristic',
self)
self.contextSolutionsHeuristicAction.triggered.connect(
self._contextSolutionsHeuristic)
self.contextSolutionsHeuristicAction.setEnabled(False)
self.generalizedRepetitionHeuristicAction \
= QAction(QIcon(':/icons/3.png'),
'Generalized repetition heuristic', self)
self.generalizedRepetitionHeuristicAction.triggered.connect(
self._generalizedRepetitionHeuristic)
self.generalizedRepetitionHeuristicAction.setEnabled(False)
self.toolBar = QToolBar('toolbar', self)
self.addToolBar(self.toolBar)
self.toolBar.addAction(self.openAction)
self.toolBar.addAction(self.solveAction)
self.toolBar.addAction(self.rawHeuristicAction)
self.toolBar.addAction(self.contextSolutionsHeuristicAction)
self.toolBar.addAction(self.generalizedRepetitionHeuristicAction)
def mousePressEvent(self, event: QMouseEvent) -> None:
"""
:param event:
:return:
"""
if self.gadget == ToolsToolBar.BrowserImageTool:
self.setCursor(Qt.ClosedHandCursor)
self.is_mouse_pressed = True
event.accept()
return
if self.gadget == ToolsToolBar.EraserTool:
self.eraser_action(event.pos())
event.accept()
return
self.last_cursor_pos = event.pos()
pressed_item = self.scene().itemAt(self.mapToScene(event.pos()),
self.transform())
if not self.is_creating_polygon and isinstance(pressed_item,
SelectionItem):
QGraphicsView.mousePressEvent(self, event)
return
if isinstance(pressed_item, OutlineItem):
self._mark_item_manager.set_selected_item(pressed_item)
if self.gadget == ToolsToolBar.MoveImageTool:
self.is_mouse_pressed = True
event.accept()
return
if event.button() == Qt.LeftButton:
if self.gadget == ToolsToolBar.RectangleTool or self.gadget == ToolsToolBar.PolygonTool:
self.about_to_create_border.emit(event.globalPos())
if self.gadget == ToolsToolBar.PolygonTool:
self.creating_polygon(event.pos())
else:
self.is_mouse_pressed = True
self.clicked_time = time.time()
else:
QGraphicsView.mousePressEvent(self, event)
elif event.button() == Qt.RightButton:
if self.is_creating_polygon:
self.scene().removeItem(self.border)
self.border = None
self.is_creating_polygon = False
self.polygon_points = []
else:
QGraphicsView.mousePressEvent(self, event)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.__videoReader = VideoLoadingManager()
lay = QGridLayout(self)
gv = QGraphicsView()
lay.addWidget(gv)
scene = QGraphicsScene(self)
gv.setScene(scene)
gv.setContentsMargins(0, 0, 0, 0)
self.pixmap_item = QGraphicsPixmapItem()
self.player = QtMultimedia.QMediaPlayer(None,
QMediaPlayer.VideoSurface)
# self.player.setPlaybackRate(0.925)
scene.addItem(self.pixmap_item)
gv.fitInView(scene.itemsBoundingRect(), QtCore.Qt.KeepAspectRatio)
self.workerThread = QtCore.QThread()
self.__videoReader.moveToThread(self.workerThread)
self.workerThread.finished.connect(self.__videoReader.deleteLater)
self.workerThread.started.connect(self.__videoReader.loadingImgs)
self.__videoReader.imageChanged.connect(self.setImage)
self.colorPaleteCallback = None
def __init__(self, map_file, cell, settings):
super().__init__()
self.setWindowTitle('Карта')
self.setModal(True)
size = settings.value('dialogs/map').split(' ')
self.setFixedSize(int(size[0]), int(size[1]))
self.cell = cell
reader = SvgReader(map_file)
scene = QGraphicsScene()
scene.setSceneRect(reader.get_size())
coord = settings.value('map/{}'.format(cell)).split(' ')
for rect in reader.get_elements(coord[0], int(coord[1])):
scene.addItem(rect)
layout = QVBoxLayout(self)
layout.addWidget(QGraphicsView(scene))
def __init__(self, parent):
super().__init__(parent)
self.uas = None
svgRenderer = QSvgRenderer('res/barometer.svg')
bkgnd = QGraphicsSvgItem()
bkgnd.setSharedRenderer(svgRenderer)
bkgnd.setCacheMode(QGraphicsItem.NoCache)
bkgnd.setElementId('background')
scene = QGraphicsScene()
scene.addItem(bkgnd)
scene.setSceneRect(bkgnd.boundingRect())
self.needle = QGraphicsSvgItem()
self.needle.setSharedRenderer(svgRenderer)
self.needle.setCacheMode(QGraphicsItem.NoCache)
self.needle.setElementId('needle')
self.needle.setParentItem(bkgnd)
self.needle.setPos(
bkgnd.boundingRect().width() / 2 -
self.needle.boundingRect().width() / 2,
bkgnd.boundingRect().height() / 2 -
self.needle.boundingRect().height() / 2)
self.needle.setTransformOriginPoint(
self.needle.boundingRect().width() / 2,
self.needle.boundingRect().height() / 2)
# textElement = svgRenderer.boundsOnElement('needle-text')
self.digitalBaro = QGraphicsTextItem()
self.digitalBaro.setDefaultTextColor(QColor(255, 255, 255))
self.digitalBaro.document().setDefaultTextOption(
QTextOption(Qt.AlignCenter))
self.digitalBaro.setFont(QFont('monospace', 13, 60))
self.digitalBaro.setParentItem(bkgnd)
txm = QTransform()
txm.translate(
bkgnd.boundingRect().center().x(),
bkgnd.boundingRect().height() -
1.5 * self.digitalBaro.document().size().height())
self.digitalBaro.setTransform(txm, False)
view = QGraphicsView(scene)
view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
layout = QVBoxLayout()
layout.addWidget(view)
self.setLayout(layout)
self.setBarometer(1000)
class Window(QMainWindow):
def __init__(self):
super().__init__()
self.title = "QPainter polygon"
self.top = 100
self.left = 100
self.width = 680
self.height = 500
self.InitWindow()
def InitWindow(self):
self.button1 = QPushButton("Rotate - ", self)
self.button1.setGeometry(200, 420, 100, 50)
self.button1.clicked.connect(self.rotateminus)
self.button2 = QPushButton("Rotate +", self)
self.button2.setGeometry(320, 420, 100, 50)
self.button2.clicked.connect(self.rotateplus)
scene = QGraphicsScene() #the scene
redbrush = QBrush(Qt.red)
bluebrush = QBrush(Qt.blue)
blackpen = QPen(Qt.black)
blackpen.setWidth(7)
ellipse = scene.addEllipse(10, 10, 200, 200, blackpen, redbrush)
rect = scene.addRect(-100, -100, 200, 200, blackpen, bluebrush)
line = scene.addLine(-100, -100, 200, 200, blackpen)
ellipse.setFlag(QGraphicsItem.ItemIsMovable)
rect.setFlag(QGraphicsItem.ItemIsMovable)
line.setFlag(QGraphicsItem.ItemIsMovable)
self.view = QGraphicsView(scene, self)
self.view.setGeometry(0, 0, 680, 400)
self.setWindowIcon(QtGui.QIcon("mongol.jpg"))
self.setWindowTitle(self.title)
self.setGeometry(self.top, self.left, self.width, self.height)
self.show()
def rotateminus(self):
self.view.rotate(-10)
def rotateplus(self):
self.view.rotate(+10)
def createGraphicsView(parent: QWidget = None, scene: QGraphicsScene = None, fixedSize: QSize = None):
"""
创建QGraphicsView，关联QGraphicsScene，用于显示画布
:param parent: 父窗口
:param scene: QGraphicsScene 场景 QGraphicsItem对象的容器
:param fixedSize: 固定大小
:return: QGraphicsView
"""
qGraphicsView = QGraphicsView(parent)
if scene:
qGraphicsView.setScene(scene)
if fixedSize:
qGraphicsView.setFixedSize(fixedSize)
return qGraphicsView
def _setup_ign_pt_map_lgnd(self):
colors = self._ign_pt_editor.colors()
fuel_types = self._ign_pt_editor.fuel_types()
assert len(colors) == len(
fuel_types), "Length of colors != length of fuel_types"
# Create the ignition point legend
res_label = QLabel()
res_label.setText('Resolution')
res_label.setFixedSize(65, 20)
self._ign_pt_type_grid_layout.addWidget(res_label, 0, 0)
res = QLabel()
res.setText(str(self._ign_pt_editor.resolution()) + 'm')
res.setMaximumSize(35, 10)
self._ign_pt_type_grid_layout.addWidget(res, 0, 1)
for i in range(len(colors)):
legend_label = QLabel()
legend_label.setText(fuel_types[i])
self._ign_pt_type_grid_layout.addWidget(legend_label, i + 1, 0)
legend_label.setFixedSize(65, 20)
g_view = QGraphicsView()
pallete = g_view.palette()
pallete.setColor(g_view.backgroundRole(), colors[i])
g_view.setPalette(pallete)
g_view.setMaximumSize(25, 10)
self._ign_pt_type_grid_layout.addWidget(g_view, i + 1, 1)
self.ignition_point_map_legend_scroll_area.setWidget(
self._ign_pt_type_grid_layout_widget)
self.ignition_point_legend_tab.setEnabled(True)
class Window(QMainWindow):
def __init__(self):
super().__init__()
self.title = "PyQt5 Window"
self.top = 100
self.left = 100
self.width = 680
self.height = 500
self.InitWindow()
def InitWindow(self):
self.button1 = QPushButton("Rotate - ", self)
self.button1.setGeometry(200,420,100,50)
self.button1.clicked.connect(self.rotateMinus)
self.button2 = QPushButton("Rotate +", self)
self.button2.setGeometry(400,420,100,50)
self.button2.clicked.connect(self.rotatePlus)
scene = QGraphicsScene(self)
redBrush = QBrush(Qt.red)
blueBrush = QBrush(Qt.blue)
blackPen = QPen(Qt.black)
blackPen.setWidth(7)
ellipse = scene.addEllipse(10,10,200,200, blackPen, redBrush)
rect = scene.addRect(-100,-100,200,200, blackPen, blueBrush)
ellipse.setFlag(QGraphicsItem.ItemIsMovable) # set it to movable
rect.setFlag(QGraphicsItem.ItemIsMovable)
self.view = QGraphicsView(scene, self)
self.view.setGeometry(0,0,680,400)
self.setWindowTitle(self.title)
self.setGeometry(self.top, self.left, self.width, self.height)
self.setWindowIcon(QtGui.QIcon('./icon/icon.png'))
self.show()
def rotateMinus(self):
self.view.rotate(-10)
def rotatePlus(self):
self.view.rotate(10)
def getAll(self, filter={}):
self.tableWidget.clear()
try:
data = self.parent.db.get(filter)
self.tableWidget.setRowCount(len(data))
self.tableWidget.setColumnCount(5)
self.tableWidget.setHorizontalHeaderLabels(
["Resim", "Ad", "Soyad", "No"])
iz = 0
for i in data:
ad = QTableWidgetItem(i[1])
soyad = QTableWidgetItem(i[2])
no = QTableWidgetItem(i[3])
gp = QGraphicsScene(self)
resim = QGraphicsView(gp)
resim.setFixedHeight(100)
resim.setFixedWidth(100)
if i[8] is not None:
gp.addPixmap(QPixmap("db/%s" % i[8]))
resim.show()
self.tableWidget.setCellWidget(iz, 0, resim)
btn = QPushButton(self)
btn.setText("Göster")
btn.data = i
btn.clicked.connect(self.showogrenci)
self.tableWidget.setItem(iz, 1, ad)
self.tableWidget.setItem(iz, 2, soyad)
self.tableWidget.setItem(iz, 3, no)
self.tableWidget.setCellWidget(iz, 4, btn)
self.tableWidget.setRowHeight(iz, 100)
iz += 1
except Exception as e:
print(e)
def update_pics_with_path(self):
self.lineDic.setText(self.FolderPath)
self.picsPaths=self.filterImgs(self.picsPaths)
widget=QWidget()
layout = QGridLayout()
widget.setLayout(layout)
rows = int((len(self.picsPaths)/3))
if (len(self.picsPaths)%3) > 0:
rows+=1
posis = [(j,k) for k in range(3) for j in range(rows)]
for pos,picPath,i in zip(posis,self.picsPaths,range(len(self.picsPaths))):
#print()
picView = QGraphicsView(objectName = "img"+str(i))
picView.setToolTip(self.FolderPath+"/"+picPath)
layout.addWidget(picView,*pos)
scene = QGraphicsScene()
if QPixmap(self.FolderPath+"/"+picPath).isNull() != True:
scene.addPixmap(QPixmap(self.FolderPath+"/"+picPath).scaled(140, 140, Qt.KeepAspectRatio))
else:
print(picPath)
scene.addText("Bild konnte nicht\ngeladen werden",QFont("Times", 10))
picView.setScene(scene)
picView.setFixedSize(150,150)
layout.setVerticalSpacing(10)
self.scroll.setWidget(widget)
i = 0
while self.scroll.findChild(QGraphicsView,"img"+str(i)) != None:
self.scroll.findChild(QGraphicsView,"img"+str(i)).mouseReleaseEvent=functools.partial(self.buttonReleased,i)
i +=1
def __init__(self, conf, defeat):
self.config = conf
super().__init__()
self.setWindowTitle(conf.get_text('victory'))
self.setFixedSize(QSize(640, 480))
self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.WindowTitleHint | Qt.FramelessWindowHint)
button = QPushButton(conf.get_text('close'), self)
button.setCheckable(True)
button.setFixedSize(QSize(640, 30))
button.move(0, 450)
# noinspection PyUnresolvedReferences
button.clicked.connect(self.close)
result_output = QTextEdit(self)
result_output.setReadOnly(True)
result_output.setFixedSize(QSize(640, 200))
result_output.move(0, 250)
result_output.setLineWrapMode(QTextEdit.NoWrap)
result_output.insertHtml(self.generate_result_text())
gview = QGraphicsView(self)
scene = QGraphicsScene()
if defeat:
img = conf.theme_selected.get_defeat_pixmap()
text = conf.get_text('defeat')
else:
img = conf.theme_selected.get_victory_pixmap()
text = conf.get_text('victory')
scene.addPixmap(img.scaled(QSize(640, 220)))
gview.move(0, 30)
gview.setScene(scene)
label_title = QLabel(self)
label_title.setText(text)
label_title.setFixedSize(QSize(640, 30))
label_title.setAlignment(Qt.AlignCenter)
label_title.setFont(self.get_font_title())
