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,
"PyQt by\nRiverbank Computing")
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 paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHints(QPainter.SmoothPixmapTransform)
rect = self.rect()
w = rect.width()
h = rect.height()
# 绘制加载信息
painter.save()
painter.setFont(ResourceLoader().qt_font_text_xs)
painter.setPen(ResourceLoader().qt_color_sub_text)
_text_rect = calculate_text_rect('正在努力加载', painter=painter)
text_rect = calculate_middle_rect(rect,
width=_text_rect.width(),
height=_text_rect.height())
painter.translate(QPoint(12, 0))
painter.drawText(text_rect, Qt.TextSingleLine, '正在努力加载')
painter.restore()
# 绘制加载图标
x2 = w / 2 - text_rect.width() / 2 - 16
y2 = h / 2
painter.save()
painter.translate(x2, y2)
self.loading_rotate += 14
painter.rotate(self.loading_rotate % 360)
# icon = qtawesome.icon('fa5s.spinner', color=ResourceLoader().qt_color_sub_text)
icon = qtawesome.icon('mdi.loading',
color=ResourceLoader().qt_color_sub_text)
icon_pixmap = icon.pixmap(QSize(24, 24))
painter.drawPixmap(QRect(-12, -12, 24, 24), icon_pixmap)
painter.restore()
QWidget.paintEvent(self, event)
def _drawLabel(self, painter: QPainter, font_metrics, offset_x, text):
"""отображение подписи оси"""
painter.rotate(-90)
offset_y = -self._margins[1] - self.getDrawArea().height() / 2
offset_y -= font_metrics.width(text) / 2
painter.drawText(QPointF(offset_y, offset_x + 45), text)
painter.rotate(90)
def paintEvent(self, QPaintEvent):
self.updatePosition()
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.transparent)
painter.setRenderHint(QPainter.Antialiasing, True)
if self._currentCounter >= self._numberOfLines:
self._currentCounter = 0
painter.setPen(Qt.NoPen)
for i in range(0, self._numberOfLines):
painter.save()
painter.translate(self._innerRadius + self._lineLength,
self._innerRadius + self._lineLength)
rotateAngle = float(360 * i) / float(self._numberOfLines)
painter.rotate(rotateAngle)
painter.translate(self._innerRadius, 0)
distance = self.lineCountDistanceFromPrimary(
i, self._currentCounter, self._numberOfLines)
color = self.currentLineColor(distance, self._numberOfLines,
self._trailFadePercentage,
self._minimumTrailOpacity,
self._color)
painter.setBrush(color)
rect = QRect(0, -self._lineWidth/2,
self._lineLength, self._lineWidth)
painter.drawRoundedRect(
rect, self._roundness, self._roundness, Qt.RelativeSize)
painter.restore()
def paintEvent(self, event):
QLabel.paintEvent(self, event)
painter = QPainter(self)
painter.translate(0, self.height() - 1)
painter.rotate(-90)
self.setGeometry(self.x(), self.y(), self.height(), self.width())
QLabel.render(self, painter)
def paintEvent(self, event):
if not self.displayedWhenStopped and not self.isAnimated():
return
width = min(self.width(), self.height())
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
outerRadius = (width - 1) * 0.5
innerRadius = (width - 1) * 0.5 * 0.38
capsuleHeight = outerRadius - innerRadius
capsuleWidth = capsuleHeight * 0.23 if width > 32 else capsuleHeight * 0.35
capsuleRadius = capsuleWidth / 2
for i in range(12):
color = QColor(self.color)
color.setAlphaF(float(1.0 - float(i / 12.0)))
p.setPen(Qt.NoPen)
p.setBrush(color)
p.save()
p.translate(self.rect().center())
p.rotate(self.angle - float(i * 30.0))
p.drawRoundedRect(-capsuleWidth * 0.5,\
-(innerRadius + capsuleHeight),\
capsuleWidth,\
capsuleHeight,\
capsuleRadius,\
capsuleRadius)
p.restore()
def paintEvent(self, paintEvent):
painter = QPainter(self)
painter.setBrush(QColor("#CCCCFF"))
painter.setPen(QColor("#00FF00"))
painter.setRenderHint(QPainter.Antialiasing) ## 抗锯齿
painter.drawRoundedRect(0, 0,
self.width() - 1,
self.height() - 1, 20, 20)
painter.translate(self.width() / 2, self.height() / 2)
painter.rotate(self.cnt)
painter.translate(-self.width() / 2, -self.height() / 2)
painter.drawPixmap(0, 0, self.width(), self.height(), self.pix)
if self.cnt >= 360:
self.cnt = 0
else:
self.cnt += 1
# #新建一个QTimer对象
# self.timer = QBasicTimer()
# self.timer.start(1000, self)
#
# # 覆写计时器事件处理函数timerEvent()
# def timerEvent(self, event):
# self.lcd.display(time.strftime("%X",time.localtime()))
def paintEvent(self, event):
"""Repaint the widget.
First create a (semi-) transparent background for the whole
parent widget, then paint six small circles, with one
colored differently.
"""
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(
event.rect(), QColor(255, 255, 255, self._transparency)
)
painter.setPen(QPen(Qt.NoPen))
painter.translate(self.rect().center())
for i in range(6):
if (self._counter // 5) % 6 == i:
painter.setBrush(
QBrush(QColor(127 + (self._counter % 5)*32, 127, 127))
)
else:
painter.setBrush(QBrush(QColor(127, 127, 127)))
painter.drawEllipse(30, -10, 20, 20)
painter.rotate(60)
painter.end()
def paintEvent(self, event):
global real_time, minotaur_standard_time
actual_time_updater()
side = min(self.width(), self.height())
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
painter.scale(side / 200.0, side / 200.0)
painter.setPen(Qt.NoPen)
painter.setBrush(AnalogClock.hourColor)
painter.save()
hour_adjust = 30.0 * (
(int(real_time.hour) + int(real_time.minute) / 60.0))
hour = math.floor(hour_adjust / 30.0)
painter.rotate(hour_adjust)
painter.drawConvexPolygon(AnalogClock.hourHand)
painter.restore()
painter.setPen(AnalogClock.hourColor)
for i in range(12):
painter.drawLine(88, 0, 96, 0)
painter.rotate(30.0)
painter.setPen(Qt.NoPen)
painter.setBrush(AnalogClock.minuteColor)
painter.save()
minute_adjust = 6.0 * (
(int(real_time.minute) + int(real_time.second) / 60.0))
if minute_adjust < 0:
minute_adjust += 360
minute = math.floor(minute_adjust / 6.0)
painter.rotate(minute_adjust)
painter.drawConvexPolygon(AnalogClock.minuteHand)
painter.restore()
painter.setPen(Qt.NoPen)
painter.setBrush(AnalogClock.secondColor)
painter.save()
second_adjust = 6.0 * int(real_time.second)
if second_adjust < 0:
second_adjust += 360
second = math.floor(second_adjust / 6.0)
painter.rotate(second_adjust)
painter.drawConvexPolygon(AnalogClock.secondHand)
painter.restore()
painter.setPen(AnalogClock.minuteColor)
for j in range(60):
if (j % 5) != 0:
painter.drawLine(92, 0, 96, 0)
painter.rotate(6.0)
def paintEvent(self, event):
radius = 50
treeSize = QSizeF(2 * radius, 2 * radius)
bounds = QRectF((self.width() - treeSize.height()) / 2,
(self.height() - treeSize.width()) / 2,
treeSize.width(), treeSize.height())
painter = QPainter(self)
# draw the shadow
painter.setBrush(Qt.black)
painter.setPen(Qt.NoPen)
painter.setOpacity(0.5)
xrad = 95
yrad = self.shadowLength * 20
rect = QRectF(-xrad, -yrad, xrad, yrad)
painter.translate(self.width() / 2, self.height() / 2)
painter.rotate(self.angle)
painter.translate(xrad / 2, yrad / 2)
painter.drawChord(rect, 0, 180 * 16)
painter.resetTransform()
# draw the tree
painter.setOpacity(1)
self.tree.render(painter, bounds)
# draw the compass
bounds = QRectF(10, 10, 50, 50)
self.compass.render(painter, bounds)
def paintEvent(self, event):
global act_array
super().paintEvent(event)
painter = QPainter(self)
for i in range(0, act_array.row*act_array.col+1):
painter.drawRect(act_array.rec[i])
bs = QBrush(act_array.actuator[i].color)
painter.fillRect(act_array.rec[i], bs)
# # 含角度显示
for index in range(0, len(Parcels)):
painter.resetTransform() # 重置变换
parcel = Parcels[index]
rec_x = parcel.x - (parcel.l-1)/2
rec_y = parcel.y - (parcel.w-1)/2
parcel.rec = QRectF(rec_x, rec_y, parcel.l, parcel.w)
theta = -parcel.theta/180*pi # 先反方向旋转
# 坐标y轴是反的，所以想要使用旋转矩阵需要反过来乘
M = np.array([[cos(theta), -sin(theta)], [sin(theta), cos(theta)]])
[rec_x2, rec_y2] = np.dot([parcel.x, parcel.y], M)
painter.rotate(-parcel.theta) # 坐标旋转角度
parcel.rec = parcel.rec.translated(
int(rec_x2-parcel.x), int(rec_y2-parcel.y))
painter.drawRect(parcel.rec)
bs = QBrush(QColor(255, 255, 255))
painter.fillRect(parcel.rec, bs)
painter.drawText(parcel.rec,str(parcel.prio))
def _draw(self, painter: QPainter, width: int, height: int):
painter.setPen(QPen(Qt.NoPen))
painter.setBrush(QBrush(Color.orange))
for i, branch in enumerate(self.branches):
h, rotation = branch
painter.save()
# translate/rotate to the position from which the branches grow
painter.translate(0, self.base_height(height * h * smoothen_curve(self.age)))
painter.rotate(degrees(rotation))
top_of_branch = self.branch_height(height) * smoothen_curve(self.get_adjusted_age()) * (1 - h)
circle_on_branch_position = top_of_branch * self.branch_circles[i][1]
r = ((width + height) / 2) * self.branch_circles[i][0] * smoothen_curve(self.get_adjusted_age()) * (
1 - h) * self.age_coefficient
painter.setBrush(QBrush(Color.orange))
painter.drawEllipse(QPointF(0, circle_on_branch_position), r, r)
painter.restore()
top_of_branch = self.base_height(height) * smoothen_curve(self.age)
circle_on_branch_position = top_of_branch * self.branch_circles[-1][1]
# make the main ellipse slightly larger
increase_size = 1.3
r = ((width + height) / 2) * self.branch_circles[-1][0] * smoothen_curve(self.get_adjusted_age()) * (
1 - self.branches[-1][0]) * self.age_coefficient * increase_size
painter.drawEllipse(QPointF(0, circle_on_branch_position), r, r)
super()._draw(painter, width, height)
def paintEvent(self, QPaintEvent):
self.updatePosition()
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.transparent)
painter.setRenderHint(QPainter.Antialiasing, True)
if self._currentCounter >= self._numberOfLines:
self._currentCounter = 0
painter.setPen(Qt.NoPen)
for i in range(0, self._numberOfLines):
painter.save()
painter.translate(self._innerRadius + self._lineLength,
self._innerRadius + self._lineLength)
rotateAngle = float(360 * i) / float(self._numberOfLines)
painter.rotate(rotateAngle)
painter.translate(self._innerRadius, 0)
distance = self.lineCountDistanceFromPrimary(
i, self._currentCounter, self._numberOfLines)
color = self.currentLineColor(distance, self._numberOfLines,
self._trailFadePercentage,
self._minimumTrailOpacity,
self._color)
painter.setBrush(color)
painter.drawRoundedRect(
QRect(0, -self._lineWidth / 2, self._lineLength,
self._lineWidth), self._roundness, self._roundness,
Qt.RelativeSize)
painter.restore()
def run(self):
random.seed()
n = self.stars
width = self.size.width()
height = self.size.height()
while not self.exiting and n > 0:
image = QImage(self.outerRadius * 2, self.outerRadius * 2,
QImage.Format_ARGB32)
image.fill(qRgba(0, 0, 0, 0))
x = random.randrange(0, width)
y = random.randrange(0, height)
angle = random.randrange(0, 360)
red = random.randrange(0, 256)
green = random.randrange(0, 256)
blue = random.randrange(0, 256)
alpha = random.randrange(0, 256)
painter = QPainter()
painter.begin(image)
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(red, green, blue, alpha))
painter.translate(self.outerRadius, self.outerRadius)
painter.rotate(angle)
painter.drawPath(self.path)
painter.end()
self.emit(
SIGNAL("output(QRect, QImage)"),
QRect(x - self.outerRadius, y - self.outerRadius,
self.outerRadius * 2, self.outerRadius * 2), image)
n -= 1
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,
"PyQt by\nRiverbank Computing")
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 draw_pointer_triangle(self, painter: QtGui.QPainter):
""" 绘制指示器, 样式triangle """
radius = 25
offset = 40
painter.save()
# QPolygon 类提供了一个使用整数精度的点向量，QPoint的集合
pts = QtGui.QPolygon()
pts.setPoints(3, -radius / 2, offset, radius / 2, offset, 0,
radius + offset)
painter.rotate(self.start_angle)
deg_rotate = (360 - self.start_angle - self.end_angle) / (
self.max_value - self.min_value) * (self.value - self.min_value)
painter.rotate(deg_rotate)
color = self.percent_color
if self.double_percent:
center = (self.value == (self.max_value - self.min_value) / 2 +
self.min_value)
color = self.border_color if center else self.percent_color
painter.setPen(color)
painter.setBrush(color)
painter.drawConvexPolygon(pts)
painter.restore()
def paintEvent(self, evt):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
# 画边框
painter.setPen(Qt.white)
painter.drawRect(self.rect())
realSize = min(self.width(), self.height()) - 10
painter.translate(self.width() / 2.0, self.height() / 2.0)
painter.scale(realSize / 1000.0, realSize / 1000.0)
painter.rotate(self.rotateAngle)
# 画外圈
painter.setPen(Qt.NoPen)
painter.setBrush(QColor(80, 80, 80))
painter.drawEllipse(QPointF(0, 0), 500, 500)
# 园内部四个扇形区域，蓝白交叉
startAngle = 0
spanAngle = 90 * 16
pieRect = QRectF(QPointF(-400, -400), QPointF(400, 400))
for i in range(4):
color = QColor(0, 120, 200) if i % 2 else QColor(240, 240, 240)
painter.setBrush(color)
painter.drawPie(pieRect, startAngle, spanAngle)
startAngle += spanAngle
def draw_pointer_indicator_r(self, painter: QtGui.QPainter):
""" 绘制指示器, 样式indicator_r """
radius = 62
offset = 8
painter.save()
painter.setOpacity(0.6)
# QPolygon 类提供了一个使用整数精度的点向量，QPoint的集合
pts = QtGui.QPolygon()
pts.setPoints(3, -offset, 0, offset, 0, 0, radius)
painter.rotate(self.start_angle)
deg_rotate = (360 - self.start_angle - self.end_angle) / (
self.max_value - self.min_value) * (self.value - self.min_value)
painter.rotate(deg_rotate)
color = self.percent_color
if self.double_percent:
center = (self.value == (self.max_value - self.min_value) / 2 +
self.min_value)
color = self.border_color if center else self.percent_color
pen = QtGui.QPen()
pen.setColor(pen)
painter.setPen(pen)
painter.setBrush(color)
painter.drawConvexPolygon(pts)
# 增加绘制圆角直线，与之前三角形重叠，形成圆角指针
pen.setCapStyle(QtCore.Qt.RoundCap)
pen.setWidth(offset - 1)
painter.setPen(pen)
painter.drawLine(0, 0, 0, radius)
painter.restore()
def painter_rotate(painter: QPainter, rect: QRectF, angle: int = 0) -> QRectF:
"""Context manager rotating and restoring the painter
:param painter: Painter, which is rotated
:param rect: Rect to be painted in
:param angle: Rotataion angle must be in (0, 90, 180, 270)
"""
supported_angles = 0, 90, 180, 270
angle = int(angle)
if angle not in supported_angles:
msg = "Rotation angle {} not in {}".format(angle, supported_angles)
raise Warning(msg)
return
center_x, center_y = rect.center().x(), rect.center().y()
with painter_save(painter):
painter.translate(center_x, center_y)
painter.rotate(angle)
if angle in (0, 180):
painter.translate(-center_x, -center_y)
elif angle in (90, 270):
painter.translate(-center_y, -center_x)
rect = QRectF(rect.y(), rect.x(), rect.height(), rect.width())
yield rect
def paintEvent(self, event):
radius = 50
treeSize = QSizeF(2 * radius, 2 * radius)
bounds = QRectF( (self.width() - treeSize.height()) / 2,
(self.height() - treeSize.width()) / 2,
treeSize.width(),
treeSize.height())
painter = QPainter(self)
# draw the shadow
painter.setBrush(Qt.black)
painter.setPen(Qt.NoPen)
painter.setOpacity(0.5)
xrad = 95
yrad = self.shadowLength * 20
rect = QRectF(-xrad, -yrad, xrad, yrad)
painter.translate(self.width() / 2, self.height() / 2)
painter.rotate(self.angle)
painter.translate(xrad/2, yrad/2)
painter.drawChord(rect, 0, 180*16)
painter.resetTransform()
# draw the tree
painter.setOpacity(1)
self.tree.render(painter, bounds)
# draw the compass
bounds = QRectF( 10, 10, 50, 50)
self.compass.render(painter, bounds)
def paintEvent(self, event):
self._update_position()
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.transparent)
painter.setRenderHint(QPainter.Antialiasing, True)
if self._current_counter > self._number_of_lines:
self._current_counter = 0
painter.setPen(Qt.NoPen)
for i in range(self._number_of_lines):
painter.save()
painter.translate(self._inner_radius + self._line_length,
self._inner_radius + self._line_length)
rotate_angle = 360.0 * i / self._number_of_lines
painter.rotate(rotate_angle)
painter.translate(self._inner_radius, 0)
distance = self._line_count_distance_from_primary(
i, self._current_counter, self._number_of_lines)
color = self._current_line_color(distance, self._number_of_lines,
self._trail_fade_percentage,
self._minimum_trail_opacity,
self._color)
painter.setBrush(color)
painter.drawRoundedRect(
QRect(0, -self._line_width // 2, self.line_length,
self._line_length), self._roundness, Qt.RelativeSize)
painter.restore()
def paintEvent(self, e):
painter = QPainter(self) # Grey background
fontSize = int(self.width() * 0.1)
padding = 4
painter.setPen(QPen(self.textColor, 1, Qt.SolidLine))
painter.setFont(QFont("Monospace", fontSize))
fontHeight = int(fontSize * 1.5)
valueText = str(self.value)[0:6]
painter.drawText(QRect(0, 0, self.width(),
self.height() * 0.9), Qt.AlignCenter, valueText)
painter.setFont(QFont("Monospace", fontSize / 2))
painter.drawText(
QRect(0, (self.height() * 0.9 / 2) + fontHeight / 2 + padding,
self.width(), fontHeight / 2), Qt.AlignCenter, self.title)
theta = clamp(
interpolate(self.value, self.minValue, self.maxValue, 0, 360 * 16),
0, 360 * 16)
barPadding = 20
painter.setPen(QPen(self.barColor, 30, Qt.SolidLine))
painter.translate(0, self.height())
painter.rotate(-90)
painter.drawArc(barPadding, barPadding,
self.width() - 2 * barPadding,
self.height() - 2 * barPadding, 0, -theta)
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
W = self.width()
H = self.height()
side = min(W, H)
rect = QRect((W-side)/2, (H-side)/2, side, side)
painter.drawRect((rect))
painter.setViewport(rect)
painter.setWindow(-100, -100, 200, 200)
pen = QPen()
pen.setWidth(1)
pen.setColor(Qt.blue)
pen.setStyle(Qt.SolidLine)
painter.setPen(pen)
linearGrad = QLinearGradient(0, 0, 100, 0)
linearGrad.setColorAt(0, Qt.yellow)
linearGrad.setColorAt(0.8, Qt.green)
linearGrad.setSpread(QGradient.ReflectSpread)
painter.setBrush(linearGrad)
painter.setCompositionMode(QPainter.CompositionMode_Difference)
for i in range(36):
painter.drawEllipse(QPoint(50, 0), 50, 50)
painter.rotate(10)
def paintEvent(self, event):
if not self.isDisplayedWhenStopped() and not self.isRunning():
return
width = min(self.width(), self.height())
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
outerRadius = (width-1) * 0.5
innerRadius = (width-1) * 0.5 * 0.38
capsuleHeight = outerRadius - innerRadius
capsuleWidth = capsuleHeight * 0.23 if width > 32 else capsuleHeight * 0.35
capsuleRadius = capsuleWidth / 2
for i in range(12):
color = QColor(self.color)
color.setAlphaF(float(1.0 - float(i / 12.0)))
p.setPen(Qt.NoPen)
p.setBrush(color)
p.save()
p.translate(self.rect().center())
p.rotate(self._angle - float(i * 30.0))
p.drawRoundedRect(-capsuleWidth * 0.5,
-(innerRadius + capsuleHeight),
capsuleWidth,
capsuleHeight,
capsuleRadius,
capsuleRadius)
p.restore()
def _draw(self, painter: QPainter, width: int, height: int):
super()._draw(painter, width, height)
painter.save()
# move to the position of the flower
painter.translate(self.x, self.y)
painter.setPen(QPen(Qt.NoPen))
painter.setBrush(QBrush(self.color))
pellet_size = self.pellet_size(width) * smoothen_curve(
self.get_age_coefficient())
# draw each of the pellets
for i in range(self.number_of_pellets):
self.pellet_drawing_function(painter, pellet_size)
painter.rotate(360 / self.number_of_pellets)
# draw the center of the flower
painter.setBrush(QBrush(Color.white))
pellet_size *= self.center_pellet_smaller_coefficient
painter.drawEllipse(
QRectF(-pellet_size / 2, -pellet_size / 2, pellet_size,
pellet_size))
painter.restore()
def paintEvent(self, p):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(106, 106)
painter.rotate(self.angle)
painter.translate(-106, -106)
painter.drawPixmap(30, 31, 150, 150, self.pix)
def paintEvent(self, p):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(37.5, 38)
painter.rotate(self.angle)
painter.translate(-37.5, -38)
painter.drawPixmap(12, 13, 50, 50, self.pix)
def paintEvent(self, event):
super(CAvatar, self).paintEvent(event)
# 画笔
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHint(QPainter.HighQualityAntialiasing, True)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
# 绘制
path = QPainterPath()
diameter = min(self.width(), self.height())
if self.shape == self.Circle:
radius = int(diameter / 2)
elif self.shape == self.Rectangle:
radius = 4
halfW = self.width() / 2
halfH = self.height() / 2
painter.translate(halfW, halfH)
path.addRoundedRect(
QRectF(-halfW, -halfH, diameter, diameter), radius, radius)
painter.setClipPath(path)
# 如果是动画效果
if self.rotateAnimation.state() == QPropertyAnimation.Running:
painter.rotate(self._angle) # 旋转
painter.drawPixmap(
QPointF(-self.pixmap.width() / 2, -self.pixmap.height() / 2), self.pixmap)
else:
painter.drawPixmap(-int(halfW), -int(halfH), self.pixmap)
# 如果在加载
if self.loadingTimer.isActive():
diameter = 2 * self.pradius
painter.setBrush(
QColor(45, 140, 240, (1 - self.pradius / 10) * 255))
painter.setPen(Qt.NoPen)
painter.drawRoundedRect(
QRectF(-self.pradius, -self.pradius, diameter, diameter), self.pradius, self.pradius)
def paintEvent(self, event):
if (not self.m_displayedWhenStopped) and (not self.isAnimated()):
return
width = min(self.width(), self.height())
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
outerRadius = (width - 1) * 0.5
innerRadius = (width - 1) * 0.5 * 0.4375
capsuleHeight = outerRadius - innerRadius
capsuleWidth = width * 3 / 32
capsuleRadius = capsuleWidth / 2
for i in range(0, 12):
color = QtGui.QColor(self.m_color)
if self.isAnimated():
color.setAlphaF(1.0 - (i / 12.0))
else:
color.setAlphaF(0.2)
painter.setPen(Qt.NoPen)
painter.setBrush(color)
painter.save()
painter.translate(self.rect().center())
painter.rotate(self.m_angle - (i * 30.0))
painter.drawRoundedRect(capsuleWidth * -0.5,
(innerRadius + capsuleHeight) * -1,
capsuleWidth, capsuleHeight, capsuleRadius,
capsuleRadius)
painter.restore()
def paintEvent(self, event):
if not self._displayedWhenStopped and not self.isAnimated():
return
width = min(self.width(), self.height())
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
outerRadius = int((width - 1) * 0.5)
innerRadius = int((width - 1) * 0.5 * 0.38)
capsuleHeight = int(outerRadius - innerRadius)
capsuleWidth = int(capsuleHeight *
0.23 if (width > 32) else capsuleHeight * 0.35)
capsuleRadius = int(capsuleWidth / 2)
for i in range(12):
color = self._color
color.setAlphaF(1.0 - (i / 12.0))
p.setPen(Qt.NoPen)
p.setBrush(color)
p.save()
p.translate(self.rect().center())
p.rotate(self._angle - i * 30.0)
p.drawRoundedRect(-capsuleWidth * 0.5,
-(innerRadius + capsuleHeight), capsuleWidth,
capsuleHeight, capsuleRadius, capsuleRadius)
p.restore()
def drawVal(self, painter: QtGui.QPainter):
count = self.prim
da = (self.finishA - self.startA) / count
dv = (self.finishV - self.startV) / count
w = QtGui.QFontMetrics(painter.font()).width(
self.f_str.format(self.finishV))
for i in range(count + 1):
v = self.startV + i * dv
w = max(
w,
QtGui.QFontMetrics(painter.font()).width(self.f_str.format(v)))
h = QtGui.QFontMetrics(painter.font()).height()
for i in range(count + 1):
painter.save()
painter.translate(self.x, self.y)
a = -self.startA - da * i
painter.rotate(a)
v = self.startV + i * dv
l = self.r + self.linewidth + h + 4 + w / 2
painter.translate(l, 0)
painter.rotate(-a)
painter.drawText(-w / 2, -h / 2, w, h, QtCore.Qt.AlignCenter,
self.f_str.format(v))
painter.restore()
def paintEvent(self, event: QPaintEvent) -> None:
painter = QPainter(self)
sz = self.bgpix.size()
w, h = sz.width(), sz.height()
painter.translate(w / 2, h / 2)
painter.rotate(self.rotate_angle)
painter.translate(-w / 2, -h / 2)
painter.drawPixmap(0, 0, w, h, self.bgpix)
def paintEvent(self, event):
painter = QPainter(self)
painter.setPen(Qt.black)
painter.translate(20, self.length-1)
painter.rotate(-90)
if self.text:
painter.drawText(0, 0, self.text)
painter.end()
def draw_label(self, painter: QPainter, value: float,
angle: float) -> None:
painter.save()
painter.translate(self.label.radius)
painter.rotate(angle)
painter.drawText(self.label.rect, QtCore.Qt.AlignCenter,
self.label.format.format(value))
painter.restore()
def paintEvent(self, event):
painter = QPainter(self)
painter.setPen(QtCore.Qt.black)
painter.translate(20, 100)
painter.rotate(-90)
if self.text:
painter.drawText(0, 0, self.text)
painter.end()
def render(self, size):
image = QImage(size, QImage.Format_ARGB32_Premultiplied)
if (self.mIncludeBackgroundColor):
if (self.mMap.backgroundColor().isValid()):
image.fill(self.mMap.backgroundColor())
else:
image.fill(Qt.gray)
else :
image.fill(Qt.transparent)
mapSize = self.mRenderer.mapSize()
margins = self.mRenderer.map().drawMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
scale = min(size.width() / mapSize.width(), size.height() / mapSize.height())
scaledSize = mapSize * scale
painter = QPainter(image)
# Center the thumbnail in the requested size
painter.translate((size.width() - scaledSize.width()) / 2,
(size.height() - scaledSize.height()) / 2)
# Scale the map and translate it to adjust for its margins
painter.scale(scale, scale)
painter.translate(margins.left() + (size.width() - scaledSize.width()) / 2,
margins.top() + (size.height() - scaledSize.height()) / 2)
if (smoothTransform(scale)):
painter.setRenderHints(QPainter.SmoothPixmapTransform)
self.mRenderer.setPainterScale(scale)
for layer in self.mMap.layers():
if (self.mVisibleLayersOnly and not layer.isVisible()):
continue
painter.setOpacity(layer.opacity())
tileLayer = dynamic_cast(layer, TileLayer)
objGroup = dynamic_cast(layer, ObjectGroup)
imageLayer = dynamic_cast(layer, ImageLayer)
if (tileLayer):
self.mRenderer.drawTileLayer(painter, tileLayer)
elif (objGroup):
objects = objGroup.objects()
if (objGroup.drawOrder() == ObjectGroup.TopDownOrder):
objects = QList(sorted(objects, key=lambda x:x.y(), reverse=True))
for object in objects:
if (object.isVisible()):
if object.rotation() != 0.0:
origin = self.mRenderer.pixelToScreenCoords(object.position())
painter.save()
painter.translate(origin)
painter.rotate(object.rotation())
painter.translate(-origin)
color = MapObjectItem.objectColor(object)
self.mRenderer.drawMapObject(painter, object, color)
if (object.rotation() != 0):
painter.restore()
elif (imageLayer):
self.mRenderer.drawImageLayer(painter, imageLayer)
return image
def render(self, page):
"""Generate an image for this Page."""
i = QImage(page.width, page.height, QImage.Format_ARGB32_Premultiplied)
i.fill(self.paperColor)
painter = QPainter(i)
rect = QRect(0, 0, page.width, page.height)
painter.translate(rect.center())
painter.rotate(page.computedRotation * 90)
if page.computedRotation & 1:
rect.setSize(rect.size().transposed())
painter.translate(-rect.center())
page._svg_r.render(painter, QRectF(rect))
return i
def paintEvent(self, event):
painter = QPainter(self)
painter.rotate(-90)
region = QtCore.QRect(-self.height(), 0, self.height(), self.width())
hint = painter.drawText(region, self.alignment(), self.text())
painter.end()
self.setMaximumWidth(hint.height())
self.setMinimumWidth(0)
self.setMaximumHeight(16777215)
self.setMinimumHeight(hint.width())
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setBrush(QBrush(QColor(192, 192, 255)))
painter.drawRect(event.rect())
painter.translate(self.width()/2.0, self.height()/2.0)
painter.rotate(self._angle)
painter.setBrush(QBrush(self.gradient))
painter.drawPath(self.path)
painter.end()
def render(self, page):
"""Generate an image for this Page."""
i = QImage(page.width, page.height, self.imageFormat)
i.fill(page.paperColor or self.paperColor or QColor(Qt.white))
painter = QPainter(i)
rect = QRect(0, 0, page.width, page.height)
painter.translate(rect.center())
painter.rotate(page.computedRotation * 90)
if page.computedRotation & 1:
rect.setSize(rect.size().transposed())
painter.translate(-rect.center())
page._svg_r.render(painter, QRectF(rect))
return i
def paintEvent(self, event):
side = min(self.width(), self.height())
time = QTime.currentTime()
time = time.addSecs(self.timeZoneOffset * 3600)
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
painter.scale(side / 200.0, side / 200.0)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(self.hourColor))
painter.save()
painter.rotate(30.0 * ((time.hour() + time.minute() / 60.0)))
painter.drawConvexPolygon(self.hourHand)
painter.restore()
painter.setPen(self.hourColor)
for i in range(0, 12):
painter.drawLine(84, 0, 96, 0)
painter.rotate(30.0)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(self.minuteColor))
painter.save()
painter.rotate(6.0 * (time.minute() + time.second() / 60.0))
painter.drawConvexPolygon(self.minuteHand)
painter.restore()
painter.setPen(QPen(self.minuteColor))
for j in range(0, 60):
if (j % 5) != 0:
painter.drawLine(90, 0, 96, 0)
painter.rotate(6.0)
painter.setPen(Qt.NoPen)
painter.setBrush(QBrush(self.secondColor))
painter.save()
painter.rotate(6.0 * time.second())
painter.drawConvexPolygon(self.secondHand)
painter.restore()
painter.end()
def paintEvent(self, event):
qp = QPainter(self)
qp.setPen(QPen(Qt.black, 5, Qt.SolidLine))
qp.setBrush(QBrush(Qt.red, Qt.SolidPattern))
qp.setRenderHint(QPainter.Antialiasing) # <- Set anti-aliasing See https://wiki.python.org/moin/PyQt/Painting%20and%20clipping%20demonstration
qp.drawEllipse(100, 15, 400, 200)
qp.translate(100, 100)
qp.rotate(30)
qp.setBrush(QBrush(Qt.red, Qt.DiagCrossPattern))
qp.drawEllipse(600, 15, 200, 100)
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.scale(self.width() / 100.0, self.height() / 100.0)
painter.translate(50.0, 50.0)
painter.rotate(-self.rotationAngle)
painter.translate(-50.0, -50.0)
painter.setPen(
QPen(self.penColor, self.penWidth, Qt.SolidLine, Qt.RoundCap,
Qt.RoundJoin))
gradient = QLinearGradient(0, 0, 0, 100)
gradient.setColorAt(0.0, self.fillColor1)
gradient.setColorAt(1.0, self.fillColor2)
painter.setBrush(QBrush(gradient))
painter.drawPath(self.path)
def paintEvent(self, event):
painter = QPainter(self)
margin = 10
length = min(self.width(), self.height()) - 2*margin
xpos = (self.width() - length)/2
ypos = (self.height() - length)/2
bounds = QRectF( xpos, ypos, length, length)
#painter.setBrush(Qt.NoBrush)
#painter.drawRect(bounds)
self.compass.render(painter, bounds)
painter.translate(self.width() / 2, self.height() / 2)
painter.rotate(self.angle)
painter.translate(-self.width() / 2, -self.height() / 2)
#painter.translate(xrad/2, yrad/2)
self.needle.render(painter, bounds)
def paintEvent(self, e):
time = QTime.currentTime()
qp = QPainter()
qp.begin(self)
#qp.setRenderHint(QPainter.Antialiasing) # 开启这个抗锯齿,会很占cpu的!
qp.translate(self.width() / 2, self.height() / 2)
qp.scale(self.side / 200.0, self.side / 200.0)
qp.setPen(QtCore.Qt.NoPen)
qp.setBrush(self.hourColor)
qp.save()
qp.rotate(30.0 * ((time.hour() + time.minute()/ 60.0)))
qp.drawConvexPolygon(self.hourHand)
qp.restore()
qp.setPen(self.minuteColor)
qp.drawText(0,0,"Testdddddddddddddd")
for i in range(12):
qp.drawLine(88, 0, 96, 0)
qp.rotate(30.0)
qp.setPen(QtCore.Qt.NoPen)
qp.setBrush(self.minuteColor)
qp.save()
qp.rotate(6.0 * ((time.minute() + (time.second()+time.msec()/1000.0) / 60.0)))
qp.drawConvexPolygon(self.minuteHand)
qp.restore()
qp.setPen(self.minuteColor)
for i in range(60):
if (i % 5) is not 0:
qp.drawLine(92, 0, 96, 0)
qp.rotate(6.0)
qp.setPen(QtCore.Qt.NoPen)
qp.setBrush(self.secondColor)
qp.save()
qp.rotate(6.0*(time.second()+time.msec()/1000.0))
qp.drawConvexPolygon(self.secondHand)
qp.restore()
qp.end()
def paintEvent(self, event):
"""Paint transparent background,animated pattern,background text."""
painter, font = QPainter(self), self.font()
painter.fillRect(event.rect(), Qt.transparent) # fill transparent rect
painter.setPen(QPen(QColor(randint(9, 255), randint(9, 255), 255)))
painter.rotate(30) # Rotate painter ~30 Degree
font.setBold(True) # Set painter Font for text
font.setPixelSize(100)
painter.setFont(font)
painter.drawText(99, 99, "Python Qt") # draw the background text
painter.rotate(-30) # Rotate -30 the QPen back
painter.setPen(Qt.NoPen) # set the pen to no pen
painter.setBrush(QColor("black")) # Background Color
painter.setOpacity(0.9) # Background Opacity
painter.drawRoundedRect(self.rect(), 25, 25) # Back Rounded Borders
for i in range(2048): # animated random dots background pattern
x = randint(10, self.size().width() - 10)
y = randint(10, self.size().height() - 10)
painter.setPen(QPen(QColor(randint(9, 255), randint(9, 255), 255)))
painter.drawPoint(x, y)
QMainWindow.paintEvent(self, event)
def paintEvent(self, event):
side = min(self.width(), self.height())
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
painter.scale(side / 200.0, side / 200.0)
painter.setPen(Qt.NoPen)
painter.setBrush(AnalogPosition.positionHandColor)
painter.save()
painter.rotate(self.angle)
painter.drawConvexPolygon(AnalogPosition.positionHand)
painter.restore()
painter.setPen(AnalogPosition.positionHandColor)
for j in range(32):
painter.drawLine(92, 0, 96, 0)
painter.rotate(11.25)
def paintEvent(self, event):
side = min(self.width(), self.height())
time = QTime.currentTime()
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.translate(self.width() / 2, self.height() / 2)
painter.scale(side / 200.0, side / 200.0)
painter.setPen(Qt.NoPen)
painter.setBrush(ShapedClock.hourColor)
painter.save()
painter.rotate(30.0 * ((time.hour() + time.minute() / 60.0)))
painter.drawConvexPolygon(ShapedClock.hourHand)
painter.restore()
painter.setPen(ShapedClock.hourColor)
for i in range(12):
painter.drawLine(88, 0, 96, 0)
painter.rotate(30.0)
painter.setPen(Qt.NoPen)
painter.setBrush(ShapedClock.minuteColor)
painter.save()
painter.rotate(6.0 * (time.minute() + time.second() / 60.0))
painter.drawConvexPolygon(ShapedClock.minuteHand)
painter.restore()
painter.setPen(ShapedClock.minuteColor)
for j in range(60):
if (j % 5) != 0:
painter.drawLine(92, 0, 96, 0)
painter.rotate(6.0)
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) angle_step = 360 / self.n_states painter.save() painter.translate(self.dist_center.x(), self.dist_center.y()) #painter.drawRect(- self.dist_radius, - self.dist_radius, self.dist_radius *2,self.dist_radius*2) #painter.drawEllipse(QPoint(0, 0), self.dist_radius , self.dist_radius) painter.rotate(-180) #to start painting from the left side of the circle x = self.dist_radius * math.cos(0) y = self.dist_radius * math.sin(0) for h in range(self.n_states): rot = angle_step * h painter.save() painter.rotate(rot) painter.translate(x,y) if self.machine.getState(h).isActive(): painter.setBrush(self.greenGradientBrush) painter.drawEllipse(QPoint(0,0), self.state_radius, self.state_radius) #global position of transformed coordinates gx = painter.worldTransform().map(QPoint(0,0)).x() gy = painter.worldTransform().map(QPoint(0,0)).y() self.machine.getState(h).setPos(gx, gy) # text transformation painter.save() painter.rotate(180) painter.rotate(-rot) font = painter.font(); font.setPixelSize(self.state_radius*.4); painter.setFont(font); rect = QRect(-self.state_radius, -self.state_radius, self.state_radius*2, self.state_radius*2) painter.drawText(rect, Qt.AlignCenter, self.machine.getState(h).getName()); painter.restore() #end text transformation painter.restore() painter.restore() #drawing transitions. painter.save() pptv = QTransform() pptv.translate(0, self.height()) pptv.rotate(-180, Qt.XAxis) painter.setTransform(pptv) s = self.machine.getStates() for j in s: t = j.getTransitions() for i in t: #get the points in the canvas init = QPoint(j.getPos()[0], j.getPos()[1]) end = QPoint(self.machine.getState(i.getStateEnd()).getPos()[0], self.machine.getState(i.getStateEnd()).getPos()[1]) # get the transformed ponts init2 = QPoint(painter.worldTransform().map(init)) end2 = QPoint(painter.worldTransform().map(end)) #get the angle between states centers angle = math.atan2(end2.y() - init2.y(), end2.x() - init2.x()) #get the coordinates of the starting point of the transition (it starts in the bound, not in the center) newX = self.state_radius * math.cos(angle) + init2.x() newY = self.state_radius * math.sin(angle) + init2.y() init2.setX(newX) init2.setY(newY) #same for the end of the transition angle2 = math.atan2(init2.y() - end2.y(), init2.x() - end2.x()) newX2 = self.state_radius * math.cos(angle2) + end2.x() newY2 = self.state_radius * math.sin(angle2) + end2.y() end2.setX(newX2) end2.setY(newY2) #painter.drawLine(init, end) painter.drawLine(init2, end2) init = QPoint(painter.worldTransform().map(init2)) end = QPoint(painter.worldTransform().map(end2)) i.setOrig(init.x(), init.y()) i.setDest(end.x(), end.y()) i.setAngle(angle) #painter.draw painter.restore() painter.setPen(QPen(QColor(Qt.gray), 3)) for i in machine.getStates(): for j in i.getTransitions(): i = QPoint(j.getOrig()[0], j.getOrig()[1]) o = QPoint(j.getDest()[0], j.getDest()[1]) painter.drawPolyline(i, o) painter.save() painter.setPen(QPen(QColor(Qt.gray), 2)) painter.translate(j.getDest()[0],j.getDest()[1]) painter.rotate(90 - j.getAngle()*180/math.pi) a = QPoint(0,0) b = QPoint(-5,10) c = QPoint(5,10) a1 = painter.worldTransform().map(a) b1 = painter.worldTransform().map(b) c1 = painter.worldTransform().map(c) pointer = QPolygon([a,b,c]) painter.drawPolygon(pointer) painter.restore() painter.save() if j.isActive(): t = self.machine.getTransition(self.t_active) init = QPoint(t.getOrig()[0], t.getOrig()[1]) end = QPoint(t.getDest()[0], t.getDest()[1]) painter.setPen(QPen(QColor(Qt.green), 3)) painter.drawPolyline(init, end) painter.setPen(QPen(QColor(Qt.gray), 3)) painter.drawPolyline(self.poly(self.pts)) painter.setBrush(QBrush(QColor(255, 0, 0))) painter.setPen(QPen(QColor(Qt.red), 2)) pointer = QPolygon([a1,b1,c1]) painter.drawPolygon(pointer) painter.setBrush(QBrush(QColor(255, 0, 0))) painter.setPen(QPen(QColor(Qt.black), 1)) painter.restore() #Ball that follows the line #for x, y in self.pts: #painter.drawEllipse(QRectF(x - 4, y - 4, 8, 8)) painter.save() pptv = QTransform() painter.setPen(QPen(QColor(Qt.black), 3)) middleX = (j.getOrig()[0] + j.getDest()[0]) /2 middleY = (j.getOrig()[1] + j.getDest()[1]) /2 pptv.translate(middleX, middleY) #pptv.rotate(-j.getAngle()*180/math.pi) painter.setTransform(pptv) font = painter.font(); font.setPixelSize(self.state_radius*.3); painter.setFont(font); rect = QRect(-self.state_radius, -self.state_radius, self.state_radius*2, self.state_radius*2) name = str(j.getId())+ '. ' + j.getName() painter.drawText(rect, Qt.AlignCenter, name) painter.restore() painter.setPen(self.palette().dark().color()) painter.setBrush(Qt.NoBrush) painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
def renderMapToImage(self):
if (not self.mMapDocument):
self.mMapImage = QImage()
return
renderer = self.mMapDocument.renderer()
r = self.contentsRect()
mapSize = renderer.mapSize()
if (mapSize.isEmpty()):
self.mMapImage = QImage()
return
margins = self.mMapDocument.map().computeLayerOffsetMargins()
mapSize.setWidth(mapSize.width() + margins.left() + margins.right())
mapSize.setHeight(mapSize.height() + margins.top() + margins.bottom())
# Determine the largest possible scale
scale = min( r.width() / mapSize.width(), r.height() / mapSize.height())
# Allocate a new image when the size changed
imageSize = mapSize * scale
if (self.mMapImage.size() != imageSize):
self.mMapImage = QImage(imageSize, QImage.Format_ARGB32_Premultiplied)
self.updateImageRect()
if (imageSize.isEmpty()):
return
drawObjects = bool(self.mRenderFlags & MiniMapRenderFlag.DrawObjects)
drawTiles = bool(self.mRenderFlags & MiniMapRenderFlag.DrawTiles)
drawImages = bool(self.mRenderFlags & MiniMapRenderFlag.DrawImages)
drawTileGrid = bool(self.mRenderFlags & MiniMapRenderFlag.DrawGrid)
visibleLayersOnly = bool(self.mRenderFlags & MiniMapRenderFlag.IgnoreInvisibleLayer)
# Remember the current render flags
renderFlags = renderer.flags()
renderer.setFlag(RenderFlag.ShowTileObjectOutlines, False)
self.mMapImage.fill(Qt.transparent)
painter = QPainter(self.mMapImage)
painter.setRenderHints(QPainter.SmoothPixmapTransform)
painter.setTransform(QTransform.fromScale(scale, scale))
painter.translate(margins.left(), margins.top())
renderer.setPainterScale(scale)
for layer in self.mMapDocument.map().layers():
if (visibleLayersOnly and not layer.isVisible()):
continue
painter.setOpacity(layer.opacity())
painter.translate(layer.offset())
tileLayer = layer
objGroup = layer
imageLayer = layer
tp = type(layer)
if (tp==TileLayer and drawTiles):
renderer.drawTileLayer(painter, tileLayer)
elif (tp==ObjectGroup and drawObjects):
objects = objGroup.objects()
if (objGroup.drawOrder() == ObjectGroup.DrawOrder.TopDownOrder):
objects = QList(sorted(objects, key=lambda x:x.y(), reverse=True))
for object in objects:
if (object.isVisible()):
if (object.rotation() != 0.0):
origin = renderer.pixelToScreenCoords_(object.position())
painter.save()
painter.translate(origin)
painter.rotate(object.rotation())
painter.translate(-origin)
color = MapObjectItem.objectColor(object)
renderer.drawMapObject(painter, object, color)
if (object.rotation() != 0.0):
painter.restore()
elif (tp==ImageLayer and drawImages):
renderer.drawImageLayer(painter, imageLayer)
painter.translate(-layer.offset())
if (drawTileGrid):
prefs = preferences.Preferences.instance()
renderer.drawGrid(painter, QRectF(QPointF(), renderer.mapSize()),
prefs.gridColor())
painter.end()
renderer.setFlags(renderFlags)
def paintEvent(self, _event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
width = self.width()
height = self.height()
if self.dynamic_resize:
knob_radius = self.dynamic_knob_radius
else:
knob_radius = self.knob_radius
# ensure that the center point is in the middle of a pixel to ensure
# that exact vertial and horizantal ticks are drawn exactly 1px wide
x = math.floor(width / 2.0) + 0.5
y = math.floor(height / 2.0) + 0.5
if DEBUG:
painter.fillRect(0, 0, width, height, Qt.yellow)
painter.translate(x, y)
if self.knob_style == KnobWidget.STYLE_NEEDLE:
r = min(x, y) - 1
painter.setPen(Qt.white)
painter.setBrush(Qt.white)
painter.drawEllipse(QPoint(0, 0), r, r)
angle = self.value_factor * self.total_angle - (self.total_angle / 2.0)
# draw base knob or needle spike
if self.knob_style == KnobWidget.STYLE_ROUND:
painter.setPen(self.border_color)
if self.pressed:
gradient = QRadialGradient(0, 0, knob_radius)
gradient.setColorAt(0, self.base_color_pressed)
gradient.setColorAt(0.85, self.base_color)
gradient.setColorAt(1, self.base_color)
painter.setBrush(gradient)
else:
painter.setBrush(self.base_color)
painter.drawEllipse(QPoint(0, 0), knob_radius, knob_radius)
elif self.knob_style == KnobWidget.STYLE_NEEDLE:
painter.save()
painter.rotate(angle)
painter.setPen(self.needle_color)
painter.setBrush(self.needle_color)
needle = QPolygonF()
needle.append(QPointF(self.needle_base_radius * 0.6, 0))
needle.append(QPointF(0, -knob_radius))
needle.append(QPointF(-self.needle_base_radius * 0.6, 0))
painter.drawPolygon(needle)
painter.restore()
# draw knob mark or needle base
if self.knob_style == KnobWidget.STYLE_ROUND:
painter.save()
painter.rotate(angle)
painter.setPen(QPen(self.mark_color, 2))
painter.drawLine(0, -knob_radius * 0.4, 0, -knob_radius * 0.8)
painter.restore()
elif self.knob_style == KnobWidget.STYLE_NEEDLE:
painter.setPen(self.border_color)
painter.setBrush(self.base_color)
painter.drawEllipse(QPoint(0, 0), self.needle_base_radius, self.needle_base_radius)
if self.scale_visible:
painter.setPen(Qt.black)
# draw scale arc
if self.scale_arc_visible:
painter.drawArc(-knob_radius - self.knob_to_scale,
-knob_radius - self.knob_to_scale,
knob_radius * 2 + self.knob_to_scale * 2,
knob_radius * 2 + self.knob_to_scale * 2,
(90 + self.total_angle / 2) * 16, -self.total_angle * 16)
# draw scale ticks
def value_to_angle(value):
return (float(value - self.minimum_value) / self.value_range) * self.total_angle - (self.total_angle / 2.0)
value = self.minimum_value
while value <= self.maximum_value:
angle = value_to_angle(value)
painter.save()
painter.rotate(value_to_angle(value))
painter.drawLine(0, -knob_radius - self.knob_to_scale,
0, -knob_radius - self.knob_to_scale - self.tick_size_large)
if self.scale_text_visible:
p = painter.worldTransform().map(QPoint(0, -knob_radius - \
self.knob_to_scale - \
self.tick_size_large - \
self.tick_to_text - \
self.text_radius))
painter.restore()
if self.scale_text_visible:
if DEBUG:
painter.save()
painter.setPen(QColor(255, 0, 0, 50))
painter.setBrush(QColor(255, 0, 0, 50))
painter.drawEllipse(QPoint(p.x() - x, p.y() - y),
self.text_radius, self.text_radius)
painter.restore()
painter.drawText(p.x() - x - 30, p.y() - y - 30, 60, 60,
Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignVCenter,
str(value))
for i in range(1, self.scale_step_divisions):
sub_value = value + (float(self.scale_step_size) * i) / self.scale_step_divisions
if sub_value > self.maximum_value:
break
painter.save()
painter.rotate(value_to_angle(sub_value))
painter.drawLine(0, -knob_radius - self.knob_to_scale,
0, -knob_radius - self.knob_to_scale - self.tick_size_small)
painter.restore()
value += self.scale_step_size
if self.title_text != None:
painter.drawText(-knob_radius, knob_radius - 30,
knob_radius * 2, 60,
Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignVCenter,
self.title_text)
class Renderer:
def __init__(self, width, height, ownWindow=False):
self.width = width
self.height = height
self.img = QImage(width, height, QImage.Format_RGB888)
self.painter = QPainter()
self.window = None
if ownWindow:
self.app = QApplication([])
self.window = Window()
def close(self):
"""
Deallocate resources used
"""
pass
def beginFrame(self):
self.painter.begin(self.img)
self.painter.setRenderHint(QPainter.Antialiasing, False)
# Clear the background
self.painter.setBrush(QColor(0, 0, 0))
self.painter.drawRect(0, 0, self.width - 1, self.height - 1)
def endFrame(self):
self.painter.end()
if self.window:
if self.window.closed:
self.window = None
else:
self.window.setPixmap(self.getPixmap())
self.app.processEvents()
def getPixmap(self):
return QPixmap.fromImage(self.img)
def getArray(self):
"""
Get a numpy array of RGB pixel values.
The size argument should be (3,w,h)
"""
width = self.width
height = self.height
shape = (width, height, 3)
numBytes = self.width * self.height * 3
buf = self.img.bits().asstring(numBytes)
output = np.frombuffer(buf, dtype='uint8')
output = output.reshape(shape)
return output
def push(self):
self.painter.save()
def pop(self):
self.painter.restore()
def rotate(self, degrees):
self.painter.rotate(degrees)
def translate(self, x, y):
self.painter.translate(x, y)
def scale(self, x, y):
self.painter.scale(x, y)
def setLineColor(self, r, g, b, a=255):
self.painter.setPen(QColor(r, g, b, a))
def setColor(self, r, g, b, a=255):
self.painter.setBrush(QColor(r, g, b, a))
def setLineWidth(self, width):
pen = self.painter.pen()
pen.setWidthF(width)
self.painter.setPen(pen)
def drawLine(self, x0, y0, x1, y1):
self.painter.drawLine(x0, y0, x1, y1)
def drawCircle(self, x, y, r):
center = QPoint(x, y)
self.painter.drawEllipse(center, r, r)
def drawPolygon(self, points):
"""Takes a list of points (tuples) as input"""
points = map(lambda p: QPoint(p[0], p[1]), points)
self.painter.drawPolygon(QPolygon(points))
def fillRect(self, x, y, width, height, r, g, b, a=255):
self.painter.fillRect(QRect(x, y, width, height), QColor(r, g, b, a))
def exportGeorefRaster(self, layer, rasterPath, isPutRotationInWorldFile):
rasterFormat = rasterPath[-3:]
try:
originalWidth = layer.image.width()
originalHeight = layer.image.height()
radRotation = layer.rotation * math.pi / 180
if isPutRotationInWorldFile:
# keep the image as is and put all transformation params
# in world file
img = layer.image
a = layer.xScale * math.cos(radRotation)
# sin instead of -sin because angle in CW
b = -layer.yScale * math.sin(radRotation)
d = layer.xScale * -math.sin(radRotation)
e = -layer.yScale * math.cos(radRotation)
c = layer.center.x() - (a * (originalWidth - 1) / 2 +
b * (originalHeight - 1) / 2)
f = layer.center.y() - (d * (originalWidth - 1) / 2 +
e * (originalHeight - 1) / 2)
else:
# transform the image with rotation and scaling between the
# axes
# maintain at least the original resolution of the raster
ratio = layer.xScale / layer.yScale
if ratio > 1:
# increase x
scaleX = ratio
scaleY = 1
else:
# increase y
scaleX = 1
scaleY = 1. / ratio
width = (abs(scaleX * originalWidth * math.cos(radRotation)) +
abs(scaleY * originalHeight * math.sin(radRotation)))
height = (abs(scaleX * originalWidth * math.sin(radRotation)) +
abs(scaleY * originalHeight * math.cos(radRotation)))
qDebug("wh %f,%f" % (width, height))
img = QImage(QSize(math.ceil(width), math.ceil(height)),
QImage.Format_ARGB32)
# transparent background
img.fill(QColor(0, 0, 0, 0))
painter = QPainter(img)
painter.setRenderHint(QPainter.Antialiasing, True)
rect = QRectF(QPointF(-layer.image.width() / 2.0,
-layer.image.height() / 2.0),
QPointF(layer.image.width() / 2.0,
layer.image.height() / 2.0))
painter.translate(QPointF(width / 2.0, height / 2.0))
painter.rotate(layer.rotation)
painter.scale(scaleX, scaleY)
painter.drawImage(rect, layer.image)
painter.end()
extent = layer.extent()
a = extent.width() / width
e = -extent.height() / height
# 2nd term because (0,0) of world file is on center of upper
# left pixel instead of upper left corner of that pixel
c = extent.xMinimum() + a / 2
f = extent.yMaximum() + e / 2
b = d = 0.0
img.save(rasterPath, rasterFormat)
worldFilePath = rasterPath[:-3]
if rasterFormat == "jpg":
worldFilePath += "jgw"
elif rasterFormat == "png":
worldFilePath += "pgw"
elif rasterFormat == "bmp":
worldFilePath += "bpw"
elif rasterFormat == "tif":
worldFilePath += "tfw"
with open(worldFilePath, "w") as writer:
writer.write("%.13f\n%.13f\n%.13f\n%.13f\n%.13f\n%.13f" %
(a, b, d, e, c, f))
crsFilePath = rasterPath + ".aux.xml"
with open(crsFilePath, "w") as writer:
writer.write(self.auxContent(
self.iface.mapCanvas().mapSettings().destinationCrs()))
widget = QgsMessageBar.createMessage(
"Raster Geoferencer", "Raster exported successfully.")
self.iface.messageBar().pushWidget(widget, Qgis.Info, 2)
except Exception as ex:
QgsMessageLog.logMessage(repr(ex))
widget = QgsMessageBar.createMessage(
"Raster Geoferencer",
"There was an error performing this command. "
"See QGIS Message log for details.")
self.iface.messageBar().pushWidget(
widget, Qgis.Critical, 5)
def paintEvent(self, event): painter = QPainter(self) painter.setPen(self.pen) painter.setBrush(self.brush) if self.antialiased: painter.setRenderHint(QPainter.Antialiasing) angle_step = 360 / self.n_states painter.save() #Save_1. Save the state of the system (push matrix) painter.translate(self.dist_center.x(), self.dist_center.y()) # go to the center of the render area painter.rotate(-180) #to start painting from the left side of the circle (clockwise) #center of the circumference where through we are going to paint our states x = self.dist_radius * math.cos(0) y = self.dist_radius * math.sin(0) for h in range(self.n_states): rot = angle_step * h # each state is equidistant from the others. We paint them in circles painter.save() #Save_2 painter.rotate(rot) #now our system is pointing to the next state to be drawn painter.translate(x,y) #now our origin is in the center of the next state to be drawn #if the state is active, fill it green if self.machine.getState(h).isActive(): painter.setBrush(self.greenGradientBrush) painter.drawEllipse(QPoint(0,0), self.state_radius, self.state_radius) #draw the new state #global position of transformed coordinates (before any transformation, origin at top-left corner) gx = painter.worldTransform().map(QPoint(0,0)).x() gy = painter.worldTransform().map(QPoint(0,0)).y() self.machine.getState(h).setPos(gx, gy) #store the center of the state without any transformation applied # text transformation. Our origin is still in the center of the current state painter.save() #Save_3 painter.rotate(180) #making the text go vertical painter.rotate(-rot) #undoing the rotation made for painting the state. No the text is horizontal font = painter.font(); font.setPixelSize(self.state_radius*.4); painter.setFont(font); rect = QRect(-self.state_radius, -self.state_radius, self.state_radius*2, self.state_radius*2) painter.drawText(rect, Qt.AlignCenter, self.machine.getState(h).getName()); painter.restore() #Restore_3 #end text transformation painter.restore() #Restore_2 painter.restore() #Restore_1. Restore the state of the system (pop matrix) #drawing transitions. Line between states painter.save() # Save_4 pptv = QTransform() #Define a new transformation. Needed to rotate the system along other axis than Z pptv.translate(0, self.height()) #We are now at the bottom-left corner of the screen pptv.rotate(-180, Qt.XAxis) #Rotate along the X-axis so now we are in a typical cartesian system. painter.setTransform(pptv) #Apply the transformation states = self.machine.getStates() for state in states: transitions = state.getTransitions() for transition in transitions: #get the center of the origin and destination states in our current system state orig = QPoint(state.getPos()[0], state.getPos()[1]) end = QPoint(self.machine.getState(transition.getStateEnd()).getPos()[0], self.machine.getState(transition.getStateEnd()).getPos()[1]) # get those coordinates without transformation orig2 = QPoint(painter.worldTransform().map(orig)) end2 = QPoint(painter.worldTransform().map(end)) #get the angle between states centers and the horizon angle = math.atan2(end2.y() - orig2.y(), end2.x() - orig2.x()) #get the coordinates of the starting point of the transition (it starts in the bound of the state, not in the center) newX = self.state_radius * math.cos(angle) + orig2.x() newY = self.state_radius * math.sin(angle) + orig2.y() #now the transition starts at the border, not in the center orig2.setX(newX) orig2.setY(newY) #same for the destination state angle2 = math.atan2(orig2.y() - end2.y(), orig2.x() - end2.x()) newX2 = self.state_radius * math.cos(angle2) + end2.x() newY2 = self.state_radius * math.sin(angle2) + end2.y() end2.setX(newX2) end2.setY(newY2) #draw the line between the origin and destination states painter.drawLine(orig2, end2) #get the start and the end of the transition untransformed init = QPoint(painter.worldTransform().map(orig2)) end = QPoint(painter.worldTransform().map(end2)) #store that info transition.setOrig(init.x(), init.y()) transition.setDest(end.x(), end.y()) transition.setAngle(angle) painter.restore() #Restore_4 #Appliying style to the transitions painter.setPen(QPen(QColor(Qt.gray), 3)) for state in self.machine.getStates(): for transition in state.getTransitions(): #get the start and end coordinates of the transition i = QPoint(transition.getOrig()[0], transition.getOrig()[1]) o = QPoint(transition.getDest()[0], transition.getDest()[1]) painter.drawPolyline(i, o) #Drawing the arrow at the end of the transition painter.save() #Save_5 painter.setPen(QPen(QColor(Qt.gray), 2)) painter.translate(transition.getDest()[0],transition.getDest()[1]) #Go to the end of the transition painter.rotate(90 - transition.getAngle()*180/math.pi) #Rotate to point in the direction of the transition #coordinates of the arrow (triangle) a = QPoint(0,0) b = QPoint(-5,10) c = QPoint(5,10) #coordinates of the arrow untransformed a1 = painter.worldTransform().map(a) b1 = painter.worldTransform().map(b) c1 = painter.worldTransform().map(c) #Drawin the actual arrow pointer = QPolygon([a,b,c]) painter.drawPolygon(pointer) painter.restore() #Restore_5 #For the animation of the transition painter.save() #Save_6 if transition.isActive(): #if the current transition is the active one the wave function will be running, so it's updating the canvas painter.setPen(QPen(QColor(Qt.green), 3)) painter.drawPolyline(i,o) painter.setPen(QPen(QColor(Qt.gray), 3)) painter.drawPolyline(self.poly(self.pts)) #Draw the arrow in the active state (red arrow) painter.setBrush(QBrush(QColor(255, 0, 0))) painter.setPen(QPen(QColor(Qt.red), 2)) pointer = QPolygon([a1,b1,c1]) painter.drawPolygon(pointer) #Ball that follows the line animation for x, y in self.pts: painter.drawEllipse(QRectF(self.pts[0][0] - 4, self.pts[0][1] - 4, 8, 8)) painter.restore() #Restore_6 #Painting the text of the transition painter.save() #Save_7 pptv = QTransform() painter.setPen(QPen(QColor(Qt.black), 3)) #get the middle point of the transition middleX = (transition.getOrig()[0] + transition.getDest()[0]) /2 middleY = (transition.getOrig()[1] + transition.getDest()[1]) /2 pptv.translate(middleX, middleY) #translate to that point painter.setTransform(pptv) #apply the transformation font = painter.font(); font.setPixelSize(self.state_radius*.2); painter.setFont(font); rect = QRect(-self.state_radius, -self.state_radius, self.state_radius*2, self.state_radius*2) name = str(transition.getId())+ '. ' + transition.getName() painter.drawText(rect, Qt.AlignCenter, name) painter.restore() #Restore_7 #paint the actual canvas painter.setPen(self.palette().dark().color()) painter.setBrush(Qt.NoBrush) painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
