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):
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 drawBackground(self, painter: QtGui.QPainter, rect: QtCore.QRectF):
painter.setRenderHint(QtGui.QPainter.Antialiasing, True)
painter.resetTransform()
painter.fillRect(0, 0,
self.size().width(),
self.size().height(), QtGui.QColor('darkGray'))
global_transform = QtGui.QTransform()
global_transform.translate(self.offsetX, self.offsetY)
painter.setTransform(global_transform, False)
# Draw tile layer
tile_layer = self.map.get_tile_layer()
if tile_layer and tile_layer.visible:
self.draw_tiles(tile_layer.data, painter, global_transform)
# painter.scale(self.sc, self.sc)
# Draw layer w/ objects
for layer in self.map.get_object_layers(only_visible=True):
self.draw_objects(layer.get_objects(), painter)
painter.resetTransform()
painter.setPen(QtGui.QColor('black'))
if self.lmbPressed:
painter.drawRect(0 + self.mouseStartX, 0 + self.mouseStartY,
self.mouseCurX - self.mouseStartX,
self.mouseCurY - self.mouseStartY)
def paintEvent(self, event):
painter = QPainter(self)
if self.layer is not None:
painter.resetTransform()
painter.drawImage(self.rect(), self.qImage)
self.drawShapes(painter)
else:
painter.eraseRect(self.rect())
def draw_cached_picture(self):
qp = QPainter()
geom = self.geometry()
qp.begin(self)
qp.resetTransform()
qp.drawPixmap((geom.width() - self.bitmap_info.width) / 2,
(geom.height() - self.bitmap_info.height) / 2,
self.pixmap_cache)
qp.end()
def draw_cached(self):
qp = QPainter()
geom = self.geometry()
qp.begin(self)
qp.resetTransform()
qp.drawPixmap(
(geom.width() - self.info.width * self.pixel_size) / 2,
(geom.height() - abs(self.info.height) * self.pixel_size) / 2,
self.pixmap_cache)
qp.end()
def qgo_draw_markers(
markers: list,
color: Color,
p: QtGui.QPainter,
left: float,
right: float,
right_offset: float,
) -> float:
"""Paint markers in ``pg.GraphicsItem`` style by first
removing the view transform for the painter, drawing the markers
in scene coords, then restoring the view coords.
"""
# paint markers in native coordinate system
orig_tr = p.transform()
start = orig_tr.map(Point(left, 0))
end = orig_tr.map(Point(right, 0))
up = orig_tr.map(Point(left, 1))
dif = end - start
# length = Point(dif).length()
angle = np.arctan2(dif.y(), dif.x()) * 180 / np.pi
p.resetTransform()
p.translate(start)
p.rotate(angle)
up = up - start
det = up.x() * dif.y() - dif.x() * up.y()
p.scale(1, 1 if det > 0 else -1)
p.setBrush(fn.mkBrush(color))
# p.setBrush(fn.mkBrush(self.currentPen.color()))
tr = p.transform()
sizes = []
for path, pos, size in markers:
p.setTransform(tr)
# XXX: we drop the "scale / %" placement
# x = length * pos
x = right_offset
p.translate(x, 0)
p.scale(size, size)
p.drawPath(path)
sizes.append(size)
p.setTransform(orig_tr)
return max(sizes)
def drawBackground(self, painter: QtGui.QPainter, rect: QtCore.QRectF):
painter.setRenderHint(QtGui.QPainter.Antialiasing, True)
painter.resetTransform()
painter.fillRect(-2000, -1000, 4000, 2000, QtGui.QColor('darkGray'))
globalTransform = QtGui.QTransform()
globalTransform.translate(self.offsetX, self.offsetY)
painter.setTransform(globalTransform, False)
for y in range(len(self.map.tiles)):
for x in range(len(self.map.tiles[y])):
painter.scale(self.sc, self.sc)
painter.translate(x * self.map.gridSize, y * self.map.gridSize)
if self.map.tiles[y][x].rotation == 90:
painter.rotate(90)
painter.translate(0, -self.map.gridSize)
elif self.map.tiles[y][x].rotation == 180:
painter.rotate(180)
painter.translate(-self.map.gridSize, -self.map.gridSize)
elif self.map.tiles[y][x].rotation == 270:
painter.rotate(270)
painter.translate(-self.map.gridSize, 0)
painter.drawImage(
QtCore.QRectF(0, 0, self.map.gridSize, self.map.gridSize),
self.tileSprites[self.map.tiles[y][x].kind])
if self.tileSelection[0] <= x < self.tileSelection[2] and self.tileSelection[1] <= y < \
self.tileSelection[3]:
painter.setPen(QtGui.QColor('green'))
painter.drawRect(
QtCore.QRectF(1, 1, self.map.gridSize - 1,
self.map.gridSize - 1))
else:
painter.setPen(QtGui.QColor('white'))
painter.drawRect(
QtCore.QRectF(0, 0, self.map.gridSize,
self.map.gridSize))
painter.setTransform(globalTransform, False)
# painter.scale(self.sc, self.sc)
if self.map.items:
for s in self.map.items:
if self.objects.__contains__(s.kind):
painter.drawImage(
QtCore.QRectF(
self.map.gridSize * self.sc * s.position['x'],
self.map.gridSize * self.sc * s.position['y'],
self.map.gridSize * self.sc / 2,
self.map.gridSize * self.sc / 2),
self.objects[s.kind])
painter.resetTransform()
painter.setPen(QtGui.QColor('black'))
if self.lmbPressed:
painter.drawRect(0 + self.mouseStartX, 0 + self.mouseStartY,
self.mouseCurX - self.mouseStartX,
self.mouseCurY - self.mouseStartY)
def paintEvent(self, event):
painter = QPainter(self)
palette = self.palette()
midColor = palette.mid().color()
highlight = palette.highlight().color()
# background
painter.fillRect(self.rect(), midColor.lighter())
# float rect
color = highlight if self.mouseHoverState == MOUSE_HOVER.HOVER_FLOAT else midColor
painter.setPen(color)
painter.setBrush(palette.light())
painter.drawRect(self.floatRect)
painter.setBrush(highlight if color == highlight else midColor)
painter.drawRect(self.floatRect.adjusted(4, 2, -2, -4))
# hsplit rect
color = highlight if self.mouseHoverState == MOUSE_HOVER.HOVER_HSPLIT else midColor
painter.setPen(color)
painter.setBrush(palette.light())
painter.drawRect(self.hSplitRect)
painter.setBrush(highlight if color == highlight else midColor)
painter.drawRect(self.hSplitRect.adjusted(2, 2, -6, -2))
# float rect
color = highlight if self.mouseHoverState == MOUSE_HOVER.HOVER_VSPLIT else midColor
painter.setPen(color)
painter.setBrush(palette.light())
painter.drawRect(self.vSplitRect)
painter.setBrush(highlight if color == highlight else midColor)
painter.drawRect(self.vSplitRect.adjusted(2, 2, -2, -6))
# float rect
color = highlight if self.mouseHoverState == MOUSE_HOVER.HOVER_CLOSE else midColor
painter.setPen(color)
painter.setBrush(palette.light())
painter.drawRect(self.closeRect)
painter.translate(self.closeRect.topLeft())
painter.setPen(QPen(color, 1.5))
painter.drawLine(QPoint(4, 4), QPoint(9, 9))
painter.drawLine(QPoint(4, 9), QPoint(9, 4))
painter.resetTransform()
def draw_filter_covariance_ellipse(painter: QPainter, x, y, cov_x, cov_y,
heading):
pen = QPen()
pen.setStyle(Qt.SolidLine)
pen.setBrush(SETTINGS["COLOR_FILTER_TRACE"])
pen.setWidth(2)
painter.setPen(pen)
painter.setBrush(Qt.white)
heading = math.degrees(heading)
painter.translate(x, y)
painter.rotate(heading)
# scaling
cov_x *= SETTINGS["COV_SCALING"]
cov_y *= SETTINGS["COV_SCALING"]
rect = QtCore.QRect(-cov_x / 2, -cov_y / 2, cov_x, cov_y)
painter.drawEllipse(rect)
painter.resetTransform()
def paint_gl(self, window_size: QSize, camera: Camera, painter: QPainter,
hover: bool) -> None:
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setPen(self.pen)
cp = (
CanvasPos(self.left, self.top),
CanvasPos(self.right, self.top),
CanvasPos(self.right, self.bottom),
CanvasPos(self.left, self.bottom),
)
ws = window_size
scale = 0.5 * camera.zoom * ws.width()
if hover:
self.pen.setWidthF(3.0 / scale)
self.pen.setColor(QColor(0x40, 0xA0, 0xFF, 0x90))
else:
self.pen.setWidthF(2.5 / scale)
self.pen.setColor(QColor(0x40, 0x90, 0xFF, 0x70))
painter.setPen(self.pen)
painter.resetTransform()
painter.translate(0.5 * ws.width(), 0.5 * ws.height())
painter.translate(-camera.center.x * scale, -camera.center.y * scale)
painter.scale(scale, scale)
x, y = cp[0].x, cp[0].y
w, h = cp[1].x - cp[0].x, cp[3].y - cp[0].y
rectangle = QtCore.QRectF(x, y, w, h)
painter.drawRect(rectangle)
outer_rect = QtCore.QRectF(x - 2, y - 2, w + 4, h + 4)
# darken everything beyond edge
outer1 = QPainterPath()
outer1.addRect(outer_rect)
outer1.addRect(rectangle)
if hover:
painter.fillPath(outer1, QColor(0x20, 0x40, 0x80, 0x50))
else:
painter.fillPath(outer1, QColor(0x20, 0x40, 0x80, 0x90))
def paintEvent(self, event):
p = QPainter(self)
r: QRect = event.rect()
for i in self.texEnums:
p.resetTransform()
if isinstance(i, BaseBlock):
p.translate(r.width() / 2, r.height() / 2)
if i.direction == 90 or i.direction == 270:
r.setRect(0, 0, r.height(), r.width())
p.rotate(i.direction)
p.translate(-r.width() / 2, -r.height() / 2)
p.drawImage(r, self.imgs[i.getDrawable()])
if i.color != EColor.none:
if not self.drawFullColor:
p.setOpacity(0.6)
p.drawImage(r, self.masks[i.color][i.getDrawable()])
p.setOpacity(1)
else:
p.drawImage(r, self.masks[i.color][i.getDrawable()])
else:
p.drawImage(r, self.imgs[i])
def drawBackground(self, p: QPainter, rect: QRectF):
p.save()
p.resetTransform()
p.drawTiledPixmap(self.viewport().rect(),
self.backgroundBrush().texture())
p.restore()
def paintEvent(self, event):
super().paintEvent(event)
painter = QPainter()
painter.begin(self)
# background
brushBG = QBrush(Qt.black, Qt.SolidPattern)
if not common.AppSettings["ShowMask"]:
brushBG.setColor(Qt.darkGray)
brushBG.setStyle(Qt.Dense1Pattern)
painter.setBackground(Qt.gray)
else:
brushBG.setColor(Qt.black)
brushBG.setStyle(Qt.SolidPattern)
painter.setBackground(Qt.black)
painter.setBackgroundMode(Qt.OpaqueMode)
painter.setBrush(brushBG)
painter.setPen(Qt.NoPen)
painter.drawRect(0, 0, self.width(), self.height())
# draw photo
if not self.myPhoto.isNull():
# rotate and draw photo as specified by user
transform = QTransform()
transform.translate(self.myPhotoDestRect.center().x(), self.myPhotoDestRect.center().y())
transform.rotate(-self.myPhotoRotation)
transform.translate(-self.myPhotoDestRect.center().x(), -self.myPhotoDestRect.center().y())
painter.setTransform(transform)
painter.drawImage(self.myPhotoDestRect, self.myPhoto, self.myPhotoSrcRect) # draw it
painter.resetTransform()
# useful local vars
centerPoint = QPoint(self.viewCenter[0], self.viewCenter[1])
destRect = QRect(0, 0, self.myPhotoDestRect.width(), self.myPhotoDestRect.height())
fontWidth = self.fontMetrics.width("X")
# mask
if common.AppSettings["ShowMask"]:
maskPainter = QPainter()
maskPainter.begin(self.mask)
maskPainter.setBrush(QBrush(Qt.magenta, Qt.SolidPattern))
maskPainter.drawEllipse(self.viewCenter[0] - self.myPhotoRadius, self.viewCenter[1] - self.myPhotoRadius, self.myPhotoDiameter, self.myPhotoDiameter)
maskPainter.end()
painter.setCompositionMode(QPainter.CompositionMode_DestinationIn)
painter.drawImage(0, 0, self.mask)
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
# HUD
if common.AppSettings["ShowHUD"]:
painter.setBackgroundMode(Qt.TransparentMode)
#painter.setBackground(Qt.black)
painter.setBrush(Qt.NoBrush)
painter.setFont(self.fontScaled)
# draw UV grid
if common.AppSettings["ShowUVGrid"]:
painter.setPen(self.penText)
# box
tl = self.myPhotoTopLeft
tr = (self.viewCenter[0] + self.myPhotoRadius, self.viewCenter[1] - self.myPhotoRadius)
bl = (self.viewCenter[0] - self.myPhotoRadius, self.viewCenter[1] + self.myPhotoRadius)
br = (self.viewCenter[0] + self.myPhotoRadius, self.viewCenter[1] + self.myPhotoRadius)
painter.drawLine(tl[0], tl[1], tr[0], tr[1])
painter.drawLine(bl[0], bl[1], br[0], br[1])
painter.drawLine(tl[0], tl[1], bl[0], bl[1])
painter.drawLine(tr[0], tr[1], br[0], br[1])
# crosshairs
painter.drawLine(tl[0], self.viewCenter[1], tr[0], self.viewCenter[1])
painter.drawLine(self.viewCenter[0], tr[1], self.viewCenter[0], br[1])
# labels
destRect.setCoords(tl[0] + 4, tl[1] + 4, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "0")
destRect.setCoords(tr[0] - (fontWidth+4), tr[1] + 4, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "1")
destRect.setCoords(bl[0] + 3, bl[1] - (self.fontMetrics.height()+3), self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "1")
destRect.setCoords(br[0] - (fontWidth+3), br[1] - (self.fontMetrics.height()+3), self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "1")
# grid coordinates
gpntrad = self.myPhotoRadius * 0.005
painter.setPen(self.penText)
painter.setBrush(self.brushGrid)
painter.setFont(self.fontScaled)
for i in range(0, len(self.gridpoints)):
point = self.gridpoints[i]
u, v = self.gridUVs[i]
t, p = self.gridskycoords[i]
painter.drawEllipse(QPoint(point[0], point[1]), gpntrad, gpntrad)
destRect.setCoords(point[0]+fontWidth/2, point[1]-self.fontMetrics.height(), self.width(), self.height())
textuv = "{0:.1f}u, {1:.1f}v".format(round(u,1), round(v,1))
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, textuv)
destRect.setCoords(point[0]+fontWidth/2, point[1], self.width(), self.height())
textuv = "{0:d}°, {1:d}°".format(int(round(t)), int(round(p)))
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, textuv)
painter.setBrush(Qt.NoBrush)
# draw lens warp
if common.AppSettings["ShowLensWarp"]:
# ideal lens longitudes along azimuth
painter.setPen(self.penText)
for i in range(0, int(len(self.compassTicks)/2), 3):
p1 = QPoint(self.compassTicks[i][2], self.compassTicks[i][3])
p2 = QPoint(self.compassTicks[i+18][2], self.compassTicks[i+18][3]) # tick opposite 180 degrees
painter.drawLine(p1, p2)
# ideal lens latitudes along zenith
for r, alt in self.lensIdealRadii:
painter.drawEllipse(centerPoint, r, r)
# actual/warped lens latitudes along zenith
painter.setPen(self.penLens)
for r, alt in self.lensRealRadii:
painter.drawEllipse(centerPoint, r, r)
destRect.setCoords(self.viewCenter[0] + r + 3, self.viewCenter[1] - (self.fontMetrics.height() + 3), self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "{0:d}°".format(int(alt)))
# draw compass
if common.AppSettings["ShowCompass"]:
# compass ticks text shadows
if common.AppSettings["ShowShadows"]:
painter.setPen(self.penShadowText)
for tick in self.compassTicks:
destRect.setCoords(tick[4] + 1, tick[5] + 1, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, str(tick[6])+"°")
# compass ticks text
painter.setPen(self.penText)
for tick in self.compassTicks:
painter.drawLine(tick[0], tick[1], tick[2], tick[3])
destRect.setCoords(tick[4], tick[5], self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, str(tick[6])+"°")
# photo radius
#painter.drawEllipse(self.viewCenter[0] - self.myPhotoRadius, self.viewCenter[1] - self.myPhotoRadius, self.myPhotoDiameter, self.myPhotoDiameter)
painter.drawEllipse(centerPoint, self.myPhotoRadius, self.myPhotoRadius)
# cardinal directions
destRect.setCoords(self.viewCenter[0] - self.myPhotoRadius - (fontWidth+4), self.viewCenter[1] - self.fontMetrics.height()/2, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "W")
destRect.setCoords(self.viewCenter[0] + self.myPhotoRadius + 4, self.viewCenter[1] - self.fontMetrics.height()/2, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "E")
destRect.setCoords(self.viewCenter[0] - fontWidth/2, self.viewCenter[1] - self.myPhotoRadius - (self.fontMetrics.height()+3), self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "S")
destRect.setCoords(self.viewCenter[0] - fontWidth/2, self.viewCenter[1] + self.myPhotoRadius + 3, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "N")
# draw sampling pattern
if common.AppSettings["ShowSamples"]:
painter.setPen(self.penText)
for i, points in enumerate(self.sampleAreaVisible):
painter.drawLine(QLine(points[0], points[1]))
painter.drawLine(QLine(points[1], points[2]))
painter.drawLine(QLine(points[2], points[3]))
painter.drawLine(QLine(points[3], points[0]))
for i in range(0, len(self.samplePoints)):
p = self.samplePoints[i]
painter.drawEllipse(QPoint(p[0],p[1]), ViewFisheye.SampleRadius, ViewFisheye.SampleRadius)
painter.drawText(p[0] + ViewFisheye.SampleRadius, p[1], str(i))
# draw sun path
if common.AppSettings["ShowSunPath"]:
sunradius = self.myPhotoRadius * 0.1
# shadows
painter.setPen(self.penShadowSun)
if common.AppSettings["ShowShadows"]:
painter.drawEllipse(QPoint(self.sunPositionVisible[0]+1, self.sunPositionVisible[1]+1), sunradius, sunradius)
self.pathSun.translate(1.0, 1.0)
painter.drawPath(self.pathSun)
self.pathSun.translate(-1.0, -1.0)
for i in range(0, self.pathSun.elementCount()):
e = self.pathSun.elementAt(i)
destRect.setCoords(e.x, e.y + self.fontMetrics.height()/2 + 1, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, str(self.sunPathPoints[i][2].hour))
# sun, path, hours
painter.setPen(self.penSun)
painter.drawEllipse(QPoint(self.sunPositionVisible[0], self.sunPositionVisible[1]), sunradius, sunradius)
painter.drawPath(self.pathSun)
for i in range(0, self.pathSun.elementCount()):
e = self.pathSun.elementAt(i)
destRect.setCoords(e.x, e.y + self.fontMetrics.height() / 2, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, str(self.sunPathPoints[i][2].hour))
# draw selected samples (ALWAYS)
r = QRect()
# shadows
if common.AppSettings["ShowShadows"]:
painter.setPen(self.penShadowSelected)
for i in self.samplesSelected:
x, y = self.samplePoints[i]
painter.drawEllipse(QPoint(x+1, y+1), ViewFisheye.SampleRadius, ViewFisheye.SampleRadius)
# samples
for i in self.samplesSelected:
painter.setPen(self.penSelected[i])
x, y = self.samplePoints[i]
painter.drawEllipse(QPoint(x, y), ViewFisheye.SampleRadius, ViewFisheye.SampleRadius)
# draw user's selection bounds
if (abs(self.dragSelectRect.right()-self.dragSelectRect.left()) >= ViewFisheye.SelectionRectMin and
abs(self.dragSelectRect.bottom()-self.dragSelectRect.top()) >= ViewFisheye.SelectionRectMin):
painter.setPen(self.penSelectRect)
painter.drawRect(self.dragSelectRect)
# draw timestamp
painter.setPen(self.penText)
painter.setFont(self.fontFixed)
destRect.setCoords(10, 10, self.width() / 2, 50)
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, str(self.myPhotoTime))
# draw sky cover assessment
destRect.setCoords(10, 25, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, self.skyCover.name + "/" + common.SkyCoverDesc[self.skyCover])
# draw photo rotation
if self.myPhotoRotation != 0:
destRect.setCoords(10, self.height()-25, self.width(), self.height())
painter.drawText(destRect, Qt.AlignTop | Qt.AlignLeft, "Rotation: " + str(self.myPhotoRotation) + "°")
# where is the mouse relative to the center?
# this is used as an optimization to only display information when mouse is in fisheye portion
dx = self.coordsMouse[0] - self.viewCenter[0]
dy = self.coordsMouse[1] - self.viewCenter[1]
distance = math.sqrt((dx * dx) + (dy * dy)) # distance from mouse to view center
# coordinates we are interested in
#self.coordsMouse # x,y of this widget
coordsxy = (-1, -1) # x,y over photo as scaled/rendered on this widget
coordsXY = (-1, -1) # x,y over actual original photo on disk
coordsUV = (-1, -1) # u,v coords of fisheye portion of photo w/ 0,0 top left and 1,1 bottom right
coordsTP = (-1, -1) # theta,phi polar coordinates
# text
textxy = "-1, -1 xy"
textXY = "-1, -1 xy"
textUV = "-1, -1 uv"
textTP = "-1, -1 θφ"
textPX = "0 0 0 px"
# compute all relevant information only when mouse is within fisheye portion of photo
if distance < self.myPhotoRadius:
coordsxy = (self.coordsMouse[0] - self.myPhotoDestRect.x(),
self.coordsMouse[1] - self.myPhotoDestRect.y())
coordsXY = (int(coordsxy[0] / self.myPhotoDestRect.width() * self.myPhoto.width()),
int(coordsxy[1] / self.myPhotoDestRect.height() * self.myPhoto.height()))
coordsUV = ((self.coordsMouse[0] - self.myPhotoTopLeft[0]) / self.myPhotoDiameter,
(self.coordsMouse[1] - self.myPhotoTopLeft[1]) / self.myPhotoDiameter)
coordsTP = utility_angles.FisheyeUV2SkyCoord(coordsUV[0], coordsUV[1])
# text
textxy = str(coordsxy[0]) + ", " + str(coordsxy[1]) + " xy"
textXY = str(coordsXY[0]) + ", " + str(coordsXY[1]) + " xy"
textUV = "{:.2f}".format(coordsUV[0]) + ", " + "{:.2f}".format(coordsUV[1]) + " uv"
textTP = "{:.2f}".format(coordsTP[0]) + ", " + "{:.2f}".format(coordsTP[1]) + " θφ"
# pixels colors
pixreg = common.AppSettings["PixelRegion"]
colorsRegion = np.zeros((pixreg, pixreg, 4))
colorFinal = colorsRegion[0,0] # RGBA of pixel under mouse of photo on disk
# colorFinal = self.myPhoto.pixelColor(coordsXY[0], coordsXY[1])
if distance < self.myPhotoRadius:
halfdim = int(pixreg / 2)
rstart = coordsXY[1]-halfdim
rstop = coordsXY[1]+halfdim+1
cstart = coordsXY[0]-halfdim
cstop = coordsXY[0]+halfdim+1
if (rstart >= 0 and rstop<=self.myPhotoPixels.shape[0] and
cstart >= 0 and cstop<=self.myPhotoPixels.shape[1]):
colorsRegion = self.myPhotoPixels[rstart:rstop, cstart:cstop]
colorFinal = colorsRegion[halfdim, halfdim]
if pixreg > 1: # with pixel weighting
colorFinal = utility_data.collectPixels([coordsXY], [pixreg], pixels=self.myPhotoPixels, weighting=common.PixelWeighting(common.AppSettings["PixelWeighting"]))[0]
textPX = str(colorFinal[0]) + " " + str(colorFinal[1]) + " " + str(colorFinal[2]) + " px"
# draw HUD text strings
# x,y coords
destRect.setCoords(0, 0, self.width() - 10, self.height()- 124)
painter.drawText(destRect, Qt.AlignBottom | Qt.AlignRight, textxy)
# X,Y coords
destRect.setCoords(0, 0, self.width() - 10, self.height() - 114)
painter.drawText(destRect, Qt.AlignBottom | Qt.AlignRight, textXY)
# u,v coords
destRect.setCoords(0, 0, self.width() - 10, self.height() - 104)
painter.drawText(destRect, Qt.AlignBottom | Qt.AlignRight, textUV)
# t,p coords
destRect.setCoords(0, 0, self.width() - 10, self.height() - 94)
painter.drawText(destRect, Qt.AlignBottom | Qt.AlignRight, textTP)
# pixel color
destRect.setCoords(0, 0, self.width() - 10, self.height() - 84)
painter.drawText(destRect, Qt.AlignBottom | Qt.AlignRight, textPX)
# compute pixel visualization coordinates
circleX = self.width() - 10 - ViewFisheye.SelectedPixelBox - 10 - ViewFisheye.SelectedPixelBox - 10 - ViewFisheye.SelectedPixelBox
circleY = self.height() - 10 - ViewFisheye.SelectedPixelBox
pixelsX = self.width() - 10 - ViewFisheye.SelectedPixelBox - 10 - ViewFisheye.SelectedPixelBox
pixelsY = self.height() - 10 - ViewFisheye.SelectedPixelBox
pixelsWeightedX = self.width() - ViewFisheye.SelectedPixelBox - 10
pixelsWeightedY = self.height() - 10 - ViewFisheye.SelectedPixelBox
# draw pixel visualization - fills
pixreg = common.AppSettings["PixelRegion"]
if distance < self.myPhotoRadius:
painter.setPen(Qt.NoPen)
# pixel region
pixdim = ViewFisheye.SelectedPixelBox / pixreg
for row in range(0, pixreg):
for col in range(0, pixreg):
color = colorsRegion[row, col]
color = QColor(color[0], color[1], color[2])
painter.setBrush(QBrush(color, Qt.SolidPattern))
painter.drawRect(pixelsX + (col * pixdim), pixelsY + (row * pixdim), math.ceil(pixdim), math.ceil(pixdim))
# final pixel color
color = QColor(colorFinal[0], colorFinal[1], colorFinal[2])
painter.setBrush(QBrush(color, Qt.SolidPattern))
cx = circleX + (coordsUV[0] * ViewFisheye.SelectedPixelBox)
cy = circleY + (coordsUV[1] * ViewFisheye.SelectedPixelBox)
painter.drawEllipse(cx - 5, cy - 5, 10, 10)
painter.drawRect(pixelsWeightedX, pixelsWeightedY, ViewFisheye.SelectedPixelBox, ViewFisheye.SelectedPixelBox)
# draw pixel visualization - outlines
painter.setPen(self.penText)
painter.setBrush(Qt.NoBrush)
painter.drawEllipse(circleX, circleY, ViewFisheye.SelectedPixelBox, ViewFisheye.SelectedPixelBox)
painter.drawRect(pixelsX, pixelsY, ViewFisheye.SelectedPixelBox, ViewFisheye.SelectedPixelBox)
painter.drawRect(pixelsWeightedX, pixelsWeightedY, ViewFisheye.SelectedPixelBox, ViewFisheye.SelectedPixelBox)
# raw data missing indicator
# if (not self.rawAvailable):
# painter.drawPixmap(pixelX + ViewFisheye.SelectedPixelBox / 2,
# pixelY + ViewFisheye.SelectedPixelBox / 2,
# self.iconWarning)
# end draw
painter.end()
def paintEvent(self,event): #在窗口上绘图
painter=QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.TextAntialiasing)
##生成五角星的5个顶点的,假设原点在五角星中心
R=100.0 #半径
Pi=3.14159 #常数
deg=Pi*72.0/180
points=[QPoint(R,0),
QPoint(R*math.cos(deg), -R*math.sin(deg)),
QPoint(R*math.cos(2*deg), -R*math.sin(2*deg)),
QPoint(R*math.cos(3*deg), -R*math.sin(3*deg)),
QPoint(R*math.cos(4*deg), -R*math.sin(4*deg)) ] #元组数据
font=painter.font()
font.setPointSize(14)
font.setBold(False)
painter.setFont(font)
#设置画笔
pen=QPen()
pen.setWidth(2) #线宽
pen.setColor(Qt.blue) #划线颜色
pen.setStyle(Qt.SolidLine) #线的类型，实线、虚线等
pen.setCapStyle(Qt.FlatCap) #线端点样式
pen.setJoinStyle(Qt.BevelJoin) #线的连接点样式
painter.setPen(pen)
##设置画刷
brush=QBrush()
brush.setColor(Qt.yellow) #画刷颜色
brush.setStyle(Qt.SolidPattern) #填充样式
painter.setBrush(brush)
##设计绘制五角星的PainterPath，以便重复使用
starPath=QPainterPath()
starPath.moveTo(points[0])
starPath.lineTo(points[2])
starPath.lineTo(points[4])
starPath.lineTo(points[1])
starPath.lineTo(points[3])
starPath.closeSubpath() #闭合路径，最后一个点与第一个点相连
starPath.addText(points[0],font,"0") #显示端点编号
starPath.addText(points[1],font,"1")
starPath.addText(points[2],font,"2")
starPath.addText(points[3],font,"3")
starPath.addText(points[4],font,"4")
##绘图
painter.save() #保存坐标状态
painter.translate(100,120)
painter.drawPath(starPath) #画星星
painter.drawText(0,0,"S1")
painter.restore() #恢复坐标状态
painter.translate(300,120) #平移
painter.scale(0.8,0.8) #缩放
painter.rotate(90) #顺时针旋转
painter.drawPath(starPath) #画星星
painter.drawText(0,0,"S2")
painter.resetTransform() #复位所有坐标变换
painter.translate(500,120) #平移
painter.rotate(-145) #逆时针旋转
painter.drawPath(starPath) #画星星
painter.drawText(0,0,"S3")
def paint(self, p: QPainter):
# hack
old = self
self = self.parent
blockSize = self._blocksize()
width = Ruler.Width
xx = int(self.viewOrigin[0] / blockSize) * blockSize
yy = int(self.viewOrigin[1] / blockSize) * blockSize
sx, sy = self.deltaxy()
smallstep = blockSize if blockSize > width * 5 else width * 5 // blockSize * blockSize + blockSize
optX = QtCore.Qt.AlignmentFlag.AlignVCenter | QtCore.Qt.AlignmentFlag.AlignLeft
optY = QtCore.Qt.AlignmentFlag.AlignVCenter | QtCore.Qt.AlignmentFlag.AlignRight
p.save()
p.setPen(Ruler.BorderPen)
p.setFont(QtGui.QFontDatabase.systemFont(QtGui.QFontDatabase.SystemFont.FixedFont))
p.fillRect(0, 0, width, self.height(), Ruler.Background)
for y in range(0, self.height() + blockSize, blockSize):
old._drawGrid(sx, y + sy, blockSize, p)
iy = int((y - yy) / blockSize)
iy == old.currentXY[1] and p.fillRect(0, y + sy, width, blockSize, Ruler.Cursor)
iy in old.hlines and old._drawLine(width, y + sy, True, blockSize, p)
if (y - yy) % smallstep != 0:
p.drawLine(0, y + sy, width / 4, y + sy)
continue
y = y + sy
p.drawLine(0, y, width, y)
p.translate(0, y + smallstep)
p.rotate(-90)
p.drawText(QtCore.QRect(0, 0, smallstep - 1, width), optY, str(iy))
p.resetTransform()
p.drawLine(width, 0, width, self.height())
p.fillRect(0, 0, self.width(), width, Ruler.Background)
for x in range(0, self.width() + blockSize, blockSize):
# old._drawGrid(sx + x, sy, False, blockSize, p)
# x + sx: on-canvas x coord
if x + sx < width:
continue
ix = int((x - xx) / blockSize)
ix == old.currentXY[0] and p.fillRect(x + sx, 0, blockSize, width, Ruler.Cursor)
ix in old.vlines and old._drawLine(x + sx, width, False, blockSize, p)
if (x - xx) % smallstep != 0:
p.drawLine(x + sx, 0, x + sx, width / 4)
continue
x = x + sx
p.drawLine(x, 0, x, width)
p.drawText(QtCore.QRect(x + 1, 0, smallstep, width), optX, str(ix))
p.drawLine(width, width, self.width(), width)
p.drawLine(width, 0, width, width)
p.drawLine(0, width, width, width)
p.fillRect(0, 0, width, width, Ruler.Corner)
p.drawRect(0, 0, self.width() - 1, self.height() - 1)
p.restore()
class DrawingWidget(QWidget):
def __init__(self, scale=10, a=1.0, b=1.0, c=0.0, d=1.0):
super().__init__()
self.a, self.b, self.c, self.d = a, b, c, d
self.scale_x, self.scale_y = scale, 0
self.width, self.height = 0, 0
self.dx, self.dy = 0, 0
self.mouse_click_x = -1
self.mouse_click_y = -1
self.qp = QPainter()
self.initUI()
def initUI(self):
self.setGeometry(150, 150, 900, 900)
# self.timer = QBasicTimer()
# self.timer.start(15, self)
self.setWindowTitle('Drawing')
self.show()
def paintEvent(self, event):
self.qp.setPen(Qt.black)
self.qp.begin(self)
self.draw()
self.qp.end()
def resizeEvent(self, event):
new_width = event.size().width()
new_height = event.size().height()
self.width = new_width
self.height = new_height
self.scale_y = self.scale_x # new_width * 6 / new_height
def draw(self):
# self.draw_parabola()
# self.draw_parabola_dists()
self.draw_parabola_deltas()
self.draw_axes()
def draw_axes(self):
a_, b_, c_, d_ = self.a, self.b, self.c, self.d
if a_ < 0:
self.qp.scale(-1.0, 1.0)
a_ = -a_
c_ = -c_
dx = self.get_screen_x(0) - self.get_screen_x(c_)
dy = self.get_screen_y(d_ - b_) - self.get_screen_y(0)
self.qp.setPen(Qt.black)
self.qp.translate(dx, dy)
self.qp.drawLine(-self.width / 2 - dx, 0, self.width / 2 - dx, 0)
self.qp.drawLine(0, -self.height / 2 - dy, 0, self.height / 2 - dy)
def draw_parabola_dists(self):
self.qp.setPen(Qt.darkBlue)
self.qp.resetTransform()
self.qp.translate(self.width / 2, self.height / 2)
self.qp.scale(1.0, -1.0)
a_, c_ = self.a, self.c
if a_ == 0:
self.qp.drawLine(c_, self.height, c_, -self.height)
return
elif a_ < 0:
self.qp.scale(-1.0, 1.0)
a_ = -a_
bound = self.width
f = self.get_screen_x(1 / (4 * a_)) - self.get_screen_x(0)
x, y = 0, 0
self.qp.drawPoint(x, y)
while x <= bound:
d1 = (f - x)**2 + (-(y + 1))**2 - (-f - x)**2
min_d = abs(d1)
n_x, n_y = x, y + 1
d2 = (f - (x + 1))**2 + (-(y + 1))**2 - (-f - (x + 1))**2
if abs(d2) < min_d:
n_x, n_y = x + 1, y + 1
min_d = abs(d2)
d3 = (f - (x + 1))**2 + (-y)**2 - (-f - (x + 1))**2
if abs(d3) < min_d:
n_x, n_y = x + 1, y
self.qp.drawPoint(n_x, n_y)
self.qp.drawPoint(n_x, -n_y)
x, y = n_x, n_y
def draw_parabola_deltas(self):
self.qp.setPen(Qt.red)
self.qp.resetTransform()
self.qp.translate(self.width / 2, self.height / 2)
self.qp.scale(1.0, -1.0)
a_, c_ = self.a, self.c
if a_ == 0:
self.qp.drawLine(c_, self.height, c_, -self.height)
return
elif a_ < 0:
self.qp.scale(-1.0, 1.0)
a_ = -a_
bound = self.width
p = self.get_screen_x(1 / (2 * a_)) - self.get_screen_x(0)
x, y = 0, 0
self.qp.drawPoint(x, y)
p2 = 2 * p
while x <= bound:
delta = (y + 1) * (y + 1) - p2 * (x + 1)
if delta < 0:
other = delta + p2
if abs(delta) < abs(other):
x, y = x + 1, y + 1
else:
x, y = x, y + 1
else:
other = delta - 2 * y - 1
if abs(delta) < abs(other):
x, y = x + 1, y + 1
else:
x, y = x + 1, y
self.qp.drawPoint(x, y)
self.qp.drawPoint(x, -y)
def draw_parabola(self):
self.qp.setPen(Qt.black)
self.qp.resetTransform()
self.qp.translate(self.width / 2, self.height / 2)
self.qp.scale(1.0, -1.0)
a_, b_, c_, d_ = self.a, self.b, self.c, self.d
if a_ == 0:
self.qp.drawLine(c_, self.height, c_, -self.height)
return
elif a_ < 0:
self.qp.scale(-1.0, 1.0)
a_ = -a_
c_ = -c_
bound = self.width
p = self.get_screen_x(1 / (2 * a_)) - self.get_screen_x(0)
p2 = 2 * p
p4 = 2 * p2
x, y = 0, 0
d = 1 - p
while (y < p) and (x <= bound):
self.qp.drawPoint(x, y)
self.qp.drawPoint(x, -y)
if d >= 0:
x += 1
d -= p2
y += 1
d += (2 * y + 1)
if d == 1:
d = 1 - p4
else:
d = 1 - p2
# self.qp.drawLine(x, 0, x, y)
while x <= bound:
self.qp.drawPoint(x, y)
self.qp.drawPoint(x, -y)
if d <= 0:
y += 1
d += 4 * y
x += 1
d -= p4
def get_screen_x(self, x):
return ((self.scale_x / 2 + x) / self.scale_x) * self.width
def get_screen_y(self, y):
return ((self.scale_y / 2 + y) / self.scale_y) * self.height
def timerEvent(self, event):
self.a += 0.15
if self.a > 10:
self.a = -10
self.repaint()
class QtRenderer(Renderer):
"""An implementation of :class:`~renderer.Renderer` for PyQt5.
This renderer will draw on any `QPaintDevice`
"""
def __init__(self, paint_device):
"""Creates a new renderer based on a QPaintDevice pd"""
self._grid_pen = QPen(QColor(0x808080))
self._grid_pen.setStyle(Qt.DashLine)
self._painter = None
Renderer.__init__(self, paint_device)
def set_canvas(self, canvas):
"""Tell the renderer to draw on canvas
The type of canvas is implementation-dependent"""
if self._painter is not None:
self._painter.restore()
self._painter.restore()
self._painter.end()
self._paintdevice = canvas
self._painter = QPainter(canvas)
self._painter.setRenderHint(QPainter.Antialiasing)
# invert the y axis
self._painter.scale(1,-1)
self._painter.translate(0,-canvas.height())
Renderer.set_canvas(self,canvas)
def _get_canvas_size(self,pd):
"""Get the canvas size tuple (width,height)"""
return (pd.width(), pd.height())
def push_state(self):
"""Store the current state on the stack.
Current state includes default pose, pen and brush"""
### FIXME store things
self._painter.save()
def pop_state(self):
"""Restore the last saved state from the stack
The state includes default pose, pen and brush"""
### FIXME store things
self._painter.restore()
def _calculate_bounds(self):
transform = self._painter.worldTransform().inverted()[0]
xs,ys = zip(
transform.map(0.0,0.0),
transform.map(0.0,float(self.size[1])),
transform.map(float(self.size[0]),float(self.size[1])),
transform.map(float(self.size[0]),0.0)
)
self._bounds = (min(xs), min(ys), max(xs), max(ys))
def _draw_grid(self):
self.reset_pose()
self._painter.setPen(self._grid_pen)
xmin, ymin, xmax, ymax = self._bounds
# Determine min/max x & y line indices:
x_ticks = (int(xmin//self._grid_spacing), int(xmax//self._grid_spacing + 1))
y_ticks = (int(ymin//self._grid_spacing), int(ymax//self._grid_spacing + 1))
self._painter.drawLines(
[QLineF(xmin, i * self._grid_spacing,
xmax, i * self._grid_spacing)
for i in range(*y_ticks)])
self._painter.drawLines(
[QLineF(i * self._grid_spacing, ymin,
i * self._grid_spacing, ymax)
for i in range(*x_ticks)])
def scale(self, factor):
"""Scale drawing operations by factor
To be implemented in subclasses."""
self._painter.scale(factor,factor)
def rotate(self, angle):
"""Rotate canvas by angle (in radians)
To be implemented in subclasses."""
self._painter.rotate(degrees(angle))
def translate(self, dx, dy):
"""Translate canvas by dx, dy
To be implemented in subclasses."""
self._painter.translate(dx,dy)
def clear_screen(self):
"""Erases the current screen with a white brush"""
self._painter.save()
self._painter.resetTransform()
self.set_pen(0xFFFFFF)
self.set_brush(0xFFFFFF)
self.draw_rectangle(0,0,self.size[0],self.size[1])
self._painter.restore()
Renderer.clear_screen(self)
@staticmethod
def __qcolor(color):
"""Returns qcolor for a given ARGB color"""
c = QColor(color)
if color > 0xFFFFFF:
c.setAlpha((color >> 24) & 0xFF)
return c
def set_pen(self,color=0, thickness=0):
"""Sets the line color and thickness.
Color is interpreted as 0xAARRGGBB."""
if color is None:
self._painter.setPen(Qt.NoPen)
else:
self._painter.setPen(QPen(self.__qcolor(color),thickness))
def set_brush(self,color):
"""Sets the fill color.
Color is interpreted as 0xAARRGGBB."""
if color is None:
self._painter.setBrush(Qt.NoBrush)
else:
self._painter.setBrush(self.__qcolor(color))
def draw_polygon(self,points):
"""Draws a polygon.
Expects a list of points as a list of tuples or as a numpy array."""
self._painter.drawPolygon(QPolygonF([QPointF(*point[:2]) for point in points]))
def draw_ellipse(self, cx, cy, ra, rb = None):
"""Draws an ellipse."""
if rb is None:
rb = ra
self._painter.drawEllipse(QRectF(cx-ra,cy-ra,2*ra,2*rb))
def draw_rectangle(self, x, y, w, h):
"""Draws a rectangle."""
self._painter.drawRect(QRectF(x,y,w,h))
def draw_text(self, text, x, y, bgcolor = 0):
"""Draws a text string at the defined position."""
pass
def draw_line(self, x1, y1, x2, y2):
"""Draws a line using the current pen from (x1,y1) to (x2,y2)"""
self._painter.drawLine(QLineF(x1,y1,x2,y2))
def draw_point(self,x,y):
"""Draw a single point using the current pen at (x,y)"""
self._painter.drawPoint(QPointF(x,y))
def draw_points(self,points):
"""Draw a set of points, given as [(x,y)], using the current pen"""
self._painter.drawPoints(QPolygonF([QPointF(x,y) for x,y in points]))
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.TextAntialiasing)
R = 100
Pi = 3.14159
deg = Pi * 72 / 180
points = [
QPoint(R, 0),
QPoint(R * math.cos(deg), -R * math.sin(deg)),
QPoint(R * math.cos(2 * deg), -R * math.sin(2 * deg)),
QPoint(R * math.cos(3 * deg), -R * math.sin(3 * deg)),
QPoint(R * math.cos(4 * deg), -R * math.sin(4 * deg))
]
font = painter.font()
font.setPointSize(12)
font.setBold(False)
painter.setFont(font)
pen = QPen()
pen.setWidth(2)
pen.setColor(Qt.blue)
pen.setStyle(Qt.SolidLine)
pen.setCapStyle(Qt.FlatCap)
pen.setJoinStyle(Qt.BevelJoin)
painter.setPen(pen)
brush = QBrush()
brush.setColor(Qt.yellow)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
starPath = QPainterPath()
starPath.moveTo(points[0])
starPath.lineTo(points[2])
starPath.lineTo(points[4])
starPath.lineTo(points[1])
starPath.lineTo(points[3])
starPath.closeSubpath()
starPath.addText(points[0], font, "0")
starPath.addText(points[1], font, "1")
starPath.addText(points[2], font, "2")
starPath.addText(points[3], font, "3")
starPath.addText(points[4], font, "4")
painter.save()
painter.translate(100, 120)
painter.drawPath(starPath)
painter.drawText(0, 0, "S1")
painter.restore()
painter.translate(300, 120)
painter.scale(0.8, 0.8)
painter.rotate(90)
painter.drawPath(starPath)
painter.drawText(0, 0, "S2")
painter.resetTransform()
painter.translate(500, 120)
painter.rotate(-145)
painter.drawPath(starPath)
painter.drawText(0, 0, "S3")
def paintEvent(self, event: QPaintEvent):
_start = perf_counter()
num = self.num_tabs
selected = self.selected
arrow_width = self._arrow_width
height = self.height()
width = self._button_width
first_width = self._first_button_width
button = self._button_path
button_box = QRect(0, 0, width + arrow_width, height)
first_box = QRect(0, 0, first_width + arrow_width, height)
icon_area = QRect(arrow_width + 10, 0, max(48, width / 2), height)
text_box = QRect(arrow_width, 0, width - arrow_width, height)
text_flags = Qt.AlignCenter | Qt.AlignVCenter
states = self.states
painter = QPainter(self)
region = event.region()
painter.setClipRegion(region)
#torender = self._tabs_within(event.region())
#print("regions:")
#for rect in event.region().rects():
# print(" - ", rect)
#painter.setPen(Qt.NoPen)
painter.setPen(
QPen(Qt.black, 2, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
titleFont = painter.font()
titleFont.setPointSizeF(14)
titleFont.setBold(True)
painter.setFont(titleFont)
painter.translate(num * width + first_width, 0)
if region.intersects(painter.transform().mapRect(button_box)):
painter.setBrush(states[num].get_color(num == selected))
painter.drawPath(self._last_button_path)
for i in reversed(range(num)):
painter.translate(-width, 0)
if not region.intersects(painter.transform().mapRect(button_box)):
continue
painter.setBrush(states[i].get_color(i == selected))
painter.drawPath(button)
if states[i].state == State.ACTIVE:
painter.save()
painter.setPen(Qt.NoPen)
gw = (width + self._arrow_width) * 2
gradient = QLinearGradient(0, 0, gw, 0)
value = self._working_anim.value
gradient.setColorAt(max(0.0, value - 0.2),
QColor(255, 255, 255, 0))
gradient.setColorAt(value, QColor(255, 255, 255, 180))
gradient.setColorAt(min(1.0, value + 0.2),
QColor(255, 255, 255, 0))
brush = QBrush(gradient)
brush.setTransform(brush.transform().translate(-gw / 4, 0))
gradient_height = int(height * 0.2)
painter.setBrush(brush)
#painter.setClipRect(0, 0, width+self._arrow_width, gradient_height)
#painter.drawPath(button)
#painter.setClipRect(0, height-gradient_height, width+self._arrow_width, gradient_height)
painter.drawPath(button)
self._active_box = painter.transform().mapRect(button_box)
painter.restore()
#if states[i].icon:
# states[i].icon.paint(painter, icon_area)
text = states[i].text
if text:
_, _, short = text.rpartition('-')
painter.drawText(text_box, text_flags, short.capitalize())
if region.intersects(first_box):
painter.resetTransform()
painter.setBrush(State.UNKNOWN.get_color(-1 == selected))
painter.drawPath(self._first_button_path)
if self.is_running:
icon = self.style().standardIcon(QStyle.SP_MediaStop)
else:
icon = self.style().standardIcon(QStyle.SP_MediaPlay)
size = min(self._first_button_width, self.height()) * 0.8
painter.translate(5, (self.height() - size) / 2)
icon.paint(painter, QRect(0, 0, size, size))
_end = perf_counter()
if not self._paint_times:
self._paint_times = times = []
else:
times = self._paint_times
times.append(_end - _start)
if len(times) > 60:
avg = sum(times) / len(times) * 1000000
print("Average render time %.2fns" % (avg, ))
self._paint_times = None
