def loadImage(self, xFactor, yFactor):
newImg = QImage()
newImg.load(self.photoFileManager.getCurPhotoFilename())
newImgInfo = self.photoFileManager.getCurPhotoInfo()
transform = QTransform()
transform.rotate(newImgInfo.rotationAngle)
interImg = newImg.transformed(transform, Qt.SmoothTransformation)
xReqdSize = self.cellSize.width() * xFactor + self.xBetweenPics * (xFactor-1)
yReqdSize = self.cellSize.height() * yFactor + self.yBetweenPics * (yFactor-1)
inter2Img = interImg.scaled(QSize(xReqdSize,yReqdSize), Qt.KeepAspectRatioByExpanding, Qt.SmoothTransformation)
finalImg = inter2Img.copy(0,0,xReqdSize,yReqdSize)
# print("XY Size", xFactor, yFactor, xReqdSize,yReqdSize)
return (finalImg, newImgInfo)
def resizeEvent(self, event):
sceneWidth = min(event.size().width(), event.size().height())
trans = QTransform()
trans.scale(sceneWidth / self.initialSceneWidth,
sceneWidth / self.initialSceneWidth)
self.setTransform(trans)
self.centerOn(sceneWidth / 2.0, sceneWidth / 2.0)
def _image(file, sub_folder, rotate=None):
pixmap = QPixmap(os_path_join(_BASE_PATH, sub_folder, file))
if rotate is None:
return pixmap
transform = QTransform()
transform.rotate(rotate)
return pixmap.transformed(transform)
def setupMatrix(self):
scale = 2.0 ** ((self.zoomLevel - 250) / 50.0)
transform = QTransform()
transform.scale(scale, scale)
self.graphicsView.setTransform(transform)
def init (self):
self.m_scaleX = self.width() / self.m_originalWidth
self.m_scaleY = self.height() / self.m_originalHeight
self.m_itemHand = QGraphicsSvgItem(":/qfi/images/vsi/vsi_hand.svg")
self.m_itemHand.setCacheMode (QGraphicsItem.NoCache)
self.m_itemHand.setZValue( self.m_handZ )
self.m_itemHand.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemHand.setTransformOriginPoint( self.m_originalVsiCtr )
self.m_scene.addItem (self.m_itemHand)
self.m_itemFace = QGraphicsSvgItem(":/qfi/images/vsi/vsi_face.svg")
self.m_itemFace.setCacheMode (QGraphicsItem.NoCache)
self.m_itemFace.setZValue( self.m_faceZ )
self.m_itemFace.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemFace.setTransformOriginPoint( self.m_originalVsiCtr )
self.m_scene.addItem (self.m_itemFace)
self.m_itemCase = QGraphicsSvgItem(":/qfi/images/vsi/vsi_case.svg")
self.m_itemCase.setCacheMode (QGraphicsItem.NoCache)
self.m_itemCase.setZValue( self.m_caseZ )
self.m_itemCase.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemCase.setTransformOriginPoint( self.m_originalVsiCtr )
self.m_scene.addItem (self.m_itemCase)
self.centerOn (self.width()/2, self.height()/2)
self.updateView()
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 paintEvent(self, event):
"""QToolBar.paintEvent reimplementation
Draws buttons, dock icon and text
"""
rect = self._spacer.rect()
painter = QPainter(self)
transform = QTransform()
transform.translate(self._spacer.pos().x(), self._spacer.pos().y())
painter.setTransform(transform)
""" Not supported currently
if self._dock.features() & QDockWidget.DockWidgetVerticalTitleBar :
transform = QTransform()
rect.setSize(QSize(rect.height(), rect.width()))
transform.rotate(-90)
transform.translate(-rect.width(), 0)
painter.setTransform(transform)
"""
# icon / title
optionB = QStyleOptionButton()
optionB.initFrom(self._dock)
optionB.rect = rect
optionB.text = self._dock.windowTitle()
optionB.iconSize = self.iconSize()
optionB.icon = self._dock.windowIcon()
self.style().drawControl(QStyle.CE_PushButtonLabel, optionB, painter, self._dock)
def ParseTransformAttrib(s):
# where s is an SVG transform attribute such as "translate(-2,1) matrix(0 1 2 3 4 5)"
# return a list of QTransforms
xforms = []
s = s.lower()
while s:
s = re.sub(r'^\s+,?\s+', '', s) # remove leading WS,WS
m = re.match(r'\s*(\w+)\s*\(((\s*[0-9e.+-]+\s*,?)+)\)', s) # match identifier(numbers) clause
if m:
values = SplitFloatValues(m.group(2))
if m.group(1) == 'translate':
if len(values) == 1: values.append(0)
xforms.append( QTransform.fromTranslate(*values) )
elif m.group(1) == 'scale':
if len(values) == 1: values.append(values[0])
xforms.append( QTransform.fromScale(*values) )
elif m.group(1) == 'rotate':
xforms.append( QTransform().rotate(values[0]) ) # TODO: handle cx,cy values
elif m.group(1) == 'matrix':
logger.trace('matrix({}): m.group(2) = {}', values, m.group(2))
xforms.append( QTransform( values[0], values[1], 0
, values[2], values[3], 0
, values[4], values[5], 1) )
# TODO: handle skewX and skewY
else: logger.warning('unrecognized transform: {}', m.group())
s = s[m.end()+1:]
else:
if s: logger.warning('unparsed transform: {}', s)
break
return xforms
def _get_selected_edge(self, pos: QPointF, transform: QTransform, horizontal_selection: bool):
x1, x2 = self.x, self.x + self.width
y1, y2 = self.y, self.y + self.height
x, y = pos.x(), pos.y()
spacing = 5
spacing /= transform.m11() if horizontal_selection else transform.m22()
if horizontal_selection:
x1a, x1b = x1 - spacing, x1 + spacing
y1a, y1b = y1, y2
x2a, x2b = x2 - spacing, x2 + spacing
y2a, y2b = y1, y2
else:
x1a, x1b, x2a, x2b = x1, x2, x1, x2
y1a, y1b = min(y1 - spacing, y1 + spacing), max(y1 - spacing, y1 + spacing)
y2a, y2b = min(y2 - spacing, y2 + spacing), max(y2 - spacing, y2 + spacing)
if x1a < x < x1b and y1a < y < y1b:
self.selected_edge = 0
return 0
if x2a < x < x2b and y2a < y < y2b:
self.selected_edge = 1
return 1
self.selected_edge = None
return None
def rotate(self):
t = QTransform()
# for x in range (0, 150):
t.rotate(-1)
self.label.setPixmap(self.label.pixmap().transformed(t))
print("FINISHED")
def zoom(self, factor, pos):
self.recenter(pos)
p = self._transform.inverted()[0].map(self.rect().center())
test = QTransform(self._transform)
test.scale(factor, factor)
# check if the bounding rectangle does not enclose the view
# refuse to zoom out (factor < 1) if this is the case
# XXX TODO
self._transform.scale(factor, factor)
self.recenter(p, True)
def mapTextureBasedOnZoom(self, brush):
if brush.texture().width() > 0 and brush.texture().height() > 0:
brush_trans = QTransform()
brush_trans.translate(self.__center_x - self.__width * 0.5,
self.__center_y - self.__height * 0.5)
brush_trans.scale(self.__width/float(brush.texture().width()),
self.__height/float(brush.texture().height()))
brush.setTransform(brush_trans)
self.setBrush(brush)
def rotatePlayer(self, direction):
"""
Function responsible for rotating players icon.
"""
rotation = QTransform()
if direction == 'up':
rotation.rotate(0)
elif direction == 'right':
rotation.rotate(90)
elif direction == 'down':
rotation.rotate(180)
elif direction == 'left':
rotation.rotate(270)
self.use_this_pixmap = \
self.nurse_pixmap_base.transformed(rotation)
self.nurse_pixmap = \
self.nurse_pixmap_base.transformed(rotation)
self.nurse_left_pixmap = \
self.nurse_left_pixmap_base.transformed(rotation)
self.nurse_right_pixmap = \
self.nurse_right_pixmap_base.transformed(rotation)
"""
def mouseMoveEvent(self, ev): if self.mode == MODE_MOVE: return QGraphicsItem.mouseMoveEvent(self, ev) center = self.transform().map(self.boundingRect().center()) origToCenter = self.origin - center originScale = vectorLength(origToCenter) origAngle = math.atan2(origToCenter.y(), origToCenter.x()) newPt = self.transform().map(ev.pos()) newToCenter = newPt - center newScale = vectorLength(newToCenter) newAngle = math.atan2(newToCenter.y(), newToCenter.x()) # build transform t = QTransform() t.translate(center.x(), center.y()) if self.mode == MODE_ROT: self._angle = math.degrees(newAngle - origAngle) t.rotate(self._angle) if self.mode == MODE_ZOOM: self._scale = newScale / originScale t.scale(self._scale, self._scale) t.translate(-center.x(), -center.y()) self.setTransform(t)
def resizeEvent(self, event):
self.setUpdatesEnabled(False)
super().resizeEvent(event)
# center scene in viewport
r = self.rect()
t = QTransform()
t.translate(-r.width() / 2, -r.height() / 2)
r = QRectF(QPointF(r.x(), r.y()) * t, QSizeF(r.width(), r.height()))
self.setSceneRect(r)
self.__resizeDelayTimer.start(self.resizeUpdateDelay)
self.setUpdatesEnabled(True)
def transform(self):
try:
return self.__dict__['transform'] if self.scale else QTransform()
except KeyError:
transform = QTransform()
image = self.client.image
if image is not None and not image.isNull():
scale = min(self.width()/image.width(), self.height()/image.height())
transform.translate((self.width() - image.width()*scale)/2, (self.height() - image.height()*scale)/2)
transform.scale(scale, scale)
transform = self.__dict__.setdefault('transform', transform)
return transform
def visibleIn(area, object, renderer):
boundingRect = renderer.boundingRect(object)
if (object.rotation() != 0):
# Rotate around object position
pos = renderer.pixelToScreenCoords_(object.position())
boundingRect.translate(-pos)
transform = QTransform()
transform.rotate(object.rotation())
boundingRect = transform.mapRect(boundingRect)
boundingRect.translate(pos)
return intersects(area, boundingRect)
def _updateSequenceText(self):
seq_item = self._seq_item
is_on_top = self._is_on_top
index = self._insertion.idx()
base_text = self._seq_text
font = styles.SEQUENCEFONT
seq_font_h = styles.SEQUENCEFONTH
insert_w = styles.INSERTWIDTH
seq_font_char_w = styles.SEQUENCEFONTCHARWIDTH
# draw sequence on the insert
if base_text: # only draw sequences if they exist i.e. not None!
len_BT = len(base_text)
if is_on_top:
angle_offset = 0
else:
angle_offset = 180
if len_BT > 20:
base_text = base_text[:17] + '...'
len_BT = len(base_text)
fraction_arc_len_per_char = (1.0 - 2.0*_FRACTION_INSERT_TO_PAD) / (len_BT + 1)
seq_item.setPen(QPen(Qt.NoPen))
seq_item.setBrush(QBrush(Qt.black))
seq_path = QPainterPath()
loop_path = self.path()
for i in range(len_BT):
frac = _FRACTION_INSERT_TO_PAD + (i+1)*fraction_arc_len_per_char
pt = loop_path.pointAtPercent(frac)
tang_ang = loop_path.angleAtPercent(frac)
temp_path = QPainterPath()
# 1. draw the text
temp_path.addText(0, 0, font, base_text[i if is_on_top else -i-1])
# 2. center it at the zero point different for top and bottom
# strands
if not is_on_top:
temp_path.translate(0, -seq_font_h - insert_w)
temp_path.translate(QPointF(-seq_font_char_w / 2.,
-2 if is_on_top else seq_font_h))
mat = QTransform()
# 3. rotate it
mat.rotate(-tang_ang + angle_offset)
rotated_path = mat.map(temp_path)
# 4. translate the rotate object to it's position on the part
rotated_path.translate(pt)
seq_path.addPath(rotated_path)
# end for
seq_item.setPath(seq_path)
def loadImage(self):
self.newImg = QImage()
self.newImg.load(self.photoFileManager.getCurPhotoFilename())
self.newImgInfo = self.photoFileManager.getCurPhotoInfo()
transform = QTransform()
transform.rotate(self.newImgInfo.rotationAngle)
self.interImg = self.newImg.transformed(transform, Qt.SmoothTransformation)
# xReqdSize = self.cellSize.width() * xFactor + self.xBetweenPics * (xFactor-1)
# yReqdSize = self.cellSize.height() * yFactor + self.yBetweenPics * (yFactor-1)
self.inter2Img = self.interImg.scaled(QSize(self.width(),self.height()),
Qt.KeepAspectRatio, Qt.SmoothTransformation)
# finalImg = interImg.copy(0,0,xReqdSize,yReqdSize)
# print("XY Size", xFactor, yFactor, xReqdSize,yReqdSize)
return self.inter2Img, self.newImgInfo
def draw_frequency_marker(self, x_pos, frequency):
if frequency is None:
self.clear_frequency_marker()
return
y1 = self.sceneRect().y()
y2 = self.sceneRect().y() + self.sceneRect().height()
if self.frequency_marker is None:
pen = QPen(constants.LINECOLOR, 0)
self.frequency_marker = [None, None]
self.frequency_marker[0] = self.addLine(x_pos, y1, x_pos, y2, pen)
self.frequency_marker[1] = self.addSimpleText("")
self.frequency_marker[1].setBrush(QBrush(constants.LINECOLOR))
font = QFont()
font.setBold(True)
font.setPointSize(int(font.pointSize() * 1.25)+1)
self.frequency_marker[1].setFont(font)
self.frequency_marker[0].setLine(x_pos, y1, x_pos, y2)
scale_x, scale_y = self.__calc_x_y_scale(self.sceneRect())
self.frequency_marker[1].setTransform(QTransform.fromScale(scale_x, scale_y), False)
self.frequency_marker[1].setText("Tune to " + Formatter.big_value_with_suffix(frequency, decimals=3))
font_metric = QFontMetrics(self.frequency_marker[1].font())
text_width = font_metric.width("Tune to") * scale_x
text_width += (font_metric.width(" ") * scale_x) / 2
self.frequency_marker[1].setPos(x_pos-text_width, 0.95*y1)
def mouseMoveEvent(self, event):
if self.__dragActive:
mousePos = self.view.mapToScene(self.view.mapFromGlobal(QCursor.pos()))
vec1 = QVector2D(mousePos)
vec1.normalize()
trans = QTransform()
trans.rotate(self.rotation())
vec2 = QVector2D(self.p2 * trans)
vec2.normalize()
angle = math.acos(max(-1, min(1, QVector2D.dotProduct(vec1, vec2)))) * 180 / math.pi
# clockwise rotation
if vec1.y() * vec2.x() < vec1.x() * vec2.y():
angle *= -1
angle = (self.rotation() + angle) % 360
self.setRotation(angle)
def new_absolute_zoom(self, factor):
"""Sets a new absolute zoom and emits viewport_changed.
"""
f = factor
scene_rect = self.scene().sceneRect() # Scene
view_rect = self.viewport().rect() # Available space
# The size of the scene if the new transform is applied
t_scene_rect = QTransform.fromScale(f, f).mapRect(scene_rect)
if (t_scene_rect.width() < view_rect.width() and
t_scene_rect.height() < view_rect.height()):
# The user wants to zoom out so that the image is smaller than the
# view
self.zoom_home()
else:
f = min(self.MAXIMUM_ZOOM, f)
msg = 'Change absolute zoom from [{0}] to [{1}]'
debug_print(msg.format(self.absolute_zoom, f))
selected = self.scene().selectedItems()
if not selected:
# No selection so we want to centre on the mouse cursor, if it
# is within the view. We need to get the mouse position in
# scene coords before applying the zoom.
mouse_pos = self.mapFromGlobal(QCursor.pos())
if self.rect().contains(mouse_pos, proper=True):
mouse_pos = self.mapToScene(mouse_pos)
else:
mouse_pos = None
self.setTransform(QTransform.fromScale(f, f))
if selected:
# Centre on selected items
self.centerOn(
unite_rects(i.sceneBoundingRect() for i in selected).center()
)
elif mouse_pos:
# Centre on mouse position
self.centerOn(mouse_pos)
else:
# Default behaviour is fine
pass
self.viewport_changed.emit(self.normalised_scene_rect())
def _fetch_tile_layer(self, timestamp, ims, transform, tile_nr, stack_id, ims_req, cache):
"""
Fetch a single tile from a layer (ImageSource).
Parameters
----------
timestamp
The timestamp at which ims_req was created
ims
The layer (image source) we're fetching from
transform
The transform to apply to the fetched data, before storing it in the cache
tile_nr
The ID of the fetched tile
stack_id
The stack ID of the tile we're fetching (e.g. which T-slice and Z-slice this tile belongs to)
ims_req
A request object (e.g. GrayscaleImageRequest) with a wait() method that produces an item of
the appropriate type for the layer (i.e. either a QImage or a QGraphicsItem)
cache
The value of self._cache at the time the ims_req was created.
(The cache can be replaced occasionally. See TileProvider._onSizeChanged().)
"""
try:
try:
with cache:
layerTimestamp = cache.layerTimestamp(stack_id, ims, tile_nr)
except KeyError:
# May not be a timestamp yet (especially when prefetching)
layerTimestamp = 0
tile_rect = QRectF(self.tiling.imageRects[tile_nr])
if timestamp > layerTimestamp:
img = ims_req.wait()
if isinstance(img, QImage):
img = img.transformed(transform)
elif isinstance(img, QGraphicsItem):
# FIXME: It *seems* like applying the same transform to QImages and QGraphicsItems
# makes sense here, but for some strange reason it isn't right.
# For QGraphicsItems, it seems obvious that this is the correct transform.
# I do not understand the formula that produces 'transform', which is used for QImage tiles.
img.setTransform(QTransform.fromTranslate(tile_rect.left(), tile_rect.top()), combine=True)
img.setTransform(self.tiling.data2scene, combine=True)
else:
assert False, "Unexpected image type: {}".format(type(img))
with cache:
try:
cache.updateTileIfNecessary(stack_id, ims, tile_nr, timestamp, img)
except KeyError:
pass
if stack_id == self._current_stack_id and cache is self._cache:
self.sceneRectChanged.emit(tile_rect)
except BaseException:
sys.excepthook(*sys.exc_info())
def setHeading(self, heading):
xForm = QTransform()
xForm.translate(self.__center_x, self.__center_y)
xForm.rotate(math.degrees(heading))
xForm.translate(-self.__center_x, -self.__center_y)
self.setTransform(xForm)
self.mapTextureBasedOnZoom(self.brush())
def textureRect(self, rect_tile):
tile_info = rect_tile.data(0)
if tile_info is None:
return False
pm = QPixmap(self.__tiler.tile_to_path(tile_info))
if pm.width() != 256:
#print("Probably didn't get tile:", next_tile_info.x, next_tile_info.y, "\n")
#TODO: Attempt to texture with a lower res tile
#Bear in mind that you will have to take Mercator projection into
#account on the lower res tile.
#First Attempt: didn't work
#if tile_info.zoom <= self.__tiler.get_min_zoom():
# return False
#
#find colocated lower res tile
#(lat,lon) = tile_info.coord()
#tile_info2 = self.__tiler.coord_to_tile(lat,lon, tile_info.zoom-1)
#rect_tile.setData(0, tile_info2)
#print("prev tile: ", tile_info.tile, tile_info.coord())
#return self.textureRect(rect_tile, depth + 1)
#until such time as we can pull lower res tiles and figure out
#which area to render on a rectangle, skip:
return False
topLeft = rect_tile.boundingRect().topLeft()
bottomRight = rect_tile.boundingRect().bottomRight()
width = bottomRight.x() - topLeft.x()
height = bottomRight.y() - topLeft.y()
brush_trans = QTransform()
brush_trans.translate(topLeft.x(), topLeft.y())
brush_trans.scale(width/256.0, height/256.0)
qb = QBrush(pm)
qb.setTransform(brush_trans)
rect_tile.setBrush(qb)
return True
def _QGraphicssItem_scale(self, *args):
if args:
warnings.warn(
"QGraphicsItem.scale(sx, sy) is obsolete and removed in PyQt5. "
"Use setTransform(QTransform.fromScale(sx, sy), True) instead.",
DeprecationWarning,
stacklevel=2
)
self.setTransform(QTransform.fromScale(*args), True)
else:
return _QGraphicsItem_scale1(self)
def objectTransform(object, renderer):
transform = QTransform()
if (object.rotation() != 0):
pos = renderer.pixelToScreenCoords_(object.position())
transform = rotateAt(pos, object.rotation())
offset = object.objectGroup().offset()
if not offset.isNull():
transform *= QTransform.fromTranslate(offset.x(), offset.y())
return transform
def timerEvent(self, event):
axelDistance = 54.0
wheelsAngleRads = (self.wheelsAngle * math.pi) / 180
turnDistance = math.cos(wheelsAngleRads) * axelDistance * 2
turnRateRads = wheelsAngleRads / turnDistance
turnRate = (turnRateRads * 180) / math.pi
rotation = self.speed * turnRate
self.setTransform(QTransform().rotate(rotation), True)
self.setTransform(QTransform.fromTranslate(0, -self.speed), True)
self.update()
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self._transform = QTransform()
# set up transform
self._transform.translate(0, 0)
# set to 100 px = 1 inch
self._transform.scale(100.0/Coord.inchToSch(1), -100.0/Coord.inchToSch(1))
self._mousePos = QPoint()
self._wheelAngle = 0
self._ctrl = None
self.setMouseTracking(True)
self.setFocusPolicy(Qt.StrongFocus)
def init (self):
self.m_scaleX = self.width() / self.m_originalWidth
self.m_scaleY = self.height() / self.m_originalHeight
self.m_itemBack = QGraphicsSvgItem(":/qfi/images/adi/adi_back.svg")
self.m_itemBack.setCacheMode (QGraphicsItem.NoCache)
self.m_itemBack.setZValue( self.m_backZ )
self.m_itemBack.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemBack.setTransformOriginPoint( self.m_originalAdiCtr )
self.m_scene.addItem (self.m_itemBack)
self.m_itemFace = QGraphicsSvgItem(":/qfi/images/adi/adi_face.svg")
self.m_itemFace.setCacheMode (QGraphicsItem.NoCache)
self.m_itemFace.setZValue( self.m_faceZ )
self.m_itemFace.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemFace.setTransformOriginPoint( self.m_originalAdiCtr )
self.m_scene.addItem (self.m_itemFace)
self.m_itemRing = QGraphicsSvgItem(":/qfi/images/adi/adi_ring.svg")
self.m_itemRing.setCacheMode (QGraphicsItem.NoCache)
self.m_itemRing.setZValue( self.m_ringZ )
self.m_itemRing.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemRing.setTransformOriginPoint( self.m_originalAdiCtr )
self.m_scene.addItem (self.m_itemRing)
self.m_itemCase = QGraphicsSvgItem(":/qfi/images/alt/alt_case.svg")
self.m_itemCase.setCacheMode (QGraphicsItem.NoCache)
self.m_itemCase.setZValue( self.m_caseZ )
self.m_itemCase.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemCase.setTransformOriginPoint( self.m_originalAdiCtr )
self.m_scene.addItem (self.m_itemCase)
self.centerOn (self.width()/2, self.height()/2)
self.updateView()
def set_rect_bars(self):
global now
if self.input_rect:
if now != None:
buf = self.scene.itemAt(now, QTransform()).rect()
self.rect = [buf.left(), buf.top(), buf.right(), buf.bottom()]
self.input_rect = False
self.adding_lines_btn.setDisabled(False)
self.clear_btn.setDisabled(False)
self.cut_btn.setDisabled(False)
else:
self.pen.setColor(self.color_out_rect)
now = None
self.rect = None
self.input_rect = True
self.adding_lines_btn.setDisabled(True)
self.clear_btn.setDisabled(True)
self.cut_btn.setDisabled(True)
def rotateImage90(self):
"""
Rotate image 90º clockwise
"""
if self.image.isNull() == False:
transform90 = QTransform().rotate(90)
pixmap = QPixmap(self.image)
rotated = pixmap.transformed(transform90,
mode=Qt.SmoothTransformation)
self.image_label.setPixmap(
rotated.scaled(self.image_label.size(), Qt.KeepAspectRatio,
Qt.SmoothTransformation))
self.image = QPixmap(rotated)
self.image_label.repaint() # repaint the child widget
else:
# No image to rotate
pass
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
##Buttons
buttonRec = QPushButton('Record new movement', self)
buttonRec.setToolTip(
'Start the recording of a new movement, do it multiple times to build the database'
)
buttonRec.move(20, 560)
buttonRec.resize(150, 30)
buttonRec.clicked.connect(self.startRec)
buttonStopRec = QPushButton('Stop recording', self)
buttonStopRec.setToolTip('Stop the recording of the new movement')
buttonStopRec.move(220, 560)
buttonStopRec.clicked.connect(self.stopRec)
buttonMakeFile = QPushButton('Save to file', self)
buttonMakeFile.setToolTip(
'Save all the recorded movements to the dataset.csv file')
buttonMakeFile.move(420, 560)
buttonMakeFile.clicked.connect(self.makeFile)
##Captors
self.captors = [150, 0, 450, 0, 625, 250, 450, 520, 150, 520, 0, 250]
self.rotation = [0, 0, 90, 180, 180, 270]
captors = []
for i in range(0, 6):
captor = QLabel(self)
img = QPixmap('ir-detector-small.png')
transform = QTransform().rotate(self.rotation[i])
img = img.transformed(transform, Qt.SmoothTransformation)
captor.setPixmap(img)
captor.move(self.captors[i * 2] - 5, self.captors[i * 2 + 1] - 5)
captors.append(captor)
self.circles = [100, 400, 150, 230, 200, 300, 480, 300, 226]
self.circlesInitPos = self.circles.copy()
##Timer
self.sampleTimer = QTimer()
self.sampleTimer.timeout.connect(self.sample)
self.updateTimer = QTimer()
self.updateTimer.timeout.connect(self.paintUpdate)
self.updateTimer.start(int(1000 / self.FPS))
self.countTimer = QTimer()
self.countTimer.timeout.connect(self.timerRec)
self.show()
def _validateImage(self):
if (self._sharedImage.transform != DemoItem._transform and
not Colors.noRescale) or (self._sharedImage.image is None and
self._sharedImage.pixmap is None):
# (Re)create image according to new transform.
self._sharedImage.image = None
self._sharedImage.pixmap = None
self._sharedImage.transform = DemoItem._transform
# Let subclass create and draw a new image according to the new
# transform.
if Colors.noRescale:
transform = QTransform()
else:
transform = DemoItem._transform
image = self.createImage(transform)
if image is not None:
if Colors.showBoundingRect:
# Draw red transparent rect.
painter = QPainter(image)
painter.fillRect(image.rect(), QColor(255, 0, 0, 50))
painter.end()
self._sharedImage.unscaledBoundingRect = self._sharedImage.transform.inverted(
)[0].mapRect(QRectF(image.rect()))
if Colors.usePixmaps:
if image.isNull():
self._sharedImage.pixmap = QPixmap(1, 1)
else:
self._sharedImage.pixmap = QPixmap(image.size())
self._sharedImage.pixmap.fill(QColor(0, 0, 0, 0))
painter = QPainter(self._sharedImage.pixmap)
painter.drawImage(0, 0, image)
else:
self._sharedImage.image = image
return True
else:
return False
return True
def contextMenuEvent(self, event):
item = self.itemAt(event.scenePos(), QTransform())
if item != None and item != self.pixmapItem and type(
item) is RectangleLabelItem:
#Later do something to remove rectangles
menu = item.contextMenu()
menu.addSeparator()
menu.addAction("Remove rectangle",
lambda: self.removeLabelItem(item))
menu.exec(event.screenPos())
return
menu = QMenu()
menu.addAction("Insert bounding rectangle",
lambda: self.insertBoundingRectangle(event.scenePos()))
menu.exec(event.screenPos())
def dataTransform(self):
"""Return the transform that maps from this image's input array to its
local coordinate system.
This transform corrects for the transposition that occurs when image data
is interpreted in row-major order.
"""
# Might eventually need to account for downsampling / clipping here
tr = QTransform()
if self.axisOrder == 'row-major':
# transpose
tr.scale(1, -1)
tr.rotate(-90)
return tr
def draw(self, page, painter, key, tile, paperColor=None):
"""Draw a tile on the painter.
The painter is already at the right position and rotation.
For the Poppler page and renderer, draw() is only used for printing.
(See AbstractPage.print().)
"""
source = self.map(key, page.pageRect()).mapRect(
QRectF(*tile)).toRect() # rounded
target = QRectF(0, 0, tile.w, tile.h)
if key.rotation & 1:
target.setSize(target.size().transposed())
doc = page.document
p = doc.page(page.pageNumber)
with self.setup(doc, self.printRenderBackend, paperColor):
if self.printRenderBackend == popplerqt5.Poppler.Document.ArthurBackend:
# Poppler's Arthur backend removes the current transform from
# the painter (it sets a default CTM, instead of combining it
# with the current transform). We let Poppler draw on a QPicture,
# and draw that on our painter.
pic = QPicture()
p.renderToPainter(QPainter(pic), page.dpi, page.dpi,
source.x(), source.y(), source.width(),
source.height())
# our resolution could be different, scale accordingly
painter.save()
painter.scale(
pic.logicalDpiX() / painter.device().logicalDpiX(),
pic.logicalDpiY() / painter.device().logicalDpiY())
pic.play(painter)
painter.restore()
else:
# Make an image exactly in the printer's resolution
m = painter.transform()
r = m.mapRect(source) # see where the source ends up
w, h = r.width(), r.height()
if m.m11() == 0:
w, h = h, w # swap if rotation & 1 :-)
# now we know the scale from our dpi to the paintdevice's logicalDpi!
hscale = w / source.width()
vscale = h / source.height()
s = QTransform().scale(hscale, vscale).mapRect(source)
dpiX = page.dpi * hscale
dpiY = page.dpi * vscale
img = p.renderToImage(dpiX, dpiY, s.x(), s.y(), s.width(),
s.height())
painter.drawImage(target, img, QRectF(img.rect()))
def init (self):
self.m_scaleX = self.width() / self.m_originalWidth
self.m_scaleY = self.height() / self.m_originalHeight
self.m_itemFace_1 = QGraphicsSvgItem(":/qfi/images/alt/alt_face_1.svg")
self.m_itemFace_1.setCacheMode (QGraphicsItem.NoCache)
self.m_itemFace_1.setZValue( self.m_face1Z )
self.m_itemFace_1.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemFace_1.setTransformOriginPoint( self.m_originalAltCtr )
self.m_scene.addItem (self.m_itemFace_1)
self.m_itemFace_2 = QGraphicsSvgItem(":/qfi/images/alt/alt_face_2.svg")
self.m_itemFace_2.setCacheMode (QGraphicsItem.NoCache)
self.m_itemFace_2.setZValue( self.m_face2Z )
self.m_itemFace_2.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemFace_2.setTransformOriginPoint( self.m_originalAltCtr )
self.m_scene.addItem (self.m_itemFace_2)
self.m_itemFace_3 = QGraphicsSvgItem(":/qfi/images/alt/alt_face_3.svg")
self.m_itemFace_3.setCacheMode (QGraphicsItem.NoCache)
self.m_itemFace_3.setZValue( self.m_face3Z )
self.m_itemFace_3.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemFace_3.setTransformOriginPoint( self.m_originalAltCtr )
self.m_scene.addItem (self.m_itemFace_3)
self.m_itemHand_1 = QGraphicsSvgItem(":/qfi/images/alt/alt_hand_1.svg")
self.m_itemHand_1.setCacheMode (QGraphicsItem.NoCache)
self.m_itemHand_1.setZValue( self.m_hand1Z )
self.m_itemHand_1.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemHand_1.setTransformOriginPoint( self.m_originalAltCtr )
self.m_scene.addItem (self.m_itemHand_1)
self.m_itemHand_2 = QGraphicsSvgItem(":/qfi/images/alt/alt_hand_2.svg")
self.m_itemHand_2.setCacheMode (QGraphicsItem.NoCache)
self.m_itemHand_2.setZValue( self.m_hand2Z )
self.m_itemHand_2.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemHand_2.setTransformOriginPoint( self.m_originalAltCtr )
self.m_scene.addItem (self.m_itemHand_2)
self.m_itemCase = QGraphicsSvgItem(":/qfi/images/alt/alt_case.svg")
self.m_itemCase.setCacheMode (QGraphicsItem.NoCache)
self.m_itemCase.setZValue( self.m_caseZ )
self.m_itemCase.setTransform( QTransform.fromScale( self.m_scaleX, self.m_scaleY ), True )
self.m_itemCase.setTransformOriginPoint( self.m_originalAltCtr )
self.m_scene.addItem (self.m_itemCase)
self.centerOn (self.width()/2, self.height()/2)
self.updateView()
def move_unit(self):
game_field = self.parent()
if not self.animation.timer.isActive():
if not self.death_animation.timer.isActive():
self.clear()
self.pacman.init_start_state()
self.animation.timer.start(70)
else:
if self.pacman.is_dead:
game_field.game.blinky.init_start_state()
game_field.game.pinky.init_start_state()
game_field.game.inky.init_start_state()
game_field.game.clyde.init_start_state()
self.animation.timer.stop()
self.death_animation.timer.start(70)
self.clear()
if self.pacman.lifes < 0:
game_field.show_game_over_dialog()
else:
if Game.is_level_complete:
if game_field.game.level + 1 > 3:
game_field.game.level = 1
else:
game_field.game.level += 1
game_field.game.restart()
game_field.scene.clear()
game_field.init_map()
game_field.scene.update()
self.pacman.move()
x_pos = self.pacman.x * self.width()
y_pos = self.pacman.y * self.height()
pacman_direction = self.pacman.current_direction
self.animation.current_direction = pacman_direction
self.move(x_pos, y_pos)
scene = self.parentWidget().scene
food = scene.itemAt(x_pos, y_pos, QTransform())
if food is not None:
scene.removeItem(food)
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
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
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
def mousePressEvent(self, event):
self.rb_selected_points.clear()
cursor_pos = event.scenePos().toPoint()
item_under_cursor = self.itemAt(cursor_pos, QTransform())
if item_under_cursor is not None:
if self.highlighted_item is not None and \
not self.highlighted_item.isHighlighted() and \
not self.highlighted_item.isPersistent():
self.highlighted_item.unhighlight_self()
if self.selected_item is not None and \
not self.selected_item.isHighlighted() and \
not self.selected_item.isPersistent():
self.selected_item.unhighlight_self()
self.selected_item = item_under_cursor
self.selected_item.mousePressEvent(event)
if not self.parent.main_window.MODE_RECOLOR_NODE:
self.highlighted_item = item_under_cursor
self.highlighted_item.highlight_self()
self._move = True
else:
# Clicking else where resets any selection previously made
if self.highlighted_item is not None:
if not self.highlighted_item.isHighlighted(
) and not self.highlighted_item.isPersistent():
self.highlighted_item.unhighlight_self()
if self.selected_item is not None:
if not self.selected_item.isHighlighted(
) and not self.selected_item.isPersistent():
self.selected_item.unhighlight_self()
self.highlighted_item = None
self.selected_item = None
if self.parent.main_window.MODE_RUBBER_BAND:
# Initializing rubber band
self.rb_origin = self.parent.mapFromScene(cursor_pos)
self.rubber_band = QRubberBand(QRubberBand.Rectangle,
self.parent)
self.rubber_band.setGeometry(QRect(self.rb_origin, QSize()))
self.rubber_band.show()
def __placeShip(self, shipListItem, x, y, rotation):
sceneX, sceneY = (x + 1) * self.tileSize, (y + 1) * self.tileSize
shipListItem.count -= 1
shipListItem.counterText.setPlainText(str(shipListItem.count))
pixmap = QPixmap(shipListItem.image).transformed(QTransform().rotate(
(rotation.value)))
placedShip = QGraphicsPixmapItem(pixmap)
placedShip.setData(0, rotation)
placedShip.setData(1, shipListItem)
placedShip.setData(2, QPoint(x, y)) # position in map coordinates
placedShip.setPos(sceneX, sceneY)
placedShip.setTransformationMode(
Qt.TransformationMode.SmoothTransformation)
placedShip.setScale(self.__scaleFactor)
self.__placedShips.append(placedShip)
self.__scene.addItem(placedShip)
def paint(self, painter):
if self._rubberBandRect is None:
return
widget = self.parent()
# okay, OS-native rubber band does not support painting with
# floating-point coordinates
# paint directly on the widget with unscaled context
widgetOrigin = widget.mapToWidget(self._rubberBandRect.bottomLeft())
widgetMove = widget.mapToWidget(self._rubberBandRect.topRight())
option = QStyleOptionRubberBand()
option.initFrom(widget)
option.opaque = False
option.rect = QRectF(widgetOrigin, widgetMove).toRect()
option.shape = QRubberBand.Rectangle
painter.save()
painter.setRenderHint(QPainter.Antialiasing, False)
painter.setTransform(QTransform())
widget.style().drawControl(QStyle.CE_RubberBand, option, painter,
widget)
painter.restore()
def actualizar_imagen_enemigos(self, MyPlayerEvent):
if self.started:
pl = MyPlayerEvent.player
d = pl.daño
r = pl.rotacion
tipo = pl.tipo
label = pl.image
if pl.is_dead:
c = pl.contador_dead % 6
pixmap = QPixmap(entidad_muerta[tipo][c])
else:
c = pl.contador_game % 40 // 10 + 1
pixmap = QPixmap(all_sprites_shits[tipo][d][c])
pixmap = pixmap.scaled(self.w / 70 * pl.tamaño**0.8,
self.w / 70 * pl.tamaño**0.8)
transform = QTransform().rotate(pl.angulo - r)
pixmap = pixmap.transformed(transform, Qt.SmoothTransformation)
label.move(pl.position[0], pl.position[1])
label.setPixmap(pixmap)
def drawGlyphImage(painter, glyph, scale, drawSelection=True, selectionColor=None):
image = glyph.image
pixmap = image.getRepresentation("defconQt.QPixmap")
if pixmap is None:
return
if selectionColor is None:
selectionColor = defaultColor("glyphSelection")
painter.save()
painter.setTransform(QTransform(*image.transformation), True)
painter.save()
painter.translate(0, pixmap.height())
painter.scale(1, -1)
painter.drawPixmap(0, 0, pixmap)
painter.restore()
if drawSelection and image.selected:
pen = QPen(selectionColor)
pen.setWidthF(3.5 * scale)
painter.setPen(pen)
painter.drawRect(pixmap.rect())
painter.restore()
def change_img(self, nro_img, iden, carpeta, angle, tipo_img):
obj = getattr(self, 'img_' + iden)
path = 'IMGS/{}/{}{}.png'.format(carpeta, tipo_img, nro_img)
if path not in self.imagenes:
img = QPixmap(path)
img = img.scaled(obj.tamano, obj.tamano, Qt.KeepAspectRatio)
self.imagenes[path] = img
else:
img = self.imagenes[path]
angle = round(360 - angle)
key = path + str(angle)
if key not in self.imagenes:
img = img.transformed(QTransform().rotate(angle),
Qt.SmoothTransformation)
self.imagenes[key] = img
else:
img = self.imagenes[key]
obj.setPixmap(img)
def __init__(self):
super().__init__()
self.language = settings.LANG
self.csv_separator = settings.CSV_SEPARATOR
self.fmt_float = settings.FMT_FLOAT
self.nodes = {}
self.nb_nodes = 0
self.adj_list = {}
self.current_line = None
self.current_port = None
self.project_path = ''
self.setSceneRect(
QRectF(0, 0, settings.SCENE_SIZE[0], settings.SCENE_SIZE[1]))
self.transform = QTransform()
self.selectionChanged.connect(self.selection_changed)
self._init_with_default_node()
def __init__(self, letter, scene, lliw="black"):
self.image = QPixmap.fromImage(self.set_tile(letter, lliw))
super(Tile, self).__init__(self.image)
self.letter = letter
self.colour = lliw
self.scene = scene
self.pixmap_item.setFlags(QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsMovable)
self.pixmap_item.setTransform(QTransform())
self.pixmap_item.setAcceptedMouseButtons(Qt.LeftButton)
self.pixmap_item.setZValue(1000)
self.pixmap_item.tile = self
self.pixmap_item.hide()
self.scene.addItem(self.pixmap_item)
self.cell = None
self.fade = None
self.movable(False)
def __init__(self,
mark_item: MarkItem,
scene,
view_scale,
transform=QTransform(),
parent=None):
super(OutlineItem, self).__init__(scene=scene,
shape=None,
view_scale=view_scale,
transform=transform,
parent=parent)
self.setFlag(QGraphicsItem.ItemIsSelectable, True)
self._is_browser_result = False
self._pen.setColor(mark_item.color)
self._mark_item = mark_item
self._mark_item.visible_changed.connect(self.visible_changed)
self._mark_item.fill_changed.connect(self.update)
self._mark_item.mark_item_color_changed.connect(self.update)
self.setSelected(True)
self._selected = False
def __init__(self, position, scene, style=Qt.SolidLine,brush=Qt.cyan,
rect=None, matrix=QTransform()):
super(BoxItem, self).__init__()
self.setFlags(QGraphicsItem.ItemIsSelectable|
QGraphicsItem.ItemIsMovable|
QGraphicsItem.ItemIsFocusable)
if rect is None:
PointSize = scene.views()[0].PointSize
rect = QRectF(-10 * PointSize, -PointSize, 20 * PointSize,
2 * PointSize)
self.rect = rect
self.style = style
self.brush = brush
self.setPos(position)
self.setTransform(matrix)
scene.clearSelection()
scene.addItem(self)
self.setSelected(True)
self.setFocus()
global Dirty
Dirty = True
def wheelEvent(self, wheel_event):
if wheel_event.modifiers() == Qt.NoModifier:
try:
delta = wheel_event.angleDelta().y()
except AttributeError:
delta = wheel_event.delta()
delta = max(min(delta, 480), -480)
mouse_before_scale_in_scene = self.mapToScene(wheel_event.pos())
scale_factor = 1 + (0.2 * (delta / 120.0))
scaling = QTransform(scale_factor, 0, 0, scale_factor, 0, 0)
self.setTransform(self.transform() * scaling)
mouse_after_scale_in_scene = self.mapToScene(wheel_event.pos())
center_in_scene = self.mapToScene(self.frameRect().center())
self.centerOn(center_in_scene + mouse_before_scale_in_scene -
mouse_after_scale_in_scene)
wheel_event.accept()
else:
QGraphicsView.wheelEvent(self, wheel_event)
def __init__(self, midiNumber, dur, acc, tieToPrev, vertPosLookUp,
extraLines, svgFolder, lineDistance, invert, horPos, vertPos,
addBarLine, head, appctxt, parent):
if dur < 16:
filePath = appctxt.get_resource(str(svgFolder / "stem.svg"))
widthRel = 1 / 5
heightRel = 3.5
horOff = head.widthRel - 1 / 5
vertOff = -heightRel + 1 / 2
else:
filePath = None
if filePath is not None:
super(Stem, self).__init__(filePath, parent)
else:
super(Stem, 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 + self.lineDistance * horOff,
vertPos + self.lineDistance * vertOff)
self.rightMostPoint = horPos + horOff * self.lineDistance + self.widthReal
def transform_factory(
horizontal_scaling_factor: float = 1.,
vertical_shearing_factor: float = .0,
horizontal_projection_factor: float = .0,
horizontal_shearing_factor: float = .0,
vertical_scaling_factor: float = 1.,
vertical_projection_factor: float = 0.,
horizontal_translation_factor: float = 0.,
vertical_translation_factor: float = 0.,
division_factor: float = 1.0,
) -> QTransform:
return QTransform(
horizontal_scaling_factor,
vertical_shearing_factor,
horizontal_projection_factor,
horizontal_shearing_factor,
vertical_scaling_factor,
vertical_projection_factor,
horizontal_translation_factor,
vertical_translation_factor,
division_factor,
)
def setIcon(self, widget, ico, rotate=0):
if isinstance(ico, str):
icon = QIcon()
if app_defs.APP_IMAGE_DIR:
path = app_defs.APP_IMAGE_DIR
else:
path = 'img'
path = os.path.join(path, ico)
if not os.path.isfile(path):
logging.warning(f'File {path} does not exist or is not a file')
pixmap = QPixmap(path)
if rotate:
transf = QTransform().rotate(rotate)
pixmap = QPixmap(pixmap.transformed(transf))
icon.addPixmap(pixmap)
else:
icon = self.style().standardIcon(ico)
widget.setIcon(icon)
def mousePressEvent(self, event):
QGraphicsScene.mousePressEvent(self, event)
if self.piano.contains(event.scenePos()):
item = self.itemAt(event.scenePos(), QTransform())
if isinstance(item, PianoKeyItem) and item.note is not None:
self.last_piano_note = item.note
self.noteclicked.emit(self.last_piano_note, True)
return
if not (any(key.pressed for key in self.piano_keys)
or any(note.pressed for note in self.notes)):
for note in self.selected_notes:
note.setSelected(False)
self.selected_notes = []
if event.button() == Qt.LeftButton:
if self.insert_mode:
self.place_ghost = True
else:
self.marquee_select = True
self.marquee_rect = QRectF(event.scenePos().x(),
event.scenePos().y(), 1, 1)
self.marquee = QGraphicsRectItem(self.marquee_rect)
self.marquee.setBrush(QColor(255, 255, 255, 100))
self.addItem(self.marquee)
else:
for s_note in self.notes:
if s_note.pressed and s_note in self.selected_notes:
break
elif s_note.pressed and s_note not in self.selected_notes:
for note in self.selected_notes:
note.setSelected(False)
self.selected_notes = [s_note]
break
for note in self.selected_notes:
if not self.velocity_mode:
note.mousePressEvent(event)
def compute_SMBR(geom):
area = float("inf")
angle = 0
width = float("inf")
height = float("inf")
if (geom is None):
return QgsGeometry()
hull = geom.convexHull()
if (hull.isEmpty()):
return QgsGeometry()
x = hull.asPolygon()
vertexId = 0
pt0 = x[0][vertexId]
pt1 = pt0
prevAngle = 0.0
size = len(x[0])
for vertexId in range(0, size - 0):
pt2 = x[0][vertexId]
currentAngle = lineAngle(pt1.x(), pt1.y(), pt2.x(), pt2.y())
rotateAngle = 180.0 / math.pi * (currentAngle - prevAngle)
prevAngle = currentAngle
t = QTransform.fromTranslate(pt0.x(), pt0.y())
t.rotate(rotateAngle)
t.translate(-pt0.x(), -pt0.y())
hull.transform(t)
bounds = hull.boundingBox()
currentArea = bounds.width() * bounds.height()
if (currentArea < area):
minRect = bounds
area = currentArea
angle = 180.0 / math.pi * currentAngle
width = bounds.width()
height = bounds.height()
pt2 = pt1
minBounds = QgsGeometry.fromRect(minRect)
minBounds.rotate(angle, QgsPointXY(pt0.x(), pt0.y()))
if (angle > 180.0):
angle = math.fmod(angle, 180.0)
return minBounds, area, angle, width, height
def __init__(self, **kwargs):
QGraphicsView.__init__(self, **kwargs)
self.setRenderHints(QPainter.Antialiasing)
self.setBackgroundBrush(QBrush(QColor(Qt.cyan).lighter(150)))
#self.setBackgroundBrush( QBrush( QColor(Qt.darkGray).darker(200) ) )
# invert y axis because scene coordinates system is direct,
# with y up oriented
self.setTransform(QTransform.fromScale(1.0, -1.0))
# viewport control (part of the scene displayed)
self.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QGraphicsView.AnchorUnderMouse)
# seems that the translate stuff is a bit buggy in Qt
# https://bugreports.qt-project.org/browse/QTBUG-7328
# this does not help
#self.setAlignment(Qt.Alignment(0))
# AnchorUnderMouse works by moving the wiewport around with scrollbars
# so movable scrollbars are needed,
# and the scenerect should be large enough
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
def wheelEvent(self, event):
#print("WHEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEL")
#print(event.angleDelta())
#print(event.pixelDelta().isNull())
if self.ctrlPressed:
if event.angleDelta().y() > 0:
#print("GIATIDENZOUMAREISSSSSSSSSSSSS")
self.currentZoomFactor += 0.1
else:
self.currentZoomFactor -= 0.1
self.currentZoomFactor = max(self.minZoomFactor, min(self.currentZoomFactor, self.maxZoomFactor))
#self.setTransformationAnchor(QtGui.QGraphicsView.AnchorUnderMouse)#self.AnchorUnderMouse)
#print(self.currentZoomFactor)
self.setTransform(QTransform(self.currentZoomFactor, 0.0, 0.0, self.currentZoomFactor, 0, 0))
# print(self.mapToScene(self.viewport().geometry()).boundingRect())
else:
deltaX = event.angleDelta().x()
self.horizontalScrollBar().setValue(self.horizontalScrollBar().value() + deltaX/2)
deltaY = event.angleDelta().y()
self.verticalScrollBar().setValue(self.verticalScrollBar().value() + deltaY/2)
self.updatePaintersRectSignal.emit(self.currentZoomFactor)
def OnWindowResize(self, event):
Timer(0.1, self.FixOverlays).start()
Timer(0.2, self.DrawFixedScale).start()
if self.camOpen and not self.capTimer.isActive():
pix = QPixmap(self.camView.width(), self.camView.height())
pix.fill(Qt.black)
img = self.img.scaled(self.camView.size(), Qt.KeepAspectRatio)
painter = QPainter(pix)
painter.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform, True)
pointx = int(np.round(np.fabs(self.camView.width() - img.width())/2))
pointy = int(np.round(np.fabs(self.camView.height() - img.height())/2))
painter.drawImage(pointx, pointy, img)
painter.end()
fh = 1
fv = 1
if self.fliphCheck.isChecked():
fh = -1
if self.flipvCheck.isChecked():
fv = -1
if(fv != 1 or fh != 1):
pix = pix.transformed(QTransform().scale(fh, fv))
self.camView.setPixmap(pix)
def show_pushka(self):
# показ инструкции
self.podskaz = QLabel('', self)
self.podskaz.setGeometry(1200, 200, 200, 100)
self.podskaz.setText(
'W - Поднять пушку,\nS - Опустить пушку,\nSpace - Выстрел ')
self.podskaz.show()
# показ пушки
self.angel = -45
self.pic = QLabel(self)
self.pixmap = QPixmap('pushka.png')
t = QTransform().rotate(self.angel)
self.pic.setPixmap(self.pixmap.transformed(t))
self.vse = {
-45: (5, self.sdvig_y - 187),
-5: (5, self.sdvig_y - 133),
-10: (6, self.sdvig_y - 139),
-15: (6, self.sdvig_y - 148),
-30: (4, self.sdvig_y - 167),
-35: (5, self.sdvig_y - 173),
-20: (5, self.sdvig_y - 155),
-25: (5, self.sdvig_y - 160),
-40: (5, self.sdvig_y - 182),
-50: (6, self.sdvig_y - 191),
-55: (7, self.sdvig_y - 200),
-60: (8, self.sdvig_y - 205),
-65: (11, self.sdvig_y - 210),
-70: (14, self.sdvig_y - 214),
-75: (18, self.sdvig_y - 217),
-80: (20, self.sdvig_y - 220),
-85: (24, self.sdvig_y - 223)
}
self.pic.move(5, self.sdvig_y - 186)
self.pic.show()