def paintEvent(self, event):
rect = QRect(10, 20, 80, 60)
path = QPainterPath()
path.moveTo(20, 80)
path.lineTo(20, 30)
path.cubicTo(80, 0, 50, 50, 80, 80)
startAngle = 30 * 16
arcLength = 120 * 16
painter = QPainter(self)
painter.setPen(self.pen)
painter.setBrush(self.brush)
if self.antialiased:
painter.setRenderHint(QPainter.Antialiasing)
for x in range(0, self.width(), 100):
for y in range(0, self.height(), 100):
painter.save()
painter.translate(x, y)
if self.transformed:
painter.translate(50, 50)
painter.rotate(60.0)
painter.scale(0.6, 0.9)
painter.translate(-50, -50)
if self.shape == RenderArea.Line:
painter.drawLine(rect.bottomLeft(), rect.topRight())
elif self.shape == RenderArea.Points:
painter.drawPoints(RenderArea.points)
elif self.shape == RenderArea.Polyline:
painter.drawPolyline(RenderArea.points)
elif self.shape == RenderArea.Polygon:
painter.drawPolygon(RenderArea.points)
elif self.shape == RenderArea.Rect:
painter.drawRect(rect)
elif self.shape == RenderArea.RoundedRect:
painter.drawRoundedRect(rect, 25, 25, Qt.RelativeSize)
elif self.shape == RenderArea.Ellipse:
painter.drawEllipse(rect)
elif self.shape == RenderArea.Arc:
painter.drawArc(rect, startAngle, arcLength)
elif self.shape == RenderArea.Chord:
painter.drawChord(rect, startAngle, arcLength)
elif self.shape == RenderArea.Pie:
painter.drawPie(rect, startAngle, arcLength)
elif self.shape == RenderArea.Path:
painter.drawPath(path)
elif self.shape == RenderArea.Text:
painter.drawText(rect, Qt.AlignCenter,
"PySide 2\nQt %s" % qVersion())
elif self.shape == RenderArea.Pixmap:
painter.drawPixmap(10, 10, self.pixmap)
painter.restore()
painter.setPen(self.palette().dark().color())
painter.setBrush(Qt.NoBrush)
painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
def paint_with_opacity(pixmap: QPixmap, opacity: float):
transparent_image = QImage(QSize(36, 36),
QImage.Format_ARGB32_Premultiplied)
transparent_image.fill(Qt.transparent)
painter = QPainter(transparent_image)
painter.setOpacity(opacity)
painter.drawPixmap(18 - pixmap.width() / 2, 18 - pixmap.height() / 2,
pixmap)
painter.end()
return QPixmap.fromImage(transparent_image)
def paintEvent(self, event):
super(Profile, self).paintEvent(event)
# DRAW BACKGROUND IMAGE
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
image = QPixmap()
image.load("res/img/back.jpg")
image = image.scaled(self.width(), self.height(), Qt.IgnoreAspectRatio,
Qt.SmoothTransformation)
p.drawPixmap(self.rect(), image)
def assert_equal(self):
__tracebackhide__ = True
self.end()
self.different_pixels = 0
actual_image: QImage = self.actual.device().toImage()
expected_image: QImage = self.expected.device().toImage()
diff_pixmap = QPixmap(actual_image.width(), actual_image.height())
diff = QPainter(diff_pixmap)
try:
white = QColor('white')
diff.fillRect(0, 0, actual_image.width(), actual_image.height(),
white)
for x in range(actual_image.width()):
for y in range(actual_image.height()):
actual_colour = actual_image.pixelColor(x, y)
expected_colour = expected_image.pixelColor(x, y)
diff.setPen(
self.diff_colour(actual_colour, expected_colour, x, y))
diff.drawPoint(x, y)
finally:
diff.end()
diff_image: QImage = diff.device().toImage()
display_diff(actual_image, diff_image, expected_image,
self.different_pixels)
if self.different_pixels == 0:
return
actual_image.save(str(self.work_dir / (self.name + '_actual.png')))
expected_image.save(str(self.work_dir / (self.name + '_expected.png')))
diff_path = self.work_dir / (self.name + '_diff.png')
is_saved = diff_image.save(str(diff_path))
diff_width = self.diff_max_x - self.diff_min_x + 1
diff_height = self.diff_max_y - self.diff_min_y + 1
diff_section = QImage(diff_width, diff_height, QImage.Format_RGB32)
diff_section_painter = QPainter(diff_section)
try:
diff_section_painter.drawPixmap(0, 0, diff_width, diff_height,
QPixmap.fromImage(diff_image),
self.diff_min_x, self.diff_min_y,
diff_width, diff_height)
finally:
diff_section_painter.end()
# To see an image dumped in the Travis CI log, copy the text from the
# log, and paste it in test_pixmap_differ.test_decode_image.
print(f'Encoded image of differing section '
f'({self.diff_min_x}, {self.diff_min_y}) - '
f'({self.diff_max_x}, {self.diff_max_y}):')
print(encode_image(diff_section))
message = f'Found {self.different_pixels} different pixels, '
message += f'see' if is_saved else 'could not write'
message += f' {diff_path.relative_to(Path(__file__).parent.parent)}.'
assert self.different_pixels == 0, message
def show_synced(self, is_sync: bool) -> None:
p1 = QPixmap(self.icon().pixmap(self.icon().actualSize(QSize(1024, 1024))))
p2 = self.get_icon(is_sync)
mode = QPainter.CompositionMode_SourceOver
s = p1.size().expandedTo(p2.size())
result = QPixmap(s)
result.fill(Qt.transparent)
painter = QPainter(result)
painter.setRenderHint(QPainter.Antialiasing)
painter.drawPixmap(QPoint(), p1)
painter.setCompositionMode(mode)
painter.drawPixmap(result.rect(), p2, p2.rect())
painter.end()
self.setIcon(QIcon(result))
def paintEvent(self, event):
"""
Paint the widget.
"""
super(WaTorWidget, self).paintEvent(event)
painter = QPainter(self)
for y in range(self._size.height()):
for x in range(self._size.width()):
pos = QPoint(x, y) * self._scale
painter.drawPixmap(pos, self._water.pixmap)
for pos, mob in self._world.mobs.items():
painter.drawPixmap(pos * self._scale, mob.pixmap)
painter.end()
def assert_equal(self):
__tracebackhide__ = True
self.end()
self.different_pixels = 0
actual_image: QImage = self.actual.device().toImage()
expected_image: QImage = self.expected.device().toImage()
diff_pixmap = QPixmap(actual_image.width(), actual_image.height())
diff = QPainter(diff_pixmap)
try:
white = QColor('white')
diff.fillRect(0, 0, actual_image.width(), actual_image.height(),
white)
for x in range(actual_image.width()):
for y in range(actual_image.height()):
actual_colour = actual_image.pixelColor(x, y)
expected_colour = expected_image.pixelColor(x, y)
diff.setPen(
self.diff_colour(actual_colour, expected_colour, x, y))
diff.drawPoint(x, y)
finally:
diff.end()
diff_image: QImage = diff.device().toImage()
display_diff(actual_image, diff_image, expected_image,
self.different_pixels)
if self.different_pixels == 0:
return
actual_image.save(str(self.work_dir / (self.name + '_actual.png')))
expected_image.save(str(self.work_dir / (self.name + '_expected.png')))
diff_path = self.work_dir / (self.name + '_diff.png')
is_saved = diff_image.save(str(diff_path))
diff_width = self.diff_max_x - self.diff_min_x + 1
diff_height = self.diff_max_y - self.diff_min_y + 1
diff_section = QImage(diff_width, diff_height, QImage.Format_RGB32)
diff_section_painter = QPainter(diff_section)
try:
diff_section_painter.drawPixmap(0, 0, diff_width, diff_height,
QPixmap.fromImage(diff_image),
self.diff_min_x, self.diff_min_y,
diff_width, diff_height)
finally:
diff_section_painter.end()
message = f'Found {self.different_pixels} different pixels.'
assert self.different_pixels == 0, message
def main():
parser = parse_args()
pov_file: Path = parser.pov_file
stem = pov_file.stem
shadow_stem = re.sub(r'-(\d+)$', r'-shadow-\1', stem)
temp_file = pov_file.parent / (stem + '-temp.png')
temp_shadow_file = pov_file.parent / (shadow_stem + '-temp.png')
png_file = pov_file.parent / (shadow_stem + '.png')
current_images = Path(__file__).parent.parent / 'shibumi_images'
current_file = current_images / png_file.name
if current_file.exists():
png_file = current_file
args = ['povray',
'-D',
f'+I{pov_file}',
'+V',
'-W640',
'-H480',
'+ua',
f'+O{temp_file}']
run(args, check=True)
app = QApplication()
images_path = Path(__file__).parent
shadow_file = images_path / 'ball-r-shadow-1.png'
shadow = QPixmap(str(shadow_file))
rendered = QPixmap(str(temp_file))
cropped = rendered.copy(120, 20, 400, 400)
scaled = cropped.scaled(98,
102,
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
painter = QPainter(shadow)
try:
painter.drawPixmap(7, 2, scaled)
finally:
painter.end()
assert app
shadow.save(str(temp_shadow_file), 'png')
temp_file.unlink()
temp_shadow_file.rename(png_file)
print(f'Generated {png_file} from {pov_file}.')
def paintEvent(self, event):
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.black)
if self.pixmap.isNull():
painter.setPen(Qt.white)
painter.drawText(self.rect(), Qt.AlignCenter,
"Rendering initial image, please wait...")
return
if self.curScale == self.pixmapScale:
painter.drawPixmap(self.pixmapOffset, self.pixmap)
else:
scaleFactor = self.pixmapScale / self.curScale
newWidth = int(self.pixmap.width() * scaleFactor)
newHeight = int(self.pixmap.height() * scaleFactor)
newX = self.pixmapOffset.x() + (self.pixmap.width() - newWidth) / 2
newY = self.pixmapOffset.y() + (self.pixmap.height() -
newHeight) / 2
painter.save()
painter.translate(newX, newY)
painter.scale(scaleFactor, scaleFactor)
exposed, _ = painter.transform().inverted()
exposed = exposed.mapRect(self.rect()).adjusted(-1, -1, 1, 1)
painter.drawPixmap(exposed, self.pixmap, exposed)
painter.restore()
text = "Use mouse wheel or the '+' and '-' keys to zoom. Press and " \
"hold left mouse button to scroll."
metrics = painter.fontMetrics()
textWidth = metrics.horizontalAdvance(text)
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(0, 0, 0, 127))
painter.drawRect((self.width() - textWidth) / 2 - 5, 0, textWidth + 10,
metrics.lineSpacing() + 5)
painter.setPen(Qt.white)
painter.drawText((self.width() - textWidth) / 2,
metrics.leading() + metrics.ascent(), text)
def paintEvent(self, event):
painter = QPainter(self)
painter.drawPixmap(QRect(0, 0, self.pixmap.width(), self.pixmap.height()), self.pixmap)
def assemble_board(self) -> QPixmap:
full_board = self.load_pixmap('board-1.png')
board_size = self.start_state.size
if board_size == 4:
return full_board
full_height = full_board.height()
full_width = full_board.width()
left_width = round(full_width * 0.28)
mid_width = round(full_width * 0.22)
right_width = round(full_width * 0.279)
top_height = round(full_height * 0.28)
mid_height = round(full_height * 0.21)
bottom_height = round(full_height * 0.29)
final_width = left_width + (board_size - 2) * mid_width + right_width
final_height = top_height + (board_size -
2) * mid_height + bottom_height
assembled_board = QPixmap(final_width, final_height)
assembled_board.fill(Qt.transparent)
assembled_painter = QPainter(assembled_board)
# top left
assembled_painter.drawPixmap(0, 0, left_width, top_height, full_board,
0, 0, left_width, top_height)
for j in range(board_size - 2):
# top middle
assembled_painter.drawPixmap(left_width + j * mid_width, 0,
mid_width, top_height, full_board,
left_width, 0, mid_width, top_height)
# top right
assembled_painter.drawPixmap(final_width - right_width, 0, right_width,
top_height, full_board,
full_width - right_width, 0, right_width,
top_height)
for i in range(board_size - 2):
# left middle
assembled_painter.drawPixmap(0, top_height + i * mid_height,
left_width, mid_height, full_board, 0,
top_height, left_width, mid_height)
for j in range(board_size - 2):
# middle middle
assembled_painter.drawPixmap(left_width + j * mid_width,
top_height + i * mid_height,
mid_width, mid_height, full_board,
left_width, top_height, mid_width,
mid_height)
# right middle
assembled_painter.drawPixmap(final_width - right_width,
top_height + i * mid_height,
right_width, mid_height, full_board,
full_width - right_width, top_height,
right_width, mid_height)
# bottom left
assembled_painter.drawPixmap(0, final_height - bottom_height,
left_width, bottom_height, full_board, 0,
full_height - bottom_height, left_width,
bottom_height)
for j in range(board_size - 2):
# bottom middle
assembled_painter.drawPixmap(left_width + j * mid_width,
final_height - bottom_height,
mid_width, bottom_height, full_board,
left_width,
full_height - bottom_height,
mid_width, bottom_height)
# bottom right
assembled_painter.drawPixmap(final_width - right_width,
final_height - bottom_height, right_width,
bottom_height, full_board,
full_width - right_width,
full_height - bottom_height, right_width,
bottom_height)
return assembled_board
def paintEvent(self, event: QPaintEvent) -> None:
if self.resizeTimer.isActive():
painter = QPainter(self.viewport())
painter.drawPixmap(0, 0, self.viewportCache)
else:
super().paintEvent(event)
def paintEvent(self, event: PySide6.QtGui.QPaintEvent) -> None:
painter = QPainter(self)
pixmap = self.movie.currentPixmap()
pixmap = pixmap.scaled(self.my_size)
painter.drawPixmap(0, 0, pixmap)
def test_board_size_3(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(240, 240,
'margo_board_size_3') as (actual,
expected):
expected_scene = QGraphicsScene(0, 0, 240, 240)
full_board = MargoDisplay.load_pixmap('board-1.png')
width = full_board.width()
height = full_board.height()
top_height = round(height * 0.28)
mid_height = round(height * 0.21)
bottom_height = round(height * 0.29)
left_width = round(width * 0.28)
mid_width = round(width * 0.22)
right_width = round(width * 0.279)
assembled_board = QPixmap(left_width + mid_width + right_width,
top_height + mid_height + bottom_height)
assembled_board.fill(Qt.transparent)
assembled_painter = QPainter(assembled_board)
# top left
assembled_painter.drawPixmap(0, 0, left_width, top_height, full_board,
0, 0, left_width, top_height)
# top middle
assembled_painter.drawPixmap(left_width, 0, mid_width, top_height,
full_board, left_width, 0, mid_width,
top_height)
# top right
assembled_painter.drawPixmap(left_width + mid_width, 0, right_width,
top_height, full_board,
width - right_width, 0, right_width,
top_height)
# left middle
assembled_painter.drawPixmap(0, top_height, left_width, mid_height,
full_board, 0, top_height, left_width,
mid_height)
# middle middle
assembled_painter.drawPixmap(left_width, top_height, mid_width,
mid_height, full_board, left_width,
top_height, mid_width, mid_height)
# right middle
assembled_painter.drawPixmap(left_width + mid_width, top_height,
right_width, mid_height, full_board,
width - right_width, top_height,
right_width, mid_height)
# bottom left
assembled_painter.drawPixmap(0, top_height + mid_height, left_width,
bottom_height, full_board, 0,
height - bottom_height, left_width,
bottom_height)
# bottom middle
assembled_painter.drawPixmap(left_width, top_height + mid_height,
mid_width, bottom_height, full_board,
left_width, height - bottom_height,
mid_width, bottom_height)
# bottom right
assembled_painter.drawPixmap(left_width + mid_width,
top_height + mid_height, right_width,
bottom_height, full_board,
width - right_width,
height - bottom_height, right_width,
bottom_height)
assembled_painter.end()
scaled_board = assembled_board.scaled(240, 240, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
board_item = expected_scene.addPixmap(scaled_board)
board_item.setPos(2, 0)
white_ball = MargoDisplay.load_pixmap('ball-w-shadow-1.png',
QSize(76, 76))
black_ball = MargoDisplay.load_pixmap('ball-b-shadow-1.png',
QSize(76, 76))
expected_scene.addPixmap(white_ball).setPos(15, 145)
expected_scene.addPixmap(black_ball).setPos(81, 79)
expected_scene.render(expected)
display = MargoDisplay(size=3)
display.resize(348, 264)
board_text = """\
A C E
5 . . . 5
3 . B . 3
1 W . . 1
A C E
>B
"""
display.update_board(SpargoState(board_text, size=3))
render_display(display, actual)
def test_board_size_2(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(240, 240,
'margo_board_size_2') as (actual,
expected):
expected_scene = QGraphicsScene(0, 0, 240, 240)
full_board = MargoDisplay.load_pixmap('board-1.png')
width = full_board.width()
height = full_board.height()
top_height = round(height * 0.28)
left_width = round(width * 0.28)
right_width = round(width * 0.279)
bottom_height = round(height * 0.29)
assembled_board = QPixmap(left_width + right_width,
top_height + bottom_height)
assembled_board.fill(Qt.transparent)
assembled_painter = QPainter(assembled_board)
# top left
assembled_painter.drawPixmap(0, 0, left_width, top_height, full_board,
0, 0, left_width, top_height)
# top right
assembled_painter.drawPixmap(left_width, 0, right_width, top_height,
full_board, width - right_width, 0,
right_width, top_height)
# bottom left
assembled_painter.drawPixmap(0, top_height, left_width, bottom_height,
full_board, 0, height - bottom_height,
left_width, bottom_height)
# bottom right
assembled_painter.drawPixmap(left_width, top_height, right_width,
bottom_height, full_board,
width - right_width,
height - bottom_height, right_width,
bottom_height)
assembled_painter.end()
scaled_board = assembled_board.scaled(232, 240, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
board_item = expected_scene.addPixmap(scaled_board)
board_item.setPos(4, 0)
white_ball = MargoDisplay.load_pixmap('ball-w-shadow-1.png',
QSize(103, 103))
black_ball = MargoDisplay.load_pixmap('ball-b-shadow-1.png',
QSize(103, 103))
expected_scene.addPixmap(white_ball).setPos(23, 108)
expected_scene.addPixmap(black_ball).setPos(113, 18)
expected_scene.render(expected)
display = MargoDisplay(size=2)
trigger_resize(display, 292, 240)
display.resize(348, 264)
board_text = """\
A C
3 . B 3
1 W . 1
A C
>B
"""
display.update_board(SpargoState(board_text, size=2))
render_display(display, actual)