def paintEvent(self, event): painter = QPainter(self) icon = self.icon_pressed if self.isDown() else self.icon if icon is not None: x = (self.width() - icon.width()) / 2 y = (self.height() - icon.height()) / 2 painter.drawPixmap(x, y, icon) else: width = self.width() height = self.height() padding = width / 5 radius = width - 2*padding palette = self.palette() # Mid is darker than Dark. Go figure... -Dan bg_color = palette.color(QPalette.Mid) if self.isDown() else palette.color(QPalette.Dark) fg_color = palette.color(QPalette.Window) # or QPalette.Base for white painter.setRenderHint(QPainter.Antialiasing, True) painter.setBrush(bg_color) painter.setPen(bg_color) painter.drawEllipse(padding, padding, radius, radius) padding = padding * 2 painter.setPen(fg_color) painter.drawLine(padding, padding, width-padding, height-padding) painter.drawLine(padding, height-padding, width-padding, padding)
def _renderedImage2(self, width, height, extent, transp_background=False, layerids=None): antialias = True if self._renderer is None: self._initRenderer() canvas = self.context.canvas if layerids is None: layerids = [mapLayer.id() for mapLayer in canvas.layers()] renderer = self._renderer renderer.setLayerSet(layerids) image = QImage(width, height, QImage.Format_ARGB32_Premultiplied) if transp_background: image.fill(QColor(Qt.transparent).rgba()) # else: image.fill(canvas.canvasColor().rgba()) # renderer.setOutputSize(image.size(), image.logicalDpiX()) renderer.setExtent(extent.unrotatedRect()) painter = QPainter() painter.begin(image) if antialias: painter.setRenderHint(QPainter.Antialiasing) renderer.render(painter) painter.end() return tools.base64image(image)
def paintEvent(self, event=None): painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing, True) xOffset = self.width() / 3 yOffset = self.height() / 3 for x in range(3): for y in range(3): cell = self.grid[x][y] rect = (QRectF(x * xOffset, y * yOffset, xOffset, yOffset).adjusted(0.5, 0.5, -0.5, -0.5)) color = None if cell == RED: color = Qt.red elif cell == YELLOW: color = Qt.yellow if color is not None: painter.save() painter.setPen(Qt.black) painter.setBrush(color) painter.drawEllipse(rect.adjusted(2, 2, -2, -2)) painter.restore() if [x, y] == self.selected: painter.setPen(QPen(Qt.blue, 3)) else: painter.setPen(Qt.black) painter.drawRect(rect)
def setNameAndBrush(self, sigma, color=Qt.black): self.sigma = sigma self.setText(str(self.brushSize)) font = QFont() font.setPointSize(10) font.setBold(True) self.setFont(font) self.setForeground(color) pixmap = QPixmap(self.pixmapSize) pixmap.fill(Qt.transparent) painter = QPainter() painter.begin(pixmap) painter.setRenderHint(QPainter.Antialiasing, True) painter.setPen(color) brush = QBrush(color) painter.setBrush(brush) painter.drawEllipse( QRect( self.pixmapSize.width() / 2 - self.brushSize / 2, self.pixmapSize.height() / 2 - self.brushSize / 2, self.brushSize, self.brushSize, ) ) painter.end() self.setIcon(QIcon(pixmap)) self.setTextAlignment(Qt.AlignVCenter)
def exportAsImage(self): filename = unicode(QFileDialog.getSaveFileName(self, self.tr('Save Model As Image'), '', self.tr('PNG files (*.png *.PNG)'))) if not filename: return if not filename.lower().endswith('.png'): filename += '.png' totalRect = QRectF(0, 0, 1, 1) for item in self.scene.items(): totalRect = totalRect.united(item.sceneBoundingRect()) totalRect.adjust(-10, -10, 10, 10) img = QImage(totalRect.width(), totalRect.height(), QImage.Format_ARGB32_Premultiplied) img.fill(Qt.white) painter = QPainter() painter.setRenderHint(QPainter.Antialiasing) painter.begin(img) self.scene.render(painter, totalRect, totalRect) painter.end() img.save(filename)
def paintEvent(self, event): if not self.displayedWhenStopped and not self.isAnimated(): return width = min(self.width(), self.height()) p = QPainter(self) p.setRenderHint(QPainter.Antialiasing) outerRadius = (width-1) * 0.5 innerRadius = (width-1) * 0.5 * 0.38 capsuleHeight = outerRadius - innerRadius capsuleWidth = capsuleHeight * 0.23 if width > 32 else capsuleHeight * 0.35 capsuleRadius = capsuleWidth / 2 for i in range(12): color = QColor(self.color) color.setAlphaF(float(1.0 - float(i / 12.0))) p.setPen(Qt.NoPen) p.setBrush(color) p.save() p.translate(self.rect().center()) p.rotate(self.angle - float(i * 30.0)) p.drawRoundedRect(-capsuleWidth * 0.5,\ -(innerRadius + capsuleHeight),\ capsuleWidth,\ capsuleHeight,\ capsuleRadius,\ capsuleRadius) p.restore()
def _get_composer_image(self, width, height, dpi): image = QImage(QSize(width, height), self._TestMapSettings.outputImageFormat()) image.fill(QColor(152, 219, 249).rgb()) image.setDotsPerMeterX(dpi / 25.4 * 1000) image.setDotsPerMeterY(dpi / 25.4 * 1000) p = QPainter(image) p.setRenderHint( QPainter.Antialiasing, self._TestMapSettings.testFlag(QgsMapSettings.Antialiasing) ) self._c.renderPage(p, 0) p.end() # image = self._c.printPageAsRaster(0) # """:type: QImage""" if image.isNull(): return False, '' filepath = getTempfilePath('png') res = image.save(filepath, 'png') if not res: os.unlink(filepath) filepath = '' return res, filepath
def paintEvent(self, e): Part.paintEvent(self, e) painter = QPainter(self) color = QColor(self._base) color.setAlpha(200) painter.setPen(color.dark(150)) painter.setBrush(color.dark(115)) painter.setRenderHint(QPainter.Antialiasing) painter.drawEllipse(11, 22, 10, 10) rect = QRectF(25, 17, 7, 20) painter.drawChord(rect, 270 * 16, 180 * 16) rect = QRectF(40, 11, 10, 30) painter.drawChord(rect, 270 * 16, 180 * 16) painter.drawEllipse(63, 14, 5, 5) painter.drawEllipse(63, 35, 5, 5) painter.drawEllipse(81, 14, 5, 5) painter.drawEllipse(81, 35, 5, 5) painter = None if self.data is None: text = None else: text = self.data.name self.drawText(text)
def painter_for ( context ): """ Returns a QPainter for the specified *context* object. """ graphics = QPainter( context ) graphics.setRenderHint( QPainter.TextAntialiasing ) return graphics
def paintEvent(self, paint_event): QFrame.paintEvent(self, paint_event) painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing, True) painter.setRenderHint(QPainter.SmoothPixmapTransform, True) rect = self.contentsRect() """@type: QRect""" painter.fillRect(rect, self.background_color) x = rect.x() y = rect.y() height = rect.height() width = floor(rect.width() * self.__progress) painter.fillRect(x, y, width, height, self.color) if self.__shiny: #Shiny overlay! gradient = QLinearGradient(rect.width() / 2, 0, rect.width() / 2, rect.height()) gradient.setColorAt(0, QColor(255, 255, 255, 0)) gradient.setColorAt(0.2, QColor(255, 255, 255, 200)) gradient.setColorAt(0.4, QColor(255, 255, 255, 0)) gradient.setColorAt(0.85, QColor(255, 255, 255, 0)) gradient.setColorAt(0.85, QColor(0, 0, 0, 0)) gradient.setColorAt(1, QColor(0, 0, 0, 127)) painter.fillRect(rect, gradient)
def paintEvent(self, event): painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.Antialiasing) painter.setPen(QPen(Qt.NoPen)) painter.setBrush(QBrush(self.palette().color(QPalette.Highlight))) num = 8 painter.translate(self.width()/2, self.height()/2) painter.rotate(360.0/num * (self.counter % num)) for i in range(num): s = 25 + i x = 50 * math.cos(2.0 * math.pi * i / num) - s/2.0 y = 50 * math.sin(2.0 * math.pi * i / num) - s/2.0 painter.drawEllipse( x, y, s, s) painter.end()
def updateFilledCircle(self, s): size = s * self.zoom pixmap = QPixmap(self.width(), self.height()) pixmap.fill(Qt.transparent) #painter filled ellipse p = QPalette() painter = QPainter() painter.begin(pixmap) painter.setRenderHint(QPainter.Antialiasing) brush = QBrush(p.link().color()) painter.setBrush(brush) painter.setOpacity(0.4) painter.drawEllipse(QRect(self.width()/2 - size/2, self.height()/2 - size/2, size, size)) painter.end() #painter ellipse 2 painter2 = QPainter() painter2.begin(pixmap) painter2.setRenderHint(QPainter.Antialiasing) pen2 = QPen(Qt.green) pen2.setWidth(1) painter2.setPen(pen2) painter2.drawEllipse(QRect(self.width()/2 - size/2, self.height()/2 - size/2, size, size)) painter2.end() self.ellipseLabel.setPixmap(QPixmap(pixmap)) self.lastSize = s
def paintEvent(self, ev): """Called when paint is needed, finds out which page to magnify.""" layout = self.parent().surface().pageLayout() pos = self.geometry().center() - self.parent().surface().pos() page = layout.pageAt(pos) if not page: return pagePos = pos - page.pos() newPage = Page(page, self._scale) if not newPage.same_page(self._page): if self._page: self._page.magnifier = None self._page = newPage self._page.magnifier = self relx = pagePos.x() / float(page.width()) rely = pagePos.y() / float(page.height()) image = cache.image(self._page) img_rect = QRect(self.rect()) if not image: cache.generate(self._page) image = cache.image(self._page, False) if image: img_rect.setWidth(self.width() * image.width() / self._page.width()) img_rect.setHeight(self.height() * image.height() / self._page.height()) if image: img_rect.moveCenter(QPoint(relx * image.width(), rely * image.height())) p = QPainter(self) p.drawImage(self.rect(), image, img_rect) p.setRenderHint(QPainter.Antialiasing, True) p.setPen(QPen(QColor(192, 192, 192, 128), 6)) p.drawEllipse(self.rect().adjusted(2, 2, -2, -2))
def paintEvent(self, event): painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.Antialiasing) painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127))) painter.setPen(QPen(Qt.NoPen)) for i in xrange(6): x_pos = self.width() / 2 + 30 * \ math.cos(2 * math.pi * i / 6.0) - 10 y_pos = self.height() / 2 + 30 * \ math.sin(2 * math.pi * i / 6.0) - 10 if (self.counter / 5) % 6 == i: linear_gradient = QLinearGradient( x_pos + 10, x_pos, y_pos + 10, y_pos) linear_gradient.setColorAt(0, QColor(135, 206, 250)) linear_gradient.setColorAt(1, QColor(0, 0, 128)) painter.setBrush(QBrush(linear_gradient)) else: linear_gradient = QLinearGradient( x_pos - 10, x_pos, y_pos + 10, y_pos) linear_gradient.setColorAt(0, QColor(105, 105, 105)) linear_gradient.setColorAt(1, QColor(0, 0, 0)) painter.setBrush(QBrush(linear_gradient)) painter.drawEllipse( x_pos, y_pos, 20, 20) painter.end()
def paintEvent( self, event ): """ Das automatisch ausgelöste paintEvent, das das Widget bei jeder Fensterveränderung neu zeichnet. """ if self.__maximum > 0: frameWidth = 1 separatorWidth = 1 # Damit der Rahmen nicht irgendwie abgeschnitten wird, muß das Quadrat entsprechend kleiner sein. squareSideLength = 10 framePen = QPen( frameWidth ) framePen.setColor( self.__colorFrame ) squareSideLengthPlus = squareSideLength + 2 * frameWidth painter = QPainter( self ) windowWidth = self.width() / min( self.__maximum, self.__columnMax ) windowHeight = self.__maximum / self.__columnMax windowHeight = math.ceil( windowHeight ) windowHeight = self.height() / windowHeight side = min( windowWidth, windowHeight ) painter.setRenderHint( QPainter.Antialiasing ) # Wenn das Widget disabled ist, muß ich den Alphakanal meiner Farben verändern. if ( not self.isEnabled() ): painter.setOpacity( .5 ) #painter.translate( float( windowWidth ), float( windowHeight ) ) painter.scale( side / squareSideLengthPlus, side / squareSideLengthPlus ) painter.setPen( framePen ) painter.setBrush( self.__colorEmpty ) painter.save() squareColumnIter = 0 squareLineIter = 0 squareCount = 0 for squareCount in range(self.__maximum): square = QRect( ( squareSideLength + separatorWidth ) * squareColumnIter + frameWidth * ( squareColumnIter + 1 ), ( squareSideLength + separatorWidth ) * squareLineIter + frameWidth * ( squareLineIter + 1 ), squareSideLength, squareSideLength ) painter.drawRect( square ) # Wir zeichnen die ausgekreuzten Quadrate if (self.__value > (self.__columnMax * squareLineIter + squareColumnIter)): painter.drawLine(square.bottomLeft(), square.topRight()) painter.drawLine(square.topLeft(), square.bottomRight()) squareColumnIter += 1 if ( squareColumnIter >= self.__columnMax ): squareColumnIter = 0 squareLineIter += 1 painter.restore()
def decorate_welcome_icon(icon, background_color): """Return a `QIcon` with a circle shaped background. """ welcome_icon = QIcon() sizes = [32, 48, 64, 80] background_color = NAMED_COLORS.get(background_color, background_color) background_color = QColor(background_color) grad = radial_gradient(background_color) for size in sizes: icon_pixmap = icon.pixmap(5 * size / 8, 5 * size / 8) icon_size = icon_pixmap.size() icon_rect = QRect(QPoint(0, 0), icon_size) pixmap = QPixmap(size, size) pixmap.fill(QColor(0, 0, 0, 0)) p = QPainter(pixmap) p.setRenderHint(QPainter.Antialiasing, True) p.setBrush(QBrush(grad)) p.setPen(Qt.NoPen) ellipse_rect = QRect(0, 0, size, size) p.drawEllipse(ellipse_rect) icon_rect.moveCenter(ellipse_rect.center()) p.drawPixmap(icon_rect.topLeft(), icon_pixmap) p.end() welcome_icon.addPixmap(pixmap) return welcome_icon
def paintEvent(self, event): if not self.text().isEmpty(): painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.Antialiasing) color = self.palette().color(QPalette.Highlight) color.setAlpha(127) painter.setBrush(QBrush(color)) color = self.palette().color(QPalette.HighlightedText) color.setAlpha(127) painter.setPen(QPen(color)) size = self.height() / 2.0 left = self.width() - 4 painter.drawRect(left - size, size * 0.5, size, size) painter.drawLine(left - size * 0.75, size * 0.75, left - size * 0.25, size * 1.25) painter.drawLine(left - size * 0.25, size * 0.75, left - size * 0.75, size * 1.25) painter.end() QLabel.paintEvent(self, event)
def paintEvent(self, paintevent): QFrame.paintEvent(self, paintevent) painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing, True) painter.setRenderHint(QPainter.SmoothPixmapTransform, True) rect = self.contentsRect() """@type: QRect""" painter.fillRect(rect, self.color) x = rect.x() y = rect.y() height = rect.height() count = len(self.__state_order) for index in range(count): state = self.__state_order[index] width = floor(rect.width() * (state.progress / 100.0)) if index == count - 1: width = rect.width() - x + 1 painter.fillRect(x, y, width, height, state.color) x += width #Shiny overlay! gradient = QLinearGradient(rect.width() / 2, 0, rect.width() / 2, rect.height()) gradient.setColorAt(0, QColor(255, 255, 255, 0)) gradient.setColorAt(0.2, QColor(255, 255, 255, 200)) gradient.setColorAt(0.4, QColor(255, 255, 255, 0)) gradient.setColorAt(0.85, QColor(255, 255, 255, 0)) gradient.setColorAt(0.85, QColor(0, 0, 0, 0)) gradient.setColorAt(1, QColor(0, 0, 0, 127)) painter.fillRect(rect, gradient)
def splash_screen(): """ """ pm = QPixmap( pkg_resources.resource_filename( __name__, "icons/orange-splash-screen.png") ) version = QCoreApplication.applicationVersion() size = 21 if len(version) < 5 else 16 font = QFont("Helvetica") font.setPixelSize(size) font.setBold(True) font.setItalic(True) font.setLetterSpacing(QFont.AbsoluteSpacing, 2) metrics = QFontMetrics(font) br = metrics.boundingRect(version).adjusted(-5, 0, 5, 0) br.moveCenter(QPoint(436, 224)) p = QPainter(pm) p.setRenderHint(QPainter.Antialiasing) p.setRenderHint(QPainter.TextAntialiasing) p.setFont(font) p.setPen(QColor("#231F20")) p.drawText(br, Qt.AlignCenter, version) p.end() return pm, QRect(88, 193, 200, 20)
def updateCircle(self, s): size = s * self.zoom pixmap = QPixmap(self.width(), self.height()) pixmap.fill(Qt.transparent) #painter ellipse 1 painter = QPainter() painter.begin(pixmap) painter.setRenderHint(QPainter.Antialiasing) pen = QPen(Qt.red) pen.setWidth(3) painter.setPen(pen) brush = QBrush(Qt.green) painter.setBrush(brush) painter.drawEllipse(QRect(self.width()/2 - size/2, self.height()/2 - size/2, size, size)) painter.end() #painter ellipse 2 painter2 = QPainter() painter2.begin(pixmap) painter2.setRenderHint(QPainter.Antialiasing) pen2 = QPen(Qt.green) pen2.setStyle(Qt.DotLine) pen2.setWidth(3) painter2.setPen(pen2) painter2.drawEllipse(QRect(self.width()/2 - size/2, self.height()/2 - size/2, size, size)) painter2.end() self.ellipseLabel.setPixmap(QPixmap(pixmap)) self.lastSize = s
def slot_canvasSaveImage(self): newPath = QFileDialog.getSaveFileName( self, self.tr("Save Image"), filter=self.tr("PNG Image (*.png);;JPEG Image (*.jpg)") ) if newPath: self.scene.clearSelection() # FIXME - must be a better way... if newPath.endswith((".jpg", ".jpG", ".jPG", ".JPG", ".JPg", ".Jpg")): imgFormat = "JPG" elif newPath.endswith((".png", ".pnG", ".pNG", ".PNG", ".PNg", ".Png")): imgFormat = "PNG" else: # File-dialog may not auto-add the extension imgFormat = "PNG" newPath += ".png" self.fExportImage = QImage( self.scene.sceneRect().width(), self.scene.sceneRect().height(), QImage.Format_RGB32 ) painter = QPainter(self.fExportImage) painter.setRenderHint(QPainter.Antialiasing) # TODO - set true, cleanup this painter.setRenderHint(QPainter.TextAntialiasing) self.scene.render(painter) self.fExportImage.save(newPath, imgFormat, 100)
def renderedImage(self, width, height, extent, transp_background=False, layerids=None): if QGis.QGIS_VERSION_INT < 20700: return self._renderedImage2(width, height, extent, transp_background, layerids) from qgis.core import QgsMapRendererCustomPainterJob antialias = True # render map image with QgsMapRendererCustomPainterJob settings = self.context.canvas.mapSettings() settings.setOutputSize(QSize(width, height)) settings.setExtent(extent.unrotatedRect()) settings.setRotation(extent.rotation()) if layerids: settings.setLayers(layerids) if transp_background: settings.setBackgroundColor(QColor(Qt.transparent)) #else: #TODO: remove #settings.setBackgroundColor(self.context.canvas.canvasColor()) image = QImage(width, height, QImage.Format_ARGB32_Premultiplied) painter = QPainter() painter.begin(image) if antialias: painter.setRenderHint(QPainter.Antialiasing) job = QgsMapRendererCustomPainterJob(settings, painter) job.start() job.waitForFinished() painter.end() return tools.base64image(image)
def paintEvent(self, paint_event): QFrame.paintEvent(self, paint_event) painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) w = self.width() h = self.height() if self.horizontal: self.min_marker = QRectF(w * self.min_value, 4, self.size, self.size) self.max_marker = QRectF(w * self.max_value - self.size - 1, 4, self.size, self.size) else: self.min_marker = QRectF(4, h - h * self.min_value - self.size - 1, self.size, self.size) self.max_marker = QRectF(4, h - h * self.max_value, self.size, self.size) pen = painter.pen() pen.setWidth(0) pen.setColor(QApplication.palette().background().color().dark()) painter.setPen(pen) painter.setBrush(self.min_marker_brush) painter.drawPie(self.min_marker, self.tilt * 16, 180 * 16) painter.setBrush(self.max_marker_brush) painter.drawPie(self.max_marker, self.tilt * 16, -180 * 16)
def paintEvent(self, event): """ Overloads the paint event to handle painting pointers for the popup \ mode. :param event | <QPaintEvent> """ # use the base technique for the dialog mode if self.currentMode() == XPopupWidget.Mode.Dialog: super(XPopupWidget, self).paintEvent(event) return # setup the coloring options palette = self.palette() painter = QPainter() painter.begin(self) pen = QPen(palette.color(palette.Window).darker(130)) pen.setWidthF(1.75) painter.setPen(pen) painter.setRenderHint(painter.Antialiasing) painter.setBrush(palette.color(palette.Window)) painter.drawPath(self.borderPath()) painter.end()
def paintEvent(self, event): option=QStyleOption() option.initFrom(self) h=option.rect.height() w=option.rect.width() if self.m_shape in (QLed.Triangle, QLed.Round): aspect=(4/3.0) if self.m_shape==QLed.Triangle else 2.0 ah=w/aspect aw=w if ah>h: ah=h aw=h*aspect x=abs(aw-w)/2.0 y=abs(ah-h)/2.0 bounds=QRectF(x,y,aw,ah) else: size=min(w,h) x=abs(size-w)/2.0 y=abs(size-h)/2.0 bounds=QRectF(x,y,size,size) painter=QPainter(self); painter.setRenderHint(QPainter.Antialiasing, True); (dark_r,dark_g,dark_b)=self.colours[self.m_onColour if self.m_value else self.m_offColour] dark_str="rgb(%d,%d,%d)" % (dark_r,dark_g,dark_b) light_str="rgb(%d,%d,%d)" % self.adjust(dark_r,dark_g,dark_b) self.renderer.load(QByteArray(self.shapes[self.m_shape] % (dark_str,light_str))) self.renderer.render(painter, bounds)
def setNameAndBrush(self, sigma, color=Qt.black): self.sigma = sigma self.setText( decode_to_qstring("σ=%.1fpx" % self.sigma, "utf-8") ) # This file is encoded as utf-8, so this string should be decoded as such. total_window = 1 + 2 * int(self.sigma * self.window_size + 0.5) self.setToolTip("sigma = {:.1f} pixels, window diameter = {:.1f}".format(self.sigma, total_window)) font = QFont() font.setPointSize(10) font.setBold(True) self.setFont(font) self.setForeground(color) pixmap = QPixmap(self.pixmapSize) pixmap.fill(Qt.transparent) painter = QPainter() painter.begin(pixmap) painter.setRenderHint(QPainter.Antialiasing, True) painter.setPen(color) brush = QBrush(color) painter.setBrush(brush) painter.drawEllipse( QRect( self.pixmapSize.width() / 2 - self.brushSize / 2, self.pixmapSize.height() / 2 - self.brushSize / 2, self.brushSize, self.brushSize, ) ) painter.end() self.setIcon(QIcon(pixmap)) self.setTextAlignment(Qt.AlignVCenter)
def draw(self): """ Draws connection. """ self.calculateRoute() if not self.routeIsValid(): return painter = QPainter(self) #logging.debug(self.__class__.__name__ +": draw()") if self._selectedFlag: # Selected framePen = QPen(self.SELECT_COLOR) framePen.setWidth(self.SELECTED_FRAME_WIDTH) else: #self.select(False) framePen = QPen(Qt.NoPen) #if hasattr(QPainter, 'Antialiasing'): if self.zoom() > 30: painter.setRenderHint(QPainter.Antialiasing) # painter.setPen(Qt.black) # for thisP in self._route: # painter.drawEllipse(self.mapFromParent(thisP), self.CONNECTION_THICKNESS * self.zoomFactor(), self.CONNECTION_THICKNESS* self.zoomFactor()) painter.setPen(framePen) for i in range(0, len(self._route) -1): #self.drawLineSection(painter, route[i], route[i + 1], self._cornerTypes[i], self._cornerTypes[i + 1]) self.drawSection(painter, i)
def paintEvent(self, e: QPaintEvent): if e.isAccepted() and e.accept(): QWidget.paintEvent(self, e) p = QPainter(self) p.setRenderHint(QPainter.Antialiasing) for l in self.__container.lines: l.paint(p)
def paintEvent(self, event): 'Paint semi-transparent background, animated pattern, background text' QWidget.paintEvent(self, event) # make a painter p = QPainter(self) p.setRenderHint(QPainter.TextAntialiasing) p.setRenderHint(QPainter.HighQualityAntialiasing) # fill a rectangle with transparent painting p.fillRect(event.rect(), Qt.transparent) # animated random dots background pattern for i in range(4096): x = randint(9, self.size().width() - 9) y = randint(9, self.size().height() - 9) p.setPen(QPen(QColor(randint(200, 255), randint(200, 255), 255), 1)) p.drawPoint(x, y) # set pen to use white color p.setPen(QPen(QColor(randint(9, 255), randint(9, 255), 255), 1)) # Rotate painter 45 Degree p.rotate(35) # Set painter Font for text p.setFont(QFont('Ubuntu', 300)) # draw the background text, with antialiasing p.drawText(99, 199, "Radio") # Rotate -45 the QPen back ! p.rotate(-35) # set the pen to no pen p.setPen(Qt.NoPen) # Background Color p.setBrush(QColor(0, 0, 0)) # Background Opacity p.setOpacity(0.75) # Background Rounded Borders p.drawRoundedRect(self.rect(), 50, 50) # finalize the painter p.end()
def paintEvent( self, event ): """ Overloads the paint event to draw rounded edges on this widget. :param event | <QPaintEvent> """ super(XRolloutItem, self).paintEvent(event) painter = QPainter() painter.begin(self) w = self.width() - 3 h = self.height() - 3 color = self.palette().color(QPalette.Midlight) color = color.darker(180) pen = QPen(color) pen.setWidthF(0.5) painter.setPen(pen) painter.setBrush(self.palette().color(QPalette.Midlight)) painter.setRenderHint(QPainter.Antialiasing) painter.drawRoundedRect(1, 1, w, h, 10, 10) painter.end()
def paintEvent(self, event): realSize = min(self.width(), self.height()) painter = QPainter() painter.begin(self) pen = QPen(Qt.black) pen.setWidth(1) painter.setPen(Qt.black) painter.setRenderHint(QPainter.Antialiasing) painter.translate(self.width() / 2, self.height() / 2) painter.scale( float(realSize) / self.scaledSize, float(realSize) / self.scaledSize) gradient = QRadialGradient(QPointF(-500, -500), 1500, QPointF(-500, -500)) gradient.setColorAt(0, QColor(224, 224, 224)) gradient.setColorAt(1, QColor(28, 28, 28)) painter.setPen(pen) painter.setBrush(QBrush(gradient)) painter.drawEllipse(QPointF(0, 0), 500, 500) gradient = QRadialGradient(QPointF(500, 500), 1500, QPointF(500, 500)) gradient.setColorAt(0, QColor(224, 224, 224)) gradient.setColorAt(1, QColor(28, 28, 28)) painter.setPen(pen) painter.setBrush(QBrush(gradient)) painter.drawEllipse(QPointF(0, 0), 450, 450) painter.setPen(pen) if (self.isChecked()): gradient = QRadialGradient(QPointF(-500, -500), 1500, QPointF(-500, -500)) gradient.setColorAt(0, self._onColor1) gradient.setColorAt(1, self._onColor2) else: gradient = QRadialGradient(QPointF(500, 500), 1500, QPointF(500, 500)) gradient.setColorAt(0, self._offColor1) gradient.setColorAt(1, self._offColor2) painter.setBrush(gradient) painter.drawEllipse(QPointF(0, 0), 400, 400) painter.end()
def _get_composer_svg_image(self, width, height, dpi): # from qgscomposer.cpp, QgsComposer::on_mActionExportAsSVG_triggered, # near end of function svgpath = getTempfilePath('svg') temp_size = os.path.getsize(svgpath) svg_g = QSvgGenerator() # noinspection PyArgumentList svg_g.setTitle(QgsProject.instance().title()) svg_g.setFileName(svgpath) svg_g.setSize(QSize(width, height)) svg_g.setViewBox(QRect(0, 0, width, height)) svg_g.setResolution(dpi) sp = QPainter(svg_g) self._c.renderPage(sp, 0) sp.end() if temp_size == os.path.getsize(svgpath): return False, '' image = QImage(width, height, self._TestMapSettings.outputImageFormat()) image.fill(QColor(152, 219, 249).rgb()) image.setDotsPerMeterX(dpi / 25.4 * 1000) image.setDotsPerMeterY(dpi / 25.4 * 1000) svgr = QSvgRenderer(svgpath) p = QPainter(image) p.setRenderHint( QPainter.Antialiasing, self._TestMapSettings.testFlag(QgsMapSettings.Antialiasing)) p.setRenderHint(QPainter.TextAntialiasing) svgr.render(p) p.end() filepath = getTempfilePath('png') res = image.save(filepath, 'png') if not res: os.unlink(filepath) filepath = '' # TODO: remove .svg file as well? return res, filepath
def create_values_text(self): painter = QPainter(self) # painter.setRenderHint(QPainter.HighQualityAntialiasing) painter.setRenderHint(QPainter.Antialiasing) # Koordinatenursprung in die Mitte der Flaeche legen painter.translate(self.width() / 2, self.height() / 2) # painter.save() # xShadow = 3.0 # yShadow = 3.0 font = QFont(self.value_fontname, self.value_fontsize) fm = QFontMetrics(font) pen_shadow = QPen() pen_shadow.setBrush(self.DisplayValueColor) painter.setPen(pen_shadow) text_radius = self.widget_diameter / 2 * self.text_radius_factor # angle_distance = (float(self.scale_angle_size) / float(self.scala_main_count)) # for i in range(self.scala_main_count + 1): text = str(int(self.value)) w = fm.width(text) + 1 h = fm.height() painter.setFont(QFont(self.value_fontname, self.value_fontsize)) # Mitte zwischen Skalenstart und Skalenende: # Skalenende = Skalenanfang - 360 + Skalenlaenge # Skalenmitte = (Skalenende - Skalenanfang) / 2 + Skalenanfang angle_end = float(self.scale_angle_start_value + self.scale_angle_size - 360) angle = (angle_end - self.scale_angle_start_value ) / 2 + self.scale_angle_start_value x = text_radius * math.cos(math.radians(angle)) y = text_radius * math.sin(math.radians(angle)) # print(w, h, x, y, text) text = [ x - int(w / 2), y - int(h / 2), int(w), int(h), Qt.AlignCenter, text ] painter.drawText(text[0], text[1], text[2], text[3], text[4], text[5])
def create_fine_scaled_marker(self): # Description_dict = 0 my_painter = QPainter(self) my_painter.setRenderHint(QPainter.Antialiasing) # Koordinatenursprung in die Mitte der Flaeche legen my_painter.translate(self.width() / 2, self.height() / 2) my_painter.setPen(Qt.black) my_painter.rotate(self.scale_angle_start_value - self.angle_offset) steps_size = (float(self.scale_angle_size) / float(self.scala_main_count * self.scala_subdiv_count)) scale_line_outer_start = self.widget_diameter / 2 scale_line_lenght = (self.widget_diameter / 2) - (self.widget_diameter / 40) for i in range((self.scala_main_count * self.scala_subdiv_count) + 1): my_painter.drawLine(scale_line_lenght, 0, scale_line_outer_start, 0) my_painter.rotate(steps_size)
def genWINDPIXMAPS(): """prepare wind tiles""" tileset = Tileset(Preferences.windTilesetName) for wind in WINDS: for prevailing in False, True: pwind = PlayerWind(wind, tileset, prevailing) pMap = QPixmap(40, 40) pMap.fill(Qt.transparent) painter = QPainter(pMap) painter.setRenderHint(QPainter.Antialiasing) painter.scale(0.40, 0.40) pwind.paint(painter, QStyleOptionGraphicsItem()) for child in pwind.childItems(): if isinstance(child, QGraphicsSvgItem): painter.save() painter.translate(child.mapToParent(0.0, 0.0)) child.paint(painter, QStyleOptionGraphicsItem()) painter.restore() WINDPIXMAPS[(wind, prevailing)] = pMap
def drawPixmapForPartiallyChecked(self): self.pixmapPartiallyChecked = QPixmap(self.itemWidth, self.itemHeight) self.pixmapPartiallyChecked.fill(Qt.transparent) painter = QPainter() painter.begin(self.pixmapPartiallyChecked) painter.setRenderHint(QPainter.Antialiasing) pen = QPen() pen.setWidth(2) painter.setPen(pen) painter.drawRect(QRect(5, 5, self.itemWidth - 10, self.itemHeight - 10)) pen.setWidth(4) pen.setColor(QColor(139, 137, 137)) painter.setPen(pen) painter.drawLine(self.itemWidth / 2 - 5, self.itemHeight / 2, self.itemWidth / 2, self.itemHeight - 9) painter.drawLine(self.itemWidth / 2, self.itemHeight - 9, self.itemWidth / 2 + 10, 2) painter.end()
def get_normal(scene_info, show_bg=True, show_sprite=True, show_box=True): sprite_id = scene_info.sprite room_id = scene_info.room scene_id = scene_info.scene out = QImage(IMG_W, IMG_H, QImage.Format_ARGB32_Premultiplied) out.fill(QColor(0, 0, 0, 0).rgba()) painter = QPainter(out) painter.setRenderHint(QPainter.Antialiasing, True) if show_bg: if scene_info.movie >= 0: bg = get_movie(scene_info.movie) elif scene_info.flash >= 0: bg = get_flash(scene_info.flash) elif scene_info.bgd >= 0: bg = get_bgd(scene_info.bgd) else: bg = get_bg(room_id) if bg: painter.drawImage(out.rect(), bg, bg.rect()) if show_sprite: sprite = get_sprite(sprite_id) if sprite: painter.drawImage(out.rect(), sprite, sprite.rect()) if not scene_info.img_filter == IMG_FILTERS.unfiltered: painter.end() out = filter_image(out, scene_info.img_filter) painter = QPainter(out) painter.setRenderHint(QPainter.Antialiasing, True) if show_box: box = get_box(scene_info) painter.drawImage(out.rect(), box, box.rect()) painter.end() return out
def draw_filled_polygon(self, outline_pen_with=0): """ Args: outline_pen_with: """ if not self.scale_polygon_colors == None: painter_filled_polygon = QPainter(self) painter_filled_polygon.setRenderHint(QPainter.Antialiasing) # Koordinatenursprung in die Mitte der Flaeche legen painter_filled_polygon.translate(self.width() / 2, self.height() / 2) painter_filled_polygon.setPen(Qt.NoPen) self.pen.setWidth(outline_pen_with) if outline_pen_with > 0: painter_filled_polygon.setPen(self.pen) colored_scale_polygon = self.create_polygon_pie( ((self.widget_diameter / 2) - (self.pen.width() / 2)) * self.gauge_color_outer_radius_factor, (((self.widget_diameter / 2) - (self.pen.width() / 2)) * self.gauge_color_inner_radius_factor), self.scale_angle_start_value, self.scale_angle_size) gauge_rect = QRect( QPoint(0, 0), QSize(self.widget_diameter / 2 - 1, self.widget_diameter - 1)) grad = QConicalGradient( QPointF(0, 0), -self.scale_angle_size - self.scale_angle_start_value + self.angle_offset - 1) # todo definition scale color as array here for eachcolor in self.scale_polygon_colors: grad.setColorAt(eachcolor[0], eachcolor[1]) # grad.setColorAt(.00, Qt.red) # grad.setColorAt(.1, Qt.yellow) # grad.setColorAt(.15, Qt.green) # grad.setColorAt(1, Qt.transparent) painter_filled_polygon.setBrush(grad) # self.brush = QBrush(QColor(255, 0, 255, 255)) # painter_filled_polygon.setBrush(self.brush) painter_filled_polygon.drawPolygon(colored_scale_polygon)
def paintEvent(self, event): painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.Antialiasing) painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127))) painter.setPen(QPen(Qt.NoPen)) for i in range(6): if (self.counter / 5) % 6 == i: painter.setBrush( QBrush(QColor(127 + (self.counter % 5) * 32, 127, 127))) else: painter.setBrush(QBrush(QColor(127, 127, 127))) painter.drawEllipse( self.width() / 2 + 30 * math.cos(2 * math.pi * i / 6.0) - 10, self.height() / 2 + 30 * math.sin(2 * math.pi * i / 6.0) - 10, 20, 20) painter.end()
def combineTiles(self): global radar1 ii = QImage(self.tilesWidth * 256, self.tilesHeight * 256, QImage.Format_ARGB32) painter = QPainter() painter.begin(ii) painter.setPen(QColor(255, 255, 255, 255)) painter.setFont(QFont("Arial", 10)) i = 0 xo = self.cornerTiles["NW"]["X"] xo = int((int(xo) - xo) * 256) yo = self.cornerTiles["NW"]["Y"] yo = int((int(yo) - yo) * 256) for y in range(0, self.totalHeight, 256): for x in range(0, self.totalWidth, 256): if self.tileQimages[i].format() == 5: painter.drawImage(x, y, self.tileQimages[i]) # painter.drawRect(x, y, 255, 255) # painter.drawText(x+3, y+12, self.tiletails[i]) i += 1 painter.end() painter = None self.tileQimages = [] ii2 = ii.copy(-xo, -yo, self.rect.width(), self.rect.height()) ii = None painter2 = QPainter() painter2.begin(ii2) timestamp = "{0:%H:%M} rainvewer.com".format( datetime.datetime.fromtimestamp(self.getTime)) painter2.setPen(QColor(63, 63, 63, 255)) painter2.setFont(QFont("Arial", 8)) painter2.setRenderHint(QPainter.TextAntialiasing) painter2.drawText(3 - 1, 12 - 1, timestamp) painter2.drawText(3 + 2, 12 + 1, timestamp) painter2.setPen(QColor(255, 255, 255, 255)) painter2.drawText(3, 12, timestamp) painter2.drawText(3 + 1, 12, timestamp) painter2.end() painter2 = None ii3 = QPixmap(ii2) ii2 = None self.frameImages.append({"time": self.getTime, "image": ii3}) ii3 = None
def paintEvent(self, event): if not self.image: return p = QPainter(self) ers, sorig = event.rect().size(), self.image.size() img_scaled = self.image.scaled(ers, Qt.KeepAspectRatio) p.drawImage(QPoint(0, 0), img_scaled) p.setRenderHint(QPainter.Antialiasing) p.setPen(Qt.green) p.drawText(10, 20, self.fullpath) p.drawText(10, 40, '#annotations: {}'.format(len(self.polylines))) sx = float(img_scaled.size().width()) / sorig.width() sy = float(img_scaled.size().height()) / sorig.height() p.scale(sx, sy) p.setPen(Qt.yellow) for polyline in self.polylines: self._draw_polyline(p, polyline)
def url2image(url, file_name=None): """Function at the specified url downloads the page and stores it QImage object and returns it. If you pass file_name, then the function will save the picture in the file. Функция по указанному url загружает страницу и сохраняет ее объект QImage и возвращает его. Если передать file_name, тогда функция сохранит в файл картинку. """ # Нужно создавать только один раз global qApp if qApp is None: qApp = QApplication([]) # TODO: прятать вертикальный и горизонтальный ползунки # Загрузка url и ожидание ее view = QWebView() view.setPage(WebPage()) view.load(QUrl(url)) loop = QEventLoop() view.loadFinished.connect(loop.quit) loop.exec_() # Запрашиваем через javascript размеры страницы сайта width = view.page().mainFrame().evaluateJavaScript( "window.document.body.scrollWidth") height = view.page().mainFrame().evaluateJavaScript( "window.document.body.scrollHeight") # Устанавливаем границы документа view.page().setViewportSize(QSize(width, height)) img = QImage(width, height, QImage.Format_ARGB32) painter = QPainter(img) painter.setRenderHint(QPainter.HighQualityAntialiasing) view.page().mainFrame().render(painter) painter.end() if file_name: img.save(file_name) return img
def create_scale_marker_values_text(self): painter = QPainter(self) # painter.setRenderHint(QPainter.HighQualityAntialiasing) painter.setRenderHint(QPainter.Antialiasing) # Koordinatenursprung in die Mitte der Flaeche legen painter.translate(self.width() / 2, self.height() / 2) # painter.save() font = QFont(self.scale_fontname, self.scale_fontsize) fm = QFontMetrics(font) pen_shadow = QPen() pen_shadow.setBrush(self.ScaleValueColor) painter.setPen(pen_shadow) text_radius_factor = 0.8 text_radius = self.widget_diameter / 2 * text_radius_factor scale_per_div = int( (self.value_max - self.value_min) / self.scala_main_count) angle_distance = (float(self.scale_angle_size) / float(self.scala_main_count)) for i in range(self.scala_main_count + 1): # text = str(int((self.value_max - self.value_min) / self.scala_main_count * i)) text = str(int(self.value_min + scale_per_div * i)) w = fm.width(text) + 1 h = fm.height() painter.setFont(QFont(self.scale_fontname, self.scale_fontsize)) angle = angle_distance * i + float(self.scale_angle_start_value - self.angle_offset) x = text_radius * math.cos(math.radians(angle)) y = text_radius * math.sin(math.radians(angle)) # print(w, h, x, y, text) text = [ x - int(w / 2), y - int(h / 2), int(w), int(h), Qt.AlignCenter, text ] painter.drawText(text[0], text[1], text[2], text[3], text[4], text[5])
def _renderedImage2(self, width, height, extent, transp_background=False, layerids=None): """rendering function for GIS < 2.7""" antialias = True if self._renderer is None: self._initRenderer() canvas = self.exportSettings.canvas if canvas is None: logMessage( "With this QGIS version (<= 2.6), map canvas needs to be set to the export settings" ) return if layerids is None: layerids = [mapLayer.id() for mapLayer in canvas.layers()] renderer = self._renderer # QgsMapRenderer renderer.setLayerSet(layerids) image = QImage(width, height, QImage.Format_ARGB32_Premultiplied) if transp_background: image.fill(QColor(Qt.transparent).rgba()) # else: image.fill(canvas.canvasColor().rgba()) # renderer.setOutputSize(image.size(), image.logicalDpiX()) renderer.setExtent(extent.unrotatedRect()) painter = QPainter() painter.begin(image) if antialias: painter.setRenderHint(QPainter.Antialiasing) renderer.render(painter) painter.end() return tools.base64image(image)
def draw_big_scaled_markter(self): my_painter = QPainter(self) my_painter.setRenderHint(QPainter.Antialiasing) # Koordinatenursprung in die Mitte der Flaeche legen my_painter.translate(self.width() / 2, self.height() / 2) # my_painter.setPen(Qt.NoPen) self.pen = QPen(QColor(0, 0, 0, 255)) self.pen.setWidth(2) # # if outline_pen_with > 0: my_painter.setPen(self.pen) my_painter.rotate(self.scale_angle_start_value - self.angle_offset) steps_size = (float(self.scale_angle_size) / float(self.scala_main_count)) scale_line_outer_start = self.widget_diameter/2 scale_line_lenght = (self.widget_diameter / 2) - (self.widget_diameter / 20) # print(stepszize) for i in range(self.scala_main_count+1): my_painter.drawLine(scale_line_lenght, 0, scale_line_outer_start, 0) my_painter.rotate(steps_size)
def exportPNG(self, view, file_name, width, height): image = QImage(QSize(width, height), QImage.Format_ARGB32_Premultiplied) paint = QPainter(image) paint.setRenderHint(QPainter.Antialiasing, True) paint.setRenderHint(QPainter.HighQualityAntialiasing, True) paint.setRenderHint(QPainter.TextAntialiasing, True) paint.setRenderHint(QPainter.SmoothPixmapTransform, True) view.mainFrame().render(paint) image.save(file_name) paint.end() QApplication.restoreOverrideCursor()
def paintEvent(self, event): painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.Antialiasing) painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127))) painter.setPen(QPen(Qt.NoPen)) for i in range(3): x = self.width() / 2.3 + (30 * i) y = self.height() / 2 # Gradiente gradient = QLinearGradient(x + 10, x, y + 10, y) gradient.setColorAt(0, QColor("black")) gradient.setColorAt(1, QColor("gray")) painter.setBrush(QBrush(gradient)) if self.counter / 2 % 3 == i: painter.drawEllipse(x, y, 25, 25) else: painter.drawEllipse(x, y, 20, 20) painter.end()
def _get_pos_widget(name, backgroundColor, foregroundColor): label = QLabel() label.setAttribute(Qt.WA_TransparentForMouseEvents, True) pixmap = QPixmap(25*10, 25*10) pixmap.fill(backgroundColor) painter = QPainter() painter.begin(pixmap) pen = QPen(foregroundColor) painter.setPen(pen) painter.setRenderHint(QPainter.Antialiasing) font = QFont() font.setBold(True) font.setPixelSize(25*10-30) path = QPainterPath() path.addText(QPointF(50, 25*10-50), font, name) brush = QBrush(foregroundColor) painter.setBrush(brush) painter.drawPath(path) painter.setFont(font) painter.end() pixmap = pixmap.scaled(QSize(20,20), Qt.KeepAspectRatio, Qt.SmoothTransformation) label.setPixmap(pixmap) spinbox = QSpinBox() spinbox.setAttribute(Qt.WA_TransparentForMouseEvents, True) spinbox.setEnabled(False) spinbox.setAlignment(Qt.AlignCenter) spinbox.setToolTip("{0} Spin Box".format(name)) spinbox.setButtonSymbols(QAbstractSpinBox.NoButtons) spinbox.setMaximumHeight(20) spinbox.setMaximum(9999) font = spinbox.font() font.setPixelSize(14) spinbox.setFont(font) sheet = TEMPLATE.format(foregroundColor.name(), backgroundColor.name()) spinbox.setStyleSheet(sheet) return label, spinbox
def draw_needle(self): painter = QPainter(self) # painter.setRenderHint(QtGui.QPainter.HighQualityAntialiasing) painter.setRenderHint(QPainter.Antialiasing) # Koordinatenursprung in die Mitte der Flaeche legen painter.translate(self.width() / 2, self.height() / 2) painter.setPen(Qt.NoPen) painter.setBrush(self.NeedleColor) # painter.rotate(((self.value - self.value_offset - self.value_min) * self.scale_angle_size / # (self.value_max - self.value_min)) + 90 + self.scale_angle_start_value) frac, whole = math.modf(self.value) if frac >= 0: frac = 1-frac rotFraction = ((self.value - self.value_offset - self.value_min)/(self.value_max - self.value_min)) else: frac = 1+frac rotFraction = (((whole-frac) - self.value_offset - self.value_min)/(self.value_max - self.value_min)) painter.rotate((1-rotFraction) * self.scale_angle_size + 90 + self.scale_angle_start_value) painter.drawConvexPolygon(self.value_needle[0])
def pixmap(self, mode=QIcon.Normal, state=QIcon.Off): pixmap = self.icon().pixmap(self.iconSize(), mode, state) if pixmap.isNull(): return pixmap size = max(pixmap.width(), pixmap.height()) offset_x = (size - pixmap.width())/2 offset_y = (size - pixmap.height())/2 new_pixmap = QPixmap(size, size) new_pixmap.fill(Qt.transparent) path = QPainterPath() path.addRoundedRect(0, 0, size, size, 3.7, 3.7) painter = QPainter(new_pixmap) painter.setRenderHint(QPainter.Antialiasing, True) painter.setCompositionMode(QPainter.CompositionMode_SourceOver) painter.setClipPath(path) painter.drawPixmap(offset_x, offset_y, pixmap) painter.end() return new_pixmap
def _drawIcon(self, color=Qt.black): self.setForeground(QBrush(color)) if self.isRootNode: pixmap = QPixmap(20, 20) pixmap.fill(Qt.transparent) painter = QPainter() painter.begin(pixmap) pen = QPen(color) pen.setWidth(1) painter.setPen(pen) painter.setBrush(color) painter.setRenderHint(QPainter.Antialiasing) if not self.isExpanded: arrowRightPolygon = [QPoint(6,6), QPoint(6,14), QPoint(14, 10)] painter.drawPolygon(QPolygon(arrowRightPolygon)) else: arrowDownPolygon = [QPoint(6,6), QPoint(15,6), QPoint(10, 14)] painter.drawPolygon(QPolygon(arrowDownPolygon)) painter.end() self.setIcon(QIcon(pixmap))
def __init__(self, parent=None, size=16): QAbstractButton.__init__(self, parent) self.setCursor(Qt.ArrowCursor) self.setFocusPolicy(Qt.NoFocus) self.setToolTip(u"Clear") self.setVisible(False) self.setMinimumSize(size + 2, size + 2) pixmap = QPixmap() if pixmap.load(Resources.get("icons/delete.svg")): self.icon = pixmap.scaled(size, size, Qt.KeepAspectRatio, Qt.SmoothTransformation) # Use QImage because QPainter using a QPixmap does not support CompositionMode_Multiply -Dan image = self.icon.toImage() painter = QPainter(image) painter.setRenderHint(QPainter.Antialiasing, True) painter.setCompositionMode(QPainter.CompositionMode_Multiply) painter.drawPixmap(0, 0, self.icon) painter.end() self.icon_pressed = QPixmap(image) else: self.icon = self.icon_pressed = None
def _render_qwebpage_full(self, web_rect, render_rect, canvas_size): """Render web page in one step.""" if self._qpainter_needs_tiling(render_rect, canvas_size): # If this condition is true, this function may get stuck. raise ValueError("Rendering region is too large to be drawn" " in one step, use tile-by-tile renderer instead") canvas = QImage(canvas_size, self.qt_image_format) if self.is_jpeg(): # White background for JPEG images, same as we have in all browsers. canvas.fill(Qt.white) else: # Preserve old behaviour for PNG format. canvas.fill(0) painter = QPainter(canvas) try: painter.setRenderHint(QPainter.Antialiasing, True) painter.setRenderHint(QPainter.TextAntialiasing, True) painter.setRenderHint(QPainter.SmoothPixmapTransform, True) painter.setWindow(web_rect) painter.setViewport(render_rect) painter.setClipRect(web_rect) self.web_page.mainFrame().render(painter) finally: painter.end() return WrappedQImage(canvas)
def _render_qwebpage_full(web_page, logger, viewport_size, image_size): image = QImage(image_size, QImage.Format_ARGB32) image.fill(0) painter = QPainter(image) try: painter.setRenderHint(QPainter.Antialiasing, True) painter.setRenderHint(QPainter.TextAntialiasing, True) painter.setRenderHint(QPainter.SmoothPixmapTransform, True) painter.setWindow(QRect(QPoint(0, 0), web_page.viewportSize())) painter.setViewport(QRect(QPoint(0, 0), viewport_size)) if image_size != viewport_size: # Try not to draw stuff that won't fit into the image. Clipping # must be specified in input (aka logical) coordinates, but we know # it in output (aka physical) coordinates, so we have to do an # inverse transformation. If, for some reason, we cannot, skip the # clipping altogether. clip_rect = QRect(QPoint(0, 0), viewport_size) inv_transform, invertible = painter.combinedTransform().inverted() if invertible: painter.setClipRect(inv_transform.mapRect(clip_rect)) web_page.mainFrame().render(painter) finally: # It is important to end painter explicitly in python code, because # Python finalizer invocation order, unlike C++ destructors, is not # deterministic and there is a possibility of image's finalizer running # before painter's which may break tests and kill your cat. painter.end() return qimage_to_pil_image(image)
def rounded_corners(image, radius=0, **kwargs): """ Appliquer un découpage du masque de l'image en rectangle arrondi :param image: image PIL :param radius: rayon en pixels des coins arrondis """ if radius == "full" or isinstance(radius, (int, float)): qimage = _pil_to_qt(image) newimage = _qt_canvas(image) painter = QPainter(newimage) painter.setRenderHint(QPainter.Antialiasing, True) painter.setBrush(QBrush(qimage)) painter.setPen(QColor(0, 0, 0, 0)) if radius == "full": # découper en ellipse painter.drawEllipse(0, 0, qimage.width(), qimage.height()) elif isinstance(radius, (int, float)): # découper en rectangle arrondi painter.drawRoundedRect(0, 0, qimage.width(), qimage.height(), radius, radius) painter.end() return _qt_to_pil(newimage) return image
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_Premultiplied) p = QPainter(buffer) p.setRenderHint(QPainter.Antialiasing) self.rebuildDataBrushIfNeeded() self.drawBackground(p, buffer.rect()) self.drawBase(p, baseRect) if self.m_value > 0: delta = (self.m_max - self.m_min) / (self.m_value - self.m_min) else: delta = 0 self.drawValue(p, baseRect, self.m_value, delta) innerRect, innerRadius = self.calculateInnerRect(outerRadius) self.drawInnerBackground(p, innerRect) self.drawText(p, innerRect, innerRadius, self.m_value) p.end() painter = QPainter(self) painter.fillRect(baseRect, self.palette().base()) painter.drawImage(0, 0, buffer)
def process(self, fullpath, image_dataurl, polylines): image_data, _ = mio.extract_image_and_type(image_dataurl) image = QtGui.QImage() image.loadFromData(image_data) sis = image.size() pixmap = QPixmap(sis.width(), sis.height()) pixmap.fill(Qt.white) p = QPainter() p.begin(pixmap) p.drawImage(QPoint(0, 0), image) p.setRenderHint(QPainter.Antialiasing) p.setPen(Qt.yellow) for polyline in polylines: self._draw_polyline(p, polyline) p.end() _, fname = path.split(fullpath) outpath = path.join(self.outdir, fname) print(outpath) pixmap.save(outpath) return [fullpath, image_dataurl, polylines]
def renderLayers(size, layers, imageFileName): imgSize = QSize(size, size) # create image img = QImage(imgSize, QImage.Format_RGB32) # set image's background color color = QColor(255, 255, 255) img.fill(color.rgb()) # create painter p = QPainter() p.begin(img) p.setRenderHint(QPainter.Antialiasing) render = QgsMapRenderer() # set layer set render.setLayerSet(layers.keys()) # set extent rect = QgsRectangle(render.fullExtent()) render.setExtent(rect) # set output size render.setOutputSize(img.size(), img.logicalDpiX()) print "render()" # do the rendering render.render(p) p.end() print " ...Done" print "save(" + imageFileName + ")" # save image img.save(imageFileName) print " ...Done"
def paintEvent( self, event ): # Wenn das Widget disabled ist, muß ich den Alphakanal meiner Farben verändern. frameWidth = 16 dotCenter = QPoint( 0, 0 ) color = self.__colorEmpty if self.__value: color = self.__colorFull # Damit der Rahmen nicht irgendwie abgeschnitten wird, muß der Kreis entsprechend kleiner sein. dotRadius = 100 framePen = QPen( frameWidth ) framePen.setColor( self.__colorFrame ) dotDiameter = 2 * dotRadius + frameWidth painter = QPainter( self ) windowWidth = self.width() windowHeight = float( self.height() ) side = min( windowWidth, windowHeight ) painter.setRenderHint( QPainter.Antialiasing ) if ( not self.isEnabled() ): painter.setOpacity( .5 ) painter.translate( side / 2, self.height() / 2 ) painter.scale( side / dotDiameter, side / dotDiameter ) painter.setPen( framePen ) painter.setBrush( color ) painter.save() painter.drawEllipse( dotCenter, dotRadius, dotRadius ) painter.restore()
def setNameAndBrush(self, sigma, color=Qt.black): self.sigma = sigma self.setText(decode_to_qstring("σ=%.1fpx" % self.sigma, 'utf-8')) # This file is encoded as utf-8, so this string should be decoded as such. total_window = (1 + 2 * int(self.sigma * self.window_size + 0.5) ) self.setToolTip( "sigma = {:.1f} pixels, window diameter = {:.1f}".format(self.sigma, total_window) ) font = QFont() font.setPointSize(10) font.setBold(True) self.setFont(font) self.setForeground(color) pixmap = QPixmap(self.pixmapSize) pixmap.fill(Qt.transparent) painter = QPainter() painter.begin(pixmap) painter.setRenderHint(QPainter.Antialiasing, True) painter.setPen(color) brush = QBrush(color) painter.setBrush(brush) painter.drawEllipse(QRect(self.pixmapSize.width()/2 - self.brushSize/2, self.pixmapSize.height()/2 - self.brushSize/2, self.brushSize, self.brushSize)) painter.end() self.setIcon(QIcon(pixmap)) self.setTextAlignment(Qt.AlignVCenter)