def _do_paint_rgb24(self, img_data, x, y, width, height, rowstride, options, callbacks): image = QImage(img_data, width, height, rowstride, QImage.Format_RGB888) pe = QPainter(self._backing) rect = QRectF(x, y, width, height) src = QRectF(0, 0, width, height) pe.drawImage(rect, image, src) return True
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 paintEvent( self, event): painter = QPainter( ) painter.begin(self) [S.draw(painter) for S in self.spriteList] self.boundary.draw(painter) painter.end( )
def endDrawing(self, pos): has_moved = self._hasMoved # _hasMoved will change after calling moveTo if has_moved: self.moveTo(pos) else: assert(self.pos == pos) self.moveTo(QPointF(pos.x()+0.0001, pos.y()+0.0001)) # move a little tempi = QImage(QSize(self.bb.width(), self.bb.height()), QImage.Format_ARGB32_Premultiplied) #TODO: format tempi.fill(0) painter = QPainter(tempi) self.scene.render(painter, target=QRectF(), source=QRectF(QPointF(self.bb.x(), self.bb.y()), QSizeF(self.bb.width(), self.bb.height()))) painter.end() ndarr = qimage2ndarray.rgb_view(tempi)[:,:,0] labels = numpy.where(ndarr>0,numpy.uint8(self.drawnNumber),numpy.uint8(0)) labels = labels.swapaxes(0,1) assert labels.shape[0] == self.bb.width() assert labels.shape[1] == self.bb.height() ## ## ensure that at least one pixel is label when the brush size is 1 ## ## this happens when the user just clicked without moving ## in that case the lineitem will be so tiny, that it won't be rendered ## into a single pixel by the code above if not has_moved and self.brushSize <= 1 and numpy.count_nonzero(labels) == 0: labels[labels.shape[0]//2, labels.shape[1]//2] = self.drawnNumber self.brushStrokeAvailable.emit(QPointF(self.bb.x(), self.bb.y()), labels)
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 draw_line_to(self, end_point): painter = QPainter(self.image) painter.setPen(QPen(self.pen_color, self.pen_width, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)) painter.drawLine(self.last_point/5, end_point/5) self.update() self.last_point = QPoint(end_point)
def preparePixmap(self): """ Prepare the pixmap(s) for the transition. This method draws the starting pixmap into the output pixmap. The transition update then draws over the output with the proper portion of the ending pixmap. """ start = self.startPixmap() end = self.endPixmap() size = start.size().expandedTo(end.size()) width = size.width() height = size.height() painter = QPainter(self.outPixmap()) painter.drawPixmap(0, 0, start) direction = self.direction() if direction == self.LeftToRight: start_rect = QRect(0, 0, 0, height) elif direction == self.RightToLeft: start_rect = QRect(width, 0, 0, height) elif direction == self.TopToBottom: start_rect = QRect(0, 0, width, 0) elif direction == self.BottomToTop: start_rect = QRect(0, height, width, 0) else: raise ValueError('Invalid direction: %s' % direction) end_rect = QRect(0, 0, width, height) return start_rect, end_rect
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 _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 draw_centering_guides(image, target_x, target_y, target_w, guide_h): left_x = target_x - (target_w / 2.0) right_x = left_x + target_w top_y = target_y bottom_y = top_y + guide_h new_img = image.copy() if not new_img.format() is QImage.Format_ARGB32_Premultiplied: new_img = new_img.convertToFormat(QImage.Format_ARGB32_Premultiplied) painter = QPainter(new_img) pen = painter.pen() pen.setColor(QColor(255, 0, 0)) painter.setPen(pen) painter.drawLine(left_x, top_y, left_x, bottom_y) painter.drawLine(right_x, top_y, right_x, bottom_y) painter.end() return new_img
def get_sprite(sprite_id): sprite_file = get_sprite_file(sprite_id) if sprite_file == None: return None sprite_file = os.path.join(SPRITE_DIR, sprite_file) if not os.path.isfile(sprite_file): sprite_file = os.path.join(SPRITE_DIR, "bustup_%02d_%02d.png" % (99, 99)) out = QImage(IMG_W, IMG_H, QImage.Format_ARGB32_Premultiplied) out.fill(QColor(0, 0, 0, 0).rgba()) painter = QPainter(out) sprite = QImage(sprite_file) # Center the sprite on our image. sprite_x = (out.width() - sprite.width()) / 2 sprite_y = 0 painter.drawImage(QRect(sprite_x, sprite_y, sprite.width(), sprite.height()), sprite, sprite.rect()) painter.end() return out
def paintEvent(self, event): painter = QPainter(self) if self.isChecked(): if self.m_color == self.BLUE: self.m_pixmap.load(":/bitmaps/led_blue.png") elif self.m_color == self.GREEN: self.m_pixmap.load(":/bitmaps/led_green.png") elif self.m_color == self.RED: self.m_pixmap.load(":/bitmaps/led_red.png") elif self.m_color == self.YELLOW: self.m_pixmap.load(":/bitmaps/led_yellow.png") elif self.m_color == self.BIG_RED: self.m_pixmap.load(":/bitmaps/led-big_on.png") else: return else: if self.m_color in (self.BLUE, self.GREEN, self.RED, self.YELLOW): self.m_pixmap.load(":/bitmaps/led_off.png") elif self.m_color == self.BIG_RED: self.m_pixmap.load(":/bitmaps/led-big_off.png") else: return painter.drawPixmap(self.m_pixmap_rect, self.m_pixmap, self.m_pixmap_rect)
def paintEvent(self, event): """ Overloads the paint event to support rendering of hints if there are no items in the tree. :param event | <QPaintEvent> """ super(XTextEdit, self).paintEvent(event) if self.document().isEmpty() and self.hint(): text = self.hint() rect = self.rect() # modify the padding on the rect rect.setX(4) rect.setY(4) align = int(Qt.AlignLeft | Qt.AlignTop) # setup the coloring options clr = self.hintColor() # paint the hint painter = QPainter(self.viewport()) painter.setPen(clr) painter.drawText(rect, align | Qt.TextWordWrap, text)
def paintEvent( self, event ): """ Overloads the paint event to support rendering of hints if there are no items in the tree. :param event | <QPaintEvent> """ super(XListWidget, self).paintEvent(event) if not self.count() and self.hint(): text = self.hint() rect = self.rect() # modify the padding on the rect rect.setX(rect.x() + 2) rect.setY(rect.y() + 2) rect.setWidth(rect.width() - 4) rect.setHeight(rect.height() - 4) align = int(self.hintAlignment()) # setup the coloring options clr = self.hintColor() # paint the hint painter = QPainter(self.viewport()) painter.setPen(clr) painter.drawText(rect, align | Qt.TextWordWrap, text)
def updateSlice(self): if self.ctslice_rgba is None: return img = self.ctslice_rgba.copy() if self.seeds is not None: if self.mode_draw: if self.contour_mode == 'fill': self.composeRgba(img, self.seeds, self.seeds_colortable) elif self.contour_mode == 'contours': self.get_contours(img, self.seeds) else: self.overRgba(img, self.seeds, self.seeds_colortable) if self.contours is not None: if self.contour_mode == 'fill': self.composeRgba(img, self.contours, CONTOURS_COLORTABLE) elif self.contour_mode == 'contours': self.get_contours(img, self.contours) image = QImage(img.flatten(), self.slice_size[0], self.slice_size[1], QImage.Format_ARGB32).scaled(self.imagesize) painter = QPainter(self.image) painter.drawImage(0, 0, image) painter.end() self.update()
def render(self): painter = QPainter(self.printer) for page in self.layoutPages[:-1]: page.render(painter) self.printer.newPage() self.layoutPages[-1].render(painter) painter.end()
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 drawLineTo( self, newPos ): p = QPainter( self.image ) pen = QPen(QtCore.Qt.black, 4, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap) p.setPen(pen) p.drawLine( self.currentPos, newPos ) self.currentPos = newPos self.update()
def __drawActiveIblSetOverlay(self): """ Draws an overlay on :obj:`Inspector.Image_Label` Widget. """ painter = QPainter(self.Image_label.pixmap()) painter.setRenderHints(QPainter.Antialiasing) iblSetPath = self.__activeIblSet.path sectionsFileParser = self.__sectionsFileParsersCache.getContent(iblSetPath) if sectionsFileParser is None: raise foundations.exceptions.ExecutionError( "'{0}' Ibl Set file 'SectionsFileParser' instance not found!".format(iblSetPath)) for section in sectionsFileParser.sections: if section == "Sun": self.__drawLightLabel(painter, Light(name="Sun", color=[int(value) for value in sectionsFileParser.getValue( "SUNcolor", section).split(",")], uCoordinate=float(sectionsFileParser.getValue("SUNu", section)), vCoordinate=float(sectionsFileParser.getValue("SUNv", section)))) elif re.search(r"Light\d+", section): self.__drawLightLabel(painter, Light(name=sectionsFileParser.getValue( "LIGHTname", section) or self.__unnamedLightName, color=[int(value) for value in sectionsFileParser.getValue( "LIGHTcolor", section).split(",")], uCoordinate=float( sectionsFileParser.getValue("LIGHTu", section)), vCoordinate=float( sectionsFileParser.getValue("LIGHTv", section)))) painter.end()
def compose_image(self): """ This loops through all the tiles and then composes a single map canvas renderable image :return: a renderable image :rtype: QImage """ width = (self.xmax - self.xmin + 1) * self.layerDef.TILE_SIZE height = (self.ymax - self.ymin + 1) * self.layerDef.TILE_SIZE image = QImage(width, height, QImage.Format_ARGB32_Premultiplied) image.fill(Qt.transparent) p = QPainter(image) for tile in self.tiles.values(): if not tile.pixel_data: continue x = tile.x - self.xmin y = tile.y - self.ymin rect = QRect(x * self.layerDef.TILE_SIZE, y * self.layerDef.TILE_SIZE, self.layerDef.TILE_SIZE, self.layerDef.TILE_SIZE) timg = QImage() timg.loadFromData(tile.pixel_data) p.drawImage(rect, timg) return image
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): if self.active: painter = QPainter(self) pen = painter.pen() pen.setWidth(self.margin) pen.setColor(QColor('red').dark(150)) painter.drawRect(0, 0, self.width(), self.height())
def pixmapFromSvg(self, pmapSize=None, withBorders=None): """returns a pixmap with default size as given in SVG and optional borders/shadows""" if withBorders is None: withBorders = Preferences.showShadows if withBorders: wantSize = self.tileset.tileSize.toSize() else: wantSize = self.tileset.faceSize.toSize() if not pmapSize: pmapSize = wantSize result = QPixmap(pmapSize) result.fill(Qt.transparent) painter = QPainter(result) if not painter.isActive(): logException('painter is not active. Wanted size: %s' % str(pmapSize)) try: xScale = float(pmapSize.width()) / wantSize.width() yScale = float(pmapSize.height()) / wantSize.height() except ZeroDivisionError: xScale = 1 yScale = 1 if not withBorders: painter.scale(*self.tileset.tileFaceRelation()) painter.translate(-self.facePos()) renderer = self.tileset.renderer() renderer.render(painter, self.elementId()) painter.resetTransform() self._drawDarkness(painter) if self.showFace(): faceSize = self.tileset.faceSize.toSize() faceSize = QSize(faceSize.width() * xScale, faceSize.height() * yScale) painter.translate(self.facePos()) renderer.render(painter, self.tileset.svgName[self.tile.element.lower()], QRectF(QPointF(), QSizeF(faceSize))) return result
def border_webpage(self): ''' get web page border and webpage ** this method inaccurate, page will change longer ** ** give up use ** ''' size = self.main_page.mainFrame().contentsSize() global _CURRENT_URL global _CURRENT_URL_TYPE nwe_border_list = [size.width(), size.height()] self.mongo_operate.add_web_border( _CURRENT_URL, _CURRENT_URL_TYPE, nwe_border_list) # print u"页面宽:%d,页面高:%d" % (size.width(), size.height()) self.main_page.setViewportSize( QSize(size.width() + 16, size.height())) img = QImage(size, QImage.Format_ARGB32) painter = QPainter(img) self.main_page.mainFrame().render(painter) painter.end() global _CURRENT_TIME_PATH img_path = _CURRENT_TIME_PATH + '/webpage.jpeg' if not img.save(img_path): sys.stderr.write('%s error to save img: %s, path: %s\n' % (time.ctime(), _CURRENT_URL, _CURRENT_TIME_PATH))
def screenshot(self): logging.debug('screenshot() invoked') frame = self.page().mainFrame() size = frame.contentsSize() if (self.screenWidth): size.setWidth(self.screenWidth) if (self.screenHeight): size.setHeight(self.screenHeight) if (self.minWidth and self.minWidth > self.screenWidth): size.setWidth(self.minWidth) if (self.minHeight and self.minHeight > self.screenHeight): size.setHeight(self.minHeight) self.page().setViewportSize(size) image = QImage(self.page().viewportSize(), QImage.Format_ARGB32) painter = QPainter(image) frame.render(painter) painter.end() buffer = QBuffer() buffer.open(QIODevice.ReadWrite) image.save(buffer, self.format, self.quality) logging.debug('screenshot() returned image of type ' + self.content_type + ' of length ' + str(buffer.data().length())) return { 'content': buffer.data(), 'content_type': self.content_type }
def testComposition(self, page=0, pixelDiff=0 ): if self.mComposition is None: myMessage = "Composition not valid" return False, myMessage #load expected image self.setControlName("expected_"+self.mTestName) # get width/height, create image and render the composition to it outputImage = QImage( self.mSize, QImage.Format_RGB32 ) self.mComposition.setPlotStyle( QgsComposition.Print ) outputImage.setDotsPerMeterX( self.mDotsPerMeter ) outputImage.setDotsPerMeterY( self.mDotsPerMeter ) QgsMultiRenderChecker.drawBackground( outputImage ) p = QPainter( outputImage ) self.mComposition.renderPage( p, page ) p.end() renderedFilePath = QDir.tempPath() + QDir.separator() + QFileInfo(self.mTestName).baseName() + "_rendered.png" outputImage.save( renderedFilePath, "PNG" ) self.setRenderedImage( renderedFilePath ) testResult = self.runTest( self.mTestName, pixelDiff ) return testResult, self.report()
def print_(self): """Prints the document.""" self._stop = False resolution = self.resolution() p = self.printer() p.setFullPage(True) p.setResolution(resolution) center = p.paperRect().center() painter = QPainter(p) pages = self.pageList() if p.pageOrder() != QPrinter.FirstPageFirst: pages.reverse() total = len(pages) opts = self.renderOptions() document = self.document() for num, pageNum in enumerate(pages, 1): if self._stop: return p.abort() self.progress(num, total, pageNum) if num > 1: p.newPage() with lock(document): opts.write(document) page = document.page(pageNum - 1) img = page.renderToImage(resolution, resolution) rect = img.rect() rect.moveCenter(center) painter.drawImage(rect, img) return painter.end()
def _paint(self, p: QPainter): self._paint_bg(p) self._paint_title(p) p.setPen(QPen(self.pen().brush(), 1)) self._paint_ins(p) self._paint_outs(p) self._paint_content(p)
def painter_for ( context ): """ Returns a QPainter for the specified *context* object. """ graphics = QPainter( context ) graphics.setRenderHint( QPainter.TextAntialiasing ) return graphics
def updatecanvas(self, canvas): """ Update the canvas object for the legend background. """ if self._lastextent == canvas.extent(): return self._lastextent = canvas.extent() if QGis.QGIS_VERSION_INT > 20200: from qgis.core import QgsMapRendererParallelJob, QgsMapSettings settings = canvas.mapSettings() extent = settings.extent() settings.setOutputSize(self.size()) settings.setExtent(extent) #settings.setFlags(QgsMapSettings.Antialiasing | QgsMapSettings.DrawLabeling ) self.renderjob = QgsMapRendererParallelJob(settings) self.renderjob.finished.connect(self._renderimage) self.renderjob.start() else: if canvas.isDrawing(): return pixmap = QPixmap(self.size()) pixmap.fill(canvas.canvasColor()) painter = QPainter(pixmap) painter.setRenderHints(QPainter.Antialiasing) renderer = canvas.mapRenderer() renderer.render(painter) del painter self.canvasimage = pixmap.toImage() self.update()
def endDrawing(self, pos): has_moved = self._hasMoved # _hasMoved will change after calling moveTo if has_moved: self.moveTo(pos) else: assert (self.pos == pos) self.moveTo(QPointF(pos.x() + 0.0001, pos.y() + 0.0001)) # move a little tempi = QImage(QSize(self.bb.width(), self.bb.height()), QImage.Format_ARGB32_Premultiplied) #TODO: format tempi.fill(0) painter = QPainter(tempi) self.scene.render(painter, target=QRectF(), source=QRectF( QPointF(self.bb.x(), self.bb.y()), QSizeF(self.bb.width(), self.bb.height()))) painter.end() ndarr = qimage2ndarray.rgb_view(tempi)[:, :, 0] labels = numpy.where(ndarr > 0, numpy.uint8(self.drawnNumber), numpy.uint8(0)) labels = labels.swapaxes(0, 1) assert labels.shape[0] == self.bb.width() assert labels.shape[1] == self.bb.height() ## ## ensure that at least one pixel is label when the brush size is 1 ## ## this happens when the user just clicked without moving ## in that case the lineitem will be so tiny, that it won't be rendered ## into a single pixel by the code above if not has_moved and self.brushSize <= 1 and numpy.count_nonzero( labels) == 0: labels[labels.shape[0] // 2, labels.shape[1] // 2] = self.drawnNumber self.brushStrokeAvailable.emit(QPointF(self.bb.x(), self.bb.y()), labels)
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, event): ''' Paints area the user is currently selecting starting from point start_x and, start_y ending at the position of the user's mouse currently on screen. ''' painter = QPainter() painter.begin(self) painter.fillRect(self.screen_geometry, QColor(10, 10, 10, 125)) self._paint_selection(painter) self._paint_usage_text(painter) painter.end()
def paintEvent(self, event): painter = QPainter(self) try: painter.drawImage(event.rect(), self.image) except: pass painter.end()
def _load_icon(filename, backgroundColor, width, height): foreground = QPixmap() foreground.load(filename) pixmap = QPixmap(foreground.size()) pixmap.fill(backgroundColor) painter = QPainter() painter.begin(pixmap) painter.drawPixmap(QPointF(0, 0), foreground) painter.end() pixmap = pixmap.scaled(QSize(width, height), Qt.KeepAspectRatio, Qt.SmoothTransformation) return pixmap
def paintEvent(self, event): """ Overloads the paint event to support rendering of hints if there are no items in the tree. :param event | <QPaintEvent> """ super(XListWidget, self).paintEvent(event) if not self.count() and self.hint(): text = self.hint() rect = self.rect() # modify the padding on the rect rect.setX(rect.x() + 2) rect.setY(rect.y() + 2) rect.setWidth(rect.width() - 4) rect.setHeight(rect.height() - 4) align = int(self.hintAlignment()) # setup the coloring options clr = self.hintColor() # paint the hint painter = QPainter(self.viewport()) painter.setPen(clr) painter.drawText(rect, align | Qt.TextWordWrap, text)
def paintEvent(self, event): """QWidget.paintEvent() implementation """ painter = QPainter(self) painter.fillRect(event.rect(), self.palette().color(QPalette.Window)) painter.setPen(Qt.black) block = self._qpart.firstVisibleBlock() blockNumber = block.blockNumber() top = int( self._qpart.blockBoundingGeometry(block).translated( self._qpart.contentOffset()).top()) bottom = top + int(self._qpart.blockBoundingRect(block).height()) singleBlockHeight = self._qpart.cursorRect().height() width = None boundingRect = self._qpart.blockBoundingRect(block) while block.isValid() and top <= event.rect().bottom(): if block.isVisible() and bottom >= event.rect().top(): number = str(blockNumber + 1) painter.drawText(0, top, self.width() - self._RIGHT_MARGIN, self._qpart.fontMetrics().height(), Qt.AlignRight, number) if boundingRect.height( ) >= singleBlockHeight * 2: # wrapped block if width is None: width = self.width() # laizy calculation painter.fillRect( 1, top + singleBlockHeight, width - 2, boundingRect.height() - singleBlockHeight - 2, Qt.darkGreen) block = block.next() boundingRect = self._qpart.blockBoundingRect(block) top = bottom bottom = top + int(boundingRect.height()) blockNumber += 1
def paintEvent(self, e): """ Overload the standard paintEvent function """ #p = QPainter(self.graphicsView) ## our painter canvas = QPainter(self) ## our painter for name, ch in self.allFpgaOutput.iteritems(): if ch.type == "spike32": self.drawRaster(canvas, ch) else: self.drawPoints(canvas, ch) ## paint clipped graphics
def qt_svg_to_png_renderer(impact_report, component): """Render SVG into PNG. :param impact_report: ImpactReport contains data about the report that is going to be generated. :type impact_report: safe.report.impact_report.ImpactReport :param component: Contains the component metadata and context for rendering the output. :type component: safe.report.report_metadata.QgisComposerComponentsMetadata :return: Whatever type of output the component should be. .. versionadded:: 4.0 """ context = component.context filepath = context['filepath'] width = component.extra_args['width'] height = component.extra_args['height'] image_format = QImage.Format_ARGB32 qimage = QImage(width, height, image_format) qimage.fill(0x00000000) renderer = QSvgRenderer(filepath) painter = QPainter(qimage) renderer.render(painter) # Should call painter.end() so that QImage is not used painter.end() # in case output folder not specified if impact_report.output_folder is None: impact_report.output_folder = mkdtemp(dir=temp_dir()) output_path = impact_report.component_absolute_output_path( component.key) qimage.save(output_path) component.output = output_path return component.output
def rasterize_svg(self, elem, width=0, height=0, format='PNG'): view_box = elem.get('viewBox', elem.get('viewbox', None)) sizes = None logger = self.oeb.logger if view_box is not None: box = [float(x) for x in view_box.split()] sizes = [box[2] - box[0], box[3] - box[1]] for image in elem.xpath('descendant::*[local-name()="image" and ' '@height and contains(@height, "%")]'): logger.info( 'Found SVG image height in %, trying to convert...') try: h = float(image.get('height').replace('%', '')) / 100. image.set('height', str(h * sizes[1])) except: logger.exception('Failed to convert percentage height:', image.get('height')) data = QByteArray(xml2str(elem, with_tail=False)) svg = QSvgRenderer(data) size = svg.defaultSize() if size.width() == 100 and size.height() == 100 and sizes: size.setWidth(sizes[0]) size.setHeight(sizes[1]) if width or height: size.scale(width, height, Qt.KeepAspectRatio) logger.info('Rasterizing %r to %dx%d' % (elem, size.width(), size.height())) image = QImage(size, QImage.Format_ARGB32_Premultiplied) image.fill(QColor("white").rgb()) painter = QPainter(image) svg.render(painter) painter.end() array = QByteArray() buffer = QBuffer(array) buffer.open(QIODevice.WriteOnly) image.save(buffer, format) return str(array)
def updateImage(self): self.readImage() self.drawSkelResult() if len(self.is_stage_move) > 0 and self.is_stage_move[ self.frame_number]: painter = QPainter() painter.begin(self.frame_qimg) pen = QPen() pen_width = 3 pen.setWidth(pen_width) pen.setColor(Qt.red) painter.setPen(pen) painter.drawRect(1, 1, self.frame_qimg.width() - pen_width, self.frame_qimg.height() - pen_width) painter.end() print(1) self.pixmap = QPixmap.fromImage(self.frame_qimg) self.ui.imageCanvas.setPixmap(self.pixmap)
def renderPDF(self, status): print "Load finished with status: ", status print "Rendering PDF ..." contentsSize = self.mainFrame.contentsSize() self.page.setViewportSize(contentsSize) self.printer = QPrinter(QPrinter.PrinterResolution) #self.printer = QPrinter ( QPrinter.ScreenResolution ) self.printer.setOutputFormat(QPrinter.PdfFormat) #self.printer.setPaperSize ( QPrinter.A4 ) self.printer.setFullPage(True) self.printer.setPaperSize(QSizeF(contentsSize), QPrinter.DevicePixel) self.printer.setOrientation(QPrinter.Portrait) self.printer.setOutputFileName(self.dest) self.painter = QPainter(self.printer) self.painter.setRenderHint(QPainter.Antialiasing) self.mainFrame.render(self.painter) self.painter.end() app = QtGui.QApplication.instance() app.exit(0)
def paintEvent(self, e): """ Overload the standard paintEvent function """ #p = QPainter(self.graphicsView) ## our painter p = QPainter(self) ## our painter #r1 = QRegion ( QRect(100,100,200,80), QRegion.Ellipse() ) r1 = QRegion(QRect(self.x, 10, 5, 100)) r2 = QRegion(QRect(100, 120, 10, 30)) ## r2 = rectangular region r3 = QRegion(r1.intersect(r2)) ## r3 = intersection #p.setClipRegion( r1 ) ## set clip region self.drawPoints(p) ## paint clipped graphics
def run(self, config): folder = os.path.abspath('./source/generated') generator = config.item_generator item = generator.generate_item(name=self.arguments[0]) file_name = item.name file_name = file_name + '.png' file_name = file_name.replace(' ', '') surface_manager = config.surface_manager icon = surface_manager.get_icon(item.icon) new_image = QImage(32, 32, QImage.Format_ARGB32) new_image.fill(QColor(200, 200, 200)) painter = QPainter(new_image) painter.drawPixmap(0, 0, icon) painter = None new_image.save(os.path.join(folder, file_name)) self.arguments[0] = os.path.join('generated/', file_name) return super(ItemImageDirective, self).run()
def mkfinished(self): if self.mkreply.error() != QNetworkReply.NoError: return self.mkpixmap = QPixmap() self.mkpixmap.loadFromData(self.mkreply.readAll()) if self.mkpixmap.size() != self.rect.size(): self.mkpixmap = self.mkpixmap.scaled(self.rect.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation) br = QBrush(QColor(Config.dimcolor)) painter = QPainter() painter.begin(self.mkpixmap) painter.fillRect(0, 0, self.mkpixmap.width(), self.mkpixmap.height(), br) painter.end() self.wmk.setPixmap(self.mkpixmap)
def paintEvent(self, event): """ Handles the drawing for this widget and its selection region. :param event | <QPaintEvent> """ pen = QPen(Qt.DashLine) pen.setColor(QColor('red')) painter = QPainter(self) painter.setPen(pen) clr = QColor('black') clr.setAlpha(100) painter.setBrush(clr) painter.drawRect(self._region)
def paintEvent(self, event): bg_color = Qt.black # configuración del painter painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing, True) # transformación window-viewport painter.setWindow(0, 0, *self.frame_size) # fondo del laberinto painter.fillRect(0, 0, self.frame_size[0], self.frame_size[1], QBrush(bg_color)) # dibujar el laberinto self._paintLaberinto(painter)
def draw_line_to(self, end_point): painter = QPainter(self.image) painter.setPen(QPen(Qt.white if self.scribbling == 1 else Qt.black, self.pen_width, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)) painter.drawLine(self.last_point/5, end_point/5) self.update() self.last_point = QPoint(end_point)
def export_scene(canvas, width, height, dpi, exportFileName): """ This function exports the scene to a file. """ # need this to make sure we take away focus from # any currently selected legend items canvas.clearFocus() with HiddenStitchManager(canvas): # NOTE: We seem to need the 1px buffer region to avoid # the image being cut off margin = 10 theScene = visible_bounding_rect(canvas.items()) theScene.adjust(-margin, -margin, margin, margin) # check if user requested an svg file svg = True if QFileInfo(exportFileName).completeSuffix() == "svg" \ else False if svg: generator = QSvgGenerator() generator.setFileName(exportFileName) generator.setSize(QSize(width, height)) generator.setViewBox(QRect(0, 0, width, height)) generator.setTitle("sconcho generated SVG image") generator.setDescription("this svg image was exported from " "a sconcho project") generator.setResolution(dpi) else: generator = QImage(width + 2 * margin, height + 2 * margin, QImage.Format_ARGB32_Premultiplied) generator.fill(1) inchesToMeter = 39.3700787 generator.setDotsPerMeterX(dpi * inchesToMeter) generator.setDotsPerMeterY(dpi * inchesToMeter) painter = QPainter(generator) painter.setRenderHints(QPainter.SmoothPixmapTransform | QPainter.HighQualityAntialiasing | QPainter.TextAntialiasing) painter.setBackgroundMode(Qt.TransparentMode) canvas.render(painter, QRectF(), theScene) painter.end() if not svg: generator.save(exportFileName)
def grab_svg(scene): """ Return a SVG rendering of the scene contents. Parameters ---------- scene : :class:`CanvasScene` """ from PyQt4.QtSvg import QSvgGenerator svg_buffer = QBuffer() gen = QSvgGenerator() gen.setOutputDevice(svg_buffer) items_rect = scene.itemsBoundingRect().adjusted(-10, -10, 10, 10) if items_rect.isNull(): items_rect = QRectF(0, 0, 10, 10) width, height = items_rect.width(), items_rect.height() rect_ratio = float(width) / height # Keep a fixed aspect ratio. aspect_ratio = 1.618 if rect_ratio > aspect_ratio: height = int(height * rect_ratio / aspect_ratio) else: width = int(width * aspect_ratio / rect_ratio) target_rect = QRectF(0, 0, width, height) source_rect = QRectF(0, 0, width, height) source_rect.moveCenter(items_rect.center()) gen.setSize(target_rect.size().toSize()) gen.setViewBox(target_rect) painter = QPainter(gen) # Draw background. painter.setBrush(QBrush(Qt.white)) painter.drawRect(target_rect) # Render the scene scene.render(painter, target_rect, source_rect) painter.end() buffer_str = str(svg_buffer.buffer()) return unicode(buffer_str.decode("utf-8"))
def printLadder(self): #printer = QPrinter(QPrinter.HighResolution) printer = QPrinter() dialog = QtGui.QPrintDialog(printer, self) if dialog.exec_() != QDialog.Accepted: return #printer.setResolution(600) #resolution = printer.resolution() #pageRect = printer.pageRect() painter = QPainter(printer) self.scene.render(painter) #self.ui.tableWidget.render(painter) del painter
def paintEvent(self, _): p = QPainter(self) points = [ QPoint(self.width(), -1), QPoint(self.width(), self.height()), QPoint(0, self.height() / 2), QPoint(0, self.height() / 2 - 1) ] grad = QLinearGradient(0, 0, 0, self.height()) grad.setColorAt(0, self.color1) grad.setColorAt(1, self.color2) p.setBrush(grad) p.setPen(QPen(Qt.NoPen)) p.drawPolygon(QPolygon(points))
def border_webpage(self): ''' get web page border and webpage ** this method inaccurate, page will change longer ** ** give up use ** ''' size = self.main_page.mainFrame().contentsSize() global _CURRENT_URL global _CURRENT_URL_TYPE nwe_border_list = [size.width(), size.height()] self.mongo_operate.add_web_border(_CURRENT_URL, _CURRENT_URL_TYPE, nwe_border_list) # print u"页面宽:%d,页面高:%d" % (size.width(), size.height()) self.main_page.setViewportSize(QSize(size.width() + 16, size.height())) img = QImage(size, QImage.Format_ARGB32) painter = QPainter(img) self.main_page.mainFrame().render(painter) painter.end() global _CURRENT_TIME_PATH img_path = _CURRENT_TIME_PATH + '/webpage.jpeg' if not img.save(img_path): sys.stderr.write('%s error to save img: %s, path: %s\n' % (time.ctime(), _CURRENT_URL, _CURRENT_TIME_PATH))
def save_png(filename, sc, background=(255, 255, 255, 0)): """Create a png image from a scene :Parameters: - `filename` (str) - name to write the image - `sc` (SVGScene) - `background` (int, int, int, int) - background color as (R, G, B, alpha) 0-255 tuple """ qapp = QApplication.instance() if qapp is None: qapp = QApplication([]) r = QSvgRenderer(None) data = QByteArray(str(to_xml(sc))) r.load(data) pix = QPixmap(r.defaultSize()) pix.fill(QColor(*background)) painter = QPainter(pix) r.render(painter) painter.end() pix.save(filename)
def __init__(self, parent): if (GLController.instance is None): GLController.instance = self QGLWidget.__init__(self, parent) self.painter = QPainter() cfg = Config('game','OpenGL') self.clearColor = cfg.get('clear_color') self.fps = cfg.get('fps') self.fps_sum = 0. self.fps_count = 0 self.show_fps = 0. self.fps_elapsed = 0. self.adjust_widget() self.adjust_timer() self.to_hook = None self.hooks = {}
def replace_all_colors(image, color): new_img = image.copy() if not new_img.format() is QImage.Format_ARGB32_Premultiplied: new_img = new_img.convertToFormat(QImage.Format_ARGB32_Premultiplied) color_img = QImage(new_img.width(), new_img.height(), QImage.Format_ARGB32_Premultiplied) color_img.fill(color.rgba()) painter = QPainter(new_img) painter.setCompositionMode(QPainter.CompositionMode_SourceAtop) painter.drawImage(new_img.rect(), color_img, color_img.rect()) painter.end() return new_img
def _makePixmap(self, width, height): pixmap = QPixmap(width, height) style = self.brushComboBox.itemData( self.brushComboBox.currentIndex()).toInt()[0] brush = QBrush(self.color, Qt.BrushStyle(style)) painter = QPainter(pixmap) painter.fillRect(pixmap.rect(), Qt.white) painter.fillRect(pixmap.rect(), brush) return pixmap
def _safeQImageCopy(source, rect): '''A modified version of QImage::copy, which avoids rendering errors even if rect is outside the bounds of the source image.''' targetRect = QRect(QPoint(), rect.size()) # copy image target = QImage(rect.size(), source.format()) p = QPainter(target) p.drawImage(targetRect, source, rect) p.end() return target
class WebKitPDF(QObject): def __init__(self, url, dest): QObject.__init__(self) self.dest = dest self.page = QtWebKit.QWebPage(self) self.mainFrame = self.page.mainFrame() self.mainFrame.load(QUrl(url)) self.connect(self.page, SIGNAL("loadProgress(int)"), self.loadProgress) self.connect(self.page, SIGNAL("loadFinished(bool)"), self.renderPDF) def loadProgress(self, progress): print "Progress: ", progress def renderPDF(self, status): print "Load finished with status: ", status print "Rendering PDF ..." contentsSize = self.mainFrame.contentsSize() self.page.setViewportSize(contentsSize) self.printer = QPrinter(QPrinter.PrinterResolution) #self.printer = QPrinter ( QPrinter.ScreenResolution ) self.printer.setOutputFormat(QPrinter.PdfFormat) #self.printer.setPaperSize ( QPrinter.A4 ) self.printer.setFullPage(True) self.printer.setPaperSize(QSizeF(contentsSize), QPrinter.DevicePixel) self.printer.setOrientation(QPrinter.Portrait) self.printer.setOutputFileName(self.dest) self.painter = QPainter(self.printer) self.painter.setRenderHint(QPainter.Antialiasing) self.mainFrame.render(self.painter) self.painter.end() app = QtGui.QApplication.instance() app.exit(0)