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 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 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)
