def dropEvent(self, event): if event.mimeData().hasText(): mime = event.mimeData() pieces = mime.text().split() position = event.pos() hotSpot = QPoint() hotSpotPos = mime.data('application/x-hotspot').split(' ') if len(hotSpotPos) == 2: hotSpot.setX(hotSpotPos[0].toInt()[0]) hotSpot.setY(hotSpotPos[1].toInt()[0]) for piece in pieces: newLabel = DragLabel(piece, self) newLabel.move(position - hotSpot) newLabel.show() position += QPoint(newLabel.width(), 0) if event.source() in self.children(): event.setDropAction(Qt.MoveAction) event.accept() else: event.acceptProposedAction() else: event.ignore()
def getPosPopup(self): pos = self.pos() pos1 = self.mapToGlobal(pos) pos2 = QPoint() cRect = self.cursorRect() pos2.setX(cRect.x()) pos2.setY(cRect.y()) return pos1 + pos2
def mouseReleaseEvent(self, event): if event.button() == Qt.LeftButton: self.pixmapOffset += event.pos() - self.lastDragPos self.lastDragPos = QPoint() deltaX = (self.width() - self.pixmap.width()) / 2 - self.pixmapOffset.x() deltaY = (self.height() - self.pixmap.height()) / 2 - self.pixmapOffset.y() self.scroll(deltaX, deltaY)
def __init__(self, parent=None): super(MandelbrotWidget, self).__init__(parent) self.thread = RenderThread() self.pixmap = QPixmap() self.pixmapOffset = QPoint() self.lastDragPos = QPoint() self.centerX = DefaultCenterX self.centerY = DefaultCenterY self.pixmapScale = DefaultScale self.curScale = DefaultScale self.thread.renderedImage.connect(self.updatePixmap) self.setWindowTitle("Mandelbrot") self.setCursor(Qt.CrossCursor) self.resize(550, 400)
def updatePixmap(self, image, scaleFactor): if not self.lastDragPos.isNull(): return self.pixmap = QPixmap.fromImage(image) self.pixmapOffset = QPoint() self.lastDragPosition = QPoint() self.pixmapScale = scaleFactor self.update()
def mouseMoveEvent(self, event): dx = event.x() - self.lastPos.x() dy = event.y() - self.lastPos.y() if event.buttons() & Qt.LeftButton: self.setXRotation(self.xRot + 8 * dy) self.setYRotation(self.yRot + 8 * dx) elif event.buttons() & Qt.RightButton: self.setXRotation(self.xRot + 8 * dy) self.setZRotation(self.zRot + 8 * dx) self.lastPos = QPoint(event.pos())
def test_add_notification(self): with patch("PySide2.QtWidgets.QToolTip.showText") as show_text: icon = ExclamationIcon(None) icon.add_notification("Please note!") icon.hoverEnterEvent(QGraphicsSceneMouseEvent()) show_text.assert_called_once_with(QPoint(0, 0), "<p>Please note!")
def setUp(self): #Acquire resources self.x, self.y = 10, 20 self.neg_x, self.neg_y = -self.x, -self.y self.qpoint = QPoint(self.x, self.y)
class RenderArea(QWidget): points = QPolygon( [QPoint(10, 80), QPoint(20, 10), QPoint(80, 30), QPoint(90, 70)]) Line, Points, Polyline, Polygon, Rect, RoundedRect, Ellipse, Arc, Chord, \ Pie, Path, Text, Pixmap = range(13) def __init__(self, parent=None): super(RenderArea, self).__init__(parent) self.pen = QPen() self.brush = QBrush() self.pixmap = QPixmap() self.shape = RenderArea.Polygon self.antialiased = False self.transformed = False self.pixmap.load(':/images/qt-logo.png') self.setBackgroundRole(QPalette.Base) self.setAutoFillBackground(True) def minimumSizeHint(self): return QSize(100, 100) def sizeHint(self): return QSize(400, 200) def setShape(self, shape): self.shape = shape self.update() def setPen(self, pen): self.pen = pen self.update() def setBrush(self, brush): self.brush = brush self.update() def setAntialiased(self, antialiased): self.antialiased = antialiased self.update() def setTransformed(self, transformed): self.transformed = transformed self.update() def paintEvent(self, event): rect = QRect(10, 20, 80, 60) path = QPainterPath() path.moveTo(20, 80) path.lineTo(20, 30) path.cubicTo(80, 0, 50, 50, 80, 80) startAngle = 30 * 16 arcLength = 120 * 16 painter = QPainter(self) painter.setPen(self.pen) painter.setBrush(self.brush) if self.antialiased: painter.setRenderHint(QPainter.Antialiasing) for x in range(0, self.width(), 100): for y in range(0, self.height(), 100): painter.save() painter.translate(x, y) if self.transformed: painter.translate(50, 50) painter.rotate(60.0) painter.scale(0.6, 0.9) painter.translate(-50, -50) if self.shape == RenderArea.Line: painter.drawLine(rect.bottomLeft(), rect.topRight()) elif self.shape == RenderArea.Points: painter.drawPoints(RenderArea.points) elif self.shape == RenderArea.Polyline: painter.drawPolyline(RenderArea.points) elif self.shape == RenderArea.Polygon: painter.drawPolygon(RenderArea.points) elif self.shape == RenderArea.Rect: painter.drawRect(rect) elif self.shape == RenderArea.RoundedRect: painter.drawRoundedRect(rect, 25, 25, Qt.RelativeSize) elif self.shape == RenderArea.Ellipse: painter.drawEllipse(rect) elif self.shape == RenderArea.Arc: painter.drawArc(rect, startAngle, arcLength) elif self.shape == RenderArea.Chord: painter.drawChord(rect, startAngle, arcLength) elif self.shape == RenderArea.Pie: painter.drawPie(rect, startAngle, arcLength) elif self.shape == RenderArea.Path: painter.drawPath(path) elif self.shape == RenderArea.Text: painter.drawText(rect, Qt.AlignCenter, "PySide 2\nQt %s" % qVersion()) elif self.shape == RenderArea.Pixmap: painter.drawPixmap(10, 10, self.pixmap) painter.restore() painter.setPen(self.palette().dark().color()) painter.setBrush(Qt.NoBrush) painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
def mousePressEvent(self, event): self.lastPos = QPoint(event.pos())
if isinstance(figure, Rectangle): painter.setBrush(QBrush(Qt.red)) painter.drawRect(figure.x(), figure.y(), figure.width(), figure.height()) continue if isinstance(figure, Ellipse): painter.setBrush(QBrush(Qt.green)) painter.drawEllipse(figure.x(), figure.y(), figure.width(), figure.height()) continue if isinstance(figure, CloseFigure): painter.setBrush(QBrush(Qt.blue)) points = [] for point in figure: points.append(QPoint(point['x'], point['y'])) painter.drawPolygon(points) continue if __name__ == '__main__': app = QApplication(sys.argv) figure_widget = FigureWidget() # Создайте список фигур figures = [] figure_widget.set_figures(figures)
def testPolygonShiftOperators(self): p = QPolygon() self.assertEqual(len(p), 0) p << QPoint(10, 20) << QPoint( 20, 30) << [QPoint(20, 30), QPoint(40, 50)] self.assertEqual(len(p), 4)
class GLWidget(QOpenGLWidget, QOpenGLFunctions): xRotationChanged = Signal(int) yRotationChanged = Signal(int) zRotationChanged = Signal(int) def __init__(self, parent=None): QOpenGLWidget.__init__(self, parent) QOpenGLFunctions.__init__(self) self.core = "--coreprofile" in QCoreApplication.arguments() self.xRot = 0 self.yRot = 0 self.zRot = 0 self.lastPos = 0 self.logo = Logo() self.vao = QOpenGLVertexArrayObject() self.logoVbo = QOpenGLBuffer() self.program = QOpenGLShaderProgram() self.projMatrixLoc = 0 self.mvMatrixLoc = 0 self.normalMatrixLoc = 0 self.lightPosLoc = 0 self.proj = QMatrix4x4() self.camera = QMatrix4x4() self.world = QMatrix4x4() self.transparent = "--transparent" in QCoreApplication.arguments() if self.transparent: fmt = self.format() fmt.setAlphaBufferSize(8) self.setFormat(fmt) def xRotation(self): return self.xRot def yRotation(self): return self.yRot def zRotation(self): return self.zRot def minimumSizeHint(self): return QSize(50, 50) def sizeHint(self): return QSize(400, 400) def normalizeAngle(self, angle): while angle < 0: angle += 360 * 16 while angle > 360 * 16: angle -= 360 * 16 return angle def setXRotation(self, angle): angle = self.normalizeAngle(angle) if angle != self.xRot: self.xRot = angle self.emit(SIGNAL("xRotationChanged(int)"), angle) self.update() def setYRotation(self, angle): angle = self.normalizeAngle(angle) if angle != self.yRot: self.yRot = angle self.emit(SIGNAL("yRotationChanged(int)"), angle) self.update() def setZRotation(self, angle): angle = self.normalizeAngle(angle) if angle != self.zRot: self.zRot = angle self.emit(SIGNAL("zRotationChanged(int)"), angle) self.update() def cleanup(self): self.makeCurrent() self.logoVbo.destroy() del self.program self.program = None self.doneCurrent() def vertexShaderSourceCore(self): return """#version 150 in vec4 vertex; in vec3 normal; out vec3 vert; out vec3 vertNormal; uniform mat4 projMatrix; uniform mat4 mvMatrix; uniform mat3 normalMatrix; void main() { vert = vertex.xyz; vertNormal = normalMatrix * normal; gl_Position = projMatrix * mvMatrix * vertex; }""" def fragmentShaderSourceCore(self): return """#version 150 in highp vec3 vert; in highp vec3 vertNormal; out highp vec4 fragColor; uniform highp vec3 lightPos; void main() { highp vec3 L = normalize(lightPos - vert); highp float NL = max(dot(normalize(vertNormal), L), 0.0); highp vec3 color = vec3(0.39, 1.0, 0.0); highp vec3 col = clamp(color * 0.2 + color * 0.8 * NL, 0.0, 1.0); fragColor = vec4(col, 1.0); }""" def vertexShaderSource(self): return """attribute vec4 vertex; attribute vec3 normal; varying vec3 vert; varying vec3 vertNormal; uniform mat4 projMatrix; uniform mat4 mvMatrix; uniform mat3 normalMatrix; void main() { vert = vertex.xyz; vertNormal = normalMatrix * normal; gl_Position = projMatrix * mvMatrix * vertex; }""" def fragmentShaderSource(self): return """varying highp vec3 vert; varying highp vec3 vertNormal; uniform highp vec3 lightPos; void main() { highp vec3 L = normalize(lightPos - vert); highp float NL = max(dot(normalize(vertNormal), L), 0.0); highp vec3 color = vec3(0.39, 1.0, 0.0); highp vec3 col = clamp(color * 0.2 + color * 0.8 * NL, 0.0, 1.0); gl_FragColor = vec4(col, 1.0); }""" def initializeGL(self): self.context().aboutToBeDestroyed.connect(self.cleanup) self.initializeOpenGLFunctions() self.glClearColor(0, 0, 0, 1) self.program = QOpenGLShaderProgram() if self.core: self.vertexShader = self.vertexShaderSourceCore() self.fragmentShader = self.fragmentShaderSourceCore() else: self.vertexShader = self.vertexShaderSource() self.fragmentShader = self.fragmentShaderSource() self.program.addShaderFromSourceCode(QOpenGLShader.Vertex, self.vertexShader) self.program.addShaderFromSourceCode(QOpenGLShader.Fragment, self.fragmentShader) self.program.bindAttributeLocation("vertex", 0) self.program.bindAttributeLocation("normal", 1) self.program.link() self.program.bind() self.projMatrixLoc = self.program.uniformLocation("projMatrix") self.mvMatrixLoc = self.program.uniformLocation("mvMatrix") self.normalMatrixLoc = self.program.uniformLocation("normalMatrix") self.lightPosLoc = self.program.uniformLocation("lightPos") self.vao.create() vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao) self.logoVbo.create() self.logoVbo.bind() float_size = ctypes.sizeof(ctypes.c_float) self.logoVbo.allocate(self.logo.constData(), self.logo.count() * float_size) self.setupVertexAttribs() self.camera.setToIdentity() self.camera.translate(0, 0, -1) self.program.setUniformValue(self.lightPosLoc, QVector3D(0, 0, 70)) self.program.release() vaoBinder = None def setupVertexAttribs(self): self.logoVbo.bind() f = QOpenGLContext.currentContext().functions() f.glEnableVertexAttribArray(0) f.glEnableVertexAttribArray(1) float_size = ctypes.sizeof(ctypes.c_float) null = VoidPtr(0) pointer = VoidPtr(3 * float_size) f.glVertexAttribPointer(0, 3, int(GL.GL_FLOAT), int(GL.GL_FALSE), 6 * float_size, null) f.glVertexAttribPointer(1, 3, int(GL.GL_FLOAT), int(GL.GL_FALSE), 6 * float_size, pointer) self.logoVbo.release() def paintGL(self): self.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) self.glEnable(GL.GL_DEPTH_TEST) self.glEnable(GL.GL_CULL_FACE) self.world.setToIdentity() self.world.rotate(180 - (self.xRot / 16), 1, 0, 0) self.world.rotate(self.yRot / 16, 0, 1, 0) self.world.rotate(self.zRot / 16, 0, 0, 1) vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao) self.program.bind() self.program.setUniformValue(self.projMatrixLoc, self.proj) self.program.setUniformValue(self.mvMatrixLoc, self.camera * self.world) normalMatrix = self.world.normalMatrix() self.program.setUniformValue(self.normalMatrixLoc, normalMatrix) self.glDrawArrays(GL.GL_TRIANGLES, 0, self.logo.vertexCount()) self.program.release() vaoBinder = None def resizeGL(self, width, height): self.proj.setToIdentity() self.proj.perspective(45, width / height, 0.01, 100) def mousePressEvent(self, event): self.lastPos = QPoint(event.pos()) def mouseMoveEvent(self, event): dx = event.x() - self.lastPos.x() dy = event.y() - self.lastPos.y() if event.buttons() & Qt.LeftButton: self.setXRotation(self.xRot + 8 * dy) self.setYRotation(self.yRot + 8 * dx) elif event.buttons() & Qt.RightButton: self.setXRotation(self.xRot + 8 * dy) self.setZRotation(self.zRot + 8 * dx) self.lastPos = QPoint(event.pos())
def __init__(self, targetImage=None, axeSize=500, layer=None, parent=None): super().__init__(targetImage=targetImage, axeSize=axeSize, layer=layer, parent=parent) graphicsScene = self.scene() ######### # L curve ######### cubic = activeCubicSpline(axeSize) graphicsScene.addItem(cubic) graphicsScene.cubicR = cubic cubic.channel = channelValues.L # get histogram as a Qimage cubic.histImg = graphicsScene.layer.inputImg().histogram(size=graphicsScene.axeSize, bgColor=graphicsScene.bgColor, range=(0, 1), chans=channelValues.L, mode='Lab') # L curve use the default axes cubic.axes = graphicsScene.defaultAxes cubic.initFixedPoints() cubic.axes.setVisible(False) cubic.setVisible(False) ########## # a curve (Green--> Magenta axis) ######### cubic = activeCubicSpline(axeSize) graphicsScene.addItem(cubic) graphicsScene.cubicG = cubic cubic.channel = channelValues.a cubic.histImg = graphicsScene.layer.inputImg().histogram(size=graphicsScene.axeSize, bgColor=graphicsScene.bgColor, range=(-100, 100), chans=channelValues.a, mode='Lab') # add specific axes gradient = QRadialGradient() gradient.setCenter(QPoint(0, 1)) gradient.setRadius(axeSize*1.4) gradient.setColorAt(0.0, Qt.green) gradient.setColorAt(1.0, Qt.magenta) cubic.axes = self.drawPlotGrid(axeSize, gradient) graphicsScene.addItem(cubic.axes) cubic.initFixedPoints() cubic.axes.setVisible(False) cubic.setVisible(False) # b curve (Blue-->Yellow axis) cubic = activeCubicSpline(axeSize) graphicsScene.addItem(cubic) graphicsScene.cubicB = cubic cubic.channel = channelValues.b cubic.histImg = graphicsScene.layer.inputImg().histogram(size=graphicsScene.axeSize, bgColor=graphicsScene.bgColor, range=(-100, 100), chans=channelValues.b, mode='Lab') # add specific axes gradient.setColorAt(0.0, Qt.blue) gradient.setColorAt(1.0, Qt.yellow) cubic.axes = self.drawPlotGrid(axeSize, gradient) graphicsScene.addItem(cubic.axes) cubic.initFixedPoints() cubic.axes.setVisible(False) cubic.setVisible(False) # set current to L curve and axes graphicsScene.cubicItem = graphicsScene.cubicR graphicsScene.cubicItem.setVisible(True) graphicsScene.cubicItem.axes.setVisible(True) # buttons pushButton1 = QPushButton("Reset Current") pushButton1.adjustSize() pushButton1.clicked.connect(self.resetCurve) pushButton2 = QPushButton("Reset All") pushButton2.adjustSize() pushButton2.clicked.connect(self.resetAllCurves) # options options = ['L', 'a', 'b'] self.listWidget1 = optionsWidget(options=options, exclusive=True) self.listWidget1.setMinimumSize(self.listWidget1.sizeHintForColumn(0) + 5, self.listWidget1.sizeHintForRow(0) * len(options) + 5) # selection changed handler curves = [graphicsScene.cubicR, graphicsScene.cubicG, graphicsScene.cubicB] curveDict = dict(zip(options, curves)) def onSelect1(item): cubicItem = self.scene().cubicItem cubicItem.setVisible(False) cubicItem.axes.setVisible(False) self.scene().cubicItem = curveDict[item.text()] self.scene().cubicItem.setVisible(True) self.scene().cubicItem.axes.setVisible(True) # Force to redraw histogram self.scene().invalidate(QRectF(0.0, -self.scene().axeSize, self.scene().axeSize, self.scene().axeSize), QGraphicsScene.BackgroundLayer) self.listWidget1.onSelect = onSelect1 # set initial selection to L item = self.listWidget1.items[options[0]] item.setCheckState(Qt.Checked) self.listWidget1.select(item) self.setWhatsThis("""<b>Lab curves</b><br>""" + self.whatsThis()) def f(): l = graphicsScene.layer l.applyToStack() l.parentImage.onImageChanged() self.scene().cubicR.curveChanged.sig.connect(f) self.scene().cubicG.curveChanged.sig.connect(f) self.scene().cubicB.curveChanged.sig.connect(f) # layout gl = QGridLayout() gl.addWidget(self.listWidget1, 0, 0, 2, 1) for i, button in enumerate([pushButton1, pushButton2]): gl.addWidget(button, i, 1) self.addCommandLayout(gl)
class MandelbrotWidget(QWidget): def __init__(self, parent=None): super(MandelbrotWidget, self).__init__(parent) self.thread = RenderThread() self.pixmap = QPixmap() self.pixmapOffset = QPoint() self.lastDragPos = QPoint() self.centerX = DefaultCenterX self.centerY = DefaultCenterY self.pixmapScale = DefaultScale self.curScale = DefaultScale self.thread.renderedImage.connect(self.updatePixmap) self.setWindowTitle("Mandelbrot") self.setCursor(Qt.CrossCursor) self.resize(550, 400) def paintEvent(self, event): painter = QPainter(self) painter.fillRect(self.rect(), Qt.black) if self.pixmap.isNull(): painter.setPen(Qt.white) painter.drawText(self.rect(), Qt.AlignCenter, "Rendering initial image, please wait...") return if self.curScale == self.pixmapScale: painter.drawPixmap(self.pixmapOffset, self.pixmap) else: scaleFactor = self.pixmapScale / self.curScale newWidth = int(self.pixmap.width() * scaleFactor) newHeight = int(self.pixmap.height() * scaleFactor) newX = self.pixmapOffset.x() + (self.pixmap.width() - newWidth) / 2 newY = self.pixmapOffset.y() + (self.pixmap.height() - newHeight) / 2 painter.save() painter.translate(newX, newY) painter.scale(scaleFactor, scaleFactor) exposed, _ = painter.matrix().inverted() exposed = exposed.mapRect(self.rect()).adjusted(-1, -1, 1, 1) painter.drawPixmap(exposed, self.pixmap, exposed) painter.restore() text = "Use mouse wheel or the '+' and '-' keys to zoom. Press and " \ "hold left mouse button to scroll." metrics = painter.fontMetrics() textWidth = metrics.width(text) painter.setPen(Qt.NoPen) painter.setBrush(QColor(0, 0, 0, 127)) painter.drawRect((self.width() - textWidth) / 2 - 5, 0, textWidth + 10, metrics.lineSpacing() + 5) painter.setPen(Qt.white) painter.drawText((self.width() - textWidth) / 2, metrics.leading() + metrics.ascent(), text) def resizeEvent(self, event): self.thread.render(self.centerX, self.centerY, self.curScale, self.size()) def keyPressEvent(self, event): if event.key() == Qt.Key_Plus: self.zoom(ZoomInFactor) elif event.key() == Qt.Key_Minus: self.zoom(ZoomOutFactor) elif event.key() == Qt.Key_Left: self.scroll(-ScrollStep, 0) elif event.key() == Qt.Key_Right: self.scroll(+ScrollStep, 0) elif event.key() == Qt.Key_Down: self.scroll(0, -ScrollStep) elif event.key() == Qt.Key_Up: self.scroll(0, +ScrollStep) else: super(MandelbrotWidget, self).keyPressEvent(event) def wheelEvent(self, event): numDegrees = event.angleDelta().y() / 8 numSteps = numDegrees / 15.0 self.zoom(pow(ZoomInFactor, numSteps)) def mousePressEvent(self, event): if event.buttons() == Qt.LeftButton: self.lastDragPos = QPoint(event.pos()) def mouseMoveEvent(self, event): if event.buttons() & Qt.LeftButton: self.pixmapOffset += event.pos() - self.lastDragPos self.lastDragPos = QPoint(event.pos()) self.update() def mouseReleaseEvent(self, event): if event.button() == Qt.LeftButton: self.pixmapOffset += event.pos() - self.lastDragPos self.lastDragPos = QPoint() deltaX = (self.width() - self.pixmap.width()) / 2 - self.pixmapOffset.x() deltaY = (self.height() - self.pixmap.height()) / 2 - self.pixmapOffset.y() self.scroll(deltaX, deltaY) def updatePixmap(self, image, scaleFactor): if not self.lastDragPos.isNull(): return self.pixmap = QPixmap.fromImage(image) self.pixmapOffset = QPoint() self.lastDragPosition = QPoint() self.pixmapScale = scaleFactor self.update() def zoom(self, zoomFactor): self.curScale *= zoomFactor self.update() self.thread.render(self.centerX, self.centerY, self.curScale, self.size()) def scroll(self, deltaX, deltaY): self.centerX += deltaX * self.curScale self.centerY += deltaY * self.curScale self.update() self.thread.render(self.centerX, self.centerY, self.curScale, self.size())
def mouseMoveEvent(self, event): if event.buttons() & Qt.LeftButton: self.pixmapOffset += event.pos() - self.lastDragPos self.lastDragPos = QPoint(event.pos()) self.update()
def testMatrixWithWrongType(self): matrix = QMatrix(11, 12, 21, 22, 100, 200) point = QPoint(3, 3) # This exception may move from a TypeError to a ValueError. self.assertRaises((TypeError, ValueError), matrix.__mul__, point)
def resizeEvent(self, resizeEvent: QResizeEvent): self.paintStep = min(self.width() / self.size, self.height() / self.size) self.paintOffset = QPoint((self.paintStep + (self.width() - self.paintStep * self.size)) / 2, (self.paintStep + (self.height() - self.paintStep * self.size)) / 2) self.player = self.playerNode.point
def point(self) -> QPoint: return QPoint(self.column * self.maze.paintStep, self.row * self.maze.paintStep)
class View(QOpenGLWidget, QOpenGLFunctions): cameraMode = Signal(str) cameraOrigin = Signal(bool) cameraMove = Signal(float, float, float) cameraOrient = Signal(float, float, float) cameraZoom = Signal(float) cameraView = Signal(int) displayRatio = Signal(float) togglePicture = Signal() removeView = Signal() selected = Signal(float, float, float, bool) def __init__(self, window, project): super(View, self).__init__(window) QOpenGLFunctions.__init__(self) self.setFocusPolicy(Qt.StrongFocus) self.aspectRatio = 0.0 self.shiftKey = False self.ctrlKey = False self.lastMousePos = QPoint() self.project = project self.project.redraw.connect(self.update, type=Qt.QueuedConnection) self.project.aspectRatio.connect(self.setAspectRatio, type=Qt.QueuedConnection) self.cameraMode.connect(self.project.setCameraMode, type=Qt.QueuedConnection) self.cameraOrigin.connect(self.project.setCameraAtOrigin, type=Qt.QueuedConnection) self.cameraMove.connect(self.project.moveCamera, type=Qt.QueuedConnection) self.cameraOrient.connect(self.project.orientCamera, type=Qt.QueuedConnection) self.cameraZoom.connect(self.project.zoomCamera, type=Qt.QueuedConnection) self.cameraView.connect(self.project.setCameraView, type=Qt.QueuedConnection) self.displayRatio.connect(self.project.setDisplayRatio, type=Qt.QueuedConnection) self.togglePicture.connect(self.project.togglePicture, type=Qt.QueuedConnection) self.removeView.connect(self.project.removeCurrentView, type=Qt.QueuedConnection) self.selected.connect(self.project.select, type=Qt.QueuedConnection) @Slot(float) def setAspectRatio(self, ratio): self.aspectRatio = ratio if self.aspectRatio > 0.0: self.setFixedHeight(self.width() * self.aspectRatio) else: self.setMinimumHeight(0) self.setMaximumHeight(16777215) def destroy(self, *args, **kwds): if self.project: self.makeCurrent() self.project.close(self) self.project = None self.doneCurrent() super(View, self).destroy(*args, **kwds) def initializeGL(self): self.initializeOpenGLFunctions() print(self.glGetString(GL.GL_VENDOR)) print(self.glGetString(GL.GL_RENDERER)) print(self.glGetString(GL.GL_VERSION)) print(self.glGetString(GL.GL_SHADING_LANGUAGE_VERSION)) # print(self.glGetString(GL.GL_EXTENSIONS)) self.context().aboutToBeDestroyed.connect(self.destroy) def paintGL(self): if not self.project: return uniforms = dict() self.project.render(self, self.width(), self.height(), uniforms) def resizeGL(self, width, height): if self.aspectRatio > 0: self.setFixedHeight(self.width() * self.aspectRatio) else: self.setMinimumHeight(0) self.setMaximumHeight(16777215) self.update() def closeEvent(self, event): self.destroy() event.accept() def keyPressEvent(self, event): k = event.key() if k == Qt.Key_Shift: self.shiftKey = True if k == Qt.Key_Control: self.ctrlKey = True # if k == Qt.Key_O: # self.cameraMode.emit('ortho') # elif k == Qt.Key_P: # self.cameraMode.emit('perspective') # elif k == Qt.Key_BracketLeft: # self.cameraMode.emit('view') if k == Qt.Key_BracketRight: self.togglePicture.emit() elif k == Qt.Key_Comma: self.cameraView.emit(-1) elif k == Qt.Key_Period: self.cameraView.emit(+1) elif k == Qt.Key_I: self.cameraOrigin.emit(event.modifiers() & Qt.ShiftModifier) elif k == Qt.Key_W: self.cameraMove.emit(0.00, 0.00, -0.25) elif k == Qt.Key_S: self.cameraMove.emit(0.00, 0.00, 0.25) elif k == Qt.Key_A: self.cameraMove.emit(-0.25, 0.00, 0.00) elif k == Qt.Key_D: self.cameraMove.emit(0.25, 0.00, 0.00) elif k == Qt.Key_R: self.cameraMove.emit(0.00, 0.25, 0.00) elif k == Qt.Key_F: self.cameraMove.emit(0.00, -0.25, 0.00) elif k == Qt.Key_QuoteLeft: self.displayRatio.emit(0.000) elif k == Qt.Key_1: self.displayRatio.emit(0.001) elif k == Qt.Key_2: self.displayRatio.emit(0.010) elif k == Qt.Key_3: self.displayRatio.emit(0.020) elif k == Qt.Key_4: self.displayRatio.emit(0.050) elif k == Qt.Key_5: self.displayRatio.emit(0.100) elif k == Qt.Key_6: self.displayRatio.emit(0.150) elif k == Qt.Key_7: self.displayRatio.emit(0.250) elif k == Qt.Key_8: self.displayRatio.emit(0.500) elif k == Qt.Key_9: self.displayRatio.emit(0.750) elif k == Qt.Key_0: self.displayRatio.emit(1.000) elif k == Qt.Key_X: self.removeView.emit() else: return def keyReleaseEvent(self, event): k = event.key() mod = event.modifiers() if k == Qt.Key_Shift: self.shiftKey = False if k == Qt.Key_Control: self.ctrlKey = False def mousePressEvent(self, event): x = event.x() y = event.y() self.lastMousePos = event.pos() if event.button() == Qt.LeftButton: if self.ctrlKey: if self.project: self.makeCurrent() pt = self.project.unproject(self, x, y, self.width(), self.height()) self.doneCurrent() self.selected.emit(pt[0], pt[1], pt[2], not self.shiftKey) def mouseMoveEvent(self, event): x = event.x() y = event.y() dx = x - self.lastMousePos.x() dy = y - self.lastMousePos.y() self.lastMousePos = event.pos() if event.buttons() & Qt.LeftButton: if self.ctrlKey: if self.project: self.makeCurrent() pt = self.project.unproject(self, x, y, self.width(), self.height()) self.doneCurrent() self.selected.emit(pt[0], pt[1], pt[2], not self.shiftKey) elif self.shiftKey: self.cameraOrient.emit(0, dy / 3, dx / 3) else: self.cameraOrient.emit(dx / 3, dy / 3, 0) # elif event.buttons() & Qt.MiddleButton: elif event.buttons() & Qt.RightButton: self.cameraMove.emit(-dx / 10, dy / 10, 0) def wheelEvent(self, event): dx = event.angleDelta().x() / 8 dy = event.angleDelta().y() / 8 self.cameraZoom.emit(dy / 15)
def paintEvent(self, event): painter = QPainter(self) # Draw background painter.save() self.brush.setColor(ThemeManager.BG_L2_QC) self.brush.setStyle(Qt.SolidPattern) painter.setBrush(self.brush) painter.setPen(Qt.NoPen) painter.drawRect(0, 0, self.size().width() - 1, self.size().height() - 1) painter.restore() # If image is set if self.imageData: if self.imageData.isValid(): # Find xy offsets self.dx = self.size().width() - self.scaledImage.size().width( ) if self.size().width() - self.scaledImage.size().width( ) else self.scaledImage.size().width() - self.size().width() self.dy = self.size().height() - self.scaledImage.size( ).height() if self.size().height() - self.scaledImage.size( ).height() else self.scaledImage.size().height() - self.size( ).height() # Paint rescaled image painter.setRenderHint(QPainter.HighQualityAntialiasing, True) painter.drawPixmap(self.dx / 2, self.dy / 2, self.scaledImage) # Paint in-progress box if self.drawingRect: painter.save() x, x2, y, y2 = self.drawingRect # Convert % to xy coords, account for off by one error x = (x * self.scaledImage.size().width() + self.dx / 2) - 1 y = (y * self.scaledImage.size().height() + self.dy / 2) - 1 x2 = (x2 * self.scaledImage.size().width() + self.dx / 2) - 2 y2 = (y2 * self.scaledImage.size().height() + self.dy / 2) - 2 # Setup painter's brush and pen colors self.brush.setColor(ThemeManager.ACCENT_VLOW_OPACITY_QC) self.brush.setStyle(Qt.SolidPattern) self.pen.setColor(ThemeManager.ACCENT_QC) painter.setBrush(self.brush) painter.setPen(self.pen) painter.drawRect(QRect(QPoint(x, y), QPoint(x2, y2))) painter.restore() # Paint existing boxes for box in self.boxes: painter.save() x, x2, y, y2 = box.getRect() # Convert % to xy coords, account for off by one error, and draw box's rect x = (x * self.scaledImage.size().width() + self.dx / 2) - 1 y = (y * self.scaledImage.size().height() + self.dy / 2) - 1 x2 = (x2 * self.scaledImage.size().width() + self.dx / 2) - 1 y2 = (y2 * self.scaledImage.size().height() + self.dy / 2) - 2 painter.drawRect(QRect(QPoint(x, y), QPoint(x2, y2))) # Setup painter's brush and pen colors self.brush.setColor(ThemeManager.ACCENT_LOW_OPACITY_QC) self.brush.setStyle(Qt.SolidPattern) self.pen.setColor(ThemeManager.ACCENT_QC) painter.setBrush(self.brush) painter.setPen(self.pen) painter.drawRect(QRect(QPoint(x, y), QPoint(x2, y2))) # Draw box's label pen = QPen() font = QFont('Arial', 8) pen.setColor(ThemeManager.LABEL_QC) painter.setPen(pen) painter.drawText(x + 2, y + 11, box.getLabel()) painter.restore() # TODO: Move this logic out of Paint Event # Image this index was referencing was deleted else: self.boxes = [] self.imageData = None if self.message: painter.save() font = QFont('Arial', 20) messageWidth = QFontMetrics(font).width(self.message) painter.setFont(font) self.pen.setColor(ThemeManager.ACCENT_QC) painter.setPen(self.pen) painter.drawText((self.width() - messageWidth) / 2, self.height() * .9, self.message) painter.restore() painter.end()
def mousePressEvent(self, event): if event.buttons() == Qt.LeftButton: self.lastDragPos = QPoint(event.pos())
def testMatrixWithWrongType(self): matrix = QMatrix(11, 12, 21, 22, 100, 200) point = QPoint(3, 3) self.assertRaises(TypeError, matrix.__mul__, point)
def get_lineSeries_psnr(self): lineSeries = QtCharts.QLineSeries() for i in range(0, len(self.psnr)): lineSeries.append(QPoint(i, self.psnr[i])) lineSeries.setName(self.filename) return lineSeries
class GLWidget(QOpenGLWidget, QOpenGLFunctions): xRotationChanged = Signal(int) yRotationChanged = Signal(int) zRotationChanged = Signal(int) zoomChanged = Signal(int) fileSaved = Signal() def __init__(self, parent=None): QOpenGLWidget.__init__(self, parent) QOpenGLFunctions.__init__(self) self.core = "--coreprofile" in QCoreApplication.arguments() self.xRot = 0 self.yRot = 0 self.zRot = 4327 self.zoom = 0 self.lastPos = 0 self.lithophane = Lithophane() self.vao = QOpenGLVertexArrayObject() self.lithophaneVbo = QOpenGLBuffer() self.program = QOpenGLShaderProgram() self.projMatrixLoc = 0 self.mvMatrixLoc = 0 self.normalMatrixLoc = 0 self.lightPosLoc = 0 self.proj = QMatrix4x4() self.camera = QMatrix4x4() self.world = QMatrix4x4() self.transparent = "--transparent" in QCoreApplication.arguments() if self.transparent: fmt = self.format() fmt.setAlphaBufferSize(8) self.setFormat(fmt) def updateImage(self, img_scr): self.fileDir = img_scr self.lithophane.generateVertex(img_scr) self.initializeGL() def generateSTL(self,file_name): file=open(file_name, "w") file.write("solid lithophane\n") i=0 v_data=[] while(i <= self.lithophane.m_count): n1=self.lithophane.m_data[i] i+=1 n2=self.lithophane.m_data[i] i+=1 n3=self.lithophane.m_data[i] i+=1 v1=self.lithophane.m_data[i] i+=1 v2=self.lithophane.m_data[i] i+=1 v3=self.lithophane.m_data[i] i+=1 v_data.append([n1,n2,n3]) triangle_count = 0 for i in range(0,len(v_data)-1,4): q1 = v_data[i] q2 = v_data[i+1] q3 = v_data[i+2] q4 = v_data[i+3] file.write("facet normal 0.0 0.0 0.0\n") file.write(" outer loop\n") file.write(" vertex {} {} {}\n".format(np.float32(q1[0]),np.float32(q1[1]),np.float32(q1[2]))) file.write(" vertex {} {} {}\n".format(np.float32(q2[0]),np.float32(q2[1]),np.float32(q2[2]))) file.write(" vertex {} {} {}\n".format(np.float32(q4[0]),np.float32(q4[1]),np.float32(q4[2]))) file.write(" end loop\n") file.write("endfacet\n") file.write("facet normal 0.0 0.0 0.0\n") file.write(" outer loop\n") file.write(" vertex {} {} {}\n".format(np.float32(q2[0]),np.float32(q2[1]),np.float32(q2[2]))) file.write(" vertex {} {} {}\n".format(np.float32(q3[0]),np.float32(q3[1]),np.float32(q3[2]))) file.write(" vertex {} {} {}\n".format(np.float32(q4[0]),np.float32(q4[1]),np.float32(q4[2]))) file.write(" end loop\n") file.write("endfacet\n") triangle_count+=2 print("Written {} triangles".format(triangle_count)) file.close() self.fileSaved.emit() def xRotation(self): return self.xRot def yRotation(self): return self.yRot def zRotation(self): return self.zRot def minimumSizeHint(self): return QSize(50, 50) def sizeHint(self): return QSize(400, 400) def normalizeAngle(self, angle): while angle < 0: angle += 360 * 16 while angle > 360 * 16: angle -= 360 * 16 return angle def setXRotation(self, angle): angle = self.normalizeAngle(angle) if angle != self.xRot: self.xRot = angle self.emit(SIGNAL("xRotationChanged(int)"), angle) self.update() def setYRotation(self, angle): angle = self.normalizeAngle(angle) if angle != self.yRot: self.yRot = angle self.emit(SIGNAL("yRotationChanged(int)"), angle) self.update() def setZRotation(self, angle): angle = self.normalizeAngle(angle) if angle != self.zRot: self.zRot = angle self.emit(SIGNAL("zRotationChanged(int)"), angle) print(angle) self.update() def setZoom(self, val): if val != self.zoom: self.zoom = -val self.emit(SIGNAL("zoomChanged(int)"), val) self.update() def applyParams(self, minT, maxT, step_size): if not self.fileDir: return self.lithophane.setParams(minT,maxT,step_size) self.updateImage(self.fileDir) def cleanup(self): self.makeCurrent() self.lithophaneVbo.destroy() del self.program self.program = None self.doneCurrent() def vertexShaderSourceCore(self): return """#version 150 in vec4 vertex; in vec3 normal; out vec3 vert; out vec3 vertNormal; uniform mat4 projMatrix; uniform mat4 mvMatrix; uniform mat3 normalMatrix; void main() { vert = vertex.xyz; vertNormal = normalMatrix * normal; gl_Position = projMatrix * mvMatrix * vertex; }""" def fragmentShaderSourceCore(self): return """#version 150 in highp vec3 vert; in highp vec3 vertNormal; out highp vec4 fragColor; uniform highp vec3 lightPos; void main() { highp vec3 L = normalize(lightPos - vert); highp float NL = max(dot(normalize(vertNormal), L), 0.0); highp vec3 color = vec3(0.39, 1.0, 0.0); highp vec3 col = clamp(color * 0.2 + color * 0.8 * NL, 0.0, 1.0); fragColor = vec4(col, 1.0); }""" def vertexShaderSource(self): return """attribute vec4 vertex; attribute vec3 normal; varying vec3 vert; varying vec3 vertNormal; uniform mat4 projMatrix; uniform mat4 mvMatrix; uniform mat3 normalMatrix; void main() { vert = vertex.xyz; vertNormal = normalMatrix * normal; gl_Position = projMatrix * mvMatrix * vertex; }""" def fragmentShaderSource(self): return """varying highp vec3 vert; varying highp vec3 vertNormal; uniform highp vec3 lightPos; void main() { highp vec3 L = normalize(lightPos - vert); highp float NL = max(dot(normalize(vertNormal), L), 0.0); highp vec3 color = vec3(0.39, 1.0, 0.0); highp vec3 col = clamp(color * 0.2 + color * 0.8 * NL, 0.0, 1.0); gl_FragColor = vec4(col, 1); }""" def initializeGL(self): self.context().aboutToBeDestroyed.connect(self.cleanup) self.initializeOpenGLFunctions() self.glClearColor(0, 0, 0, 1) self.program = QOpenGLShaderProgram() if self.core: self.vertexShader = self.vertexShaderSourceCore() self.fragmentShader = self.fragmentShaderSourceCore() else: self.vertexShader = self.vertexShaderSource() self.fragmentShader = self.fragmentShaderSource() self.program.addShaderFromSourceCode(QOpenGLShader.Vertex, self.vertexShader) self.program.addShaderFromSourceCode(QOpenGLShader.Fragment, self.fragmentShader) self.program.bindAttributeLocation("vertex", 0) self.program.bindAttributeLocation("normal", 1) self.program.link() self.program.bind() self.projMatrixLoc = self.program.uniformLocation("projMatrix") self.mvMatrixLoc = self.program.uniformLocation("mvMatrix") self.normalMatrixLoc = self.program.uniformLocation("normalMatrix") self.lightPosLoc = self.program.uniformLocation("lightPos") self.vao.create() vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao) self.lithophaneVbo.create() self.lithophaneVbo.bind() float_size = ctypes.sizeof(ctypes.c_float) self.lithophaneVbo.allocate(self.lithophane.constData(), 300000 *6 * float_size) self.setupVertexAttribs() self.camera.setToIdentity() self.camera.translate(0, 0, -90) self.program.setUniformValue(self.lightPosLoc, QVector3D(10, 0, 20)) self.program.release() vaoBinder = None def setupVertexAttribs(self): self.lithophaneVbo.bind() f = QOpenGLContext.currentContext().functions() f.glEnableVertexAttribArray(0) f.glEnableVertexAttribArray(1) float_size = ctypes.sizeof(ctypes.c_float) null = VoidPtr(0) pointer = VoidPtr(3 * float_size) f.glVertexAttribPointer(0, 3, int(GL.GL_FLOAT), int(GL.GL_FALSE), 6 * float_size, null) f.glVertexAttribPointer(1, 3, int(GL.GL_FLOAT), int(GL.GL_FALSE), 6 * float_size, pointer) self.lithophaneVbo.release() def paintGL(self): self.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT) self.glEnable(GL.GL_DEPTH_TEST) self.glEnable(GL.GL_CULL_FACE) self.world.setToIdentity() self.world.rotate(self.xRot / 16, 1, 0, 0) self.world.rotate(self.yRot / 16, 0, 1, 0) self.world.rotate(self.zRot / 16, 0, 0, 1) self.camera.setToIdentity() self.camera.translate(0,0,self.zoom) self.world.translate(-self.lithophane.width*0.5*0.2,-self.lithophane.height*0.5*0.2 , 0) vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao) self.program.bind() self.program.setUniformValue(self.projMatrixLoc, self.proj) self.program.setUniformValue(self.mvMatrixLoc, self.camera * self.world) normalMatrix = self.world.normalMatrix() self.program.setUniformValue(self.normalMatrixLoc, normalMatrix) self.glDrawArrays(GL.GL_QUADS, 0, self.lithophane.vertexCount()) self.program.release() vaoBinder = None def resizeGL(self, width, height): self.proj.setToIdentity() self.proj.perspective(45, width / height, 0.01, 1000) def mousePressEvent(self, event): self.lastPos = QPoint(event.pos()) def mouseMoveEvent(self, event): dx = event.x() - self.lastPos.x() dy = event.y() - self.lastPos.y() if event.buttons() & Qt.LeftButton: self.setXRotation(self.xRot + 8 * dy) self.setYRotation(self.yRot + 8 * dx) elif event.buttons() & Qt.RightButton: self.setXRotation(self.xRot + 8 * dy) self.setZRotation(self.zRot + 8 * dx) self.lastPos = QPoint(event.pos())
def contextMenuEvent(self, event): hit = self.page.hittestcontent(event.pos()) menu = ContextMenu(self, hit) pos = event.globalPos() p = QPoint(pos.x(), pos.y() + 1) menu.exec_(p)
def _show_menu(self, index, pos): node_id, \ node_name, \ is_online, \ is_itself, \ is_wiped = self._model.get_node_id_online_itself(index) if not node_id: return license_free = self._license_type == FREE_LICENSE menu = QMenu(self._view) menu.setStyleSheet("background-color: #EFEFF4; ") menu.setToolTipsVisible(license_free) if license_free: menu.setStyleSheet( 'QToolTip {{background-color: #222222; color: white;}}') menu.hovered.connect(lambda a: self._on_menu_hovered(a, menu)) def add_menu_item(caption, index=None, action_name=None, action_type="", start_transfers=False, disabled=False, tooltip=""): action = menu.addAction(caption) action.setEnabled(not disabled) action.tooltip = tooltip if tooltip else "" if not start_transfers: action.triggered.connect(lambda: self._on_menu_clicked( index, action_name, action_type)) else: action.triggered.connect(self.start_transfers.emit) tooltip = tr("Not available for free license") \ if license_free and not is_itself else "" if not is_online: action_in_progress = ("hideNode", "") in \ self._nodes_actions.get(node_id, set()) item_text = tr("Remove node") if not action_in_progress \ else tr("Remove node in progress...") add_menu_item(item_text, index, "hideNode", disabled=action_in_progress) elif is_itself: add_menu_item(tr("Transfers..."), start_transfers=True) if not is_wiped: wipe_in_progress = ("execute_remote_action", "wipe") in \ self._nodes_actions.get(node_id, set()) if not wipe_in_progress: action_in_progress = ("execute_remote_action", "logout") in \ self._nodes_actions.get(node_id, set()) item_text = tr("Log out") if not action_in_progress \ else tr("Log out in progress...") add_menu_item(item_text, index, "execute_remote_action", "logout", disabled=action_in_progress or license_free and not is_itself, tooltip=tooltip) item_text = tr("Log out && wipe") if not wipe_in_progress \ else tr("Wipe in progress...") add_menu_item(item_text, index, "execute_remote_action", "wipe", disabled=wipe_in_progress or license_free and not is_itself, tooltip=tooltip) pos_to_show = QPoint(pos.x(), pos.y() + 20) menu.exec_(self._view.mapToGlobal(pos_to_show))
def showCalender(self): print('in show') p = self.mapToGlobal(QPoint(0, self.height() + self.__margin__)) self.dialog.setGeometry(p.x(), p.y(), 0, 0) self.dialog.show()
def testQPointHash(self): p1 = QPoint(12, 34) p2 = QPoint(12, 34) self.assertFalse(p1 is p2) self.assertEqual(p1, p2) self.assertEqual(hash(p1), hash(p2))
def __init__( self, campaigns: List[Campaign], faction_selection: FactionSelection, parent=None, ) -> None: super().__init__(parent) self.faction_selection = faction_selection self.setTitle("Theater configuration") self.setSubTitle("\nChoose a terrain and time period for this game.") self.setPixmap( QtWidgets.QWizard.LogoPixmap, QtGui.QPixmap("./resources/ui/wizard/logo1.png"), ) self.setPixmap( QtWidgets.QWizard.WatermarkPixmap, QtGui.QPixmap("./resources/ui/wizard/watermark3.png"), ) # List of campaigns campaignList = QCampaignList(campaigns) self.registerField("selectedCampaign", campaignList) # Faction description self.campaignMapDescription = QTextEdit("") self.campaignMapDescription.setReadOnly(True) self.campaignMapDescription.setMaximumHeight(100) self.performanceText = QTextEdit("") self.performanceText.setReadOnly(True) self.performanceText.setMaximumHeight(90) # Campaign settings mapSettingsGroup = QtWidgets.QGroupBox("Map Settings") invertMap = QtWidgets.QCheckBox() self.registerField("invertMap", invertMap) mapSettingsLayout = QtWidgets.QGridLayout() mapSettingsLayout.addWidget(QtWidgets.QLabel("Invert Map"), 0, 0) mapSettingsLayout.addWidget(invertMap, 0, 1) mapSettingsGroup.setLayout(mapSettingsLayout) # Time Period timeGroup = QtWidgets.QGroupBox("Time Period") timePeriod = QtWidgets.QLabel("Start date :") timePeriodSelect = QtWidgets.QComboBox() timePeriodPresetLabel = QLabel("Use preset :") timePeriodPreset = QtWidgets.QCheckBox() timePeriodPreset.setChecked(True) self.calendar = QLiberationCalendar() self.calendar.setSelectedDate(QDate()) self.calendar.setDisabled(True) def onTimePeriodChanged(): self.calendar.setSelectedDate( list( db.TIME_PERIODS.values())[timePeriodSelect.currentIndex()]) timePeriodSelect.currentTextChanged.connect(onTimePeriodChanged) for r in db.TIME_PERIODS: timePeriodSelect.addItem(r) timePeriod.setBuddy(timePeriodSelect) timePeriodSelect.setCurrentIndex(21) def onTimePeriodCheckboxChanged(): if timePeriodPreset.isChecked(): self.calendar.setDisabled(True) timePeriodSelect.setDisabled(False) onTimePeriodChanged() else: self.calendar.setDisabled(False) timePeriodSelect.setDisabled(True) timePeriodPreset.stateChanged.connect(onTimePeriodCheckboxChanged) # Bind selection method for campaign selection def on_campaign_selected(): template = jinja_env.get_template("campaigntemplate_EN.j2") template_perf = jinja_env.get_template( "campaign_performance_template_EN.j2") index = campaignList.selectionModel().currentIndex().row() campaign = campaignList.campaigns[index] self.setField("selectedCampaign", campaign) self.campaignMapDescription.setText( template.render({"campaign": campaign})) self.faction_selection.setDefaultFactions(campaign) self.performanceText.setText( template_perf.render({"performance": campaign.performance})) campaignList.selectionModel().setCurrentIndex( campaignList.indexAt(QPoint(1, 1)), QItemSelectionModel.Rows) campaignList.selectionModel().selectionChanged.connect( on_campaign_selected) on_campaign_selected() # Docs Link docsText = QtWidgets.QLabel( '<a href="https://github.com/Khopa/dcs_liberation/wiki/Custom-Campaigns"><span style="color:#FFFFFF;">How to create your own theater</span></a>' ) docsText.setAlignment(Qt.AlignCenter) docsText.setOpenExternalLinks(True) # Register fields self.registerField("timePeriod", timePeriodSelect) self.registerField("usePreset", timePeriodPreset) timeGroupLayout = QtWidgets.QGridLayout() timeGroupLayout.addWidget(timePeriodPresetLabel, 0, 0) timeGroupLayout.addWidget(timePeriodPreset, 0, 1) timeGroupLayout.addWidget(timePeriod, 1, 0) timeGroupLayout.addWidget(timePeriodSelect, 1, 1) timeGroupLayout.addWidget(self.calendar, 0, 2, 3, 1) timeGroup.setLayout(timeGroupLayout) layout = QtWidgets.QGridLayout() layout.setColumnMinimumWidth(0, 20) layout.addWidget(campaignList, 0, 0, 5, 1) layout.addWidget(docsText, 5, 0, 1, 1) layout.addWidget(self.campaignMapDescription, 0, 1, 1, 1) layout.addWidget(self.performanceText, 1, 1, 1, 1) layout.addWidget(mapSettingsGroup, 2, 1, 1, 1) layout.addWidget(timeGroup, 3, 1, 3, 1) self.setLayout(layout)
def testQPointToTuple(self): p = QPoint(1, 2) self.assertEqual((1, 2), p.toTuple())
def testMatrix(self): matrix = QMatrix(11, 12, 21, 22, 100, 200) point = QPoint(3, 3) self.assertEqual(point * matrix, qpointTimesQMatrix(point, matrix))
def run(self): import face_recognition #detector = dlib.get_frontal_face_detector() known_faces = {} persons = [o for o in os.listdir(FACES_DIR) if os.path.isdir(os.path.join(FACES_DIR,o))] for person in persons: images = os.listdir(os.path.join(FACES_DIR, person)) known_faces[person] = list() for image in images: if not image.endswith(".jpg"): continue image_path = os.path.join(FACES_DIR, person, image) cache_path = image_path + '.c' #print("IMAGE for", person, ": ", image) if os.path.isfile(cache_path): face_encodings = pickle.load(open(cache_path, "rb")) else: image = face_recognition.load_image_file(image_path) face_encodings = face_recognition.face_encodings(image) pickle.dump(face_encodings, open(cache_path, "wb")) #print("FACES", face_encodings) known_faces[person].append(face_encodings[0]) while not self.exit_event.is_set(): y, u, v, h, w, h2, w2 = self.task_queue.get() y = y.reshape((h, w)) u = u.reshape((h2, w2)).repeat(2, axis=0).repeat(2, axis=1) v = v.reshape((h2, w2)).repeat(2, axis=0).repeat(2, axis=1) yuv_img = np.dstack((y, u, v))[:h, :w, :].astype(np.float) rgb_img = convertYUVtoRGB(yuv_img) #print("has detector...") #dets = detector(rgb_img, 1) face_locations = face_recognition.face_locations(rgb_img, number_of_times_to_upsample=1, model="hog") face_encodings = face_recognition.face_encodings(rgb_img, face_locations) #print("has detected...") #print("dets", face_locations) rects = [] for (top, right, bottom, left), face_encoding in zip(face_locations, face_encodings): #print("Left: {} Top: {} Right: {} Bottom: {}".format( # left, top, right, bottom)) min_value = 1 min_person = "Unknown" for person, pictures in known_faces.items(): distances = face_recognition.face_distance(pictures, face_encoding) #print("FACE distance for ", person, distances) if min(distances) < min_value and min(distances) < 0.6: min_value = any(distances) min_person = person rects.append([QRect(QPoint(left, top), QPoint(right, bottom)), min_person]) self.task_queue.task_done() self.result_queue.put(rects)
def advance(self, phase): if not self.phase: return location = QPoint(self.pos()) self.setPos(self.mapToParent(0, -speed))
def qpointTimesQMatrix(point, matrix): '''As seen in "QPoint QMatrix::map(const QPoint &p) const" C++ implementation.''' return QPoint( matrix.m11() * point.x() + matrix.m21() * point.y() + matrix.dx(), matrix.m12() * point.x() + matrix.m22() * point.y() + matrix.dy())
def mouseMoveEvent(self, event): if self.mouseIsDown: self.center = QPoint(event.pos().x(), event.pos().y()) self.viewport().repaint() QTableView.mouseMoveEvent(self, event)