def paintEvent( self, event ): """ Das automatisch ausgelöste paintEvent, das das Widget bei jeder Fensterveränderung neu zeichnet. """ if self.__maximum > 0: frameWidth = 1 separatorWidth = 1 # Damit der Rahmen nicht irgendwie abgeschnitten wird, muß das Quadrat entsprechend kleiner sein. squareSideLength = 10 framePen = QPen( frameWidth ) framePen.setColor( self.__colorFrame ) squareSideLengthPlus = squareSideLength + 2 * frameWidth painter = QPainter( self ) windowWidth = self.width() / min( self.__maximum, self.__columnMax ) windowHeight = self.__maximum / self.__columnMax windowHeight = math.ceil( windowHeight ) windowHeight = self.height() / windowHeight side = min( windowWidth, windowHeight ) painter.setRenderHint( QPainter.Antialiasing ) # Wenn das Widget disabled ist, muß ich den Alphakanal meiner Farben verändern. if ( not self.isEnabled() ): painter.setOpacity( .5 ) #painter.translate( float( windowWidth ), float( windowHeight ) ) painter.scale( side / squareSideLengthPlus, side / squareSideLengthPlus ) painter.setPen( framePen ) painter.setBrush( self.__colorEmpty ) painter.save() squareColumnIter = 0 squareLineIter = 0 squareCount = 0 for squareCount in range(self.__maximum): square = QRect( ( squareSideLength + separatorWidth ) * squareColumnIter + frameWidth * ( squareColumnIter + 1 ), ( squareSideLength + separatorWidth ) * squareLineIter + frameWidth * ( squareLineIter + 1 ), squareSideLength, squareSideLength ) painter.drawRect( square ) # Wir zeichnen die ausgekreuzten Quadrate if (self.__value > (self.__columnMax * squareLineIter + squareColumnIter)): painter.drawLine(square.bottomLeft(), square.topRight()) painter.drawLine(square.topLeft(), square.bottomRight()) squareColumnIter += 1 if ( squareColumnIter >= self.__columnMax ): squareColumnIter = 0 squareLineIter += 1 painter.restore()
def drawForeground(self, painter, rect):
QGraphicsView.drawForeground(self, painter, rect)
if self._sel_accepted:
painter.save()
painter.resetTransform()
rect = self._sel_rect
viewport = self.viewport()
option = QStyleOptionRubberBand()
option.initFrom(viewport)
option.rect = self._sel_rect
option.shape = QRubberBand.Rectangle
mask = QStyleHintReturnMask()
self.style().drawControl(QStyle.CE_RubberBand, option, painter,
viewport)
painter.restore()
elif self._div_accepted:
painter.save()
painter.resetTransform()
line = self._div_line
viewport = self.viewport()
palette = viewport.palette()
pen = QPen(Qt.DashDotLine)
pen.setWidth(2)
pen.setColor(Qt.red)
painter.setPen(pen)
painter.drawLine(self._div_line)
painter.restore()
def drawForeground(self, painter, rect):
if self._tiling is None:
return
tile_nos = self._tiling.intersected(rect)
for tileId in tile_nos:
p = self._brushingLayer[tileId]
if p.dataVer == p.imgVer:
continue
p.paint(painter) #access to the underlying image patch is serialized
## draw tile outlines
if self._showTileOutlines:
# Dashed black line
pen = QPen()
pen.setDashPattern([5,5])
painter.setPen(pen)
painter.drawRect(self._tiling.imageRects[tileId])
# Dashed white line
# (offset to occupy the spaces in the dashed black line)
pen = QPen()
pen.setDashPattern([5,5])
pen.setDashOffset(5)
pen.setColor(QColor(Qt.white))
painter.setPen(pen)
painter.drawRect(self._tiling.imageRects[tileId])
def drawForeground(self, painter, rect):
QGraphicsView.drawForeground(self, painter, rect)
if self._sel_accepted:
painter.save()
painter.resetTransform()
rect = self._sel_rect
viewport = self.viewport()
option = QStyleOptionRubberBand()
option.initFrom(viewport)
option.rect = self._sel_rect
option.shape = QRubberBand.Rectangle
mask = QStyleHintReturnMask()
self.style().drawControl(QStyle.CE_RubberBand, option, painter, viewport);
painter.restore()
elif self._div_accepted:
painter.save()
painter.resetTransform()
line = self._div_line
viewport = self.viewport()
palette = viewport.palette()
pen = QPen(Qt.DashDotLine)
pen.setWidth(2)
pen.setColor(Qt.red)
painter.setPen(pen)
painter.drawLine(self._div_line)
painter.restore()
def __init__(self, parent, pos, angle, pit=False):
QGraphicsItemGroup.__init__(self, parent)
AbstractSector.__init__(self, pos, angle)
self.setZValue(3)
self.black = QGraphicsPathItem(self)
self.white = QGraphicsPathItem(self)
start = 3 * (_trackWidth / 2)
end = -start - abs(_pitDistance if pit else 0)
rowdelta = _trackWidth / 4
for item, y in [(self.black, -rowdelta),
(self.white, rowdelta)]:
item.setCacheMode(QGraphicsPathItem.DeviceCoordinateCache)
self.addToGroup(item)
path = QPainterPath()
path.moveTo(start, y)
path.lineTo(end, y)
path.moveTo(end, -y)
path.lineTo(start, -y)
item.setPath(path)
pen = QPen(Qt.black, _trackWidth / 2)
pen.setCapStyle(Qt.FlatCap)
pen.setDashPattern([1, 1])
self.black.setPen(QPen(pen))
pen.setColor(Qt.white)
self.white.setPen(pen)
def paintEvent(self, event):
painter = QPainter(self)
minSize = min(self.rect().width(), self.rect().height())
myRect = QRect(self.rect().x(), self.rect().y(), minSize, minSize)
painter.drawPixmap(myRect, self.backgroundPic,
self.backgroundPic.rect())
pen = QPen()
pen.setCapStyle(Qt.RoundCap)
pen.setWidthF(4.0)
pen.setColor(Qt.red)
pen.setJoinStyle(Qt.RoundJoin)
painter.setPen(pen)
spacing = 40
contentRect = myRect.adjusted(spacing, spacing, -spacing, -spacing)
valueInPercent = (self.m_value - self.m_minimum) / (self.m_maximum -
self.m_minimum)
math_pi = 3.14159265358979323846
degree = (self.m_startAngle +
90) - valueInPercent * 2.0 * self.m_startAngle
degree = degree * math_pi / 180.0
radius = (contentRect.width() - spacing * 0.5) * 0.5
vec = QPoint(radius * math.cos(degree), radius * -math.sin(degree))
painter.drawLine(contentRect.center(), contentRect.center() + vec)
def draw_image(name, q): image = QSvgGenerator() image.setSize(QSize(IMAGE_SIZE, IMAGE_SIZE)) image.setFileName(name + ".svg") painter = QPainter() painter.begin(image) painter.setBrush(Qt.white) painter.setPen(Qt.NoPen) painter.drawEllipse(QPointF(IMAGE_SIZE/2, IMAGE_SIZE/2), IMAGE_SIZE/2, IMAGE_SIZE/2) painter.setBrush(QBrush()) painter.setPen(QPen()) draw_defect(painter, q) draw_circle(painter, q) pen = QPen() pen.setWidth(7) pen.setColor(Qt.red) painter.setPen(pen) painter.drawLine(IMAGE_SIZE/2 - ARROW_SIZE, IMAGE_SIZE/2, IMAGE_SIZE/2 + ARROW_SIZE, IMAGE_SIZE/2) painter.drawLine(IMAGE_SIZE/2 + ARROW_SIZE, IMAGE_SIZE/2, IMAGE_SIZE/2 + ARROW_SIZE - 30, IMAGE_SIZE/2 + 20) painter.drawLine(IMAGE_SIZE/2 + ARROW_SIZE, IMAGE_SIZE/2, IMAGE_SIZE/2 + ARROW_SIZE - 30, IMAGE_SIZE/2 - 20) font = painter.font() font.setPixelSize(40) font.setBold(True) painter.setFont(font) painter.drawText(QPointF(IMAGE_SIZE/2 + ARROW_SIZE - 30, IMAGE_SIZE/2 - 30), "E") painter.end()
def paintEvent(self, QPaintEvent):
super(LabelerWindow, self).paintEvent(QPaintEvent)
p = QtGui.QPainter(self)
image = ImageQt(Image.fromarray(self.buffer))
image = image.scaled(self.width(), self.height())
p.drawImage(0, 0, image)
# Now for the HUD
# -> Draw green cross-hairs
old_pen = p.pen()
new_pen = QPen()
new_pen.setColor(Qt.green)
new_pen.setStyle(Qt.DotLine)
new_pen.setWidth(1)
p.setPen(new_pen)
p.drawLine(0, self.height()/2, self.width(), self.height()/2)
p.drawLine(self.width()/2, 0, self.width()/2, self.height())
p.setPen(old_pen)
# -> Show help for keystrokes
help = "[X] Pos. [C] Neg. [UP] Zoom in [DN] Zoom Out [LT] Undo Last [RT] Ignore [LMB] Move "
p.fillRect(0, 0, self.width(), p.fontMetrics().height()*1.5, Qt.gray)
p.drawText(0, p.fontMetrics().height(), help)
def paint(self, painter, option, widget): #Set Pen############################# if self.isSelected(): line_style = Qt.DashLine width = 2 steps = 25 else: line_style = Qt.SolidLine width = 2 steps = 125 pen = QPen() pen.setWidth(width) pen.setColor(self._color) pen.setStyle(line_style) painter.setPen(pen) self.setSteps(steps) ###################################### #painter.drawLine(self.p1(),self.p2()) control_points = self.controlPoints() oldPoint = control_points[0] for point in bezierCurveRange(self.steps(), control_points): painter.drawLine(self.mapToScene(oldPoint), self.mapToScene(point)) oldPoint = point
def create_multicut_edge_layer(self):
ActionInfo = ShortcutManager.ActionInfo
op = self.__topLevelOperatorView
if not op.Output.ready():
return None
# Final segmentation -- Edges
default_pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN)
default_pen.setColor(Qt.blue)
layer = SegmentationEdgesLayer(LazyflowSource(op.Output), default_pen)
layer.name = "Multicut Edges"
layer.visible = False # Off by default...
layer.opacity = 1.0
layer.shortcutRegistration = (
"m",
ActionInfo(
"Multicut",
"MulticutEdgesVisibility",
"Show/Hide Multicut Edges",
layer.toggleVisible,
self.viewerControlWidget(),
layer,
),
)
return layer
def __drawLine(self, painter, graph, width, height): path = QPainterPath() try: day = graph[0][0].day value = graph[0][0].data(self.__index) (x, y) = self.__getCoordinates(width, height, day, value) path.moveTo(x, y) except IndexError: pass for pos in range(1, len(graph[0])): point = graph[0][pos] day = point.day value = point.data(self.__index) (x, y) = self.__getCoordinates(width, height, day, value) path.lineTo(x, y) pen = QPen() pen.setColor(QColor(graph[2])) pen.setWidth(3) pen.setCapStyle(Qt.RoundCap); pen.setJoinStyle(Qt.RoundJoin); painter.setPen(pen) painter.setBrush(Qt.NoBrush) painter.drawPath(path)
def draw_arrow(self, line, width, color):
(x1, y1), (x2, y2) = line
# compute points
line = QLineF(x1, y1, x2, y2)
# If the line is very small, we make our arrowhead smaller
arrowsize = min(14, line.length())
lineangle = radians(line.angle())
arrowpt1 = line.p2() + QPointF(sin(lineangle - (pi/3)) * arrowsize, cos(lineangle - (pi/3)) * arrowsize)
arrowpt2 = line.p2() + QPointF(sin(lineangle - pi + (pi/3)) * arrowsize, cos(lineangle - pi + (pi/3)) * arrowsize)
head = QPolygonF([line.p2(), arrowpt1, arrowpt2])
# We have to draw the actual line a little short for the tip of the arrowhead not to be too wide
adjustedLine = QLineF(line)
adjustedLine.setLength(line.length() - arrowsize/2)
# draw line
painter = self.current_painter
color = COLORS[color]
painter.save()
pen = QPen(painter.pen())
pen.setColor(color)
pen.setWidthF(width)
painter.setPen(pen)
painter.drawLine(adjustedLine)
# draw arrowhead
painter.setPen(Qt.NoPen)
brush = painter.brush()
brush.setColor(color)
brush.setStyle(Qt.SolidPattern)
painter.setBrush(brush)
painter.drawPolygon(head)
painter.restore()
def draw( self, scene, baseX, baseY ):
" Draws the diagram on the real canvas "
self.baseX = baseX
self.baseY = baseY
currentY = baseY
for row in self.cells:
if not row:
continue
height = row[ 0 ].height
currentX = baseX
for cell in row:
if self.settings.debug:
pen = QPen( Qt.DotLine )
pen.setWidth( 1 )
if cell.kind == CellElement.VCANVAS:
pen.setColor( QColor( 255, 0, 0, 255 ) )
scene.addLine( currentX + 1, currentY + 1, currentX + cell.width - 2, currentY + 1, pen )
scene.addLine( currentX + 1, currentY + 1, currentX + 1, currentY + cell.height - 2, pen )
scene.addLine( currentX + 1, currentY + cell.height - 2, currentX + cell.width - 2, currentY + cell.height - 2, pen )
scene.addLine( currentX + cell.width - 2, currentY + 1, currentX + cell.width - 2, currentY + cell.height - 2, pen )
else:
pen.setColor( QColor( 0, 255, 0, 255 ) )
scene.addLine( currentX, currentY, currentX + cell.width, currentY, pen )
scene.addLine( currentX, currentY, currentX, currentY + cell.height, pen )
scene.addLine( currentX, currentY + cell.height, currentX + cell.width, currentY + cell.height, pen )
scene.addLine( currentX + cell.width, currentY, currentX + cell.width, currentY + cell.height, pen )
cell.draw( scene, currentX, currentY )
currentX += cell.width
currentY += height
return
def paintEvent(self, QPaintEvent):
super(LabelerWindow, self).paintEvent(QPaintEvent)
p = QtGui.QPainter(self)
image = ImageQt(Image.fromarray(self.buffer))
image = image.scaled(self.width(), self.height())
p.drawImage(0, 0, image)
# Now for the HUD
# -> Draw green cross-hairs
old_pen = p.pen()
new_pen = QPen()
new_pen.setColor(Qt.green)
new_pen.setStyle(Qt.DotLine)
new_pen.setWidth(1)
p.setPen(new_pen)
p.drawLine(0, self.height() / 2, self.width(), self.height() / 2)
p.drawLine(self.width() / 2, 0, self.width() / 2, self.height())
p.setPen(old_pen)
# -> Show help for keystrokes
help = "[X] Pos. [C] Neg. [UP] Zoom in [DN] Zoom Out [LT] Undo Last [RT] Ignore [LMB] Move "
p.fillRect(0, 0, self.width(), p.fontMetrics().height() * 1.5, Qt.gray)
p.drawText(0, p.fontMetrics().height(), help)
def paintEvent(self, event): """ Reimplements the :meth:`QWidget.paintEvent` method. :param event: Event. :type event: QEvent """ def __setBold(state): """ Sets the current painter font bold state. :return: Definiton success. :rtype: bool """ font = painter.font() font.setBold(state) painter.setFont(font) return True painter = QPainter(self) painter.fillRect(event.rect(), self.__backgroundColor) pen = QPen(QBrush(), self.__separatorWidth) pen.setColor(self.__separatorColor) painter.setPen(pen) topRightCorner = event.rect().topRight() bottomRightCorner = event.rect().bottomRight() painter.drawLine(topRightCorner.x(), topRightCorner.y(), bottomRightCorner.x(), bottomRightCorner.y()) painter.setPen(self.__color) viewportHeight = self.__editor.viewport().height() metrics = QFontMetrics(self.__editor.document().defaultFont()) currentBlock = self.__editor.document().findBlock( self.__editor.textCursor().position()) block = self.__editor.firstVisibleBlock() blockNumber = block.blockNumber() painter.setFont(self.__editor.document().defaultFont()) while block.isValid(): blockNumber += 1 position = self.__editor.blockBoundingGeometry(block).topLeft() + self.__editor.contentOffset() if position.y() > viewportHeight: break if not block.isVisible(): continue block == currentBlock and __setBold(True) or __setBold(False) painter.drawText(self.width() - metrics.width(foundations.strings.toString(blockNumber)) - self.__margin / 3, round(position.y() + metrics.ascent() + metrics.descent() - \ (self.__editor.blockBoundingRect(block).height() * 8.0 / 100)), foundations.strings.toString(blockNumber)) block = block.next() painter.end() QWidget.paintEvent(self, event)
def paint(self, painter, option, widget=None):
with painter_context(painter):
pen = QPen(painter.pen())
pen.setWidth(10.0)
pen.setColor( QColor(255,0,0) )
painter.setPen(pen)
shrunken_rectf = self.rectf.adjusted(10,10,-10,-10)
painter.drawRoundedRect(shrunken_rectf, 50, 50, Qt.RelativeSize)
def paint(self, painter, option, widget=None):
with painter_context(painter):
pen = QPen(painter.pen())
pen.setWidth(10.0)
pen.setColor( QColor(255,0,0) )
painter.setPen(pen)
shrunken_rectf = self.rectf.adjusted(10,10,-10,-10)
painter.drawRoundedRect(shrunken_rectf, 50, 50, Qt.RelativeSize)
def penForID(self, penId):
pen = QPen()
if penId == PenID.Axis:
pen.setColor(Qt.darkGray)
pen.setWidthF(self.LINE_WIDTH)
elif penId == PenID.AxisOverlay:
pen.setColor(Qt.darkGray)
pen.setWidthF(self.OVERLAY_AXIS_WIDTH)
return pen
def penForID(self, penId):
if penId == PenID.Bar:
return self.linePen
elif penId == PenID.TodayLine:
pen = QPen(self.linePen)
pen.setColor(Qt.red)
return pen
else:
return GraphView.penForID(self, penId)
def setupLayers(self):
layers = []
op = self.__topLevelOperatorView
mc_edge_layer = self.create_multicut_edge_layer()
if mc_edge_layer:
layers.append(mc_edge_layer)
# Superpixels -- Edge Probabilities
# We use the RAG's superpixels, which may have different IDs
self.superpixel_edge_layer = None
if op.Superpixels.ready() and op.EdgeProbabilitiesDict.ready():
layer = SegmentationEdgesLayer(LazyflowSource(op.Superpixels))
layer.name = "Superpixel Edge Probabilities"
layer.visible = True
layer.opacity = 1.0
self.superpixel_edge_layer = layer
self.__update_probability_edges() # Initialize
layers.append(layer)
del layer
# Superpixels -- Edges
if op.Superpixels.ready():
default_pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN)
default_pen.setColor(Qt.yellow)
layer = SegmentationEdgesLayer(LazyflowSource(op.Superpixels),
default_pen)
layer.name = "Superpixel Edges"
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
del layer
mc_seg_layer = self.create_multicut_segmentation_layer()
if mc_seg_layer:
layers.append(mc_seg_layer)
# Superpixels
if op.Superpixels.ready():
layer = self.createStandardLayerFromSlot(op.Superpixels)
layer.name = "Superpixels"
layer.visible = False
layer.opacity = 0.5
layers.append(layer)
del layer
# Raw Data (grayscale)
if op.RawData.ready():
layer = self.createStandardLayerFromSlot(op.RawData)
layer.name = "Raw Data"
layer.visible = True
layer.opacity = 1.0
layers.append(layer)
del layer
return layers
def assign_random_color( id_pair):
print "handling click: {}".format(id_pair)
pen = pen_table[id_pair]
if pen:
pen = QPen(pen)
else:
pen = QPen()
random_color = QColor( *list( np.random.randint(0,255,(3,)) ) )
pen.setColor(random_color)
pen_table[id_pair] = pen
def assign_random_color(id_pair, buttons):
print "handling click: {}".format(id_pair)
pen = pen_table[id_pair]
if pen:
pen = QPen(pen)
else:
pen = QPen()
random_color = QColor(*list(np.random.randint(0, 255, (3, ))))
pen.setColor(random_color)
pen_table[id_pair] = pen
def setupLayers(self):
layers = []
op = self.__topLevelOperatorView
mc_edge_layer = self.create_multicut_edge_layer()
if mc_edge_layer:
layers.append(mc_edge_layer)
# Superpixels -- Edge Probabilities
# We use the RAG's superpixels, which may have different IDs
self.superpixel_edge_layer = None
if op.Superpixels.ready() and op.EdgeProbabilitiesDict.ready():
layer = SegmentationEdgesLayer(LazyflowSource(op.Superpixels))
layer.name = "Superpixel Edge Probabilities"
layer.visible = True
layer.opacity = 1.0
self.superpixel_edge_layer = layer
self.__update_probability_edges() # Initialize
layers.append(layer)
del layer
# Superpixels -- Edges
if op.Superpixels.ready():
default_pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN)
default_pen.setColor(Qt.yellow)
layer = SegmentationEdgesLayer(LazyflowSource(op.Superpixels), default_pen)
layer.name = "Superpixel Edges"
layer.visible = False
layer.opacity = 1.0
layers.append(layer)
del layer
mc_seg_layer = self.create_multicut_segmentation_layer()
if mc_seg_layer:
layers.append(mc_seg_layer)
# Superpixels
if op.Superpixels.ready():
layer = self.createStandardLayerFromSlot(op.Superpixels)
layer.name = "Superpixels"
layer.visible = False
layer.opacity = 0.5
layers.append(layer)
del layer
# Raw Data (grayscale)
if op.RawData.ready():
layer = self.createStandardLayerFromSlot(op.RawData)
layer.name = "Raw Data"
layer.visible = True
layer.opacity = 1.0
layers.append(layer)
del layer
return layers
def paintEvent(event):
painter = QPainter(self.label_image)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
w = self.label_image.size().width()
h = self.label_image.size().height()
painter.scale(w / 80.0, h / 60.0)
painter.drawImage(0, 0, self.image)
if 35 != None and 45 != None:
pen = QPen()
pen.setColor(Qt.white)
pen.setWidth(0.2)
painter.setPen(pen)
from_x, from_y, to_x, to_y = [35, 25, 45, 35]
from_x = from_x * self.image_pixel_width + 1
from_y = from_y * self.image_pixel_width + 1
to_x = to_x * self.image_pixel_width + 1
to_y = to_y * self.image_pixel_width + 1
cross_x = from_x + (to_x - from_x) / 2.0
cross_y = from_y + (to_y - from_y) / 2.0
if to_x - from_x > 5 or to_y - from_y > 5:
lines = [
QLine(from_x, from_y, from_x + self.crosshair_width,
from_y),
QLine(from_x, from_y, from_x,
from_y + self.crosshair_width),
QLine(to_x, to_y, to_x, to_y - self.crosshair_width),
QLine(to_x, to_y, to_x - self.crosshair_width, to_y),
QLine(from_x, to_y, from_x,
to_y - self.crosshair_width),
QLine(from_x, to_y, from_x + self.crosshair_width,
to_y),
QLine(to_x, from_y, to_x,
from_y + self.crosshair_width),
QLine(to_x, from_y, to_x - self.crosshair_width,
from_y)
]
painter.drawLines(lines)
lines = [
QLine(cross_x - self.crosshair_width, cross_y,
cross_x + self.crosshair_width, cross_y),
QLine(cross_x, cross_y - self.crosshair_width, cross_x,
cross_y + self.crosshair_width)
]
painter.drawLines(lines)
self.update_spotmeter_roi_label()
def drawSkel(self, worm_img, worm_qimg, row_data, roi_corner=(0, 0)):
if not self.skel_file or not isinstance(self.trajectories_data,
pd.DataFrame):
return
c_ratio_y = worm_qimg.width() / worm_img.shape[1]
c_ratio_x = worm_qimg.height() / worm_img.shape[0]
skel_id = int(row_data['skeleton_id'])
qPlg = {}
with tables.File(self.skel_file, 'r') as ske_file_id:
for tt in ['skeleton', 'contour_side1', 'contour_side2']:
dat = ske_file_id.get_node('/' + tt)[skel_id]
dat[:, 0] = (dat[:, 0] - roi_corner[0]) * c_ratio_x
dat[:, 1] = (dat[:, 1] - roi_corner[1]) * c_ratio_y
qPlg[tt] = QPolygonF()
for p in dat:
qPlg[tt].append(QPointF(*p))
if 'is_good_skel' in row_data and row_data['is_good_skel'] == 0:
self.skel_colors = {
'skeleton': (102, 0, 0),
'contour_side1': (102, 0, 0),
'contour_side2': (102, 0, 0)
}
else:
self.skel_colors = {
'skeleton': (27, 158, 119),
'contour_side1': (217, 95, 2),
'contour_side2': (231, 41, 138)
}
pen = QPen()
pen.setWidth(2)
painter = QPainter()
painter.begin(worm_qimg)
for tt, color in self.skel_colors.items():
pen.setColor(QColor(*color))
painter.setPen(pen)
painter.drawPolyline(qPlg[tt])
pen.setColor(Qt.black)
painter.setBrush(Qt.white)
painter.setPen(pen)
radius = 3
painter.drawEllipse(qPlg['skeleton'][0], radius, radius)
painter.end()
def setup_mem_axis(self):
self.memAxis = QGraphicsLineItem(self.memXOffset, 0, self.memXOffset, self.memAxisLen, None, self.scene)
self.memAxis.setPen(QPen(Qt.white))
step = int(self._memTickInterval * self.memAxisLen)
pen = QPen(Qt.CustomDashLine)
pen.setDashPattern([2, 20])
pen.setColor(Qt.lightGray)
for y in range(step, self.memAxisLen + step, step):
self.scene.addLine(self.memXOffset, y, 2500.0, y, pen)
def draw_rectangle(self, rect, bgcolor, pencolor):
x, y, width, height = rect
painter = self.current_painter
painter.save()
r = QRectF(x, y, width, height)
if bgcolor is not None:
painter.fillRect(r, COLORS[bgcolor])
if pencolor is not None:
pen = QPen(painter.pen())
pen.setColor(COLORS[pencolor])
painter.setPen(pen)
painter.drawRect(r)
painter.restore()
def draw_rectangle(self, rect, bgcolor, pencolor):
x, y, width, height = rect
painter = self.current_painter
painter.save()
r = QRectF(x, y, width, height)
if bgcolor is not None:
painter.fillRect(r, COLORS[bgcolor])
if pencolor is not None:
pen = QPen(painter.pen())
pen.setColor(COLORS[pencolor])
painter.setPen(pen)
painter.drawRect(r)
painter.restore()
def _dialog_paintEvent(self, d, event):
QDialog.paintEvent(d, event)
pen = QPen()
pen.setWidth(2)
pen.setColor(QColor(200, 200, 200))
rect = d.rect()
rect = rect.adjusted(0, 0, -1, -1)
painter = QPainter(d)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setPen(pen)
painter.setOpacity(0.8)
painter.setBrush(QBrush(QColor(Qt.white)))
painter.drawRoundedRect(rect, 15, 15)
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 __init_disagreement_label_colortable(self):
self.disagreement_colortable = [ QColor(0, 255, 255, 255), # cyan
QColor(255, 0, 255, 255) ] # magenta
self.disagreement_pen_table = []
for color in self.disagreement_colortable:
pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN)
pen.setColor(color)
pen.setWidth(3)
self.disagreement_pen_table.append(pen)
op = self.topLevelOperatorView
op.EdgeLabelDisagreementDict.notifyDirty( self.__update_disagreement_edges )
self.__cleanup_fns.append( partial( op.EdgeLabelDisagreementDict.unregisterDirty, self.__update_disagreement_edges ) )
def paintEvent(self, event):
"""
Draw the QImage on screen.
"""
textPosX,textPosY = 10,200
painter = QPainter(self)
painter.drawImage(painter.viewport(), self._image)
innerFont = QFont()
innerFont.setPointSize(12)
painter.setFont(innerFont)
painter.setPen(QColor(QtCore.Qt.white))
painter.drawText(10,180,'Current Action:')
painter.drawText(10,200,self._currentMovement)
self.drawMoreText(painter,10,300,['Control Buttons:',
'w,s - Walking Forwards/Backwards',
'q,e - Walking Left/Right',
'a,d - Turning Left/Right',
'x - stopping',
'Space - standing up',
'Ctrl - crouch',
'Escape,Enter - restMode, wakeUp',
'1 - Grabbing small',
'2 - Grabbing large',
'3 - Grabbing Kuscheltier',
'4 - Grabbing bottle'])
self.drawMoreText(painter,self.width()-300-25,300,['Dialog Control:({})'.format(self._attitude),
'u - Introduction',
'i - Ask for object',
'h - Object is Somat',
'j - Object is Muesli',
'k - Object is Bottle',
'l - Object is Kuscheltier',
'n - Wertstoff',
'm - Altpapier',
'o - Ask for help',
'z - Ask proband to repeat sentence',
'p - Repeat task',
'0(Null) - construct initial state',
't - Goodbye',
'b - thanks',
'# - Start free Speech(PopUp)'])
self.drawMoreText(painter,100,50,['Movement Speeds','Forward: {}'.format(self._currentSpeeds['Forward']),'Leftward: {}'.format(self._currentSpeeds['Leftward']),'CounterClockwise: {}'.format(self._currentSpeeds['CounterClockwise'])])
pen = QPen()
pen.setColor(QColor(QtCore.Qt.red))
pen.setWidth(5)
painter.setPen(pen)
painter.drawEllipse(20,15,60,30)
pen.setColor(QColor(QtCore.Qt.blue))
painter.setPen(pen)
painter.drawPolygon(self.rotatePolygon(arrowPolygon,math.degrees(self._motionProxy.getAngles('HeadYaw',True)[0]),[30,20]))
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 paintEvent(self, event):
"""
Handles the drawing for this widget and its selection region.
:param event | <QPaintEvent>
"""
pen = QPen(Qt.DashLine)
pen.setColor(QColor('red'))
painter = QPainter(self)
painter.setPen(pen)
clr = QColor('black')
clr.setAlpha(100)
painter.setBrush(clr)
painter.drawRect(self._region)
def _init_probability_colortable(self):
self.probability_colortable = []
for v in np.linspace(0.0, 1.0, num=101):
self.probability_colortable.append( QColor(255*(v), 255*(1.0-v), 0) )
self.probability_pen_table = []
for color in self.probability_colortable:
pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN)
pen.setColor(color)
self.probability_pen_table.append(pen)
# When the edge probabilities are dirty, update the probability edge layer pens
op = self.topLevelOperatorView
cleanup_fn = op.EdgeProbabilitiesDict.notifyDirty( self.update_probability_edges, defer=True )
self.__cleanup_fns.append( cleanup_fn )
def __init_probability_colortable(self):
self.probability_colortable = []
for v in np.linspace(0.0, 1.0, num=101):
self.probability_colortable.append(QColor(255 * (v), 255 * (1.0 - v), 0))
self.probability_pen_table = []
for color in self.probability_colortable:
pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN)
pen.setColor(color)
self.probability_pen_table.append(pen)
# When the edge probabilities are dirty, update the probability edge layer pens
op = self.__topLevelOperatorView
op.EdgeProbabilitiesDict.notifyDirty(self.__update_probability_edges)
self.__cleanup_fns.append(partial(op.EdgeProbabilitiesDict.unregisterDirty, self.__update_probability_edges))
def paintEvent(self, event):
"""
Handles the drawing for this widget and its selection region.
:param event | <QPaintEvent>
"""
pen = QPen(Qt.DashLine)
pen.setColor(QColor('red'))
painter = QPainter(self)
painter.setPen(pen)
clr = QColor('black')
clr.setAlpha(100)
painter.setBrush(clr)
painter.drawRect(self._region)
def drawPixmapForPartiallyChecked(self):
self.pixmapPartiallyChecked = QPixmap(self.itemWidth, self.itemHeight)
self.pixmapPartiallyChecked.fill(Qt.transparent)
painter = QPainter()
painter.begin(self.pixmapPartiallyChecked)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
painter.drawRect(QRect(5,5,self.itemWidth-10, self.itemHeight-10))
pen.setWidth(4)
pen.setColor(QColor(139,137,137))
painter.setPen(pen)
painter.drawLine(self.itemWidth/2-5, self.itemHeight/2, self.itemWidth/2, self.itemHeight-9)
painter.drawLine(self.itemWidth/2, self.itemHeight-9, self.itemWidth/2+10, 2)
painter.end()
def handle_edge_clicked(self, id_pair):
"""
Handles clicks from our associated SegmentationEdgesItem(s).
(See connection made in SegmentationEdgesItemRequest.)
id_pair: The edge that was clicked.
"""
DEBUG_BEHAVIOR = False
if DEBUG_BEHAVIOR:
# Simple debug functionality: change to a random color.
# Please verify in the viewer that edges spanning multiple tiles changed color
# together, even though only one of the tiles was clicked.
random_color = QColor( *list( numpy.random.randint(0,255,(3,)) ) )
pen = QPen(self.pen_table[id_pair])
pen.setColor(random_color)
self.pen_table[id_pair] = pen
def _init_edge_label_colortable(self):
self.edge_label_colortable = [ QColor( 0, 0, 0, 0), # transparent
QColor( 0, 255, 0, 255), # green
QColor(255, 0, 0, 255) ] # red
self.edge_label_pen_table = []
for color in self.edge_label_colortable:
pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN)
pen.setColor(color)
pen.setWidth(5)
self.edge_label_pen_table.append(pen)
# When the edge labels are dirty, update the edge label layer pens
op = self.topLevelOperatorView
cleanup_fn = op.EdgeLabelsDict.notifyDirty( self.update_labeled_edges, defer=True )
self.__cleanup_fns.append( cleanup_fn )
def _init_edge_label_colortable(self):
self.edge_label_colortable = [ QColor( 0, 0, 0, 0), # transparent
QColor( 0, 255, 0, 255), # green
QColor(255, 0, 0, 255) ] # red
self.edge_label_pen_table = []
for color in self.edge_label_colortable:
pen = QPen(SegmentationEdgesLayer.DEFAULT_PEN)
pen.setColor(color)
pen.setWidth(5)
self.edge_label_pen_table.append(pen)
# When the edge labels are dirty, update the edge label layer pens
op = self.topLevelOperatorView
op.EdgeLabelsDict.notifyDirty( self.update_labeled_edges )
self.__cleanup_fns.append( partial( op.EdgeLabelsDict.unregisterDirty, self.update_labeled_edges ) )
def paint(self, painter, option, widget):
if self.isSelected():
pen = QPen(Qt.DashLine)
pen.setColor(QColor(0xccff33))
pen.setWidth(2)
painter.setPen(pen)
else:
pen = QPen(Qt.SolidLine)
pen.setColor(Qt.black)
painter.setPen(pen)
painter.setBrush(QBrush(self.color))
painter.drawRoundedRect(self.rect, 5, 5)
painter.setPen(Qt.SolidLine | Qt.black)
painter.drawText(self.rect,
str(self.model.id()),
option=QTextOption(Qt.AlignCenter))
def drawPixmapForPartiallyChecked(self):
self.pixmapPartiallyChecked = QPixmap(self.itemWidth, self.itemHeight)
self.pixmapPartiallyChecked.fill(Qt.transparent)
painter = QPainter()
painter.begin(self.pixmapPartiallyChecked)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
painter.drawRect(QRect(5,5,self.itemWidth-10, self.itemHeight-10))
pen.setWidth(4)
pen.setColor(QColor(139,137,137))
painter.setPen(pen)
painter.drawLine(self.itemWidth/2-5, self.itemHeight/2, self.itemWidth/2, self.itemHeight-9)
painter.drawLine(self.itemWidth/2, self.itemHeight-9, self.itemWidth/2+10, 2)
painter.end()
def handle_edge_clicked(self, id_pair):
"""
Handles clicks from our associated SegmentationEdgesItem(s).
(See connection made in SegmentationEdgesItemRequest.)
id_pair: The edge that was clicked.
"""
DEBUG_BEHAVIOR = False
if DEBUG_BEHAVIOR:
# Simple debug functionality: change to a random color.
# Please verify in the viewer that edges spanning multiple tiles changed color
# together, even though only one of the tiles was clicked.
random_color = QColor( *list( numpy.random.randint(0,255,(3,)) ) )
pen = QPen(self.pen_table[id_pair])
pen.setColor(random_color)
self.pen_table[id_pair] = pen
def drawSkel(self, worm_img, worm_qimg, row_data, roi_corner = (0,0)):
if not self.skel_file or not isinstance(self.trajectories_data, pd.DataFrame):
return
c_ratio_y = worm_qimg.width()/worm_img.shape[1];
c_ratio_x = worm_qimg.height()/worm_img.shape[0];
skel_id = int(row_data['skeleton_id'])
qPlg = {}
with tables.File(self.skel_file, 'r') as ske_file_id:
for tt in ['skeleton', 'contour_side1', 'contour_side2']:
dat = ske_file_id.get_node('/' + tt)[skel_id];
dat[:,0] = (dat[:,0]-roi_corner[0])*c_ratio_x
dat[:,1] = (dat[:,1]-roi_corner[1])*c_ratio_y
qPlg[tt] = QPolygonF()
for p in dat:
qPlg[tt].append(QPointF(*p))
if 'is_good_skel' in row_data and row_data['is_good_skel'] == 0:
self.skel_colors = {'skeleton':(102, 0, 0 ),
'contour_side1':(102, 0, 0 ), 'contour_side2':(102, 0, 0 )}
else:
self.skel_colors = {'skeleton':(27, 158, 119 ),
'contour_side1':(217, 95, 2), 'contour_side2':(231, 41, 138)}
pen = QPen()
pen.setWidth(2)
painter = QPainter()
painter.begin(worm_qimg)
for tt, color in self.skel_colors.items():
pen.setColor(QColor(*color))
painter.setPen(pen)
painter.drawPolyline(qPlg[tt])
pen.setColor(Qt.black)
painter.setBrush(Qt.white)
painter.setPen(pen)
radius = 3
painter.drawEllipse(qPlg['skeleton'][0], radius, radius)
painter.end()
def initPlots(self):
self.plot1.clear()
# self.plot1.setTitle("Observed Isotope Distribution")
# self.plot1.setAxisTitle(Qwt.QwtPlot.xBottom, 'Raman shift (cm-1)')
# self.plot1.setAxisTitle(Qwt.QwtPlot.yLeft, 'Intensity')
# grid = Qwt.QwtPlotGrid()
pen = QPen(Qt.DotLine)
pen.setColor(Qt.black)
pen.setWidth(0)
# grid.setPen(pen)
# grid.attach(self.plot1)
self.mass1=self.mass/self.massy*100
self.plot1.setAxisScale(self.plot1.xBottom,self.x_min,self.x_max)
self.plot1.setAxisScale(self.plot1.yLeft,0,1.1*100)
color = QColor('black')
curve = Qwt.QwtPlotCurve("test1")
pen = QPen(color)
pen.setWidth(1)
curve.setPen(pen)
curve.setData(self.mass_x,self.mass_y)
curve.setStyle(Qwt.QwtPlotCurve.Sticks)
curve.attach(self.plot1)
self.plot1.replot()
self.plot2.clear()
# self.plot2.setTitle("Theoretical Isotope Distribution")
# self.plot2.setAxisTitle(Qwt.QwtPlot.xBottom, 'Raman shift (cm-1)')
# self.plot2.setAxisTitle(Qwt.QwtPlot.yLeft, 'Intensity')
# grid = Qwt.QwtPlotGrid()
pen = QPen(Qt.DotLine)
pen.setColor(Qt.blue)
self.plot2.setAxisScale(self.plot1.xBottom,self.x_min,self.x_max)
self.plot2.setAxisScale(self.plot1.yLeft,0,1.1*100)
color = QColor('blue')
curve = Qwt.QwtPlotCurve("test1")
pen = QPen(color)
pen.setWidth(1)
curve.setPen(pen)
# self.axis= np.arange(len(self.mass))
curve.setData(self.x,self.y)
curve.setStyle(Qwt.QwtPlotCurve.Sticks)
curve.attach(self.plot2)
pen.setWidth(0)
# grid.setPen(pen)
# grid.attach(self.plot2)
self.plot2.replot()
def paint(self, painter, option, widget = None):
QGraphicsPolygonItem.paint(self, painter, option, widget)
pen = QPen(QColor("yellow"))
pen.setWidth(10)
painter.setPen(pen)
painter.drawPoint(self.entrance())
pen.setColor(QColor("magenta"))
painter.setPen(pen)
painter.drawPoint(self.exit())
for c in self.connectors[2:]:
painter.drawPoint(c)
pen.setColor(QColor(0,255,255))
pen.setWidth(2)
painter.setPen(pen)
painter.drawEllipse(self.cog(), 5, 5)
def paintEvent(self, event):
QWidget.paintEvent(self, event)
pen = QPen()
pen.setWidth(2)
pen.setColor(QColor(200, 200, 200))
rect = self.rect()
rect = rect.adjusted(0, 0, -1, -1)
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setPen(pen)
painter.setOpacity(0.5)
painter.setBrush(QBrush(QColor(Qt.white)))
painter.drawRoundedRect(rect, 15, 15)
painter.setOpacity(1)
pen.setColor(Qt.black)
painter.setPen(pen)
text = self.name + "\n" + self.description
painter.drawText(self.rect(), Qt.AlignHCenter | Qt.AlignVCenter, text)
def finalizeImage(self, painter, imageid, image_transform, size=None):
caps = self.caps
params = self.parameters
if params.draw_line:
pt1, pt2 = self.pts
painter.save()
painter.setWorldTransform(image_transform)
pen = QPen()
pen.setCosmetic(True)
pen.setColor(params.line_color)
pen.setWidth(params.line_width)
painter.setPen(pen)
painter.drawLine(pt1, pt2)
painter.restore()
del self.direction
del self.pts
del self.current_image
return self.parameters.drawScaleBar(painter, caps, self.unit, size)
def paintEvent(self, event):
QFrame.paintEvent(self, event)
factorForWidth = self.width() / 40
factorForHeight = self.height() / 30
row = 1
column = 1
painter = QPainter(self)
painter.setOpacity(0.9)
pen = QPen()
pen.setColor(Qt.white)
painter.setPen(pen)
while factorForWidth * column < self.width():
painter.drawLine(factorForWidth * column, 0, factorForWidth * column, self.height())
column += 1
while factorForHeight * row < self.height():
painter.drawLine(0, factorForHeight * row, self.width(), factorForHeight * row)
row += 1
def draw(self, scene, baseX, baseY):
" Draws the diagram on the real canvas "
self.baseX = baseX
self.baseY = baseY
currentY = baseY
for row in self.cells:
if not row:
continue
height = row[0].height
currentX = baseX
for cell in row:
if self.settings.debug:
pen = QPen(Qt.DotLine)
pen.setWidth(1)
if cell.kind == CellElement.VCANVAS:
pen.setColor(QColor(255, 0, 0, 255))
scene.addLine(currentX + 1, currentY + 1,
currentX + cell.width - 2, currentY + 1,
pen)
scene.addLine(currentX + 1, currentY + 1, currentX + 1,
currentY + cell.height - 2, pen)
scene.addLine(currentX + 1, currentY + cell.height - 2,
currentX + cell.width - 2,
currentY + cell.height - 2, pen)
scene.addLine(currentX + cell.width - 2, currentY + 1,
currentX + cell.width - 2,
currentY + cell.height - 2, pen)
else:
pen.setColor(QColor(0, 255, 0, 255))
scene.addLine(currentX, currentY,
currentX + cell.width, currentY, pen)
scene.addLine(currentX, currentY, currentX,
currentY + cell.height, pen)
scene.addLine(currentX, currentY + cell.height,
currentX + cell.width,
currentY + cell.height, pen)
scene.addLine(currentX + cell.width, currentY,
currentX + cell.width,
currentY + cell.height, pen)
cell.draw(scene, currentX, currentY)
currentX += cell.width
currentY += height
return
def initPlots(self):
self.plot3.clear()
self.plot3.setAxisScale(self.plot1.xBottom, -4, 4)
self.plot3.setAxisScale(self.plot1.yLeft, -4, 4)
self.plot1.clear()
self.plot1.setTitle("Search MS")
self.plot1.setAxisTitle(Qwt.QwtPlot.yLeft, 'Intensity')
grid = Qwt.QwtPlotGrid()
pen = QPen(Qt.DotLine)
pen.setColor(Qt.black)
pen.setWidth(0)
grid.setPen(pen)
grid.attach(self.plot1)
self.plot1.setAxisScale(self.plot1.yLeft, 0, 1.1 * np.max(self.mass))
color = QColor('black')
curve = Qwt.QwtPlotCurve("test1")
pen = QPen(color)
pen.setWidth(1)
curve.setPen(pen)
#self.axis= np.arange(len(self.mass))
curve.setData(self.axis, self.mass)
curve.setStyle(Qwt.QwtPlotCurve.Sticks)
curve.attach(self.plot1)
for i in range(len(self.peak_MS)):
text_MS = Qwt.QwtText('%s' % (str(self.peak_MS[i][0])))
marker_MS = Qwt.QwtPlotMarker()
marker_MS.setLabelAlignment(Qt.AlignCenter | Qt.AlignTop)
marker_MS.setLabel(text_MS)
marker_MS.setValue(self.peak_MS[i][0], self.peak_MS[i][1])
marker_MS.attach(self.plot1)
self.plot1.replot()
self.plot2.clear()
self.plot2.setTitle("NIST MS")
# self.plot2.setAxisTitle(Qwt.QwtPlot.xBottom, 'Raman shift (cm-1)')
self.plot2.setAxisTitle(Qwt.QwtPlot.yLeft, 'Intensity')
grid = Qwt.QwtPlotGrid()
pen = QPen(Qt.DotLine)
pen.setColor(Qt.black)
pen.setWidth(0)
grid.setPen(pen)
grid.attach(self.plot2)
self.plot2.replot()
def __init__(self):
super(QFramesInTracksScene, self).__init__()
self._coords = CoordTransform()
self._track_items = {}
self._frame_items = {}
pen = QPen()
pen.setWidthF(1.25)
pen.setColor(Qt.black)
# pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
brush = QBrush()
brush.setColor(Qt.blue)
brush.setStyle(Qt.SolidPattern)
self._frame_pen_brush = pen, brush
pen = QPen(pen)
pen.setWidthF(3.5)
pen.setJoinStyle(Qt.RoundJoin)
pen.setColor(Qt.blue)
brush = QBrush(brush)
brush.setColor(Qt.gray)
self._track_pen_brush = pen, brush
def paintEvent(self, event):
QWidget.paintEvent(self, event)
width, height = self.width(), self.height()
polygon = QPolygon()
for i, rate in enumerate(self.loads):
x = width - i * self.pointDistance
y = height - rate * height
if x < self.boxWidth:
break
polygon.append(QPoint(x, y))
painter = QPainter(self)
pen = QPen()
pen.setColor(Qt.darkGreen)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing, True)
#画网格
painter.setOpacity(0.5)
gridSize = self.pointDistance * 4
deltaX = (width - self.boxWidth) % gridSize + self.boxWidth
deltaY = height % gridSize
for i in range(int(width / gridSize)):
x = deltaX + gridSize * i
painter.drawLine(x, 0, x, height)
for j in range(int(height / gridSize)):
y = j * gridSize + deltaY
painter.drawLine(self.boxWidth, y, width, y)
#画折线
pen.setColor(Qt.darkCyan)
pen.setWidth(2)
painter.setPen(pen)
painter.setOpacity(1)
painter.drawPolyline(polygon)
#画展示框
if len(self.loads) > 0:
rate = self.loads[0]
else:
rate = 1.0
rect1 = QRect(4, height * 0.05, self.boxWidth - 9, height * 0.7)
rect2 = QRect(4, height * 0.8, self.boxWidth - 9, height * 0.2)
centerX = int(rect1.width() / 2) + 1
pen.setWidth(1)
for i in range(rect1.height()):
if i % 4 == 0:
continue
if (rect1.height() - i) / rect1.height() > rate:
pen.setColor(Qt.darkGreen)
else:
pen.setColor(Qt.green)
painter.setPen(pen)
for j in range(rect1.width()):
if centerX - 1 <= j <= centerX + 1:
continue
painter.drawPoint(rect1.x() + j, rect1.y() + i)
pen.setColor(Qt.black)
painter.setPen(pen)
painter.drawText(rect2, Qt.AlignHCenter | Qt.AlignVCenter, str(int(rate * 100)) + "%")
