Beispiel #1
0
 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
Beispiel #2
0
    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 )
Beispiel #3
0
 def paintEvent( self, event):
     painter = QPainter( )
     painter.begin(self)
     [S.draw(painter) for S in self.spriteList]
        
     self.boundary.draw(painter)
     painter.end( )
Beispiel #4
0
    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)
Beispiel #6
0
    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)
Beispiel #7
0
    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
Beispiel #8
0
 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
Beispiel #12
0
    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)
Beispiel #13
0
 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)
Beispiel #14
0
 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)
Beispiel #15
0
    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()
Beispiel #16
0
 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()
Beispiel #17
0
    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)
Beispiel #18
0
    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()
Beispiel #19
0
	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
Beispiel #21
0
    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)
Beispiel #22
0
 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())
Beispiel #23
0
 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
Beispiel #24
0
 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))
Beispiel #25
0
    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 }
Beispiel #26
0
    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()
Beispiel #27
0
    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()
Beispiel #28
0
 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)
Beispiel #29
0
def painter_for ( context ):
    """ Returns a QPainter for the specified *context* object.
    """
    graphics = QPainter( context )
    graphics.setRenderHint( QPainter.TextAntialiasing )

    return graphics
Beispiel #30
0
    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 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
Beispiel #32
0
    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
Beispiel #34
0
    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()
Beispiel #35
0
 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
Beispiel #37
0
    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)
Beispiel #38
0
    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
Beispiel #39
0
    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
Beispiel #40
0
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
Beispiel #41
0
    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)
Beispiel #42
0
    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)
Beispiel #43
0
    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)
Beispiel #44
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
Beispiel #45
0
    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()
Beispiel #46
0
 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)
Beispiel #49
0
    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)
Beispiel #50
0
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)
Beispiel #51
0
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"))
Beispiel #52
0
    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
Beispiel #53
0
 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))
Beispiel #54
0
 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)
Beispiel #56
0
 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
Beispiel #58
0
 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
Beispiel #59
0
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
Beispiel #60
0
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)