def drawPolygonOnVideo(values, painter, surface, gt):
''' Draw Polygons on Video '''
poly = []
for pt in values:
if hasElevationModel():
pt = GetLine3DIntersectionWithPlane(
GetSensor(), pt, GetFrameCenter()[2])
scr_x, scr_y = vut.GetInverseMatrix(
pt[1], pt[0], gt, surface)
center = QPoint(scr_x, scr_y)
poly.append(center)
poly.append(poly[0])
radius = 3
polygon = QPolygonF(poly)
pen = QPen()
pen.setColor(Qt.green)
pen.setWidth(radius)
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
brush = QBrush()
brush.setColor(QColor(176, 255, 128, 28))
brush.setStyle(Qt.SolidPattern)
path = QPainterPath()
path.addPolygon(polygon)
painter.setPen(pen)
painter.drawPolygon(polygon)
painter.fillPath(path, brush)
return
def drawSnakeAndFood(self, event, painter):
""" Draws the snake and food"""
pen = QPen()
pen.setWidth(1)
pen.setBrush(Qt.white)
pen.setCapStyle(Qt.SquareCap)
pen.setJoinStyle(Qt.MiterJoin)
brush = QBrush(Qt.white)
painter.setPen(pen)
painter.setBrush(brush)
# Draw each individual square of snake
for bodySquare in self.snake.bodyPositions:
x = bodySquare[0] * self.squareSize
y = bodySquare[1] * self.squareSize
painter.drawRect(x, y, self.squareSize, self.squareSize)
# Draw food
x = self.foodPosition[0] * self.squareSize
y = self.foodPosition[1] * self.squareSize
painter.drawRect(x, y, self.squareSize, self.squareSize)
def dessin(self, point1, point2, pointpiste1, pointpiste2, nb):
#dessin de ligne de carrés entre point1 et point2
Deltax, Deltay = (point1.x - point2.x), (point1.y - point2.y)
deltax, deltay = pointpiste1.x - pointpiste2.x, pointpiste1.y - pointpiste2.y
v = math.sqrt(deltax**2 + deltay**2)
V2 = LARGEUR / 10
pen = QPen(QtGui.QColor('white'), V2)
pen.setCapStyle(Qt.SquareCap)
pen.setJoinStyle(Qt.RoundJoin)
if v != 0:
deltax, deltay = deltax / v, deltay / v
if nb == 1:
for i in range(1, 5):
P1 = piste.Point(point1.x - i * Deltax / 5,
point1.y - i * Deltay / 5)
P2 = piste.Point(point1.x - i * Deltax / 5 + V2 * deltax * 0.5,
point1.y - i * Deltay / 5 + V2 * deltay * 0.5)
self.scene.addLine(P1.x, P1.y, P2.x, P2.y, pen)
else:
for i in range(5):
P1 = piste.Point(point1.x - (2 * i + 1) * Deltax / 10,
point1.y - (2 * i + 1) * Deltay / 10)
P2 = piste.Point(
point1.x - (2 * i + 1) * Deltax / 10 + V2 * deltax * 0.5,
point1.y - (2 * i + 1) * Deltay / 10 + V2 * deltay * 0.5)
self.scene.addLine(P1.x, P1.y, P2.x, P2.y, pen)
def paint(self, QPainter, QStyleOptionGraphicsItem, QWidget_widget=None):
# setPen
pen = QPen()
pen.setWidth(2)
pen.setJoinStyle(Qt.MiterJoin)
QPainter.setPen(pen)
# setBrush
brush = QBrush()
brush.setColor(Qt.black)
brush.setStyle(Qt.SolidPattern)
QPainter.setBrush(brush)
v = self.line.unitVector()
v.setLength(10)
v.translate(QPointF(self.line.dx(), self.line.dy()))
n = v.normalVector()
n.setLength(n.length() * 0.5)
n2 = n.normalVector().normalVector()
p1 = v.p2()
p2 = n.p2()
p3 = n2.p2()
QPainter.drawLine(self.line)
QPainter.drawPolygon(p1, p2, p3)
def draw_trigger_port(painter, rect, info):
painter.save()
size = int(rect.height() / 2)
triangle = QPolygonF()
triangle.append(QPointF(-size, -size))
triangle.append(QPointF(size, 0))
triangle.append(QPointF(-size, size))
transform = QTransform()
transform.translate(rect.center().x(), rect.center().y())
port_poly = transform.map(triangle)
if info["hovered"]:
color = QColor(17, 43, 82)
border_color = QColor(136, 255, 35)
elif info["connected"]:
color = QColor(14, 45, 59)
border_color = QColor(107, 166, 193)
else:
color = QColor(*info["color"])
border_color = QColor(*info["border_color"])
pen = QPen(border_color, 1.8)
pen.setJoinStyle(Qt.MiterJoin)
painter.setPen(pen)
painter.setBrush(color)
painter.drawPolygon(port_poly)
painter.restore()
def paintEvent(self, event):
"""Paint event for the overlay
:param event: QPaintEvent event
:type event: QPaintEvent
"""
super().paintEvent(event)
painter = QPainter(self)
pen = QPen(Qt.black)
pen.setWidth(1)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.drawRect(0, 0, 16 * 25 - 1, self.height * 25 - 1)
lines = []
for longitude in range(16):
line = QLineF(longitude * 25, 0, longitude * 25, self.height * 25)
lines.append(line)
for latitude in range(self.height):
line = QLineF(0, latitude * 25, 16 * 25, latitude * 25)
lines.append(line)
painter.drawLines(lines)
s_root, s_width, s_height = self.selected
x = s_root % 16
y = math.floor(s_root / 16)
pen.setColor(Qt.red)
pen.setWidth(3)
pen.setJoinStyle(Qt.MiterJoin)
painter.setPen(pen)
painter.drawRect(x * 25, y * 25, s_width * 25, s_height * 25)
def draw(self, painter: QPainter):
pen = QPen(Layer.color(LayerType.annotate))
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setWidth(0)
painter.setPen(pen)
painter.drawLine(self.pt1, self.pt2)
def show_select_area_at_default_position(self):
trimming_data = Project.latest_trimming_data()
if trimming_data.position:
self.start_position = QPoint(trimming_data.position[0],
trimming_data.position[1])
rect = QRectF(trimming_data.position[0], trimming_data.position[1],
self.width, self.height)
else:
self.start_position = QPoint((self.w - self.width) // 2,
(self.h - self.height) // 2)
rect = QRectF((self.w - self.width) // 2,
(self.h - self.height) // 2, self.width, self.height)
self.select_area = QGraphicsRectItem(rect)
self.select_area.setZValue(1)
pen = QPen(QColor('#ffa00e'))
pen.setWidth(4)
pen.setJoinStyle(Qt.RoundJoin)
self.select_area.setPen(pen)
self.select_area.setFlag(QGraphicsItem.ItemIsMovable, True)
self.original_image_scene.addItem(self.select_area)
self.select_area_label_proxy = QGraphicsProxyWidget(self.select_area)
self.select_area_label = SelectAreaLabel()
self.select_area_label.set_label()
self.select_area_label_proxy.setWidget(self.select_area_label)
self.select_area_label_proxy.setPos(
self.select_area.boundingRect().left() + 2,
self.select_area.boundingRect().bottom() -
self.select_area_label.height() - 2)
def paintEvent(self, pe):
super().paintEvent(pe)
if (self.mRedrawMapImage):
self.renderMapToImage()
self.mRedrawMapImage = False
if (self.mMapImage.isNull() or self.mImageRect.isEmpty()):
return
p = QPainter(self)
p.setRenderHints(QPainter.SmoothPixmapTransform)
backgroundColor = QColor(Qt.darkGray)
if (self.mMapDocument
and self.mMapDocument.map().backgroundColor().isValid()):
backgroundColor = self.mMapDocument.map().backgroundColor()
p.setBrush(backgroundColor)
p.setPen(Qt.NoPen)
p.drawRect(self.contentsRect())
p.drawImage(self.mImageRect, self.mMapImage)
viewRect = self.viewportRect()
p.setBrush(Qt.NoBrush)
p.setPen(QColor(0, 0, 0, 128))
p.translate(1, 1)
p.drawRect(viewRect)
outLinePen = QPen(QColor(255, 0, 0), 2)
outLinePen.setJoinStyle(Qt.MiterJoin)
p.translate(-1, -1)
p.setPen(outLinePen)
p.drawRect(viewRect)
p.end()
def initPainter(self):
pen = QPen()
pen.setWidth(1)
pen.setJoinStyle(Qt.RoundJoin)
pen.setCapStyle(Qt.RoundCap)
pen.setCosmetic(True)
self.setPen(pen)
def paintEvent(self, event):
"""Preview paint event to draw regular and transparent color selections
:param event: Paint event
:type event: QPaintEvent
"""
super().paintEvent(event)
painter = QPainter(self)
rect_pen = QPen(Qt.black)
trans_pen = QPen(Qt.red)
rect_pen.setWidth(3)
trans_pen.setWidth(3)
rect_pen.setJoinStyle(Qt.MiterJoin)
trans_pen.setCapStyle(Qt.RoundCap)
sec_brush = QBrush(self.secondary_color)
prim_brush = QBrush(self.primary_color)
painter.setPen(rect_pen)
painter.setBrush(sec_brush)
painter.drawRect(27, 27, 61, 61)
if self.source is Source.SPRITE:
if self.secondary_index == 0:
painter.setPen(trans_pen)
painter.drawLine(30, 30, 61 + 25, 61 + 25)
painter.setPen(rect_pen)
painter.setBrush(prim_brush)
painter.drawRect(1, 1, 61, 61)
if self.source is Source.SPRITE:
if self.primary_index == 0:
painter.setPen(trans_pen)
painter.drawLine(4, 4, 61 - 1, 61 - 1)
def test_paint(self, event):
#QPainter
# 练习画图的例子
p1 = QPoint()
point_list = []
w = self.width() # 绘图区的宽度
h = self.height() # 绘图区的高度
rect = QRect(w / 4, h / 4, w / 2, h / 2) # 中间区域矩形框
# 设置画笔
pen = QPen()
pen.setWidth(3) # 线宽
pen.setColor(Qt.red) # 划线颜色
pen.setStyle(Qt.SolidLine) # 线的样式
pen.setCapStyle(Qt.FlatCap) # 线端点式样
pen.setJoinStyle(Qt.BevelJoin) # 线的连接点样式
# 设置画刷
brush = QBrush()
brush.setColor(Qt.yellow)
brush.setStyle(Qt.SolidPattern)
painter = QPainter()
painter.begin(self)
painter.setPen(pen)
painter.setBrush(brush)
painter.drawRect(rect)
painter.end()
pass
def paintEvent(self, pe):
super().paintEvent(pe)
if (self.mRedrawMapImage):
self.renderMapToImage()
self.mRedrawMapImage = False
if (self.mMapImage.isNull() or self.mImageRect.isEmpty()):
return
p = QPainter(self)
p.setRenderHints(QPainter.SmoothPixmapTransform)
backgroundColor = QColor(Qt.darkGray)
if (self.mMapDocument and self.mMapDocument.map().backgroundColor().isValid()):
backgroundColor = self.mMapDocument.map().backgroundColor()
p.setBrush(backgroundColor)
p.setPen(Qt.NoPen)
p.drawRect(self.contentsRect())
p.drawImage(self.mImageRect, self.mMapImage)
viewRect = self.viewportRect()
p.setBrush(Qt.NoBrush)
p.setPen(QColor(0, 0, 0, 128))
p.translate(1, 1)
p.drawRect(viewRect)
outLinePen = QPen(QColor(255, 0, 0), 2)
outLinePen.setJoinStyle(Qt.MiterJoin)
p.translate(-1, -1)
p.setPen(outLinePen)
p.drawRect(viewRect)
p.end()
def paintEvent(self, paintEvent: QPaintEvent):
painter = QPainter(self)
painter.setBackgroundMode(Qt.TransparentMode)
painter.setRenderHint(QPainter.Antialiasing)
brush = QBrush()
brush.setStyle(Qt.SolidPattern)
pen = QPen()
pen.setJoinStyle(Qt.RoundJoin)
pen.setCapStyle(Qt.RoundCap)
center = QPoint(self.width() // 2, self.height() // 2)
radius = 0.45 * min(self.width(), self.height())
pen.setColor(self.palette().color(self.color[0]))
brush.setColor(self.palette().color(self.color[1]))
if self.highlight is True:
pen.setColor(self.palette().color(QPalette.Highlight))
pen.setWidth(round(0.15 * radius))
painter.setBrush(brush)
painter.setPen(pen)
painter.drawEllipse(center, radius, radius)
if self.checked is True:
brush.setColor(self.palette().color(QPalette.Background))
pen.setColor(self.palette().color(QPalette.Background))
painter.setPen(pen)
painter.setBrush(brush)
painter.drawEllipse(center, 0.40 * radius, 0.40 * radius)
del painter, brush, pen
def paint(self, painter, option, widget=None):
# Draw header
rect = QRectF(0, 0, 20, 20)
if self.stage:
brush = QBrush(self.on_color_1)
else:
brush = QBrush(self.off_color_1)
pen = QPen()
pen.setStyle(LINE_SOLID)
pen.setWidthF(1)
pen.setWidth(2)
pen.setCapStyle(ROUND_CAP)
pen.setJoinStyle(ROUND_JOIN)
painter.setBrush(brush)
painter.setPen(pen)
painter.drawEllipse(-5, -5, 10, 10)
if self.stage:
brush = QBrush(self.on_color_2)
else:
brush = QBrush(self.off_color_2)
painter.setBrush(brush)
painter.setPen(pen)
painter.drawEllipse(-7, -7, 14, 14)
def paintEvent(self, event):
painter = QPainter(self)
pen = QPen(QColor("orange"))
pen.setWidth(5)
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
painter.setPen(pen)
painter.drawPath(self.painter)
def _default_pen():
pen = QPen(QColor('white'))
pen.setStyle(Qt.SolidLine)
pen.setWidth(3)
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setCosmetic(True)
return pen
def draw(self, painter):
pen = QPen(Layer.color(LayerType.annotate))
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setWidth(0)
painter.setPen(pen)
if self._firstPt is not None:
painter.drawLine(self._firstPt, self._pos)
def get_fold_qpen():
pen = QPen()
pen.setWidth(0.1)
pen.setStyle(QtCore.Qt.SolidLine)
pen.setColor(QColor(51, 204, 255))
pen.setCapStyle(QtCore.Qt.SquareCap)
pen.setJoinStyle(QtCore.Qt.RoundJoin)
return pen
def get_all_qpen():
pen = QPen()
pen.setWidth(0.5)
pen.setStyle(QtCore.Qt.SolidLine)
pen.setColor(QColor(252, 3, 3))
pen.setCapStyle(QtCore.Qt.SquareCap)
pen.setJoinStyle(QtCore.Qt.RoundJoin)
return pen
def draw_circular_bar(
painter: QPainter,
radius: int,
angle: int,
span: int,
width: int,
fill_brush: QBrush,
line_brush: QBrush,
line_width: int
):
"""
Draw a circular bar using the QPainter handler given by the outer caller.
:param painter: Painter handler
:param radius: Circular radius
:param angle: Starting angle
:param span: Span angle
:param width: Width between circular
:param fill_brush: Color pattern used to fill the path
:param line_brush: Color pattern used to draw lines
:param line_width: Line width
"""
painter.save()
path = QPainterPath()
path.moveTo(
QPointF(
(radius - width / 2) * cos(radians(angle)) + radius,
-(radius - width / 2) * sin(radians(angle)) + radius
)
)
path.lineTo(
QPointF(
radius * cos(radians(angle)) + radius,
-radius * sin(radians(angle)) + radius
)
)
path.arcTo(QRectF(0, 0, radius * 2, radius * 2), angle, span)
path.lineTo(
QPointF(
(radius - width / 2) * cos(radians(angle + span)) + radius,
-(radius - width / 2) * sin(radians(angle + span)) + radius
)
)
path.arcTo(
QRectF(
width // 2, width // 2,
radius * 2 - width, radius * 2 - width
),
angle + span,
-span
)
pen = QPen(line_brush, line_width)
pen.setJoinStyle(Qt.RoundJoin)
painter.setPen(pen)
painter.fillPath(path, fill_brush)
painter.drawPath(path)
painter.restore()
def draw(self, painter):
pen = QPen(Layer.color(LayerType.selection))
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setWidth(0)
painter.setPen(pen)
for h in self._handles:
h.draw(painter)
painter.drawLine(self._obj.pt1, self._obj.pt2)
def paintEvent(self, event): ##在窗口上绘图
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.TextAntialiasing)
rect = QRect(0, 0, self.width(), self.height()) #viewport矩形区
painter.setViewport(rect) #设置Viewport
painter.setWindow(0, 0, 120, 50) #设置窗口大小，逻辑坐标
##绘制电池边框
pen = QPen()
pen.setWidth(2) #线宽
pen.setColor(self.colorBorder) #划线颜色
pen.setStyle(Qt.SolidLine) #线的类型，实线、虚线等
pen.setCapStyle(Qt.FlatCap) #线端点样式
pen.setJoinStyle(Qt.BevelJoin) #线的连接点样式
painter.setPen(pen)
brush = QBrush() #设置画刷
brush.setColor(self.colorBack) #画刷颜色
brush.setStyle(Qt.SolidPattern) #画刷填充样式
painter.setBrush(brush)
rect.setRect(1, 1, 109, 48)
painter.drawRect(rect) #绘制电池边框
brush.setColor(self.colorBorder) #画刷颜色
painter.setBrush(brush)
rect.setRect(110, 15, 10, 20)
painter.drawRect(rect) #画电池正极头
##画电池柱
if self.__powerLevel > self.__warnLevel: #正常颜色电量柱
brush.setColor(self.colorPower) #画刷颜色
pen.setColor(self.colorPower) #划线颜色
else: ##电量低电量柱
brush.setColor(self.colorWarning) #画刷颜色
pen.setColor(self.colorWarning) #划线颜色
painter.setBrush(brush)
painter.setPen(pen)
if self.__powerLevel > 0:
rect.setRect(5, 5, self.__powerLevel, 40)
painter.drawRect(rect) #画电池柱
##绘制电量百分比文字
textSize = QFontMetrics(self.font())
powStr = "%d%%" % self.__powerLevel
textRect = QRect(textSize.boundingRect(powStr)) #得到字符串的rect
painter.setFont(self.font())
pen.setColor(self.colorBorder) #划线颜色
painter.setPen(pen)
painter.drawText(55 - textRect.width() / 2, 23 + textRect.height() / 2,
powStr)
def pen(self):
"""create and return default pen"""
pen = QPen()
pen.setStyle(DefaultDrawParams.pen_style)
pen.setWidth(DefaultDrawParams.pen_thickness)
pen.setBrush(self.border_color)
pen.setCapStyle(DefaultDrawParams.pen_cap_style)
pen.setJoinStyle(DefaultDrawParams.pen_join_style)
return pen
def paint(self, QPainter, QStyleOptionGraphicsItem, QWidget_widget=None):
# setPen
pen = QPen()
pen.setWidth(1)
pen.setJoinStyle(Qt.MiterJoin) #让箭头变尖
QPainter.setPen(pen)
# draw line
QPainter.drawLine(self.line)
ptextx = (self.line.x1() + self.line.x2()) / 2
ptexty = (self.line.y1() + self.line.y2()) / 2
ptexty -= 5
ptextx -= len(self.boxName) * 3
#QPainter.drawText(QPointF(ptextx, ptexty+20), self.direction)
# setBrush
brush = QBrush()
brush.setColor(Qt.black)
brush.setStyle(Qt.SolidPattern)
QPainter.setBrush(brush)
v = self.line.unitVector()
v.setLength(5)
v.translate(QPointF(self.line.dx(), self.line.dy()))
n = v.normalVector()
n.setLength(n.length() * 0.5)
n2 = n.normalVector().normalVector()
p1 = v.p2()
p2 = n.p2()
p3 = n2.p2()
# 方法1
QPainter.drawLine(self.line)
QPainter.drawPolygon(p1, p2, p3)
if self.fromLocation is not None and self.toLocation is not None:
if self.fromLocation.boxName == self.toLocation.boxName:
QPainter.drawArc(self.arcx1, self.arcy1, 80, 80,
self.minAngle * 16, self.spanAngle * 16)
ptextx = self.arcTextx
ptexty = self.arcTexty
#QPainter.drawArc(self.arcx1, self.arcy1+100, 50, 50, 270*16, 89*16)
#QPainter.drawArc(self.arcx1, self.arcy1+200, 50, 50, 0*16, 89*16)
#QPainter.drawArc(self.arcx1, self.arcy1+300, 50, 50, 270*16, 180*16)
#QPainter.drawArc(self.arcx1, self.arcy1+400, 50, 50, 270*16, 270*16)
#QPainter.drawArc(self.arcx1, self.arcy1+500, 50, 50, 180*16, 89*16)
QPainter.drawText(QPointF(ptextx, ptexty), self.boxName)
#QPainter.drawRect(self.arcx1, self.arcy1, 50, 50)
self.scene.update()
def paint(self, QPainter, QStyleOptionGraphicsItem, QWidget_widget=None):
# setPen
pen = QPen()
pen.setWidth(1)
pen.setJoinStyle(Qt.MiterJoin) #让箭头变尖
QPainter.setPen(pen)
# draw line
QPainter.drawLine(self.line)
ptextx = (self.line.x1() + self.line.x2()) / 2
ptexty = (self.line.y1() + self.line.y2()) / 2
ptexty -= 5
ptextx -= len(self.boxName) * 3
QPainter.drawText(QPointF(ptextx, ptexty), self.boxName)
#Painter.drawText(QPointF(ptextx, ptexty+20), self.direction)
# setBrush
brush = QBrush()
brush.setColor(Qt.black)
brush.setStyle(Qt.SolidPattern)
QPainter.setBrush(brush)
v = self.line.unitVector()
v.setLength(5)
v.translate(QPointF(self.line.dx(), self.line.dy()))
n = v.normalVector()
n.setLength(n.length() * 0.5)
n2 = n.normalVector().normalVector()
p1 = v.p2()
p2 = n.p2()
p3 = n2.p2()
# 方法1
QPainter.drawLine(self.line)
QPainter.drawPolygon(p1, p2, p3)
QPainter.drawArc(10, 10, 50, 50, 0, 180 * 16)
v = self.line.unitVector()
v.setLength(5)
v.translate(QPointF(10, 60))
n = v.normalVector()
n.setLength(n.length() * 0.5)
n2 = n.normalVector().normalVector()
p1 = v.p2()
p2 = n.p2()
p3 = n2.p2()
# 方法1
#QPainter.drawLine(self.line)
QPainter.drawPolygon(p1, p2, p3)
self.scene.update()
def _plot_baseline(self):
if not self.baseline_plot:
self.baseline_plot = self.parent.image_view.plot_item.plot()
pen = QPen(QColor('red'))
pen.setStyle(Qt.DashDotLine)
pen.setWidth(4)
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setCosmetic(True)
self.baseline_plot.setData(self._x_axis, self._baseline, pen=pen)
def set_pen(self, width: int = 3, color: str or QColor = 'white'):
if isinstance(color, str):
color = QColor(color)
pen = QPen(color)
pen.setStyle(Qt.SolidLine)
pen.setWidth(width)
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setCosmetic(True)
self.plot.setPen(pen)
def addBorder(self):
width, ok = QInputDialog.getInt(self, 'Add Border', 'Enter Border Width :', 2, 1)
if ok:
painter = QPainter(self.image.pic)
pen = QPen(Qt.black)
pen.setWidth(width)
pen.setJoinStyle(Qt.MiterJoin);
painter.setPen(pen)
painter.drawRect(width/2, width/2, self.image.pic.width()-width, self.image.pic.height()-width)
self.image.showScaled()
def paintEvent(self, paintEvent: QPaintEvent):
pen = QPen()
pen.setJoinStyle(Qt.RoundJoin)
pen.setCapStyle(Qt.RoundCap)
painter = QPainter(self)
painter.translate(self.paintOffset)
painter.setBackgroundMode(Qt.TransparentMode)
painter.setRenderHint(QPainter.Antialiasing)
if self.nodes is not None:
painted = set()
def paintNode(node):
nonlocal painter, painted
if node in painted:
return
painted.add(node)
for link in node.links:
if link not in painted:
painter.drawLine(node.point, link.point)
paintNode(link)
color = self.palette().color(QPalette.Dark)
pen.setColor(color)
pen.setWidth(0.50 * self.paintStep)
painter.setPen(pen)
for node in self.nodes.values():
if paintEvent.region().contains(node.point):
paintNode(node)
if self.startNode is not None:
color = self.palette().color(QPalette.Dark)
pen.setColor(color)
pen.setWidth(0.75 * self.paintStep)
painter.setPen(pen)
if paintEvent.region().contains(self.startNode.point):
painter.drawPoint(self.startNode.point)
if self.finishNode is not None and paintEvent.region().contains(
self.finishNode.point):
color = self.palette().color(QPalette.Dark).darker(120)
pen.setColor(color)
pen.setWidth(0.75 * self.paintStep)
painter.setPen(pen)
painter.drawPoint(self.finishNode.point)
if self.player is not None:
color = self.palette().color(QPalette.Highlight)
color.setAlpha(196)
pen.setColor(color)
pen.setWidth(0.90 * self.paintStep)
painter.setPen(pen)
painter.drawPoint(self.player)
del painter, pen
def paintEvent(self, e):
p = QPainter(self)
cell_rect = QRect()
ramp_count = len(self._ramps)
col_count = self._ramps[0].color_count
index = 0
ramp_index = 0
for ramp in self._ramps:
for i in range(0, col_count):
cell_rect.setRect(i * (self._cellSize + 1),
(index // ramp_count) * (self._cellSize + 1),
self._cellSize, self._cellSize)
p.fillRect(cell_rect, ramp.color_at(col_count - 1 - i))
index += 1
ramp_index += 1
pen = QPen()
pen.setWidth(self._cellIndicatorSize)
pen.setJoinStyle(Qt.MiterJoin)
border_adjust = self._cellIndicatorSize / 2
# PAINT SELECTED CELL A
pen.setColor(self._primaryIndicatorColor)
p.setPen(pen)
cell_rect = self._cell_rect(self._selectedCellA2.index)
p.drawRect(cell_rect.adjusted(border_adjust,
border_adjust,
-border_adjust,
-border_adjust))
# PAINT SELECTED CELL B
pen.setColor(self._secondaryIndicatorColor)
p.setPen(pen)
cell_rect = self._cell_rect(self._selectedCellB2.index)
p.drawRect(cell_rect.adjusted(border_adjust,
border_adjust,
-border_adjust,
-border_adjust))
def _rounded_qimage(qimg, radius): r_image = QImage(qimg.width(), qimg.height(), QImage.Format_ARGB32) r_image.fill(Qt.transparent) p = QPainter() pen = QPen(Qt.darkGray) pen.setJoinStyle(Qt.RoundJoin) p.begin(r_image) p.setRenderHint(p.Antialiasing) p.setPen(Qt.NoPen) p.setBrush(QBrush(qimg)) p.drawRoundedRect(0, 0, r_image.width(), r_image.height(), radius, radius) p.end() return r_image
def paintEvent(self, event):
painter = QPainter(self)
# erase background
painter.setBackground(QBrush(Layer.color(LayerType.background)))
painter.setClipping(True)
painter.eraseRect(self.rect())
# draw document
if self._ctrl is not None:
# draw grid
painter.setRenderHint(QPainter.Antialiasing, False)
pen = QPen(Layer.color(LayerType.grid))
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setWidth(0)
painter.setTransform(self._transform)
painter.setPen(pen)
self._drawGrid(painter)
# draw drawables
# painter.setRenderHint(QPainter.Antialiasing)
for d in self._ctrl.getDrawables():
d.draw(painter)
painter.end()
def getPenObj(hex_string: str,
stroke_width: int,
alpha: int = None,
lighter: int=None,
penstyle: Qt.PenStyle = None,
capstyle: Qt.PenCapStyle = None,
joinstyle: Qt.PenJoinStyle = None) -> QPen:
"""If the specified :class:`QPen` is cached, return it.
Otherwise, cache and return a new :class:`QPen`.
Args:
hex_string (str): hexadecimal color code in the form: #RRGGBB
stroke_width (int)
alpha (int): 0–255
lighter (int): see `QColor.lighter <http://doc.qt.io/qt-5/qcolor.html#lighter>`_.
penstyle: see `QPen.pen-style <http://doc.qt.io/qt-5/qt.html#PenStyle-enum>`_.
capstyle: see `QPen.cap-style <http://doc.qt.io/qt-5/qt.html#PenCapStyle-enum>`_.
joinstyle: see `QPen.join-style <http://doc.qt.io/qt-5/qt.html#PenJoinStyle-enum>`_.
Returns:
:class:`QPen` object
"""
global pen_cache
if alpha is not None:
hex_string = '#%0.2x%s' % (alpha, hex_string[1:])
# print(hex_string)
key = (hex_string, stroke_width, lighter, capstyle, joinstyle, penstyle)
pen = pen_cache.get(key)
if pen is None:
color = getColorObj(hex_string, lighter=lighter)
pen = QPen(color, stroke_width)
if penstyle is not None:
pen.setStyle(penstyle)
if capstyle is not None:
pen.setCapStyle(capstyle)
if joinstyle is not None:
pen.setJoinStyle(joinstyle)
pen_cache[key] = pen
return pen
def overlay_marks(self, img, is_cseed=False, calibration_sheet=False):
border_color = Qt.white
base_img = QImage(self.f_size.width(),self.f_size.height(), QImage.Format_ARGB32)
base_img.fill(border_color)
img = QImage(img)
painter = QPainter()
painter.begin(base_img)
total_distance_h = round(base_img.width() / self.abstand_v)
dist_v = round(total_distance_h) / 2
dist_h = round(total_distance_h) / 2
img = img.scaledToWidth(base_img.width() - (2 * (total_distance_h)))
painter.drawImage(total_distance_h,
total_distance_h,
img)
#frame around image
pen = QPen(Qt.black, 2)
painter.setPen(pen)
#horz
painter.drawLine(0, total_distance_h, base_img.width(), total_distance_h)
painter.drawLine(0, base_img.height()-(total_distance_h), base_img.width(), base_img.height()-(total_distance_h))
#vert
painter.drawLine(total_distance_h, 0, total_distance_h, base_img.height())
painter.drawLine(base_img.width()-(total_distance_h), 0, base_img.width()-(total_distance_h), base_img.height())
#border around img
border_thick = 6
Rpath = QPainterPath()
Rpath.addRect(QRectF((total_distance_h)+(border_thick/2),
(total_distance_h)+(border_thick/2),
base_img.width()-((total_distance_h)*2)-((border_thick)-1),
(base_img.height()-((total_distance_h))*2)-((border_thick)-1)))
pen = QPen(Qt.black, border_thick)
pen.setJoinStyle (Qt.MiterJoin)
painter.setPen(pen)
painter.drawPath(Rpath)
Bpath = QPainterPath()
Bpath.addRect(QRectF((total_distance_h), (total_distance_h),
base_img.width()-((total_distance_h)*2), (base_img.height()-((total_distance_h))*2)))
pen = QPen(Qt.black, 1)
painter.setPen(pen)
painter.drawPath(Bpath)
pen = QPen(Qt.black, 1)
painter.setPen(pen)
painter.drawLine(0, base_img.height()/2, total_distance_h, base_img.height()/2)
painter.drawLine(base_img.width()/2, 0, base_img.width()/2, total_distance_h)
painter.drawLine(base_img.width()-total_distance_h, base_img.height()/2, base_img.width(), base_img.height()/2)
painter.drawLine(base_img.width()/2, base_img.height(), base_img.width()/2, base_img.height() - total_distance_h)
#print code
f_size = 37
QFontDatabase.addApplicationFont(os.path.join(os.path.dirname(__file__), 'DejaVuSansMono-Bold.ttf'))
font = QFont("DejaVu Sans Mono", f_size-11, QFont.Bold)
font.setPixelSize(35)
painter.setFont(font)
if not calibration_sheet:
if is_cseed: #its a secret
painter.setPen(QPen(Qt.black, 1, Qt.DashDotDotLine))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0, base_img.height()-dist_v, base_img.width(), base_img.height()-(dist_v))
painter.drawLine(base_img.width()-(dist_h), 0, base_img.width()-(dist_h), base_img.height())
painter.drawImage(((total_distance_h))+11, ((total_distance_h))+11,
QImage(icon_path('electrumb.png')).scaledToWidth(2.1*(total_distance_h), Qt.SmoothTransformation))
painter.setPen(QPen(Qt.white, border_thick*8))
painter.drawLine(base_img.width()-((total_distance_h))-(border_thick*8)/2-(border_thick/2)-2,
(base_img.height()-((total_distance_h)))-((border_thick*8)/2)-(border_thick/2)-2,
base_img.width()-((total_distance_h))-(border_thick*8)/2-(border_thick/2)-2 - 77,
(base_img.height()-((total_distance_h)))-((border_thick*8)/2)-(border_thick/2)-2)
painter.setPen(QColor(0,0,0,255))
painter.drawText(QRect(0, base_img.height()-107, base_img.width()-total_distance_h - border_thick - 11,
base_img.height()-total_distance_h - border_thick), Qt.AlignRight,
self.versioned_seed.version + '_'+self.versioned_seed.checksum)
painter.end()
else: # revealer
painter.setPen(QPen(border_color, 17))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0, base_img.height()-dist_v, base_img.width(), base_img.height()-(dist_v))
painter.drawLine(base_img.width()-(dist_h), 0, base_img.width()-(dist_h), base_img.height())
painter.setPen(QPen(Qt.black, 2))
painter.drawLine(0, dist_v, base_img.width(), dist_v)
painter.drawLine(dist_h, 0, dist_h, base_img.height())
painter.drawLine(0, base_img.height()-dist_v, base_img.width(), base_img.height()-(dist_v))
painter.drawLine(base_img.width()-(dist_h), 0, base_img.width()-(dist_h), base_img.height())
logo = QImage(icon_path('revealer_c.png')).scaledToWidth(1.3*(total_distance_h))
painter.drawImage((total_distance_h)+ (border_thick), ((total_distance_h))+ (border_thick), logo, Qt.SmoothTransformation)
#frame around logo
painter.setPen(QPen(Qt.black, border_thick))
painter.drawLine(total_distance_h+border_thick, total_distance_h+logo.height()+3*(border_thick/2),
total_distance_h+logo.width()+border_thick, total_distance_h+logo.height()+3*(border_thick/2))
painter.drawLine(logo.width()+total_distance_h+3*(border_thick/2), total_distance_h+(border_thick),
total_distance_h+logo.width()+3*(border_thick/2), total_distance_h+logo.height()+(border_thick))
#frame around code/qr
qr_size = 179
painter.drawLine((base_img.width()-((total_distance_h))-(border_thick/2)-2)-qr_size,
(base_img.height()-((total_distance_h)))-((border_thick*8))-(border_thick/2)-2,
(base_img.width()/2+(total_distance_h/2)-border_thick-(border_thick*8)/2)-qr_size,
(base_img.height()-((total_distance_h)))-((border_thick*8))-(border_thick/2)-2)
painter.drawLine((base_img.width()/2+(total_distance_h/2)-border_thick-(border_thick*8)/2)-qr_size,
(base_img.height()-((total_distance_h)))-((border_thick*8))-(border_thick/2)-2,
base_img.width()/2 + (total_distance_h/2)-border_thick-(border_thick*8)/2-qr_size,
((base_img.height()-((total_distance_h)))-(border_thick/2)-2))
painter.setPen(QPen(Qt.white, border_thick * 8))
painter.drawLine(
base_img.width() - ((total_distance_h)) - (border_thick * 8) / 2 - (border_thick / 2) - 2,
(base_img.height() - ((total_distance_h))) - ((border_thick * 8) / 2) - (border_thick / 2) - 2,
base_img.width() / 2 + (total_distance_h / 2) - border_thick - qr_size,
(base_img.height() - ((total_distance_h))) - ((border_thick * 8) / 2) - (border_thick / 2) - 2)
painter.setPen(QColor(0,0,0,255))
painter.drawText(QRect(((base_img.width()/2) +21)-qr_size, base_img.height()-107,
base_img.width()-total_distance_h - border_thick -93,
base_img.height()-total_distance_h - border_thick), Qt.AlignLeft, self.versioned_seed.get_ui_string_version_plus_seed())
painter.drawText(QRect(0, base_img.height()-107, base_img.width()-total_distance_h - border_thick -3 -qr_size,
base_img.height()-total_distance_h - border_thick), Qt.AlignRight, self.versioned_seed.checksum)
# draw qr code
qr_qt = self.paintQR(self.versioned_seed.get_ui_string_version_plus_seed()
+ self.versioned_seed.checksum)
target = QRectF(base_img.width()-65-qr_size,
base_img.height()-65-qr_size,
qr_size, qr_size )
painter.drawImage(target, qr_qt)
painter.setPen(QPen(Qt.black, 4))
painter.drawLine(base_img.width()-65-qr_size,
base_img.height()-65-qr_size,
base_img.width() - 65 - qr_size,
(base_img.height() - ((total_distance_h))) - ((border_thick * 8)) - (border_thick / 2) - 4
)
painter.drawLine(base_img.width()-65-qr_size,
base_img.height()-65-qr_size,
base_img.width() - 65,
base_img.height()-65-qr_size
)
painter.end()
else: # calibration only
painter.end()
cal_img = QImage(self.f_size.width() + 100, self.f_size.height() + 100,
QImage.Format_ARGB32)
cal_img.fill(Qt.white)
cal_painter = QPainter()
cal_painter.begin(cal_img)
cal_painter.drawImage(0,0, base_img)
#black lines in the middle of border top left only
cal_painter.setPen(QPen(Qt.black, 1, Qt.DashDotDotLine))
cal_painter.drawLine(0, dist_v, base_img.width(), dist_v)
cal_painter.drawLine(dist_h, 0, dist_h, base_img.height())
pen = QPen(Qt.black, 2, Qt.DashDotDotLine)
cal_painter.setPen(pen)
n=15
cal_painter.setFont(QFont("DejaVu Sans Mono", 21, QFont.Bold))
for x in range(-n,n):
#lines on bottom (vertical calibration)
cal_painter.drawLine((((base_img.width())/(n*2)) *(x))+ (base_img.width()/2)-13,
x+2+base_img.height()-(dist_v),
(((base_img.width())/(n*2)) *(x))+ (base_img.width()/2)+13,
x+2+base_img.height()-(dist_v))
num_pos = 9
if x > 9 : num_pos = 17
if x < 0 : num_pos = 20
if x < -9: num_pos = 27
cal_painter.drawText((((base_img.width())/(n*2)) *(x))+ (base_img.width()/2)-num_pos,
50+base_img.height()-(dist_v),
str(x))
#lines on the right (horizontal calibrations)
cal_painter.drawLine(x+2+(base_img.width()-(dist_h)),
((base_img.height()/(2*n)) *(x))+ (base_img.height()/n)+(base_img.height()/2)-13,
x+2+(base_img.width()-(dist_h)),
((base_img.height()/(2*n)) *(x))+ (base_img.height()/n)+(base_img.height()/2)+13)
cal_painter.drawText(30+(base_img.width()-(dist_h)),
((base_img.height()/(2*n)) *(x))+ (base_img.height()/2)+13, str(x))
cal_painter.end()
base_img = cal_img
return base_img
def drawMapObject(self, painter, object, color):
painter.save()
pen = QPen(Qt.black)
pen.setCosmetic(True)
cell = object.cell()
if (not cell.isEmpty()):
tile = cell.tile
imgSize = tile.size()
pos = self.pixelToScreenCoords_(object.position())
tileOffset = tile.offset()
CellRenderer(painter).render(cell, pos, object.size(), CellRenderer.BottomCenter)
if (self.testFlag(RenderFlag.ShowTileObjectOutlines)):
rect = QRectF(QPointF(pos.x() - imgSize.width() / 2 + tileOffset.x(),
pos.y() - imgSize.height() + tileOffset.y()),
QSizeF(imgSize))
pen.setStyle(Qt.SolidLine)
painter.setPen(pen)
painter.drawRect(rect)
pen.setStyle(Qt.DotLine)
pen.setColor(color)
painter.setPen(pen)
painter.drawRect(rect)
else:
lineWidth = self.objectLineWidth()
scale = self.painterScale()
x = 1
if lineWidth != 0:
x = lineWidth
shadowOffset = x / scale
brushColor = QColor(color)
brushColor.setAlpha(50)
brush = QBrush(brushColor)
pen.setJoinStyle(Qt.RoundJoin)
pen.setCapStyle(Qt.RoundCap)
pen.setWidth(lineWidth)
colorPen = QPen(pen)
colorPen.setColor(color)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing)
# TODO: Do something sensible to make null-sized objects usable
x = object.shape()
if x==MapObject.Ellipse:
polygon = self.pixelRectToScreenPolygon(object.bounds())
tw = self.map().tileWidth()
th = self.map().tileHeight()
transformScale = QPointF(1, 1)
if (tw > th):
transformScale = QPointF(1, th/tw)
else:
transformScale = QPointF(tw/th, 1)
l1 = polygon.at(1) - polygon.at(0)
l2 = polygon.at(3) - polygon.at(0)
trans = QTransform()
trans.scale(transformScale.x(), transformScale.y())
trans.rotate(45)
iTrans, ok = trans.inverted()
l1x = iTrans.map(l1)
l2x = iTrans.map(l2)
ellipseSize = QSizeF(l1x.manhattanLength(), l2x.manhattanLength())
if (ellipseSize.width() > 0 and ellipseSize.height() > 0):
painter.save()
painter.setPen(pen)
painter.translate(polygon.at(0))
painter.scale(transformScale.x(), transformScale.y())
painter.rotate(45)
painter.drawEllipse(QRectF(QPointF(0, 0), ellipseSize))
painter.restore()
painter.setBrush(Qt.NoBrush)
painter.drawPolygon(polygon)
painter.setPen(colorPen)
painter.setBrush(Qt.NoBrush)
painter.translate(QPointF(0, -shadowOffset))
painter.drawPolygon(polygon)
painter.setBrush(brush)
if (ellipseSize.width() > 0 and ellipseSize.height() > 0):
painter.save()
painter.translate(polygon.at(0))
painter.scale(transformScale.x(), transformScale.y())
painter.rotate(45)
painter.drawEllipse(QRectF(QPointF(0, 0), ellipseSize))
painter.restore()
elif x==MapObject.Rectangle:
polygon = self.pixelRectToScreenPolygon(object.bounds())
painter.drawPolygon(polygon)
painter.setPen(colorPen)
painter.setBrush(brush)
polygon.translate(0, -shadowOffset)
painter.drawPolygon(polygon)
elif x==MapObject.Polygon:
pos = object.position()
polygon = object.polygon().translated(pos)
screenPolygon = self.pixelToScreenCoords_(polygon)
thickPen = QPen(pen)
thickColorPen = QPen(colorPen)
thickPen.setWidthF(thickPen.widthF() * 4)
thickColorPen.setWidthF(thickColorPen.widthF() * 4)
painter.drawPolygon(screenPolygon)
painter.setPen(thickPen)
painter.drawPoint(screenPolygon.first())
painter.setPen(colorPen)
painter.setBrush(brush)
screenPolygon.translate(0, -shadowOffset)
painter.drawPolygon(screenPolygon)
painter.setPen(thickColorPen)
painter.drawPoint(screenPolygon.first())
elif x==MapObject.Polyline:
pos = object.position()
polygon = object.polygon().translated(pos)
screenPolygon = self.pixelToScreenCoords_(polygon)
thickPen = QPen(pen)
thickColorPen = QPen(colorPen)
thickPen.setWidthF(thickPen.widthF() * 4)
thickColorPen.setWidthF(thickColorPen.widthF() * 4)
painter.drawPolyline(screenPolygon)
painter.setPen(thickPen)
painter.drawPoint(screenPolygon.first())
painter.setPen(colorPen)
screenPolygon.translate(0, -shadowOffset)
painter.drawPolyline(screenPolygon)
painter.setPen(thickColorPen)
painter.drawPoint(screenPolygon.first())
painter.restore()
_PATH_CENTER = QPointF(styles.PATH_BASE_WIDTH / 2,\
styles.PATH_BASE_WIDTH / 2)
_PATH_U_CENTER = QPointF(styles.PATH_BASE_WIDTH / 2, 0)
_PATH_D_CENTER = QPointF(styles.PATH_BASE_WIDTH / 2, styles.PATH_BASE_WIDTH)
_PPATH_LU = QPainterPath()
_hashMarkGen(_PPATH_LU, _PP_RECT.bottomLeft(), _PATH_D_CENTER, _PATH_CENTER)
_PPATH_RU = QPainterPath()
_hashMarkGen(_PPATH_RU, _PP_RECT.bottomRight(), _PATH_D_CENTER, _PATH_CENTER)
_PPATH_RD = QPainterPath()
_hashMarkGen(_PPATH_RD, _PP_RECT.topRight(), _PATH_U_CENTER, _PATH_CENTER)
_PPATH_LD = QPainterPath()
_hashMarkGen(_PPATH_LD, _PP_RECT.topLeft(), _PATH_U_CENTER, _PATH_CENTER)
_SCAF_PEN = QPen(styles.PXI_SCAF_STROKE, styles.PATH_STRAND_STROKE_WIDTH)
_SCAF_PEN.setCapStyle(Qt.FlatCap) # or Qt.RoundCap
_SCAF_PEN.setJoinStyle(Qt.RoundJoin)
_STAP_PEN = QPen(styles.PXI_STAP_STROKE, styles.PATH_STRAND_STROKE_WIDTH)
_STAP_PEN.setCapStyle(Qt.FlatCap) # or Qt.RoundCap
_STAP_PEN.setJoinStyle(Qt.RoundJoin)
_DISAB_PEN = QPen(styles.PXI_DISAB_STROKE, styles.PATH_STRAND_STROKE_WIDTH)
_DISAB_PEN.setCapStyle(Qt.FlatCap)
_DISAB_PEN.setJoinStyle(Qt.RoundJoin)
_DISAB_BRUSH = QBrush(styles.PXI_DISAB_STROKE) # For the helix number label
_ENAB_BRUSH = QBrush(Qt.SolidPattern) # Also for the helix number label
_BASE_WIDTH = styles.PATH_BASE_WIDTH
_RECT = QRectF(0, 0, styles.PATH_BASE_WIDTH, 1.2*styles.PATH_BASE_WIDTH)
_TO_HELIX_NUM_FONT = styles.XOVER_LABEL_FONT
# precalculate the height of a number font. Assumes a fixed font
# and that only numbers will be used for labels
_FM = QFontMetrics(_TO_HELIX_NUM_FONT)
