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 mousePressEvent(self, event):
if event.buttons() == Qt.LeftButton:
self.lastDragPos = QPoint(event.pos())
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
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
self.pixmapOffset += event.pos() - self.lastDragPos
self.lastDragPos = QPoint(event.pos())
self.update()
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())
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 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 mousePressEvent(self, event):
self.lastPos = QPoint(event.pos())
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 testQPointToTuple(self):
p = QPoint(1, 2)
self.assertEqual((1, 2), p.toTuple())
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)
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 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)
