def drawBackgroundToPixmap(self):
r = self.sceneRect()
self.background = QPixmap(qRound(r.width()), qRound(r.height()))
self.background.fill(Qt.black)
painter = QPainter(self.background)
bg = QImage("%simg/BG.png" % (colors.SYSPATH))
painter.drawImage(0, 0, bg)
def make_cypherseed(self, img, rawnoise, calibration=False, is_seed = True):
img = img.convertToFormat(QImage.Format_Mono)
p = QPainter()
p.begin(img)
p.setCompositionMode(26) #xor
p.drawImage(0, 0, rawnoise)
p.end()
cypherseed = self.pixelcode_2x2(img)
cypherseed = QBitmap.fromImage(cypherseed)
cypherseed = cypherseed.scaled(self.f_size, Qt.KeepAspectRatio)
cypherseed = self.overlay_marks(cypherseed, True, calibration)
if not is_seed:
self.filename_prefix = 'custom_secret_'
self.was = _('Custom secret')
else:
self.filename_prefix = self.wallet_name + '_seed_'
self.was = self.wallet_name + ' ' + _('seed')
if self.extension:
self.ext_warning(self.c_dialog)
if not calibration:
self.toPdf(QImage(cypherseed))
QDesktopServices.openUrl(QUrl.fromLocalFile(self.get_path_to_revealer_file('.pdf')))
cypherseed.save(self.get_path_to_revealer_file('.png'))
self.bcrypt(self.c_dialog)
return cypherseed
def paintEvent(self, pe):
super().paintEvent(pe)
if (self.mRedrawMapImage):
self.renderMapToImage()
self.mRedrawMapImage = False
if (self.mMapImage.isNull() or self.mImageRect.isEmpty()):
return
p = QPainter(self)
p.setRenderHints(QPainter.SmoothPixmapTransform)
backgroundColor = QColor(Qt.darkGray)
if (self.mMapDocument and self.mMapDocument.map().backgroundColor().isValid()):
backgroundColor = self.mMapDocument.map().backgroundColor()
p.setBrush(backgroundColor)
p.setPen(Qt.NoPen)
p.drawRect(self.contentsRect())
p.drawImage(self.mImageRect, self.mMapImage)
viewRect = self.viewportRect()
p.setBrush(Qt.NoBrush)
p.setPen(QColor(0, 0, 0, 128))
p.translate(1, 1)
p.drawRect(viewRect)
outLinePen = QPen(QColor(255, 0, 0), 2)
outLinePen.setJoinStyle(Qt.MiterJoin)
p.translate(-1, -1)
p.setPen(outLinePen)
p.drawRect(viewRect)
p.end()
def calibration_pdf(self, image):
printer = QPrinter()
printer.setPaperSize(QSizeF(210, 297), QPrinter.Millimeter)
printer.setResolution(600)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(self.get_path_to_calibration_file())
printer.setPageMargins(0,0,0,0,6)
painter = QPainter()
painter.begin(printer)
painter.drawImage(553,533, image)
font = QFont('Source Sans Pro', 10, QFont.Bold)
painter.setFont(font)
painter.drawText(254,277, _("Calibration sheet"))
font = QFont('Source Sans Pro', 7, QFont.Bold)
painter.setFont(font)
painter.drawText(600,2077, _("Instructions:"))
font = QFont('Source Sans Pro', 7, QFont.Normal)
painter.setFont(font)
painter.drawText(700, 2177, _("1. Place this paper on a flat and well iluminated surface."))
painter.drawText(700, 2277, _("2. Align your Revealer borderlines to the dashed lines on the top and left."))
painter.drawText(700, 2377, _("3. Press slightly the Revealer against the paper and read the numbers that best "
"match on the opposite sides. "))
painter.drawText(700, 2477, _("4. Type the numbers in the software"))
painter.end()
def saveChanges(self):
newImage = QImage(self.image.size(), QImage.Format_ARGB32_Premultiplied)
painter = QPainter(newImage)
painter.drawImage(0,0, self.image)
painter.drawImage(0,0, self.foreground)
painter.end()
return newImage
def _prepareImage(self):
"""
set the pixmap here.
"""
painter = QPainter(self)
if len(self.thumbs) == 0:
return
destwidth = self.width()
division = len(self.thumbs)
NF = division
slit_width = destwidth // division + 1
if slit_width < self.minwidth:
slit_width = self.minwidth
division = destwidth // slit_width - 1
for slit in range(division):
point = QPoint(slit*destwidth // division,0)
i = slit*NF // division
thumb = self.transformer(self.thumbs[i])
w = thumb.width()
h = thumb.height()
if w > slit_width:
w0 = (w-slit_width)//2
cropped = thumb.copy(w0,0,slit_width,h)
painter.drawImage(point, cropped)
else:
painter.drawImage(point, thumb)
def paintEvent(self, ev):
"""Called when paint is needed, finds out which page to magnify."""
layout = self.parent().surface().pageLayout()
pos = self.geometry().center() - self.parent().surface().pos()
page = layout.pageAt(pos)
if not page:
return
pagePos = pos - page.pos()
max_zoom = self.parent().surface().view().MAX_ZOOM * self.MAX_EXTRA_ZOOM
newPage = Page(page, min(max_zoom, self._scale * page.scale()))
if not newPage.same_page(self._page):
if self._page:
self._page.magnifier = None
self._page = newPage
self._page.magnifier = self
relx = pagePos.x() / float(page.width())
rely = pagePos.y() / float(page.height())
image = cache.image(self._page)
img_rect = QRect(self.rect())
if not image:
cache.generate(self._page)
image = cache.image(self._page, False)
if image:
img_rect.setWidth(self.width() * image.width() / self._page.width())
img_rect.setHeight(self.height() * image.height() / self._page.height())
if image:
img_rect.moveCenter(QPoint(relx * image.width(), rely * image.height()))
p = QPainter(self)
p.drawImage(self.rect(), image, img_rect)
p.setRenderHint(QPainter.Antialiasing, True)
p.setPen(QPen(QColor(192, 192, 192, 128), 6))
p.drawEllipse(self.rect().adjusted(2, 2, -2, -2))
def paintEvent(self, event):
painter = QPainter(self)
pixmap = None
if self.status == STATUS_NORMAL:
pixmap = self.normalPix
elif self.status == STATUS_HOVER:
pixmap = self.hoverPix
elif self.status == STATUS_PRESS:
pixmap = self.pressPix
if not pixmap:
return
if not self._enable:
if self.disablePix:
painter.drawPixmap(0, 0, self.disablePix)
else:
image = pixmap.toImage()
grayImg = convertToGray(image)
painter.drawImage(0, 0, grayImg)
elif self.autoRenderMask and self.status != STATUS_NORMAL:
if self.status == STATUS_PRESS:
painter.drawPixmap(1, 1, pixmap)
else:
painter.drawPixmap(0, 0, pixmap)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(QColor(250, 250, 250, 100)))
painter.drawRoundedRect(self.rect(), 2, 2)
else:
painter.drawPixmap(0, 0, pixmap)
def paintEvent(self, QPaintEvent):
qp = QPainter()
image = QImage("default.png")
image = image.scaled(32, 32)
sky_image = QImage("sky.png")
qp.begin(self)
qp.drawImage(0, 0, sky_image)
for obj in game_manager.GameManager.get_all_objects():
pos = obj.get_position()
size = obj.get_size()
#if isinstance(obj, object.MovingObject):
#qp.setPen(QColor(0, 0, 0))
#else:
#qp.setPen(QColor(255, 0, 0))
if obj is object.Bullet:
pass
if isinstance(obj, object.Unit):
qp.drawImage(pos.x + START_PLAYER_POSITION[0] - game_manager.GameManager.player.get_position().x,
pos.y + START_PLAYER_POSITION[1] - game_manager.GameManager.player.get_position().y,
image)
else:
qp.drawRect(pos.x + START_PLAYER_POSITION[0] - game_manager.GameManager.player.get_position().x,
pos.y + START_PLAYER_POSITION[1] - game_manager.GameManager.player.get_position().y,
size.x, size.y)
#qp.setPen(QColor(255, 0, 0))
#for x in game_manager.GameManager.get_map().grid.keys():
#for y in game_manager.GameManager.get_map().grid[x].keys():
#qp.drawRect(x + START_PLAYER_POSITION[0] - game_manager.GameManager.player.get_position().x,
#y + START_PLAYER_POSITION[1] - game_manager.GameManager.player.get_position().y,
#TILE_LENGHT, TILE_LENGHT)
qp.end()
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 __print(self, printer):
"""
Private slot to the actual printing.
@param printer reference to the printer object (QPrinter)
"""
p = QPainter(printer)
marginX = (printer.pageRect().x() - printer.paperRect().x()) // 2
marginY = (printer.pageRect().y() - printer.paperRect().y()) // 2
# double the margin on bottom of page
if printer.orientation() == QPrinter.Portrait:
width = printer.width() - marginX * 2
height = printer.height() - marginY * 3
else:
marginX *= 2
width = printer.width() - marginX * 2
height = printer.height() - marginY * 2
if qVersion() >= "5.0.0":
img = self.mainWidget.grab().toImage()
else:
img = QPixmap.grabWidget(self.mainWidget).toImage()
self.__updateChildren(self.lastStyle)
p.drawImage(marginX, marginY,
img.scaled(width, height,
Qt.KeepAspectRatio, Qt.SmoothTransformation))
p.end()
def createImage(self, transform):
original = QImage(self.image)
if original.isNull():
return original
size = transform.map(QPoint(self.maxWidth, self.maxHeight))
w = size.x()
h = size.y()
# Optimization: if image is smaller than maximum allowed size, just
# return the loaded image.
if original.size().height() <= h and original.size().width() <= w and not self.adjustSize and self.scale == 1:
return original
# Calculate what the size of the final image will be.
w = min(w, float(original.size().width()) * self.scale)
h = min(h, float(original.size().height()) * self.scale)
adjustx = 1.0
adjusty = 1.0
if self.adjustSize:
adjustx = min(transform.m11(), transform.m22())
adjusty = max(transform.m22(), adjustx)
w *= adjustx
h *= adjusty
# Create a new image with correct size, and draw original on it.
image = QImage(int(w + 2), int(h + 2),
QImage.Format_ARGB32_Premultiplied)
image.fill(QColor(0, 0, 0, 0).rgba())
painter = QPainter(image)
painter.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform)
if self.adjustSize:
painter.scale(adjustx, adjusty)
if self.scale != 1:
painter.scale(self.scale, self.scale)
painter.drawImage(0, 0, original)
if not self.adjustSize:
# Blur out edges.
blur = 30
if h < original.height():
brush1 = QLinearGradient(0, h - blur, 0, h)
brush1.setSpread(QLinearGradient.PadSpread)
brush1.setColorAt(0.0, QColor(0, 0, 0, 0))
brush1.setColorAt(1.0, Colors.sceneBg1)
painter.fillRect(0, int(h) - blur, original.width(), int(h),
brush1)
if w < original.width():
brush2 = QLinearGradient(w - blur, 0, w, 0)
brush2.setSpread(QLinearGradient.PadSpread)
brush2.setColorAt(0.0, QColor(0, 0, 0, 0))
brush2.setColorAt(1.0, Colors.sceneBg1)
painter.fillRect(int(w) - blur, 0, int(w), original.height(),
brush2)
return image
def paintEvent(self, e):
_width = self.width()
_height = self.height()
width = 2
painter=QPainter(self)
pen = QPen(Qt.blue, width)
painter.setPen(pen)
#Centro del widget
painter.translate(QPoint(_width/2, _height/2))
#eje
painter.drawLine(QPointF(-_width, 0),
QPointF( _width, 0))
painter.drawLine(QPointF(0, -_height),
QPointF(0, _height))
#con el raton
pen = QPen(Qt.red, width)
painter.setPen(pen)
#Comprobamos que el raton este dentro de los limites
if abs(self.line.x()*2) >= self.size().width():
if self.line.x()>=0:
self.line.setX(self.size().width()/2)
elif self.line.x()<0:
self.line.setX((-self.size().width()/2)+1)
if abs(self.line.y()*2) >= self.size().height():
if self.line.y()>=0:
self.line.setY(self.size().height()/2)
elif self.line.y()<0:
self.line.setY((-self.size().height()/2)+1)
painter.drawLine(QPointF(self.line.x(), -_height),
QPointF(self.line.x(), _height))
painter.drawLine(QPointF(-_width, self.line.y()),
QPointF( _width, self.line.y()))
#print "x: %f y: %f" % (self.line.x(), self.line.y())
v_normalized = (1.0/(self.size().height()/2)) * self.line.y()
v_normalized = float("{0:.2f}".format(v_normalized))
w_normalized = (1.0/(self.size().width()/2)) * self.line.x()
w_normalized = float("{0:.2f}".format(w_normalized))
#print "v: %f w: %f" % (v_normalized,w_normalized)
if self.id == 1:
self.winParent.setZYawValues(v_normalized,w_normalized*math.pi)
elif self.id == 0:
self.winParent.setXYValues(w_normalized,v_normalized)
painter.drawImage(self.line.x()-self.qimage.width()/2, self.line.y()-self.qimage.height()/2, self.qimage);
def drawBackgroundToPixmap(self):
r = self.scene.sceneRect()
self.background = QPixmap(qRound(r.width()), qRound(r.height()))
self.background.fill(Qt.black)
painter = QPainter(self.background)
bg = QImage(':/images/demobg.png')
painter.drawImage(0, 0, bg)
def resizeImage(self, image, newSize):
if image.size() == newSize:
return
newImage = QImage(newSize, QImage.Format_RGB32)
newImage.fill(qRgb(255, 255, 255))
painter = QPainter(newImage)
painter.drawImage(QPoint(0, 0), image)
self.image = newImage
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
if self.pix:
qp.drawImage(self.rect(), self.pix)
self.drawText(event, qp)
self.drawCircle(event, qp)
self.drawCrossHair(event, qp)
qp.end()
def paintEvent(self, event):
if self.qimage:
painter = QPainter(self)
painter.drawImage(QtCore.QRect(0, 0, self.width(), self.height()), self.qimage)
painter.end()
else:
painter = QPainter(self)
painter.setBrush(QtGui.QColor(255, 255, 255, 255))
painter.drawRect(0, 0, self.width(), self.height())
painter.end()
def _drawPlanetPic(self, painter: QPainter):
if self._img_loaded:
painter.drawImage(self._img.rect(), self._img, self._img.rect(), Qt.AutoColor)
if self._planet.is_current:
pen = QPen(QColor(0, 200, 0))
pen.setWidth(4)
painter.setPen(pen)
rc = self.rect()
rc.adjust(0, 0, -1, -1)
painter.drawRect(rc)
def paintEvent(self, event):
painter = QPainter(self)
if self.border:
size = self.size()
painter.setPen(Colors.eyegrade_blue)
painter.drawRoundedRect(0, 0, size.width() - 2, size.height() - 2,
10, 10)
painter.drawImage(5, 5, self.image)
else:
painter.drawImage(event.rect(), self.image)
def _blendTile(self, stack_id, tile_nr):
"""
Blend all of the QImage layers of the patch
specified by (stack_id, tile_nr) into a single QImage.
"""
qimg = None
p = None
for i, (visible, layerOpacity, layerImageSource) in enumerate(reversed(self._sims)):
image_type = layerImageSource.image_type()
if issubclass(image_type, QGraphicsItem):
with self._cache:
patch = self._cache.layer(stack_id, layerImageSource, tile_nr)
if patch is not None:
assert isinstance(
patch, image_type
), "This ImageSource is producing a type of image that is not consistent with it's declared image_type()"
# This is a QGraphicsItem, so we don't blend it into the final tile.
# (The ImageScene will just draw it on top of everything.)
# But this is a convenient place to update the opacity/visible state.
if patch.opacity() != layerOpacity or patch.isVisible() != visible:
patch.setOpacity(layerOpacity)
patch.setVisible(visible)
patch.setZValue(i) # The sims ("stacked image sources") are ordered from
# top-to-bottom (see imagepump.py), but in Qt,
# higher Z-values are shown on top.
# Note that the current loop is iterating in reverse order.
continue
# No need to fetch non-visible image tiles.
if not visible or layerOpacity == 0.0:
continue
with self._cache:
patch = self._cache.layer(stack_id, layerImageSource, tile_nr)
# patch might be a QGraphicsItem instead of QImage,
# in which case it is handled separately,
# not composited into the tile.
if patch is not None:
assert isinstance(
patch, QImage
), "Unknown tile layer type: {}. Expected QImage or QGraphicsItem".format(type(patch))
if qimg is None:
qimg = QImage(self.tiling.imageRects[tile_nr].size(), QImage.Format_ARGB32_Premultiplied)
qimg.fill(0xFFFFFFFF) # Use a hex constant instead.
p = QPainter(qimg)
p.setOpacity(layerOpacity)
p.drawImage(0, 0, patch)
if p is not None:
p.end()
return qimg
def paintEvent(self, ev):
image = self.viewer.image()
painter = QPainter(self)
if self.size() == image.size():
painter.drawImage(ev.rect(), image, ev.rect())
else:
s = image.size()
s.scale(self.size(), Qt.KeepAspectRatio)
r = QRect()
r.setSize(s)
r.moveCenter(self.rect().center())
painter.drawPixmap(r, self.viewer.pixmap(s))
def paintEvent(self, _):
"""Redraw graph."""
if not self._qimg:
return
t = time.time()
size = self.size()
rect = self._center_frame(self._qimg.size(), size)
qp = QPainter()
qp.begin(self)
qp.drawImage(rect, self._qimg)
qp.end()
d = time.time() - t
logging.info("cam paint: %6.3f ms (rect %r)", d * 1000.0, rect)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
#painter.setPen(QColor('#FFFFFF'))
#painter.setBrush(Qt.white)
#painter.drawRect(event.rect())
image = QImage('./lena.png')
x = (self.width() - image.width()) / 2
y = (self.height() - image.height()) / 2
painter.drawImage(x, y, image)
painter.end()
def pasteArea(self): # Функция вставки области
if not self.copyA: # Если область пустая
return
x = self.get_cord('Координата x',
'Координата левого верхнего угла по x', 0,
2000) # Координата левого верхнего угла по x
y = self.get_cord('Координата по y',
'Координата левого верхнего угла по y', 0,
2000) # Координата левого верхнего угла по y
painter = QPainter(self.image) # Создание объекта
painter.drawImage(x, y, self.copyA) # Вывод изображения
self.lastImage() # Добавление изображения
self.update() # Обновление окна
def mask(self, image: QImage) -> QImage:
clip_rect = self._build_clip_rect(image)
masked = QImage(self.size, QImage.Format_RGB32)
painter = QPainter(masked)
painter.setRenderHints(QPainter.Antialiasing, QPainter.SmoothPixmapTransform)
painter.setClipRegion(self.clip_region)
painter.drawImage(masked.rect(), image, clip_rect)
painter.end()
return masked
def paintEvent(self, event):
super(Video, self).paintEvent(event)
p = QPainter()
p.begin(self)
if not self.camImage is None:
p.drawImage(0, 0, self.camImage)
self.mapToParent(QPoint(0, 0))
if self.isDrawing:
p.setCompositionMode(QPainter.CompositionMode_SourceOver)
p.setRenderHint(QPainter.Antialiasing)
p.setPen(QPen(Qt.blue, 4, Qt.SolidLine))
p.drawRect(self.startX, self.startY, self.width, self.height)
p.end()
def print_(self):
printer = QPrinter(QPrinter.HighResolution)
printDialog = QPrintDialog(printer, self)
if printDialog.exec_() == QPrintDialog.Accepted:
painter = QPainter(printer)
rect = painter.viewport()
size = self.image.size()
size.scale(rect.size(), Qt.KeepAspectRatio)
painter.setViewport(rect.x(), rect.y(), size.width(), size.height())
painter.setWindow(self.image.rect())
painter.drawImage(0, 0, self.image)
painter.end()
def print_(self):
printer = QPrinter(QPrinter.HighResolution)
printDialog = QPrintDialog(printer, self)
if printDialog.exec_() == QPrintDialog.Accepted:
painter = QPainter(printer)
rect = painter.viewport()
size = self.image.size()
size.scale(rect.size(), Qt.KeepAspectRatio)
painter.setViewport(rect.x(), rect.y(), size.width(), size.height())
painter.setWindow(self.image.rect())
painter.drawImage(0, 0, self.image)
painter.end()
def save_as_png(self, file_path):
pixmap = self.grab()
child = self.findChild(QOpenGLWidget)
painter = QPainter(pixmap)
if child is not None:
d = child.mapToGlobal(QPoint()) - self.mapToGlobal(QPoint())
painter.setCompositionMode(QPainter.CompositionMode_SourceAtop)
painter.drawImage(d, child.grabFramebuffer())
painter.end()
pixmap.save(file_path, 'PNG')
def drawOverlayImage(self):
if self.overlay_image.width() <= 1:
return
pxmap = self.pixmap.copy()
p = QPainter()
p.begin(pxmap)
p.setOpacity(self.opacity)
p.drawImage(0, 0, self.overlay_image)
p.end()
self.pixmapitem.setPixmap(pxmap)
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
qp.fillRect(self.rect(), Qt.black)
self.img = self.render_image()
self.rect_x = (self.rect().width() / 2) - ((self.maxPixelsPerLine * self.pixelSize) / 2)
qp.drawImage(QRect(QPoint(self.rect_x, 0),
QPoint(self.rect_x + self.maxPixelsPerLine * self.pixelSize, (self.maxPixelsTotal / self.maxPixelsPerLine) * self.pixelSize)),
self.img)
qp.end()
def convert_pic(filename, out_file):
data = ConstBitStream(filename=filename)
magic = data.read("bytes:4")
if conf.SWITCH:
magic2 = data.read("bytes:4")
size = data.read("uintle:32")
ew = data.read("uintle:16")
eh = data.read("uintle:16")
width = data.read("uintle:16")
height = data.read("uintle:16")
unk1 = data.read("uintle:32")
chunks = data.read("uintle:32")
if conf.SWITCH:
unk2 = data.read("uintle:32")
if conf.debug:
print("EW, EH: ", ew, eh)
print("Width: ", width)
print("Height: ", height)
print("Unk: ", unk1)
print()
image = QImage(width, height, QImage.Format_ARGB32)
image.fill(0)
painter = QPainter(image)
for i in range(chunks):
x = data.read("uintle:16")
y = data.read("uintle:16")
offset = data.read("uintle:32")
if conf.SWITCH:
size = data.read("uintle:32")
# if not i == chunks - 1:
# continue
if conf.debug:
print("X, Y, offset: ", i, x, y, offset)
chunk, shift_x, shift_y, masked = process_chunk(data, offset)
if not chunk:
continue
painter.drawImage(x, y, chunk)
painter.end()
image.save(out_file)
def convert_pic_umi(filename, out_file):
data = ConstBitStream(filename=filename)
magic = data.read("bytes:4")
size = data.read("uintle:32")
ew = data.read("uintle:16")
eh = data.read("uintle:16")
width = data.read("uintle:16")
height = data.read("uintle:16")
unk1 = data.read("uintle:32")
chunks = data.read("uintle:32")
image = QImage(width, height, QImage.Format_ARGB32)
image.fill(0)
painter = QPainter(image)
for i in range(chunks):
version = data.read("uintle:32")
x = data.read("uintle:16")
y = data.read("uintle:16")
w = data.read("uintle:16")
h = data.read("uintle:16")
offset = data.read("uintle:32")
size = data.read("uintle:32")
# if not i == 1:
# continue
print(w, h, size, offset)
temp_pos = data.bytepos
data.bytepos = offset
chunk = data.read(size * 8)
data.bytepos = temp_pos
chunk = decompress_umi(chunk)
chunk = adjust_scanline(chunk, w, h)
dump_to_file(chunk)
chunk = QImage(chunk, w, h, QImage.Format_ARGB32)
chunk.fill(0)
# chunk.save("test.bmp")
painter.drawImage(QRectF(x, y, w, h), chunk, QRectF((chunk.rect())))
# break
painter.end()
image.save(out_file)
################################################################################
def _drawMask(self, painter : QPainter):
'''Display the given image. Image is supposed to be a numpy array.
'''
if self.image is not None and self.activationMask is not None:
scale_width = self.width() / self.image.width()
scale_height = self.height() / self.image.height()
delta = (self.image.size() - self.activationMask.size())/2
target = QRect(delta.width()*scale_width,
delta.height()*scale_height,
self.activationMask.width()*scale_width,
self.activationMask.height()*scale_height)
#source = QRect(QPoint(),self.activationMask.size())
painter.drawImage(target, self.activationMask)
def paintEvent(self, event):
painter = QPainter(self)
painter.drawImage(event.rect(), self.image.scaledToWidth(self.width*self.image_pixel_width, Qt.SmoothTransformation))
if self.agc_roi_from != None and self.agc_roi_to != None and not self.image_is_16bit:
pen = QPen()
pen.setColor(Qt.green)
pen.setWidth(1)
painter.setPen(pen)
roi = self.parent.get_agc_roi()
painter.drawRect(roi[0] * self.image_pixel_width + 1,
roi[1] * self.image_pixel_width + 1,
(roi[2] - roi[0]) * self.image_pixel_width + 1,
(roi[3] - roi[1]) * self.image_pixel_width + 1)
self.parent.update_agc_roi_label()
if self.spotmeter_roi_from != None and self.spotmeter_roi_to != None:
pen = QPen()
pen.setColor(Qt.white)
pen.setWidth(1)
painter.setPen(pen)
from_x, from_y, to_x, to_y = self.parent.get_spotmeter_roi()
from_x = from_x * self.image_pixel_width + 1
from_y = from_y * self.image_pixel_width + 1
to_x = to_x * self.image_pixel_width + 1
to_y = to_y * self.image_pixel_width + 1
cross_x = from_x + (to_x-from_x) / 2.0
cross_y = from_y + (to_y-from_y) / 2.0
if to_x-from_x > 5 or to_y - from_y > 5:
lines = [QLineF(from_x, from_y, from_x + self.crosshair_width, from_y),
QLineF(from_x, from_y, from_x, from_y + self.crosshair_width),
QLineF(to_x, to_y, to_x, to_y - self.crosshair_width),
QLineF(to_x, to_y, to_x - self.crosshair_width, to_y),
QLineF(from_x, to_y, from_x, to_y-self.crosshair_width),
QLineF(from_x, to_y, from_x + self.crosshair_width, to_y),
QLineF(to_x, from_y, to_x, from_y+self.crosshair_width),
QLineF(to_x, from_y, to_x - self.crosshair_width, from_y)]
painter.drawLines(lines)
lines = [QLineF(cross_x - self.crosshair_width, cross_y, cross_x + self.crosshair_width, cross_y),
QLineF(cross_x, cross_y - self.crosshair_width, cross_x, cross_y+self.crosshair_width)]
painter.drawLines(lines)
self.parent.update_spotmeter_roi_label()
def paintEvent(self, event):
# Создаём QPainter и начинаем рисование на виджете.
p = QPainter()
p.begin(self)
# необязательная настройка для рисования линий. Рисование будет идти
# чуть медленнее, но сами линии будут более сглаженными.
p.setRenderHint(QPainter.Antialiasing)
# Устанавливаем красную ручку шириной 2 пикселя для рисования контура
p.setPen(QPen(QColor(255, 0, 0), 2))
# Рисуем точку в координате 30, 40.
p.drawPoint(QPointF(30, 40))
# Рисуем две параллельные линии, одну зелёным, другую синим цветом
p.setPen(QPen(QColor(0, 255, 0), 2))
p.drawLine(QPointF(50, 10), QPointF(100, 110))
p.setPen(QPen(QColor(0, 0, 255), 2))
p.drawLine(QPointF(70, 10), QPointF(120, 110))
# Чёрная ручка шириной 2 для контура и светло-красная кисть
# для внутренней части фигуры
p.setPen(QPen(QColor(0, 0, 100), 2))
p.setBrush(QBrush(QColor(200, 100, 100)))
# Рисуем прямоугольник 50 на 50 с левой верхней точкой (150, 40).
p.drawRect(QRectF(150, 40, 50, 50))
# Рисуем эллипс с центром в точке (270, 65) и полуосями
# 50 по X и 30 по Y.
p.setPen(QPen(QColor(0, 230, 100), 2))
p.drawEllipse(QPointF(270, 65), 50, 30)
# Рисуем небольшой прямогуольный треугольник с помощью
# drawPolygon
points = [QPointF(50, 350), QPointF(70, 370), QPointF(50, 390)]
polygon = QPolygonF(points)
p.drawPolygon(polygon)
p.drawText(50, 200, "Hello world!")
# Загружаем рисунок из файла. Загрузка рисунка достаточно
# долгая операция, поэтому в более сложных программах лучше
# выполнять загрузки не при каждой перерисовке окна, как здесь,
# а один раз загружать картинку в свойство и потом пользоваться им.
# Например, можно перенести загрузку картинок в метод __init__.
img = QImage("grumpycat.jpg")
p.drawImage(QPointF(200, 200), img)
p.drawImage(QRectF(70, 250, 50, 50), img)
# Заканчиваем рисование
p.end()
def paintEvent(self, paintEvent):
painter = QPainter(self)
if (self.model is not None):
nr = self.model.getNumRows()
nc = self.model.getNumCols()
img = EMImageGenerator.genImageFromModel(self.model)
painter.drawImage(0, 0, img.scaled(self.width, self.height))
EMImageGenerator.drawGrid(painter, nc, nr, self.xOffset,
self.yOffset, self.tileSize)
if self.mouseIndex != (-1, -1) and not self.mousePressed:
if self.openTab == 0 and self.selectedObject[0] != -1:
self.drawPreviewTileSingle(painter)
elif self.openTab == 1 and self.selectedObject[1] != -1:
self.drawPreviewTileGroup(painter)
# Draw the notes
notes = self.model.getMapNotes()
for index in range(len(notes)):
# print(index)
note = notes[index]
if self.pressedItem is None or self.pressedItem[1] is not note:
np = note.getPos()
# print(np)
np = (int(np[0] * self.tileSize),
int(np[1] * self.tileSize))
options = []
print(self.mouseOverItem)
if (self.mouseOverItem is not None
and self.mouseOverItem[0] == 3
and self.mouseOverItem[1] == index):
options.append("mouseover")
EMImageGenerator.drawNoteIcon(painter, note, np[0] - 24,
np[1] - 24, 48, index + 1,
options)
# note.drawNoteIcon(painter, )
index += 1
if self.pressedItem is not None:
if self.pressedItem[0] == 3:
note = self.pressedItem[1]
np = note.getPos()
# print(np)
np = (int(np[0] * self.tileSize),
int(np[1] * self.tileSize))
EMImageGenerator.drawNoteIcon(painter, note, np[0] - 24,
np[1] - 24, 48,
notes.index(note) + 1,
["selected"])
def paint(self, painter: QPainter):
if Component.components.get('enemy') == None:
return
enemyComs = Component.components.get('enemy')
for enemyCom in enemyComs:
enemy = Entity.entities.get(enemyCom.id)
pos = enemy.positionCom.position
size = enemy.sizeCom
x = pos.x() - size.width / 2
y = pos.y() - size.height / 2
image = self.enemyImg
if hasattr(enemy, 'image'):
image = enemy.image
painter.drawImage(QRectF(x, y, size.width, size.height), image)
def new_frame(self, frame, offset):
self.image = QImage(240, 160, QImage.Format_ARGB32)
self.image.fill(QColor(128, 160, 128))
painter = QPainter()
painter.begin(self.image)
painter.drawImage(offset[0], offset[1],
frame.copy()) # Draw image on top of autotiles
painter.end()
# self.image = f
# self.image.paste(QImage(frame), offset)
self.setSceneRect(0, 0, 240, 160)
# self.image.save('image_%d.png' % self.image_counter)
# self.image_counter += 1
self.show_image()
def drawFrame(self, t):
temp = time.time()
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
im = ui.video_backend.get_frame(t)
img = QImage(im.data, im.shape[1], im.shape[0], im.shape[1] * 3,
QImage.Format_RGB888)
# pixmap = QPixmap()
# pixmap.convertFromImage(img)
# painter.drawPixmap(self.geometry(), pixmap)
painter.drawImage(self.geometry(), img)
painter.end()
print(time.time() - temp)
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
self.image4.scaledToWidth(320, qtc.Qt.SmoothTransformation)
self.image4.scaledToHeight(240, qtc.Qt.SmoothTransformation)
self.result4 = self.image4.scaled(
320, 240, qtc.Qt.KeepAspectRatioByExpanding,
qtc.Qt.SmoothTransformation)
qp.drawImage(500, 400, self.result4)
self.image3.scaledToWidth(320, qtc.Qt.SmoothTransformation)
self.image3.scaledToHeight(240, qtc.Qt.SmoothTransformation)
self.result3 = self.image3.scaled(
320, 240, qtc.Qt.KeepAspectRatioByExpanding,
qtc.Qt.SmoothTransformation)
qp.drawImage(10, 400, self.result3)
self.image2.scaledToWidth(320, qtc.Qt.SmoothTransformation)
self.image2.scaledToHeight(240, qtc.Qt.SmoothTransformation)
self.result2 = self.image2.scaled(
320, 240, qtc.Qt.KeepAspectRatioByExpanding,
qtc.Qt.SmoothTransformation)
qp.drawImage(500, 70, self.result2)
self.image1.scaledToWidth(320, qtc.Qt.SmoothTransformation)
self.image1.scaledToHeight(240, qtc.Qt.SmoothTransformation)
self.result1 = self.image1.scaled(
320, 240, qtc.Qt.KeepAspectRatioByExpanding,
qtc.Qt.SmoothTransformation)
qp.drawImage(10, 70, self.result1)
qp.end()
def paintEvent(self, a0: QPaintEvent) -> None:
if self.previous_hash != hash(self.graph): # if the graph changed: clear
self.graph_image.fill(QColor(255,255,255,0))
self.bkg_image.fill(QColor(255,255,255,0))
self.previous_hash = hash(self.graph)
self.drawEdges() # and repaint
self.drawNodes()
print(self.previous_hash)
painter = QPainter(self.bkg_image) # combine the occasional background
painter.drawImage(0, 0, self.graph_image) # and the actual graph
painter.end()
painter = QPainter(self)
painter.drawImage(0, 0, self.bkg_image)
painter.end()
def paintEvent(self, event):
painter = QPainter(self)
painter.drawImage(QRect(0, 0, super().width(), super().height()), self.image)
if self.grid_enabled:
painter.setPen(QPen(self.grid_color))
for x in range(1, self.width):
painter.drawLine(x * self.scaling_factor, 0, x * self.scaling_factor, super().height())
for y in range(1, self.height):
painter.drawLine(0, y * self.scaling_factor, super().width(), y * self.scaling_factor)
self.parent.paint_overlay(event, painter)
def paintEvent(self, event):
self._repainting = True
painter = QPainter(self)
if self._image:
painter.drawImage(0, 0, self._image)
painter.drawText(5, 15, "FPS: %-05i" % self._fps)
if self.paused:
painter.setPen(Qt.NoPen)
painter.setBrush(Qt.gray)
painter.drawRoundedRect(0, 0, 20, 60, 5.0, 5.0)
painter.drawRoundedRect(40, 0, 20, 60, 5.0, 5.0)
self._repainting = False
def paintEvent(self, event):
if self.renderer == SvgView.Image:
if self.image.size() != self.viewport().size():
self.image = QImage(self.viewport().size(),
QImage.Format_ARGB32_Premultiplied)
imagePainter = QPainter(self.image)
QGraphicsView.render(self, imagePainter)
imagePainter.end()
p = QPainter(self.viewport())
p.drawImage(0, 0, self.image)
else:
super(SvgView, self).paintEvent(event)
def paintEvent(self,e):
painter = QPainter(self)
painter.setBrush(QColor('yellow'))
painter.setPen(Qt.NoPen)
rect = QRect(0, 0, self.width(), self.height())
painter.drawRect(rect)
pen = QPen(QColor('black'))
pen.setWidth(10)
painter.setPen(pen)
line = QLine(500,250,500,0)
painter.drawLine(line)
painter.drawImage(self.F1x, self.F1y, self.imageFledermaus1)
painter.drawImage(self.F2x, self.F2y, self.imageFledermaus2)
painter.drawImage(self.Bx, self.By, self.imageBalloon)
def paintEvent(self, event):
if self.renderer == SvgView.Image:
if self.image.size() != self.viewport().size():
self.image = QImage(self.viewport().size(),
QImage.Format_ARGB32_Premultiplied)
imagePainter = QPainter(self.image)
QGraphicsView.render(self, imagePainter)
imagePainter.end()
p = QPainter(self.viewport())
p.drawImage(0, 0, self.image)
else:
super(SvgView, self).paintEvent(event)
def paintEvent(self, _event):
"""Paint a board"""
painter = QPainter()
painter.begin(self)
painter.drawImage(
QRect(0, 0, self.width(), self.height()),
self.bgimage,
QRect(0, 0, 905, 898),
)
borderspace = self.get_bordersize()
boardwidth = self.width() - 2 * borderspace
dist = boardwidth / self.boardsize
hdist = dist / 2
for pos in range(self.boardsize):
pen = painter.pen()
pen.setColor(QColor("black"))
pen.setWidth(4 if pos in (0, self.boardsize - 1) else 2)
painter.setPen(pen)
painter.setRenderHints(painter.Antialiasing
| painter.SmoothPixmapTransform
| painter.HighQualityAntialiasing)
x = pos * dist
painter.drawText(
QRect(x + borderspace, borderspace / 4, dist, dist),
Qt.AlignCenter,
COORDS[pos].upper(),
)
painter.drawText(
QRect(borderspace / 4, x + borderspace, dist, dist),
Qt.AlignCenter,
str(self.boardsize - pos),
)
painter.drawLine(
x + hdist + borderspace,
hdist + borderspace,
x + hdist + borderspace,
(dist * self.boardsize - hdist) + borderspace,
)
painter.drawLine(
hdist + borderspace,
x + hdist + borderspace,
dist * self.boardsize - hdist + borderspace,
x + hdist + borderspace,
)
painter.end()
def paintEvent(self,event): #paintEvent 当窗口变化是直接调用，不需要调用函数
painter=QPainter()
painter.begin(self)
#设置画笔和字体
painter.setPen(QColor(2,1,3))
painter.setFont(QFont('SimSun',12))
'''绘制圆弧'''
#(1)确定绘制区域
rect=QRect(0,0,100,100) #前两个值为左上角的坐标，后两个值为宽度和高度
#(2)在区域绘制图形
painter.drawArc(rect,0,50*16) #后面两个参数为为起始的角度，和结束的角度，为什么乘16，因为单位为alen，一度=16alen，也就是50度为50*16
'''绘制圆'''
rect=QRect(100,0,50,50)
painter.setPen(Qt.red)
painter.drawArc(rect,0,360*16)
'''绘制带弦的弧'''
rect = QRect(200, 0, 50, 50)
painter.drawChord(rect,1,90*16)
'''绘制扇形'''
rect = QRect(0,50, 50, 50)
painter.drawPie(rect,12,76*16)
'''绘制椭圆'''
painter.drawEllipse(0,100,60,50) #前两个参数为起始坐标，后两个为宽和高，当后两个参数一样为圆
'''绘制多边形'''
#绘制一个正方形
p1=QPoint(100,100)
p2=QPoint(130,100)
p3=QPoint(130,130)
p4=QPoint(100,130)
polygon=QPolygon([p1,p2,p3,p4])
painter.drawPolygon(polygon)
'''绘制一个图形'''
#（1）读取图像
img=QImage('python.png')
#（2）进行绘制,对图片的大小压说为原来的二分之一
rect=QRect(100,100,img.width()/3,img.height()/3)
painter.drawImage(rect,img)
painter.end()
def doAnticlockwise(self):
# 逆时针45度
image = QImage(self.srcImage.size(),
QImage.Format_ARGB32_Premultiplied)
painter = QPainter()
painter.begin(image)
# 以图片中心为原点
hw = self.srcImage.width() / 2
hh = self.srcImage.height() / 2
painter.translate(hw, hh)
painter.rotate(-45) # 旋转-45度
painter.drawImage(-hw, -hh, self.srcImage) # 把图片绘制上去
painter.end()
self.srcImage = image # 替换
self.imageLabel.setPixmap(QPixmap.fromImage(self.srcImage))
def _pasteIcon(self):
mime = QApplication.clipboard().mimeData()
if mime.hasImage():
image = mime.imageData()
# Fill transparent color if present
fixedImage = QImage(image.size(), QImage.Format_RGB32)
fixedImage.fill(QColor(Qt.white).rgb())
painter = QPainter(fixedImage)
painter.drawImage(0, 0, image)
painter.end()
self._setNewImage(fixedImage)
elif mime.hasUrls():
url = mime.urls()[0]
self.loadFromFile(url.toLocalFile())
def expandAndFormat(img, margin=0, is_jpg=False):
"""
Draws the image with transparent background if `is_jpg == False`, otherwise with a white background.
It's done in a single function, to avoid creating extra images
"""
if not margin and not is_jpg:
return img
corner = QSize(margin, margin)
white = QColor(255, 255, 255) if is_jpg else QColor(255, 255, 255, 0)
canvas = QImage(img.size() + corner * 2,
QImage.Format_RGB32 if is_jpg else QImage.Format_ARGB32)
canvas.fill(white)
p = QPainter(canvas)
p.drawImage(margin, margin, img)
return canvas
def _pasteIcon(self):
mime = QApplication.clipboard().mimeData()
if mime.hasImage():
image = mime.imageData()
# Fill transparent color if present
fixedImage = QImage(image.size(), QImage.Format_RGB32)
fixedImage.fill(QColor(Qt.white).rgb())
painter = QPainter(fixedImage)
painter.drawImage(0, 0, image)
painter.end()
self._setNewImage(fixedImage)
elif mime.hasUrls():
url = mime.urls()[0]
self.loadFromFile(url.toLocalFile())
def paintEvent(self, event):
painter = QPainter(self)
if self.qimage:
painter.drawImage(QtCore.QRect(0, 0, self.width(), self.height()), self.qimage)
else:
painter.setBrush(QtGui.QColor(255, 255, 255, 255))
painter.drawRect(0, 0, self.browser_buffer.buffer_width, self.browser_buffer.buffer_height)
if self.browser_buffer.loading_flag:
painter.setPen(QtGui.QColor(10, 138, 255, 255))
painter.setBrush(QtGui.QColor(10, 138, 255, 255))
painter.drawRect(0, 0, self.browser_buffer.buffer_width * self.browser_buffer.loading_percent / 100, 1)
painter.end()
def updateWorldFrame(self, queens_img):
#new_image = QPixmap(1000,1000)
self.new_image.fill() #White color is default
painter = QPainter(self.new_image)
#First draw the table
painter.drawPixmap(self.new_image.rect(), self.img)
#Then draw the queens
painter.drawImage(self.new_image.rect(), queens_img)
painter.end()
#Set new image to the frame
self.frameWorld.img = self.new_image
#Redrawing frames
self.frameWorld.repaint()
self.frameChart.repaint()
app.processEvents()
def filePrint(self):
if self.currentImage.isNull():
return
if self.printer is None:
self.printer = QPrinter(QPrinter.HighResolution)
self.printer.setPageSize(QPrinter.Letter)
form = QPrintDialog(self.printer, self)
if form.exec_():
painter = QPainter(self.printer)
rect = painter.viewport()
size = self.currentImage.size()
size.scale(rect.size(), Qt.KeepAspectRatio)
painter.setViewport(rect.x(), rect.y(), size.width(),
size.height())
painter.drawImage(0, 0, self.currentImage)
def _prepareImage(self):
"""
set the pixmap here.
"""
painter = QPainter(self)
if len(self.thumbs) == 0:
return
first = self.transformer(self.thumbs[0])
h = first.height()
w = first.width() + 2
pw = self.width()
nframes = pw//w + 1
for i in range(nframes):
f = i*len(self.thumbs)//nframes
point = QPoint(i*w,0)
painter.drawImage(point, self.transformer(self.thumbs[f]))
def getPix(self, url1, url2=None):
img1 = self.cache.get_resource(url1)
i1 = QImage.fromData(img1)
i1 = i1.scaledToHeight(60, Qt.SmoothTransformation)
if url2 is not None:
img2 = self.cache.get_resource(url2)
i2 = QImage.fromData(img2)
i2 = i2.scaledToHeight(30, Qt.SmoothTransformation)
p = QPainter()
p.begin(i1)
p.drawImage(0, 30, i2)
p.end()
ret = QLabel()
ret.setPixmap(QPixmap.fromImage(i1))
return ret
def editPaste(self, pasting=False):
"""
Public slot to paste an image from the clipboard.
@param pasting flag indicating part two of the paste operation
(boolean)
"""
img, ok = self.__clipboardImage()
if ok:
if img.width() > self.__image.width() or \
img.height() > self.__image.height():
res = E5MessageBox.yesNo(
self,
self.tr("Paste"),
self.tr(
"""<p>The clipboard image is larger than the"""
""" current image.<br/>Paste as new image?</p>"""))
if res:
self.editPasteAsNew()
return
elif not pasting:
self.__isPasting = True
self.__clipboardSize = img.size()
else:
cmd = IconEditCommand(self, self.tr("Paste Clipboard"),
self.__image)
self.__markImage.fill(self.NoMarkColor.rgba())
painter = QPainter(self.__image)
painter.setPen(self.penColor())
painter.setCompositionMode(self.__compositingMode)
painter.drawImage(
self.__pasteRect.x(), self.__pasteRect.y(), img, 0, 0,
self.__pasteRect.width() + 1,
self.__pasteRect.height() + 1)
self.__undoStack.push(cmd)
cmd.setAfterImage(self.__image)
self.__updateImageRect(
self.__pasteRect.topLeft(),
self.__pasteRect.bottomRight() + QPoint(1, 1))
else:
E5MessageBox.warning(
self,
self.tr("Pasting Image"),
self.tr("""Invalid image data in clipboard."""))
