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