def paintEvent(self, event):
painter = QPainter(self)
image = self._alignment.image()
painter.drawImage(self.rect(), QImage(image.tobytes(), *image.shape,
QImage.Format_Grayscale8))
painter.setCompositionMode(QPainter.CompositionMode_Lighten)
pen = QPen()
pen.setWidth(self.width()/500)
pen.setCapStyle(Qt.RoundCap)
painter.scale(self.width() / image.shape[0],
self.height() / image.shape[1])
def drawCentre(color, y, x):
pen.setColor(color)
painter.setPen(pen)
length = self.width() /10
painter.translate(x, y)
painter.drawLine(-length, -length, length, length)
painter.drawLine(-length, length, length, -length)
painter.drawEllipse(QPoint(0, 0), length/2, length/2)
painter.translate(-x, -y)
drawCentre(Qt.red, *self._alignment.reference())
drawCentre(Qt.green, *self._alignment.current())
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
class PartialLinkGI(QGraphicsPathItem):
def __init__(self, dstTempPos=(0, 0)):
super().__init__()
self.dstTempPos = dstTempPos
# set the pen style
self.linkPen = QPen()
self.linkPen.setWidth(2)
self.linkPen.setCapStyle(Qt.RoundCap)
self.linkPen.setColor(schemastyle.LINK_COLOR)
self.setPen(self.linkPen)
def setSourceSocket(self, srcSock):
self.srcSocket = srcSock
self.srcSocket.link = self
self.updateShape()
def setDestTempPos(self, xpos, ypos):
self.dstTempPos = xpos, ypos
self.updateShape()
def updateShape(self):
# Create the bezier curve path
srcX, srcY = self.srcSocket.linkConnectionPos()
dstX, dstY = self.dstTempPos
linkPath = QPainterPath()
linkPath.setFillRule(Qt.WindingFill)
linkPath.moveTo(srcX, srcY)
linkPath.cubicTo(srcX + 100, srcY, dstX - 100, dstY, dstX, dstY)
self.setPath(linkPath)
def __init__(self):
super().__init__()
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setScene(QGraphicsScene())
self.setBackgroundBrush(Qt.transparent)
self.setRenderHint(QPainter.Antialiasing)
self.graph = self.scene().addPolygon(QPolygonF(), QPen(Qt.transparent),
QBrush())
color = QColor.fromRgb(0x35, 0x37, 0x72)
pen = QPen(color, 3)
pen.setCapStyle(Qt.RoundCap)
self.path = self.scene().addPath(QPainterPath(), pen)
self.score_text = self.scene().addText("")
self.score_text.setDefaultTextColor(color)
self.msg_text = self.scene().addText("")
self.msg_text.setDefaultTextColor(color)
self.msg_text.setX(0)
self.msg_text.setY(0)
self.sitting_time_text = self.scene().addText("")
self.sitting_time_text.setDefaultTextColor(color)
self.score_list = [0]
self.minimize = False
self.size_changed(False)
self.connected_changed(False)
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 __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
pen = QPen(Qt.red)
pen.setWidth(3)
pen.setCapStyle(Qt.RoundCap)
scene = QtWidgets.QGraphicsScene()
pen.setCosmetic(True)
scene.addPixmap(QPixmap('back.png'))
self.item = scene.addLine(60, 170, 97, 97, pen)
pen = QtGui.QPen(QtGui.QColor(QtCore.Qt.gray))
brush = QtGui.QBrush(pen.color().darker(100))
scene.addEllipse(87, 87, 20, 20, pen, brush)
self.item.setTransformOriginPoint(97, 97)
self.Grafik.setScene(scene)
self.stop_flag_time = Event()
self.stop_flag_RS232 = Event()
self.getController = Controller(self.stop_flag_time)
self.getController.start()
self.getController.newTime.connect(self.updateTime)
self.getArduino = ControlArduino(self.stop_flag_RS232)
self.getArduino.newValue.connect(self.updatePoti)
self.getArduino.testRS232.connect(self.updateInfoRS232)
self.getArduino.start()
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 drawPointOnVideo(number, pt, painter, surface, gt):
''' Draw Points on Video '''
if hasElevationModel():
pt = GetLine3DIntersectionWithPlane(
GetSensor(), pt, GetFrameCenter()[2])
scr_x, scr_y = vut.GetInverseMatrix(
pt[1], pt[0], gt, surface)
# don't draw something outside the screen.
if scr_x < vut.GetXBlackZone(surface) or scr_y < vut.GetYBlackZone(surface):
return
if scr_x > vut.GetXBlackZone(surface) + vut.GetNormalizedWidth(surface) or scr_y > vut.GetYBlackZone(surface) + vut.GetNormalizedHeight(surface):
return
radius = 10
center = QPoint(scr_x, scr_y)
pen = QPen(Qt.red)
pen.setWidth(radius)
pen.setCapStyle(Qt.RoundCap)
painter.setPen(pen)
painter.drawPoint(center)
font12 = QFont("Arial", 12, weight=QFont.Bold)
painter.setFont(font12)
painter.drawText(center + QPoint(5, -5), str(number))
return
def paint(self, painter, QStyleOptionGraphicsItem, widget=None):
pen = QPen(QBrush(self.color), self.thickness)
pen.setCapStyle(Qt.FlatCap)
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(pen)
painter.drawArc(self.drawingRect, self.startAngle, self.spanAngle)
def drawLinesOnVideo(self, pt):
''' Draw Lines on Video '''
scr_x, scr_y = self.GetInverseMatrix(pt[1], pt[0])
radius = 3
center = QPoint(scr_x, scr_y)
pen = QPen(Qt.yellow)
pen.setWidth(radius)
pen.setCapStyle(Qt.RoundCap)
pen.setDashPattern([1, 4, 5, 4])
painter_p = QPainter(self)
painter_p.setPen(pen)
painter_p.setRenderHint(QPainter.HighQualityAntialiasing, True)
painter_p.drawPoint(center)
if len(self.drawLines) > 1:
try:
idx = self.drawLines.index(pt)
scr_x, scr_y = self.GetInverseMatrix(
self.drawLines[idx + 1][1], self.drawLines[idx + 1][0])
end = QPoint(scr_x, scr_y)
painter_p.drawLine(center, end)
except:
None
return
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 draw_beacon_indicators(painter: QPainter, map: map, robot: Robot):
pen = QPen()
pen.setStyle(Qt.DotLine)
pen.setCapStyle(Qt.RoundCap)
pen.setBrush(SETTINGS["COLOR_BEACON"])
pen.setWidth(2)
painter.setPen(pen)
distances = [b.distance_to(robot.x, robot.y) for b in map.beacons]
closest_beacon_id = distances.index(min(distances))
for i, beacon in enumerate(map.beacons):
if beacon.distance_to(
robot.x, robot.y) <= SETTINGS["BEACON_INDICATOR_DISTANCE"]:
painter.drawLine(beacon.x, beacon.y, robot.x, robot.y)
if i == closest_beacon_id:
pen.setWidth(1)
pen.setStyle(Qt.SolidLine)
painter.setPen(pen)
painter.drawEllipse(QPoint(beacon.x, beacon.y),
SETTINGS["BEACON_SIZE"] * 1.2,
SETTINGS["BEACON_SIZE"] * 1.2)
pen.setWidth(2)
pen.setStyle(Qt.DotLine)
painter.setPen(pen)
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 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 paintEvent(self, QPaintEvent):
font = QFont("宋体", 20, QFont.Black, True)
painter = QPainter(self)
if self.is_show_tri:
painter.drawPixmap(
self.rect(),
QPixmap(
self.qtri_img.scaled(self.size(), Qt.IgnoreAspectRatio,
Qt.SmoothTransformation)))
else:
painter.drawPixmap(self.rect(), self.qPixmap)
pen = QPen()
pen.setCapStyle(Qt.RoundCap)
pen.setWidth(10)
pen.setBrush(QColor(255, 0, 0))
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setFont(font)
for i, pos in enumerate(self.points):
pen.setBrush(QColor(255, 0, 0))
painter.setPen(pen)
painter.drawPoint(pos)
pen.setBrush(QColor(218, 112, 214))
painter.setPen(pen)
painter.drawText(pos, str(i))
def paintEvent(self, event: QPaintEvent):
QPushButton.paintEvent(self, event)
if not self._delay:
return
# set progress parameter
width = self.width - self.progress_width
height = self.height - self.progress_width
margin = self.progress_width // 2
value = self.value * 360 // self.MAX_VALUE
# painter
paint = QPainter()
paint.begin(self)
paint.setRenderHint(QPainter.HighQualityAntialiasing)
# draw rectangle
rect = QRect(0, 0, self.width, self.height)
paint.setPen(Qt.NoPen)
paint.drawRect(rect)
# pen
pen = QPen()
color = QColor(self.progress_color)
pen.setColor(color)
pen.setWidth(11)
# set round cap
if self.progress_rounded_cap:
pen.setCapStyle(Qt.RoundCap)
# create arc / circular progress
paint.setPen(pen)
paint.drawArc(margin, margin, width, height, -90 * 16, -value * 16)
paint.end()
def __init__(self, port_mode, port_type, parent):
QGraphicsPathItem.__init__(self)
self.setParentItem(parent)
self.m_port_mode = port_mode
self.m_port_type = port_type
# Port position doesn't change while moving around line
self.p_itemX = self.scenePos().x()
self.p_itemY = self.scenePos().y()
self.p_width = parent.getPortWidth()
if port_type == PORT_TYPE_AUDIO_JACK:
pen = QPen(canvas.theme.line_audio_jack, 2)
elif port_type == PORT_TYPE_MIDI_JACK:
pen = QPen(canvas.theme.line_midi_jack, 2)
elif port_type == PORT_TYPE_MIDI_ALSA:
pen = QPen(canvas.theme.line_midi_alsa, 2)
elif port_type == PORT_TYPE_PARAMETER:
pen = QPen(canvas.theme.line_parameter, 2)
else:
qWarning(
"PatchCanvas::CanvasBezierLineMov({}, {}, {}) - invalid port type"
.format(port_mode2str(port_mode), port_type2str(port_type),
parent))
pen = QPen(Qt.black)
pen.setCapStyle(Qt.FlatCap)
pen.setWidthF(pen.widthF() + 0.00001)
self.setPen(pen)
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):
epyqlib.widgets.abstractwidget.AbstractWidget.paintEvent(self, event)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.translate(self.width() / 2, self.height() / 2)
diameter = self.dimension() - self.tweaked_thickness()
radius = diameter / 2
rectangle = QRectF(-radius, -radius, diameter, diameter)
maximum = max(abs(self.maximum), abs(self.minimum))
span_angle = self.angle_span * (self.value / maximum)
if self.clockwise:
span_angle = -span_angle
pen = QPen()
pen.setWidthF(self.tweaked_thickness())
pen.setCapStyle(Qt.RoundCap)
pen.setColor(self.background_color)
painter.setPen(pen)
painter.drawEllipse(rectangle)
pen.setColor(self.color)
painter.setPen(pen)
qt_span = arc_angle(span_angle)
if qt_span == 0:
qt_span = 1
painter.drawArc(rectangle, arc_angle(self.zero_angle), qt_span)
def mouseMoveEvent(self, event):
if event.buttons() & Qt.LeftButton:
downPos = event.buttonDownPos(Qt.LeftButton)
if not self.__tmpLine and self.__dragStartItem and \
(downPos - event.pos()).manhattanLength() > \
QApplication.instance().startDragDistance():
# Start a line drag
line = QGraphicsLineItem(self)
start = self.__dragStartItem.boundingRect().center()
start = self.mapFromItem(self.__dragStartItem, start)
line.setLine(start.x(), start.y(),
event.pos().x(),
event.pos().y())
pen = QPen(Qt.black, 4)
pen.setCapStyle(Qt.RoundCap)
line.setPen(pen)
line.show()
self.__tmpLine = line
if self.__tmpLine:
# Update the temp line
line = self.__tmpLine.line()
line.setP2(event.pos())
self.__tmpLine.setLine(line)
QGraphicsWidget.mouseMoveEvent(self, event)
def labelPoints(self, img: Optional[QPixmap], toSrc: bool):
if not img or not self.points:
return None
painter = QPainter()
painter.begin(img)
painter.setRenderHint(QPainter.Antialiasing, True)
pen = QPen()
pen.setCapStyle(Qt.RoundCap)
font = QFont('Consolas')
if toSrc:
pen.setWidthF(config.pointWidth * self.ratioToSrc)
font.setPointSizeF(config.fontSize * self.ratioToSrc)
else:
pen.setWidthF(config.pointWidth)
font.setPointSizeF(config.fontSize)
painter.setFont(font)
for index, (point, color) in self.points.items():
labelPoint: QPointF
if toSrc:
pen.setColor(color)
labelPoint = self.getSrcPoint(point)
else:
pen.setColor(
color if index != self.highlightMoveIndex and index not in self.highlightPoints
else QColor.lighter(color)
)
labelPoint = point
painter.setPen(pen)
painter.drawPoint(labelPoint)
painter.drawText(static.getIndexShift(labelPoint), str(index))
painter.end()
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 labelLines(self, img: Optional[QPixmap], toSrc: bool):
if not img or not self.lines:
return None
painter = QPainter()
painter.begin(img)
painter.setRenderHint(QPainter.Antialiasing, True)
pen = QPen()
pen.setCapStyle(Qt.RoundCap)
font = QFont('Consolas')
if toSrc:
pen.setWidthF(config.lineWidth * self.ratioToSrc)
font.setPointSizeF(config.fontSize * self.ratioToSrc)
else:
pen.setWidthF(config.lineWidth)
font.setPointSizeF(config.fontSize)
painter.setFont(font)
for (indexA, indexB), color in self.lines.items():
isHighlight = indexA in self.highlightPoints and indexB in self.highlightPoints \
and (self.mode == LabelMode.AngleMode or self.mode == LabelMode.VerticalMode)
pen.setColor(QColor.lighter(color) if isHighlight else color)
painter.setPen(pen)
A = self.points[indexA][0]
B = self.points[indexB][0]
srcA = self.getSrcPoint(A)
srcB = self.getSrcPoint(B)
labelPoint: QPointF
if toSrc:
painter.drawLine(srcA, srcB)
labelPoint = static.getMidpoint(srcA, srcB)
else:
painter.drawLine(A, B)
labelPoint = static.getMidpoint(A, B)
painter.drawText(static.getDistanceShift(A, B, labelPoint), str(round(static.getDistance(srcA, srcB), 2)))
painter.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 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 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 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 draw_points(self, qp):
pen = QPen(Qt.red)
pen.setCapStyle(Qt.RoundCap)
pen.setWidth(5)
qp.setPen(pen)
for point in self.points:
qp.drawPoint(point)
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 _updatePensAndBrushes(self):
color = QColor(_PENCIL_COLOR)
penWidth = styles.PATH_STRAND_STROKE_WIDTH
pen = QPen(color, penWidth)
brush = QBrush(color)
pen.setCapStyle(Qt.FlatCap)
self.setPen(pen)
self._low_cap.setBrush(brush)
self._high_cap.setBrush(brush)
def drawWidget(self, qp): color = self.palette().color(QPalette.Background) qp.setBrush(QColor(100,0,0)) pen=QPen() pen.setWidth(self.width()/10) pen.setColor(QColor(0,0,255)) pen.setCapStyle(Qt.RoundCap) w=self.width()/2 x_shift=w+w*0.05 y_shift=w+w*0.05 r=0.35*w r1=w*0.8 qp.setPen(pen) my_max=100 p=[] c=[] for phi in range(0,360,30): p.append(phi) c.append(0) f=0 for i in range(0,len(p)): if p[i]>self.delta: f=i break i=f m=1.0 while(i>=0): c[i]=m m=m*0.7 i=i-1 i=len(c)-1 while(i>f): c[i]=m m=m*0.7 i=i-1 for i in range(0,len(p)): self.pos=p[i] x = r * cos( (2*pi)*self.pos/360 ) y = r * sin( (2*pi)*self.pos/360 ) x1 = r1 * cos( (2*pi)*self.pos/360 ) y1 = r1 * sin( (2*pi)*self.pos/360 ) cb=self.blue_target*c[i]+color.blue()*(1.0-c[i]) cg=self.green_target*c[i]+color.green()*(1.0-c[i]) cr=self.red_target*c[i]+color.red()*(1.0-c[i]) pen.setColor(QColor(cr,cg,cb)) qp.setPen(pen) qp.drawLine(x+x_shift,y+y_shift,x1+x_shift,y1+y_shift)
def _updateColor(self, strand):
oligo = strand.oligo()
color = self.pen().color() if self.isSelected() else QColor(oligo.color())
# print "update xover color", color.value(), self.isSelected(), self.group(), self.parentItem()
pen_width = styles.PATH_STRAND_STROKE_WIDTH
if oligo.shouldHighlight():
pen_width = styles.PATH_STRAND_HIGHLIGHT_STROKE_WIDTH
color.setAlpha(128)
pen = QPen(color, pen_width)
# pen.setCosmetic(True)
pen.setCapStyle(Qt.FlatCap)
self.setPen(pen)
def __init__(self, id_pair, painter_path, initial_pen=None):
super(SingleEdgeItem, self).__init__()
self.parent = None # Should be initialized with set_parent()
self.id_pair = id_pair
if not initial_pen:
initial_pen = QPen()
initial_pen.setCosmetic(True)
initial_pen.setCapStyle(Qt.RoundCap)
initial_pen.setColor(Qt.white)
initial_pen.setWidth(3)
self.setPen(initial_pen)
self.setPath(painter_path)
def set_style(self, style):
super().set_style(style)
# minute
pen = QPen(self.style.foreground_color)
pen.setWidth(12)
pen.setCapStyle(Qt.RoundCap)
self.minutes_hand.setPen(pen)
# hour
pen = QPen(self.style.foreground_color)
pen.setWidth(16)
pen.setCapStyle(Qt.RoundCap)
self.hours_hand.setPen(pen)
# second
pen = QPen(self.style.midcolor)
pen.setWidth(4)
pen.setCapStyle(Qt.RoundCap)
self.seconds_hand.setPen(pen)
# outer circle
pen = QPen(self.style.foreground_color)
pen.setWidth(6)
self.circle.setPen(pen)
# inner circle
self.hand_circle.setBrush(QBrush(self.style.background_color))
# minute lines
pen = QPen()
pen.setCapStyle(Qt.RoundCap)
pen.setColor(self.style.midcolor)
pen.setWidth(4)
bold_pen = QPen()
bold_pen.setCapStyle(Qt.RoundCap)
bold_pen.setColor(self.style.foreground_color)
bold_pen.setWidth(6)
for i, line in enumerate(self.lines):
if i % 5 == 0:
line.setPen(bold_pen)
else:
line.setPen(pen)
self.layout()
def _updateHighlight(self, color):
"""
"""
oligo = self._model_strand.oligo()
pen_width = styles.PATH_STRAND_STROKE_WIDTH
if oligo.shouldHighlight():
color.setAlpha(128)
pen_width = styles.PATH_STRAND_HIGHLIGHT_STROKE_WIDTH
pen = QPen(color, pen_width)
# pen.setCosmetic(True)
brush = QBrush(color)
pen.setCapStyle(Qt.FlatCap)
self.setPen(pen)
self._low_cap.updateHighlight(brush)
self._high_cap.updateHighlight(brush)
self._dual_cap.updateHighlight(brush)
def _updateHighlight(self, color):
"""
"""
#TODO: called when oligo is highlighted
oligo = self._model_strand.oligo()
pen_width = styles.PATH_STRAND_STROKE_WIDTH
if oligo.shouldHighlight():
color.setAlpha(128)
pen_width = styles.PATH_STRAND_HIGHLIGHT_STROKE_WIDTH
pen = QPen(color, pen_width)
pen.setCosmetic(False)
brush = QBrush(color)
pen.setCapStyle(QtCore.Qt.FlatCap)
self.setPen(pen)
self._low_cap.updateHighlight(brush)
self._high_cap.updateHighlight(brush)
self._dual_cap.updateHighlight(brush)
self._tick.updateHighlight(brush)
self.toeholdCap3p().updateHighlight(brush)
self.toeholdCap5p().updateHighlight(brush)
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 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 paintEdge(self, painter, lod):
pen = QPen(Qt.black)
pen.setWidth(1)
pen.setCapStyle(Qt.RoundCap)
brush = QBrush(self.edgeColor)
if self.hover:
#pen.setColor(self.edgeColorHover)
brush.setColor(self.edgeColorHover)
if QGraphicsItem.isSelected(self):
#pen.setColor(self.edgeColorSelected)
brush.setColor(self.edgeColorSelected)
painter.setPen(pen)
painter.setBrush(brush)
edgePath = self.getEdgePath()
edgePath = edgePath.simplified()
painter.drawPath(edgePath)
if lod > 0.4:
self.drawPCRates(painter)
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()
import time
import numpy as np
from PyQt5.QtGui import QTransform
from PyQt5.QtWidgets import QApplication, QGraphicsView, QGraphicsScene
app = QApplication([])
import h5py
with h5py.File("/magnetic/data/multicut-testdata/2d/256/Superpixels.h5", "r") as superpixels_f:
labels_img = superpixels_f["data"][:]
labels_img = labels_img[..., 0] # drop channel
default_pen = QPen()
default_pen.setCosmetic(True)
default_pen.setCapStyle(Qt.RoundCap)
default_pen.setColor(Qt.blue)
default_pen.setWidth(3)
# Changes to this pen table will be detected automatically in the QGraphicsItem
pen_table = SignalingDict(None)
start = time.time()
path_items = generate_path_items_for_labels(pen_table, default_pen, labels_img, None)
print("generate took {}".format(time.time() - start)) # 52 ms
edges_item = SegmentationEdgesItem(path_items, pen_table, default_pen)
def assign_random_color(id_pair, buttons):
print("handling click: {}".format(id_pair))
pen = pen_table[id_pair]
def _updateFloatPen(self):
pen_width = styles.PATH_STRAND_STROKE_WIDTH
pen = QPen(_PENCIL_COLOR, pen_width)
pen.setCapStyle(Qt.FlatCap)
self.setPen(pen)
_PP_RECT = QRectF(0, 0, styles.PATH_BASE_WIDTH, styles.PATH_BASE_WIDTH)
_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)
