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