def mousePressEvent(self, event):
if self._pickGridOrigin:
self._gridOrigin = event.scenePos()
self.update()
self._pickGridOrigin = False
return
if not self._placeItems:
if not self._moveItems:
item = self.itemAt(event.scenePos(), QTransform())
if item:
if isinstance(item, ControlPoint):
self._placeItems = [item]
pos = event.scenePos()
self.dragStarted.emit(self._placeItems, pos)
for item in self._placeItems:
if hasattr(item, 'mouseDragBegan'):
item.mouseDragBegan.emit(pos)
else:
pos = event.scenePos()
self.dragEnded.emit(self._moveItems, pos)
for item in self._moveItems:
if hasattr(item, 'mouseDragEnded'):
item.mouseDragEnded.emit(pos)
self._moveItems = None
super().mousePressEvent(event)
def saveas(self):
"""Saves the modified image with another name. Uses the stored original image, not the modified version currently displayed in the window."""
self.model.set_image(
self.model.image.transformed(
QTransform().rotate(self.image_area.rot),
Qt.SmoothTransformation))
self.set_state('saveas')
def draw_frog(self, qp):
self.pixmap = QPixmap('resources/Frog.png')
self.image.resize(self.pixmap.width() * math.sqrt(2),
self.pixmap.height() * math.sqrt(2))
self.image.move(
self.width // 2 - self.current_level.turret[0] -
self.image.width() // 2, self.height -
self.current_level.turret[1] - self.image.height() // 2)
t = QTransform().rotate(
(self.current_level.turret_angle - math.pi / 2) / math.pi * 180)
self.image.setPixmap(self.pixmap.transformed(t))
if len(self.current_level.current_colors) == 0:
return
if (self.current_level.turret_ball >= len(
self.current_level.current_colors)):
self.current_level.turret_ball = len(
self.current_level.current_colors) - 1
transform = qp.transform()
qp.translate(self.width // 2 - self.current_level.turret[0],
self.height - self.current_level.turret[1])
qp.rotate(self.current_level.turret_angle / math.pi * 180)
qp.setBrush(
QColor(*self.current_level.current_colors[
self.current_level.turret_ball]))
qp.drawEllipse(QtCore.QPoint(0, 0), 2, 2)
qp.drawEllipse(QtCore.QPointF(38, 0), 19, 17)
qp.setTransform(transform)
def contextMenuEvent(self, event):
self._menuEventPos = event.scenePos()
item = self.itemAt(event.scenePos(), QTransform())
if self._contextMenu and item is None:
self._contextMenu.exec_(event.screenPos())
else:
super().contextMenuEvent(event)
def __init__(self, x, y, rotation, i, scene: QGraphicsScene, rocket_id):
super().__init__()
self.rocket_id = rocket_id.__int__()
number_of_active_bullets = 0
if self.rocket_id == 1:
number_of_active_bullets = Server.rocket1_bulletsCounter
elif self.rocket_id == 2:
number_of_active_bullets = Server.rocket2_bulletsCounter
elif self.rocket_id == 3:
number_of_active_bullets = Server.rocket3_bulletsCounter
elif self.rocket_id == 4:
number_of_active_bullets = Server.rocket4_bulletsCounter
if number_of_active_bullets < Server.maximum_of_bullets:
self.image = QPixmap("Images/bullet.png")
t = QTransform().rotate(rotation)
self.setStyleSheet("background:transparent;color:white;")
self.image = self.image.transformed(t)
self.setPixmap(self.image)
self.init_x = x + 20 + 30 * float(cos(radians(rotation)))
self.init_y = y + 20 - 30 * float(sin(radians(rotation)))
self.IDS = Server.bulletIDS
Server.bulletIDS = Server.bulletIDS + 1
inttX = int(round(self.init_x))
inttY = int(round(self.init_y))
if self.rocket_id == 1:# u odnosu na to koja raketa je ispalila metak svrstaj ga u odredjen kolekciju
Server.bulletsCollection1X[self.IDS] = 0
Server.bulletsCollection1Y[self.IDS] = 0
Server.bulletsCollection1X[self.IDS] = inttX
Server.bulletsCollection1Y[self.IDS] = inttY
elif self.rocket_id == 2:
Server.bulletsCollection2X[self.IDS] = 0
Server.bulletsCollection2Y[self.IDS] = 0
Server.bulletsCollection2X[self.IDS] = inttX
Server.bulletsCollection2Y[self.IDS] = inttY
elif self.rocket_id == 3:
Server.bulletsCollection3X[self.IDS] = 0
Server.bulletsCollection3Y[self.IDS] = 0
Server.bulletsCollection3X[self.IDS] = inttX
Server.bulletsCollection3Y[self.IDS] = inttY
elif self.rocket_id == 4:
Server.bulletsCollection4X[self.IDS] = 0
Server.bulletsCollection4Y[self.IDS] = 0
Server.bulletsCollection4X[self.IDS] = inttX
Server.bulletsCollection4Y[self.IDS] = inttY
self.scene = scene
self.xMovement = float(cos(radians(rotation)))
self.yMovement = float(sin(radians(rotation)))
scene.addWidget(self)
self.kreni.connect(self.moveSelf)
self.initBullet()
if self.rocket_id == 1:
Server.rocket1_bulletsCounter = Server.rocket1_bulletsCounter + 1
elif self.rocket_id == 2:
Server.rocket2_bulletsCounter = Server.rocket2_bulletsCounter + 1
elif self.rocket_id == 3:
Server.rocket3_bulletsCounter = Server.rocket3_bulletsCounter + 1
elif self.rocket_id == 4:
Server.rocket4_bulletsCounter = Server.rocket4_bulletsCounter + 1
def boundingRect(self):
polygon_to_draw = self.translated(0, 0)
try:
# print('tada')
if self.theta is not None and self.theta != 0:
# print('entering')
center = polygon_to_draw.boundingRect().center()
# print('entering2')
t = QTransform().translate(center.x(), center.y()).rotate(
self.theta).translate(-center.x(), -center.y())
# print('entering3')
# transformed = self.setTransform(t)
# print('entering4')
# print(transformed)
# print(QRectF(min(transformed.p1().x(), transformed.p2().x()), min(transformed.p1().y(), transformed.p2().y()),
# abs(transformed.p2().x() - transformed.p1().x()), abs(transformed.p2().y() - transformed.p1().y())))
# return QRectF(min(transformed.p1().x(), transformed.p2().x()), min(transformed.p1().y(), transformed.p2().y()),
# abs(transformed.p2().x() - transformed.p1().x()), abs(transformed.p2().y() - transformed.p1().y()))
# copy.setT
# print('entering')
# t = QTransform().translate( center.x(), center.y()).rotate(self.theta).translate(-center.x(), -center.y())
# # print('entersd')
transformed = t.map(
polygon_to_draw
) # // mapRect() returns the bounding rect of the rotated rect
# print('rotated',rotatedRect )
# return rotatedRect
return transformed.boundingRect()
except:
pass
return polygon_to_draw.boundingRect()
def scalePolygon(self):
rect_size = max(self.rect().width(), self.rect().height())
polygon_size = max(self._node_polygon.boundingRect().width(),
self._node_polygon.boundingRect().height())
scale = rect_size / polygon_size if polygon_size > 0. else 1.
self._node_polygon = QTransform().scale(scale,
scale).map(self._node_polygon)
def __init__(self,
panda3DWorld,
label_info,
parent=None,
FPS=60,
debug=False):
QWidget.__init__(self, parent)
# set fixed geometry
self.panda3DWorld = panda3DWorld
self.panda3DWorld.set_parent(self)
self.label_info = label_info
self.setFocusPolicy(Qt.StrongFocus)
self.paintSurface = QPainter()
self.rotate = QTransform()
self.rotate.rotate(180)
self.out_image = QImage()
size = self.panda3DWorld.cam.node().get_lens().get_film_size()
self.initial_film_size = QSizeF(size.x, size.y)
self.initial_size = self.size()
self.synchronizer = QPanda3DSynchronizer(self, FPS)
self.synchronizer.start()
self.debug = debug
self.update_sgam()
def image(self, clip=None):
"""Load and return the image.
If clip is given, it should be a QRect describing the area to load.
"""
with locking.lock(self):
reader = self._reader()
if clip:
if self.autoTransform:
size = reader.size()
transf = reader.transformation()
m = QTransform()
m.translate(size.width() / 2, size.height() / 2)
if transf & QImageIOHandler.TransformationMirror:
# horizontal mirror
m.scale(-1, 1)
if transf & QImageIOHandler.TransformationFlip:
# vertical mirror
m.scale(1, -1)
if transf & QImageIOHandler.TransformationRotate90:
# rotate 90
m.rotate(-90)
m.translate(size.height() / -2, size.width() / -2)
else:
m.translate(size.width() / -2, size.height() / -2)
clip = m.mapRect(clip)
reader.setClipRect(clip)
return reader.read()
def __closePincers(self):
self.image = QImage()
self.image.load(self.routeImage + "/closePincer.png")
pixmap = QPixmap(self.image)
transform = QTransform().rotate(self.rotation)
pixmap = pixmap.transformed(transform, QtCore.Qt.SmoothTransformation)
self.setPixmap(pixmap)
def on_slider_y_scale_value_changed(self, new_value: int):
# Scale Up = Top Half, Scale Down = Lower Half
transform = self.graphics_view.transform()
self.graphics_view.setTransform(
QTransform(transform.m11(), transform.m12(), transform.m13(),
transform.m21(), new_value, transform.m23(),
transform.m31(), transform.m32(), transform.m33()))
def paintEvent(self, event):
painter = QPainter(self)
painter.fillRect(self.rect(), QColor('#101010'))
image = self._image
if image is not None:
if self.height() < 240:
fast_scaler = QTransform()
scale = 297 / image.height()
if self.mirror:
fast_scaler.scale(-scale, scale)
else:
fast_scaler.scale(scale, scale)
rect = event.rect()
painter.drawPixmap(
rect,
QPixmap.fromImage(
image.transformed(fast_scaler)).scaledToHeight(
self.height(), Qt.SmoothTransformation), rect)
else:
transform = QTransform()
scale = min(self.width() / image.width(),
self.height() / image.height())
if self.mirror:
transform.translate(
(self.width() + image.width() * scale) / 2,
(self.height() - image.height() * scale) / 2)
transform.scale(-scale, scale)
else:
transform.translate(
(self.width() - image.width() * scale) / 2,
(self.height() - image.height() * scale) / 2)
transform.scale(scale, scale)
inverse_transform, invertible = transform.inverted()
rect = inverse_transform.mapRect(event.rect()).adjusted(
-1, -1, 1, 1).intersected(image.rect())
painter.setTransform(transform)
if self.height() > 400:
painter.drawPixmap(rect, QPixmap.fromImage(image), rect)
else:
painter.drawImage(rect, image, rect)
painter.end()
def __init__(self,
midiNumber,
dur,
acc,
tieToPrev,
vertPosLookUp,
extraLines,
svgFolder,
lineDistance,
invert,
horPos,
vertPos,
addBarLine,
head,
appctxt,
parent=None):
if dur == 1:
filePath = appctxt.get_resource(str(svgFolder / "flag16.svg"))
#print(self.filePath)
heightRel = 3.5
widthRel = 1
vertOff = -heightRel + 1 / 2
horOff = head.widthRel - 1 / 5
elif dur in [2, 3]:
filePath = appctxt.get_resource(str(svgFolder / "flag8.svg"))
heightRel = 3
widthRel = 1
vertOff = -heightRel
horOff = head.widthRel - 1 / 8
else:
filePath = None
#filePath = None
if filePath is not None:
super(Flag, self).__init__(filePath, parent)
else:
super(Flag, self).__init__()
self.isNone = True if filePath is None else False
if self.isNone is False:
self.widthRel = widthRel
self.heightRel = heightRel # na to ypologisw akrivws
self.lineDistance = lineDistance
self.dur = dur
self.heightBefore = self.boundingRect().height()
self.widthBefore = self.boundingRect().width()
self.widthScale = self.widthRel * self.lineDistance / self.widthBefore
self.heightScale = self.heightRel * self.lineDistance / self.heightBefore
self.widthReal = self.widthRel * self.lineDistance
self.heightReal = self.heightRel * self.lineDistance
if invert == 1:
self.setTransform(
QTransform(-1, 0, 0, -1, self.widthReal, self.heightReal))
self.scale(self.widthScale, self.heightScale)
#print(f"{horPos} {vertPos}")
# self.setPos(horPos + self.lineDistance - self.widthReal, vertPos - self.heightReal + self.lineDistance/2) #
########self.setPos(horPos, vertPos + self.lineDistance/2)
#print(f" before {self.heightBefore} real {self.heightReal} vertPos {vertPos}")
self.setPos(horPos + horOff * self.lineDistance,
vertPos + vertOff * self.lineDistance)
self.rightMostPoint = horPos + horOff * self.lineDistance + self.widthReal
def __init__(self,
midiNumber,
dur,
acc,
tieToPrev,
vertPosLookUp,
extraLines,
svgFolder,
lineDistance,
invert,
horPos,
vertPos,
addBarLine,
appctxt,
parent=None):
if dur in [1, 2, 3, 4, 6]:
filePath = appctxt.get_resource(str(svgFolder / "noteFilled.svg"))
#print(self.filePath)
heightRel = 1
widthRel = 1.2
elif dur in [8, 12]:
filePath = appctxt.get_resource(str(svgFolder / "noteHalf.svg"))
heightRel = 1.12
widthRel = 1.3
elif dur in [16, 24]:
filePath = appctxt.get_resource(str(svgFolder / "noteWhole.svg"))
heightRel = 1
widthRel = 2
else:
filePath = None
if filePath is not None:
super(Head, self).__init__(filePath, parent)
else:
super(Head, self).__init__()
self.isNone = True if filePath is None else False
if self.isNone is False:
#self.rect = QRectF(0, 0, self.widthReal, self.heightReal)
self.widthRel = widthRel
self.heightRel = heightRel # na to ypologisw akrivws
self.lineDistance = lineDistance
self.dur = dur
self.heightBefore = self.boundingRect().height()
self.widthBefore = self.boundingRect().width()
self.widthScale = self.widthRel * self.lineDistance / self.widthBefore
self.heightScale = self.heightRel * self.lineDistance / self.heightBefore
self.widthReal = self.widthRel * self.lineDistance
self.heightReal = self.heightRel * self.lineDistance
if invert == 1:
self.setTransform(
QTransform(-1, 0, 0, -1, self.widthReal, self.heightReal))
self.scale(self.widthScale, self.heightScale)
#print(f"{horPos} {vertPos}")
# self.setPos(horPos + self.lineDistance - self.widthReal, vertPos - self.heightReal + self.lineDistance/2) #
########self.setPos(horPos, vertPos + self.lineDistance/2)
#print(f" before {self.heightBefore} real {self.heightReal} vertPos {vertPos}")
self.setPos(horPos, vertPos)
self.rightMostPoint = horPos + self.widthReal
print(f"{horPos} {vertPos} {self.widthScale}")
def clipping(win):
buf = win.scene.itemAt(now, QTransform()).rect()
win.clip = [buf.left(), buf.right(), buf.top(), buf.bottom()]
for b in win.lines:
pass
win.pen.setColor(blue)
cohen_sutherland(b, win.clip, win)
win.pen.setColor(red)
def drawGlyphImage(painter, glyph, scale, rect):
if glyph.image.fileName is None:
return
painter.save()
painter.setTransform(QTransform(*glyph.image.transformation), True)
image = glyph.image.getRepresentation("defconQt.QPixmap")
painter.drawPixmap(0, 0, image)
painter.restore()
def right_rotate(self):
"""Rotate the main image of 90 degrees to the right and update the view"""
self.rotate = True
self.rotation += 90
transform = QTransform().rotate(self.rotation)
self.qpix = self.qpix.transformed(transform, Qt.SmoothTransformation)
self.update_view()
self.rotation = 0
def resizeEvent(self, event):
self.resize(self.sizeHint())
path = QPainterPath()
radius = 10
path.addRoundedRect(QRectF(self.rect()), radius, radius)
mask = QRegion(path.toFillPolygon(QTransform()).toPolygon())
self.setMask(mask)
QDialog.resizeEvent(self, event)
def draw(self):
transform = QTransform()
transform.rotate(self.ROTATE_ANGLES[self.direction])
pixmap = QPixmap(self.SPRITES[self.type])
pixmap = pixmap.scaled(self.CELL_SIZE, self.CELL_SIZE)
pixmap = pixmap.transformed(transform)
self.cell_label.setPixmap(pixmap)
def right_rotate(self):
"""Rotate the image to the left 90 degrees"""
self.rotate = True
self.rotation += 90
transform = QTransform().rotate(self.rotation)
self.canvas.loadPixmap(
self.canvas.pixmap.transformed(transform, Qt.SmoothTransformation))
self.rotation = 0
def mouseReleaseEvent(self, event):
found_item = self.itemAt(event.scenePos().x(),
event.scenePos().y(), QTransform())
if found_item:
move = MoveCommand(self.controller, found_item, self.dragPos)
self.controller.get_undo_stack().push(move)
# handle drag and drop
return QGraphicsScene.mouseReleaseEvent(self, event)
def updateZoom(self, zx, zy):
trans = QTransform()
trans.scale(1.0 / zx, 1.0 / zy)
# self.setTransform( trans )
self.VP.setTransform(trans)
self.preBP.setTransform(trans)
self.postBP.setTransform(trans)
self.updateTPPos()
def setZoom(self, x, y):
self.zx = x
self.zy = y
trans = QTransform()
trans.scale(self.zx, self.zy)
self.setTransform(trans)
for vert in self.vertItems:
vert.updateZoom(self.zx, self.zy)
def _QGraphicsItem_rotate(self, angle):
warnings.warn(
"QGraphicsItem.rotate(angle) is obsolete and removed in PyQt5. "
"Use setTransform(QTransform().rotate(angle), True)",
DeprecationWarning,
stacklevel=2
)
self.setTransform(QTransform().rotate(angle), True)
def wind_icon_direction(self):
transf = QTransform()
angle = self.weatherdata['Wind'][2]
logging.debug('Wind degrees direction: ' + angle)
transf.rotate(int(float(angle)))
rotated = self.wind_icon.transformed(transf,
mode=Qt.SmoothTransformation)
self.wind_icon_label.setPixmap(rotated)
def doRotate(self, alfa):
tr = QTransform()
tr.translate(self.tx, self.ty)
tr.rotate(alfa)
tr.translate(-self.tx, -self.ty)
self.setTransform(tr)
def updatePixmap(self):
path = self._base_image
self.__pixmap = QPixmap(path)
self.__pixmap = self.__pixmap.scaled(self.__pixmap.width() * _SCALE,
self.__pixmap.height() * _SCALE)
self.__pixmap = self.__pixmap.transformed(QTransform().rotate(
self.angle))
self._base_label.setPixmap(self.__pixmap)
def keyPressEvent(self, evento):
if evento.key() == Qt.Key_Plus:
self.zoom_in()
if evento.key() == Qt.Key_Minus:
self.zoom_out()
if evento.key() == Qt.Key_R:
# Reset
self.programa.vista.setTransform(QTransform())
def updateViewer(self):
# if not self.hasImage():
# return
if self.zoom < 0:
self.fitInView(self.sceneRect(), self.aspectRatioMode)
self.zoom = self.size().width() / self.scene.width()
else:
self.setTransform(QTransform().scale(self.zoom, self.zoom))
def _QGraphicsItem_translate(self, dx, dy):
warnings.warn(
"QGraphicsItem.translate(sx, dy) is obsolete and removed in PyQt5. "
"Use setTransform(QTransform().translate(dx, dy), True) instead.",
DeprecationWarning,
stacklevel=2
)
self.setTransform(QTransform().translate(dx, dy), True)
