def paint(
self,
painter: QtGui.QPainter,
option: QtWidgets.QStyleOptionGraphicsItem,
widget: QtWidgets.QWidget = None,
):
painter.drawImage(self.rect, self.image)
def paint(self, painter: QPainter, option: QStyleOptionGraphicsItem, widget: QWidget = None):
painter.setRenderHint(QPainter.SmoothPixmapTransform)
for layer_view in self.layer_views:
if layer_view.visible and layer_view.image_view is not None:
painter.setOpacity(layer_view.opacity)
image_view_origin = layer_view.image_view.spatial.origin
painter.drawImage(QPointF(image_view_origin[1], image_view_origin[0]), layer_view.displayed_image)
def updateScene(self):
'''
Clear the displayed scene using self.__lastclearcolor,
then draw the scaled current image.
'''
# get the scaled scene size
labelwidth = int(self.__scalefactor * self.__scenewidth + 0.5)
labelheight = int(self.__scalefactor * self.__sceneheight + 0.5)
# Create the new pixmap for the label to display
newpixmap = QPixmap(labelwidth, labelheight)
newpixmap.fill(self.__lastclearcolor)
if self.__sceneimage != None:
# Draw the scaled image to the pixmap
mypainter = QPainter(newpixmap)
trgrect = QRectF(0.0, 0.0, float(labelwidth), float(labelheight))
srcrect = QRectF(0.0, 0.0, float(self.__scenewidth),
float(self.__sceneheight))
mypainter.drawImage(trgrect, self.__sceneimage, srcrect,
Qt.AutoColor)
mypainter.end()
# Assign the new pixmap to the label
self.__label.setPixmap(newpixmap)
# set the label size and values
# so the scrollarea knows of the new size
self.__label.setMinimumSize(labelwidth, labelheight)
self.__label.resize(labelwidth, labelheight)
# update the label from the new pixmap
self.__label.update()
def merge_with_layer_immediately_below(self):
"""
Merges a layer with the next lower visible layer. Does nothing
if mode is preview or the target layer is an adjustment layer.
"""
if not hasattr(self, 'inputImg'):
return
ind = self.getLowerVisibleStackIndex()
if ind < 0:
# no visible layer found
return
target = self.parentImage.layersStack[ind]
if hasattr(target, 'inputImg') or self.parentImage.useThumb:
info = "Uncheck Preview first" if self.parentImage.useThumb else "Target layer must be background or image"
dlgWarn("Cannot Merge layers", info=info)
return
# update stack
self.parentImage.layersStack[0].applyToStack()
# merge
# target.setImage(self)
qp = QPainter(target)
qp.setCompositionMode(self.compositionMode)
qp.setOpacity(self.opacity)
qp.drawImage(QRect(0, 0, self.width(), self.height()), self)
target.updatePixmap()
self.parentImage.layerView.clear(delete=False)
currentIndex = self.getStackIndex()
self.parentImage.activeLayerIndex = ind
self.parentImage.layersStack.pop(currentIndex)
self.parentImage.layerView.setLayers(self.parentImage)
def paintEvent(self, event):
outerRadius = min(self.width(), self.height())
baseRect = QRectF(1, 1, outerRadius - 2, outerRadius - 2)
buffer = QImage(outerRadius, outerRadius, QImage.Format_ARGB32)
buffer.fill(0)
p = QPainter(buffer)
p.setRenderHint(QPainter.Antialiasing)
# data brush
self.rebuildDataBrushIfNeeded()
# background
self.drawBackground(p, buffer.rect())
# base circle
self.drawBase(p, baseRect)
# data circle
arcStep = 360.0 / (self.max - self.min) * self.value
self.drawValue(p, baseRect, self.value, arcStep)
# center circle
innerRect, innerRadius = self.calculateInnerRect(baseRect, outerRadius)
self.drawInnerBackground(p, innerRect)
# text
self.drawText(p, innerRect, innerRadius, self.value)
# finally draw the bar
p.end()
painter = QPainter(self)
painter.drawImage(0, 0, buffer)
def draw(self, painter: QPainter, block_length, _):
for i, image in enumerate(self.blocks):
x = self.x_position + (i % self.width)
y = self.y_position + (i // self.width)
x_offset = enemy_handle_x[self.obj_index]
y_offset = enemy_handle_y[self.obj_index]
x += x_offset
y += y_offset
block = image.copy()
mask = block.createMaskFromColor(
QColor(*MASK_COLOR).rgb(), Qt.MaskOutColor)
block.setAlphaChannel(mask)
# todo better effect
if self.selected:
apply_selection_overlay(block, mask)
if block_length != Block.SIDE_LENGTH:
block = block.scaled(block_length, block_length)
painter.drawImage(x * block_length, y * block_length, block)
def run(self):
image = QImage()
image.load(str(self.filename))
mask = QImage(image.size(), QImage.Format_RGB32)
mask.fill(Qt.black)
maskfile = self.filename.parent / (self.filename.stem + ".mask")
if maskfile.exists():
bitmap = QImage(str(maskfile))
if bitmap.size() != image.size():
raise Exception("Mask %s doesn't match image size" % maskfile)
mask.fill(QColor.fromRgbF(1.0, 0.0, 1.0))
p = QPainter(mask)
p.setCompositionMode(QPainter.CompositionMode_Multiply)
p.drawImage(mask.rect(), bitmap)
p.end()
self.view.imagefile = self.filename
self.view.image = image
self.view.mask = mask
self.view.maskfile = maskfile
self.view.path = list()
self.view.changed = False
self.view.update()
def paintEvent(self, event: QPaintEvent):
painter = QPainter(self)
if self.q_image is not None:
painter.drawImage(event.rect(), self.q_image)
else:
painter.drawText(event.rect(), Qt.AlignCenter, "No Image Data")
def draw(self,
painter: QPainter,
x,
y,
block_length,
selected=False,
transparent=False):
block_attributes = (self._block_id, block_length, selected,
transparent)
if block_attributes not in Block._block_cache:
image = self.image.copy()
if block_length != Block.WIDTH:
image = image.scaled(block_length, block_length)
# mask out the transparent pixels first
mask = image.createMaskFromColor(
QColor(*MASK_COLOR).rgb(), Qt.MaskOutColor)
image.setAlphaChannel(mask)
if not transparent: # or self._whole_block_is_transparent:
image = self._replace_transparent_with_background(image)
if selected:
apply_selection_overlay(image, mask)
Block._block_cache[block_attributes] = image
painter.drawImage(x, y, Block._block_cache[block_attributes])
def paint(self, painter: QPainter, option: QStyleOptionViewItem,
index: QModelIndex):
pixmap = self.get_pixmap(option, index)
if not pixmap.isNull():
view = option.styleObject
view.setRowHeight(index.row(), pixmap.height())
painter.drawImage(option.rect, pixmap)
def apply_selection_overlay(image, mask):
overlay = image.copy()
overlay.fill(SELECTION_OVERLAY_COLOR)
overlay.setAlphaChannel(mask)
_painter = QPainter(image)
_painter.drawImage(QPoint(), overlay)
_painter.end()
def paintEvent(self, e: QEvent):
"""
Call when Qt renderer engine estimate that is needed
:param e: the event
"""
qp = QPainter(self)
qp.drawImage(0, 0, self._buffer)
qp.setBrush(QColor.fromRgb(255, 255, 0, 180))
qp.drawEllipse(QPoint(self.mouseX, self.mouseY), 5, 5)
def paintEvent(self, event: PySide2.QtGui.QPaintEvent):
painter = QPainter(self)
if self.orientation is None:
return
if self.image is not None:
painter.save()
image_width = self.image.width()
image_height = self.image.height()
if self.orientation % 2 == 0:
scale = min(self.width() / image_width,
self.height() / image_height)
else:
scale = min(self.width() / image_height,
self.height() / image_width)
target_width = image_width * scale
target_height = image_height * scale
padding_left = (self.width() - target_width) // 2
padding_top = (self.height() - target_height) // 2
painter.translate(self.width() / 2, self.height() / 2)
painter.rotate(90 * self.orientation)
painter.translate(-self.width() / 2, -self.height() / 2)
painter.drawImage(
QRect(padding_left, padding_top, target_width, target_height),
self.image)
painter.restore()
if self.original_orientation is not None:
painter.save()
self.render_orientation_indicator(painter,
self.original_orientation,
target_height,
target_width,
pen_color=Qt.yellow,
brush_color=Qt.darkYellow)
painter.restore()
if self.suggested_orientation is not None:
painter.save()
self.render_orientation_indicator(painter,
self.suggested_orientation,
target_height,
target_width,
pen_color=Qt.green,
brush_color=Qt.darkGreen)
painter.restore()
if self.loading:
painter.save()
painter.setPen(self.palette().brush(QPalette.Foreground).color())
font = painter.font()
font.setPointSize(font.pointSize() * 2)
painter.setFont(font)
draw_text(painter,
self.width() / 2,
self.height() / 2, Qt.AlignVCenter | Qt.AlignHCenter,
"Loading...")
painter.restore()
def resizeImage(self, image, newSize):
if self.image.size() == newSize:
return
newImage = QImage(newSize, QImage.Format_RGB32)
newImage.fill(qRgb(255, 255, 255))
painter = QPainter(newImage)
painter.drawImage(QPoint(0, 0), self.image)
self.image = newImage
def paintEvent(self, paintEvent): # pylint: disable=unused-argument
"""
The paint event actually drawing the image
:param paintEvent: a QPaintEvent instance
:return:
"""
p = QPainter(self)
p.scale(self._scale, self._scale)
p.drawImage(0, 0, self._img)
def _replace_transparent_with_background(self, image):
# draw image on background layer, to fill transparent pixels
background = image.copy()
background.fill(self.bg_color)
_painter = QPainter(background)
_painter.drawImage(QPoint(), image)
_painter.end()
return background
def paintEvent(self, event):
mapP = QPainter()
mapP.begin(self)
mapP.drawImage(self.centralGP.x(),self.centralGP.y(),self.mapPx)
mapP.end()
self.drawRobot(self.robotM,'blue')
self.drawRobot(self.robotG,'purple')
self.drawElts(self.staticElts,'black','pink')
self.drawElts([self.robotM_traget,self.robotG_traget],'red','white')
def paintEvent(self, event):
painter = QPainter(self)
dirtyRect = event.rect()
scaledImage = self.image.scaled(self.imageAreaWidth,
self.imageAreaHeight,
Qt.KeepAspectRatio,
Qt.FastTransformation)
self.scaleFactor = float(scaledImage.width()) / float(
self.scribbleWidth)
painter.drawImage(dirtyRect, scaledImage, dirtyRect)
def getCurrentMaskedImage(self):
"""
Reduces the layer stack up to self (included),
taking into account the masks. if self.isClipping is True
self.mask applies to all lower layers and to self only otherwise.
The method uses the non color managed rPixmaps to build the masked image.
For convenience, mainly to be able to use its color space buffers,
the built image is of type QLayer. It is drawn on a container image,
created only once.
@return: masked image
@rtype: QLayer
"""
# init containers if needed
if self.parentImage.useHald:
return self.getHald()
if self.maskedThumbContainer is None:
self.maskedThumbContainer = QLayer.fromImage(
self.getThumb(), parentImage=self.parentImage)
if self.maskedImageContainer is None:
self.maskedImageContainer = QLayer.fromImage(
self, parentImage=self.parentImage)
if self.parentImage.useThumb:
img = self.maskedThumbContainer
else:
img = self.maskedImageContainer
# no thumbnails for containers
img.getThumb = lambda: img
# draw lower stack
qp = QPainter(img)
top = self.parentImage.getStackIndex(self)
bottom = 0
for i, layer in enumerate(self.parentImage.layersStack[bottom:top +
1]):
if layer.visible:
if i == 0:
qp.setCompositionMode(QPainter.CompositionMode_Source)
else:
qp.setOpacity(layer.opacity)
qp.setCompositionMode(layer.compositionMode)
if layer.rPixmap is not None:
qp.drawPixmap(QRect(0, 0, img.width(), img.height()),
layer.rPixmap)
else:
qp.drawImage(QRect(0, 0, img.width(), img.height()),
layer.getCurrentImage())
# clipping
if layer.isClipping and layer.maskIsEnabled: #TODO modified 23/06/18
# draw mask as opacity mask
# mode DestinationIn (set dest opacity to source opacity)
qp.setCompositionMode(
QPainter.CompositionMode_DestinationIn)
omask = vImage.color2OpacityMask(layer.mask)
qp.drawImage(QRect(0, 0, img.width(), img.height()), omask)
qp.end()
return img
def getCurrentMaskedImage(self):
"""
Blend the layer stack up to self (included),
taking into account the masks. The method uses the
non color managed rPixmap to build the masked image.
For convenience, mainly to be able to use its color space buffers,
the built image is of type bImage. It is drawn on a container image,
instantiated only once.
@return: masked image
@rtype: bImage
"""
# init containers if needed. They are instantiated only
# once and updated by drawing.
if self.parentImage.useHald:
return self.getHald()
if self.maskedThumbContainer is None:
self.maskedThumbContainer = bImage.fromImage(
self.getThumb(), parentImage=self.parentImage)
if self.maskedImageContainer is None:
self.maskedImageContainer = bImage.fromImage(
self, parentImage=self.parentImage)
if self.parentImage.useThumb:
img = self.maskedThumbContainer
else:
img = self.maskedImageContainer
# draw lower stack
qp = QPainter(img)
top = self.parentImage.getStackIndex(self)
bottom = 0
for i, layer in enumerate(self.parentImage.layersStack[bottom:top +
1]):
if layer.visible:
if i == 0:
qp.setCompositionMode(QPainter.CompositionMode_Source)
else:
qp.setOpacity(layer.opacity)
qp.setCompositionMode(layer.compositionMode)
if layer.rPixmap is None:
layer.rPixmap = QPixmap.fromImage(layer.getCurrentImage(
)) # TODO modified 9/12/18 validate
qp.drawPixmap(QRect(0, 0, img.width(), img.height()),
layer.rPixmap)
# clipping
if layer.isClipping and layer.maskIsEnabled:
# draw mask as opacity mask
# mode DestinationIn (set dest opacity to source opacity)
qp.setCompositionMode(
QPainter.CompositionMode_DestinationIn)
omask = vImage.color2OpacityMask(layer.mask)
qp.drawImage(QRect(0, 0, img.width(), img.height()), omask)
qp.end()
return img
def setPixmap(self, pxmap):
"""
Paints the histogram on a copy of pxmap
and displays the copy.
@param pxmap:
@type pxmap: QPixmap
"""
if self.targetHist is not None and self.showTargetHist:
pxmap1 = QPixmap(pxmap)
qp = QPainter(pxmap1)
qp.drawImage(0, 0, self.targetHist)
qp.end()
pxmap = pxmap1
super().setPixmap(pxmap)
def paintEvent(self, event: QPaintEvent):
"""
custom paint event to
draw camera stream and droplet approximation if available
uses double buffering to avoid flicker
"""
# completely override super.paintEvent() to use double buffering
painter = QPainter(self)
buf = self.doubleBufferPaint(self._double_buffer)
# painting the buffer pixmap to screen
painter.drawImage(0, 0, buf)
painter.end()
def make_compose_image(self):
self.make_layer_image()
self.compose_qimg = QImage(self.org_img_width, self.org_img_height,
QImage.Format_RGBA8888)
painter = QPainter(self.compose_qimg)
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.drawImage(0, 0, self.org_qimg)
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.drawImage(0, 0, self.layer_qimg)
painter.end()
def paintEvent(self, e: QEvent):
"""
Call when Qt renderer engine estimate that is needed
:param e: the event
"""
ratio = self.ratio if self.scaleToWindow else 1
qp = QPainter(self)
qp.drawImage(
0, 0,
self._buffer.scaled(self.sessionWidth * ratio,
self.sessionHeight * ratio,
aspectMode=Qt.KeepAspectRatio))
qp.setBrush(QColor.fromRgb(255, 255, 0, 180))
qp.drawEllipse(QPoint(self.mouseX * ratio, self.mouseY * ratio), 5, 5)
def _draw_mario(self, painter: QPainter, level: Level):
mario_actions = QImage(str(data_dir / "mario.png"))
mario_actions.convertTo(QImage.Format_RGBA8888)
mario_position = QPoint(*level.header.mario_position()) * self.block_length
x_offset = 32 * level.start_action
mario_cutout = mario_actions.copy(QRect(x_offset, 0, 32, 32)).scaled(
2 * self.block_length, 2 * self.block_length
)
painter.drawImage(mario_position, mario_cutout)
def paintEvent(self, event: QPaintEvent):
if self.object is not None:
painter = QPainter(self)
if self.draw_background_color:
painter.fillRect(event.rect(), QColor(*bg_color_for_palette(self.object.palette_group)))
scaled_image = self.image.scaled(self.size(), aspectMode=Qt.KeepAspectRatio)
x = (self.width() - scaled_image.width()) // 2
y = (self.height() - scaled_image.height()) // 2
painter.drawImage(x, y, scaled_image)
return super(ObjectIcon, self).paintEvent(event)
def __init__(
self,
block_index: int,
palette_group: List[List[int]],
pattern_table: PatternTable,
tsa_data: bytes,
mirrored=False,
):
self.index = block_index
palette_index = (block_index & 0b1100_0000) >> 6
self.bg_color = QColor(*NESPalette[palette_group[palette_index][0]])
self._block_id = (block_index, self.bg_color.toTuple(),
pattern_table.graphics_set)
lu = tsa_data[TSA_BANK_0 + block_index]
ld = tsa_data[TSA_BANK_1 + block_index]
ru = tsa_data[TSA_BANK_2 + block_index]
rd = tsa_data[TSA_BANK_3 + block_index]
self.lu_tile = Tile(lu, palette_group, palette_index, pattern_table)
self.ld_tile = Tile(ld, palette_group, palette_index, pattern_table)
if mirrored:
self.ru_tile = Tile(lu,
palette_group,
palette_index,
pattern_table,
mirrored=True)
self.rd_tile = Tile(ld,
palette_group,
palette_index,
pattern_table,
mirrored=True)
else:
self.ru_tile = Tile(ru, palette_group, palette_index,
pattern_table)
self.rd_tile = Tile(rd, palette_group, palette_index,
pattern_table)
self.image = QImage(Block.WIDTH, Block.HEIGHT, QImage.Format_RGB888)
painter = QPainter(self.image)
painter.drawImage(QPoint(0, 0), self.lu_tile.as_image())
painter.drawImage(QPoint(Tile.WIDTH, 0), self.ru_tile.as_image())
painter.drawImage(QPoint(0, Tile.HEIGHT), self.ld_tile.as_image())
painter.drawImage(QPoint(Tile.WIDTH, Tile.HEIGHT),
self.rd_tile.as_image())
painter.end()
if _image_only_one_color(self.image) and self.image.pixelColor(
0, 0) == QColor(*MASK_COLOR):
self._whole_block_is_transparent = True
else:
self._whole_block_is_transparent = False
def notifyImage(self, x: int, y: int, qimage: QImage, width: int,
height: int):
"""
Draw an image on the buffer.
:param x: x position of the new image
:param y: y position of the new image
:param qimage: new QImage
:param width: width of the new image
:param height: height of the new image
"""
# Fill buffer image
qp = QPainter(self._buffer)
qp.drawImage(x, y, qimage, 0, 0, width, height)
# Force update
self.update()
def printImage(self, printer):
"Prints the current diagram"
self.image = QImage('test1.tif')
# # Create the printer
printerobject = QPrinter()
# Set the settings
printdialog = QPrintDialog(printerobject)
if printdialog.exec_() == QDialog.Accepted:
painter = QPainter(printer)
rect = painter.viewport()
size = self.image.size()
size.scale(rect.size(), Qt.KeepAspectRatio)
painter.setViewport(rect.x(), rect.y(), size.width(),
size.height())
painter.setWindow(self.image.rect())
painter.drawImage(0, 0, self.image)
def mergeVisibleLayers(self):
"""
Merges the visible masked images and returns the
resulting QImage, eventually scaled to fit the image size.
@return: image
@rtype: QImage
"""
# init a new image
img = QImage(self.width(), self.height(), self.format())
# Image may contain transparent pixels, hence we
# fill the image with a background color.
img.fill(vImage.defaultBgColor)
# draw layers with (eventually) masked areas.
qp = QPainter(img)
qp.drawImage(QRect(0, 0, self.width(), self.height()),
self.layersStack[-1].getCurrentMaskedImage())
qp.end()
return img
