def addRectIndependencePearson(self, rect, x, y, w, h, xAttr_xVal, yAttr_yVal, actual, sum, width):
xAttr, xVal = xAttr_xVal
yAttr, yVal = yAttr_yVal
expected = float(xVal*yVal)/float(sum)
pearson = (actual - expected) / sqrt(expected)
if pearson > 0: # if there are more examples that we would expect under the null hypothesis
intPearson = floor(pearson)
pen = QPen(QColor(0,0,255), width); rect.setPen(pen)
b = 255
r = g = 255 - intPearson*20
r = g = max(r, 55) #
elif pearson < 0:
intPearson = ceil(pearson)
pen = QPen(QColor(255,0,0), width)
rect.setPen(pen)
r = 255
b = g = 255 + intPearson*20
b = g = max(b, 55)
else:
pen = QPen(QColor(255,255,255), width)
r = g = b = 255 # white
color = QColor(r,g,b)
brush = QBrush(color)
rect.setBrush(brush)
if pearson > 0:
pearson = min(pearson, 10)
kvoc = 1 - 0.08 * pearson # if pearson in [0..10] --> kvoc in [1..0.2]
else:
pearson = max(pearson, -10)
kvoc = 1 - 0.4*pearson
pen.setWidth(1)
self.addLines(x,y,w,h, kvoc, pen)
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 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 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
class CoreItem(QGraphicsEllipseItem):
def __init__(self, radius, parent=None):
QGraphicsEllipseItem.__init__(self, QRectF(-radius, -radius, radius*2.0, radius*2.0), parent=parent)
self._pen = QPen(QColor('#000000'))
self._pen.setWidth(1)
self.setPen(self._pen)
self._hoverPen = QPen(QColor('#000000'))
self._hoverPen.setWidth(2)
brush = QBrush(QColor('#FF9966'))
self.setBrush(brush)
self._isSelected = False
self._isHover = False
self.setAcceptHoverEvents(True)
def setIsHover(self, isHover):
self._isHover = isHover
pen = self._hoverPen if isHover else self._pen
self.setPen(pen)
self.update()
def hoverEnterEvent(self, event):
QGraphicsEllipseItem.hoverEnterEvent(self, event)
event.accept()
self.setIsHover(True)
def hoverLeaveEvent(self, event):
QGraphicsEllipseItem.hoverLeaveEvent(self, event)
event.accept()
self.setIsHover(False)
def setRectanglePen(self):
" Sets the diagram pen "
pen = QPen(QColor(0, 0, 0))
pen.setWidth(2)
pen.setJoinStyle(Qt.RoundJoin)
self.setPen(pen)
return
def paintEvent(self, e):
super().paintEvent(e)
painter = QPainter()
painter.begin(self)
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
right_as_line = False
ral_place = []
if self.previous_commit != None and '\\' in self.previous_commit[-1]:
right_as_line = True
for f in range(len(self.previous_commit[-1])):
if self.previous_commit[-1][f] == '\\':
ral_place.append(f)
i = 0
for j in range(len(self.commit[0])):
if self.commit[0][j] == '*':
painter.drawImage(QPoint(i,0), self.commit_image())
elif self.commit[0][j] == '|':
x = 30/len(self.commit)
if len(self.commit) > 1 and len(self.commit[1]) > j+1 and self.commit[1][j+1] == '\\':
x = 15
painter.drawLine(i+15, 0, i+15, x)
elif self.commit[0][j] == '\\':
if right_as_line == True and j-1 in ral_place:
painter.drawLine(i+15, 0, i+15, 15)
else:
painter.drawLine(i+15, 15, i+30, 15+(15/len(self.commit)))
elif self.commit[0][j] == '/':
painter.drawImage(QPoint(i,0), QImage(dirname(__file__)+'/icons/right.png'))
elif self.commit[0][j] == '_':
painter.drawImage(QPoint(i,0), QImage(dirname(__file__)+'/icons/line-flipped.png'))
i += self.char_size
down = 0
up = 0
left = False
for j in range(1, len(self.commit)):
i = 0
for k in range(len(self.commit[j])):
if self.commit[j][k] == '|':
x = (30/len(self.commit))*j
if len(self.commit[0]) > k and self.commit[0][k] == '*':
x += 15
if len(self.commit[j-1]) > k and self.commit[j-1][k-1] == '\\':
x += (30/len(self.commit))/2
painter.drawLine(i+15, x, i+15, (30/len(self.commit))*(j+1))
elif self.commit[j][k] == '\\':
painter.drawLine(i+1, 15, i+29, 15+(15/len(self.commit))*(j+1))
down = 5
up = 2
left = True
elif self.commit[j][k] == '/':
if left == True:
painter.drawLine(i+2, 15+(13/len(self.commit))*(j+1), i+29, 15+(15/len(self.commit))*j)
else:
painter.drawLine(i+1, (30/len(self.commit))*(j+1)-up, i+27, down+(30/len(self.commit))*j)
elif self.commit[j][k] == '_':
painter.drawLine(i, 15+(15/len(self.commit))*j, i+30, 15+(15/len(self.commit))*j)
i += self.char_size
painter.end()
def setRectanglePen( self ):
" Sets the diagram pen "
pen = QPen( QColor( 0, 0, 0) )
pen.setWidth( 2 )
pen.setJoinStyle( Qt.RoundJoin )
self.setPen( pen )
return
def updateFilledCircle(self, s):
size = s * self.zoom
pixmap = QPixmap(self.width(), self.height())
pixmap.fill(Qt.transparent)
#painter filled ellipse
p = QPalette()
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
brush = QBrush(p.link().color())
painter.setBrush(brush)
painter.setOpacity(0.4)
painter.drawEllipse(QRect(self.width()/2 - size/2, self.height()/2 - size/2, size, size))
painter.end()
#painter ellipse 2
painter2 = QPainter()
painter2.begin(pixmap)
painter2.setRenderHint(QPainter.Antialiasing)
pen2 = QPen(Qt.green)
pen2.setWidth(1)
painter2.setPen(pen2)
painter2.drawEllipse(QRect(self.width()/2 - size/2, self.height()/2 - size/2, size, size))
painter2.end()
self.ellipseLabel.setPixmap(QPixmap(pixmap))
self.lastSize = s
def _drawIcon(self, color=Qt.black):
self.setForeground(QBrush(color))
if self.isRootNode:
pixmap = QPixmap(20, 20)
pixmap.fill(Qt.transparent)
painter = QPainter()
painter.begin(pixmap)
pen = QPen(color)
pen.setWidth(1)
painter.setPen(pen)
painter.setBrush(color)
painter.setRenderHint(QPainter.Antialiasing)
if not self.isExpanded:
arrowRightPolygon = [
QPoint(6, 6), QPoint(6, 14),
QPoint(14, 10)
]
painter.drawPolygon(QPolygon(arrowRightPolygon))
else:
arrowDownPolygon = [
QPoint(6, 6), QPoint(15, 6),
QPoint(10, 14)
]
painter.drawPolygon(QPolygon(arrowDownPolygon))
painter.end()
self.setIcon(QIcon(pixmap))
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 drawItem(self, item, painter, option):
"""
Draws the inputed item as a bar graph.
:param item | <XChartDatasetItem>
painter | <QPainter>
option | <QStyleOptionGraphicsItem>
"""
dataset = item.dataset()
painter.save()
painter.setRenderHint(painter.Antialiasing)
pen = QPen(dataset.color())
pen.setWidth(3)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.drawPath(item.path())
if self.showPoints():
palette = QApplication.palette()
pen = QPen(palette.color(palette.Base))
pen.setWidth(2)
painter.setBrush(dataset.color())
painter.setPen(pen)
for point in item.buildData('ellipses', []):
painter.drawEllipse(point, self.pointRadius(),
self.pointRadius())
painter.restore()
def drawItem(self, item, painter, option):
"""
Draws the inputed item as a bar graph.
:param item | <XChartDatasetItem>
painter | <QPainter>
option | <QStyleOptionGraphicsItem>
"""
dataset = item.dataset()
painter.save()
painter.setRenderHint(painter.Antialiasing)
pen = QPen(dataset.color())
pen.setWidth(3)
painter.setPen(pen)
painter.setBrush(Qt.NoBrush)
painter.drawPath(item.path())
if self.showPoints():
palette = QApplication.palette()
pen = QPen(palette.color(palette.Base))
pen.setWidth(2)
painter.setBrush(dataset.color())
painter.setPen(pen)
for point in item.buildData('ellipses', []):
painter.drawEllipse(point,
self.pointRadius(),
self.pointRadius())
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 __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 updateCircle(self, s):
size = s * self.zoom
pixmap = QPixmap(self.width(), self.height())
pixmap.fill(Qt.transparent)
#painter ellipse 1
painter = QPainter()
painter.begin(pixmap)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen(Qt.red)
pen.setWidth(3)
painter.setPen(pen)
brush = QBrush(Qt.green)
painter.setBrush(brush)
painter.drawEllipse(QRect(self.width()/2 - size/2, self.height()/2 - size/2, size, size))
painter.end()
#painter ellipse 2
painter2 = QPainter()
painter2.begin(pixmap)
painter2.setRenderHint(QPainter.Antialiasing)
pen2 = QPen(Qt.green)
pen2.setStyle(Qt.DotLine)
pen2.setWidth(3)
painter2.setPen(pen2)
painter2.drawEllipse(QRect(self.width()/2 - size/2, self.height()/2 - size/2, size, size))
painter2.end()
self.ellipseLabel.setPixmap(QPixmap(pixmap))
self.lastSize = s
def paintEvent(self, event):
""" custom paint event to draw vertical text """
painter = QPainter(self)
# draw box around
arc_size, line_width = 10, 1
pen = QPen(QtCore.Qt.gray)
pen.setWidth(line_width)
painter.setPen(pen)
painter.drawLine(arc_size, 0, self.width(), 0)
painter.drawLine(0, arc_size, 0, self.height() - arc_size)
painter.drawLine(arc_size - 5,
self.height() - 1, self.width(),
self.height() - 1)
painter.drawArc(0, 0, arc_size * 2, arc_size * 2, 180 * 16, -90 * 16)
painter.drawArc(0,
self.height() - arc_size * 2, arc_size * 2,
arc_size * 2, 180 * 16, 90 * 16)
# draw box around
#if (self.isEnabled()):
if self.selected:
painter.setPen(QtCore.Qt.black)
else:
painter.setPen(QtCore.Qt.gray)
painter.translate(self.width(), self.height())
painter.rotate(270)
painter.drawText(QtCore.QPointF(10, -self.width() / 3), self.text())
# destroy
del painter
def paintEvent(self, ev):
color = self.palette().color(QPalette.Highlight)
painter = QPainter(self)
# Filled rectangle.
painter.setClipRect(self.rect())
color.setAlpha(50)
painter.fillRect(self.rect().adjusted(2,2,-2,-2), color)
# Thin rectangle outside.
color.setAlpha(150)
painter.setPen(color)
painter.drawRect(self.rect().adjusted(0,0,-1,-1))
# Pseudo-handles at the corners and sides
color.setAlpha(100)
pen = QPen(color)
pen.setWidth(8)
painter.setPen(pen)
painter.setBackgroundMode(Qt.OpaqueMode)
# Clip at 4 corners
region = QRegion(QRect(0,0,20,20))
region += QRect(self.rect().width()-20, 0, 20, 20)
region += QRect(self.rect().width()-20, self.rect().height()-20, 20, 20)
region += QRect(0, self.rect().height()-20, 20, 20)
# Clip middles
region += QRect(0, self.rect().height()/2-10, self.rect().width(), 20)
region += QRect(self.rect().width()/2-10, 0, 20, self.rect().height())
# Draw thicker rectangles, clipped at corners and sides.
painter.setClipRegion(region)
painter.drawRect(self.rect())
def draw(self):
""" Draws connection.
"""
self.calculateRoute()
if not self.routeIsValid():
return
painter = QPainter(self)
#logging.debug(self.__class__.__name__ +": draw()")
if self._selectedFlag:
# Selected
framePen = QPen(self.SELECT_COLOR)
framePen.setWidth(self.SELECTED_FRAME_WIDTH)
else:
#self.select(False)
framePen = QPen(Qt.NoPen)
#if hasattr(QPainter, 'Antialiasing'):
if self.zoom() > 30:
painter.setRenderHint(QPainter.Antialiasing)
# painter.setPen(Qt.black)
# for thisP in self._route:
# painter.drawEllipse(self.mapFromParent(thisP), self.CONNECTION_THICKNESS * self.zoomFactor(), self.CONNECTION_THICKNESS* self.zoomFactor())
painter.setPen(framePen)
for i in range(0, len(self._route) -1):
#self.drawLineSection(painter, route[i], route[i + 1], self._cornerTypes[i], self._cornerTypes[i + 1])
self.drawSection(painter, i)
def paintEvent(self, event):
""" custom paint event to draw vertical text """
painter = QPainter(self)
# draw box around
arc_size, line_width=10, 1
pen = QPen(QtCore.Qt.gray)
pen.setWidth(line_width)
painter.setPen(pen)
painter.drawLine(arc_size,0, self.width(), 0)
painter.drawLine(0, arc_size,0, self.height()-arc_size)
painter.drawLine(arc_size-5,self.height()-1,self.width(), self.height()-1)
painter.drawArc(0,0, arc_size*2, arc_size*2, 180*16, -90*16)
painter.drawArc(0,self.height()-arc_size*2, arc_size*2, arc_size*2, 180*16, 90*16)
# draw box around
#if (self.isEnabled()):
if self.selected:
painter.setPen(QtCore.Qt.black)
else:
painter.setPen(QtCore.Qt.gray)
painter.translate(self.width(), self.height())
painter.rotate(270)
painter.drawText(QtCore.QPointF(10,- self.width()/3), self.text())
# destroy
del painter
def paint(self, painter, option, widget):
params = parameters.instance
tr = painter.worldMatrix()
saved = False
scale = self.scale
ms = min(scale)
if tr.m11() < 1 / scale[0] or tr.m12() < 1 / scale[1]:
painter.save()
saved = True
dx = tr.dx()
dy = tr.dy()
painter.setWorldTransform(
QTransform(1 / scale[0], 0, 0, 1 / scale[1], dx, dy))
if self.hover:
pen_color = params.old_point_matching_color
else:
pen_color = params.old_point_color
half_size = params.old_point_size / 2.
pen = QPen(pen_color)
pen.setWidth(params.old_point_thickness * ms)
painter.setPen(pen)
painter.drawLine(0, -half_size * scale[1], 0, half_size * scale[1])
painter.drawLine(-half_size * scale[0], 0, half_size * scale[0], 0)
if saved:
painter.restore()
def paint(self, painter, option, widget):
params = parameters.instance
col = QColor(params.arrow_color)
pen = QPen(col)
pen.setWidth(params.arrow_line_size)
painter.setPen(pen)
painter.setBrush(col)
painter.drawPath(self.path)
def paint(self, painter, option, widget):
params = parameters.instance
col = QColor(params.arrow_color)
pen = QPen(col)
pen.setWidth(params.arrow_line_size)
painter.setPen(pen)
painter.setBrush(col)
painter.drawPath(self.path)
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)
class BaseConnectorItem(QGraphicsPathItem):
IOTypeIn = 1
IOTypeOut = 1 << 1
def __init__(self, radiusOut, raiusIn, angle, arcLen, parent=None):
QGraphicsPathItem.__init__(self, parent=parent)
self._radiusOut = radiusOut
self._raiusIn = raiusIn
self._angle = angle
self._arcLen = arcLen
self._pen = QPen(QColor('#000000'))
self._pen.setWidth(1)
self.setPen(self._pen)
self._hoverPen = QPen(QColor('#000000'))
self._hoverPen.setWidth(2)
brush = QBrush(QColor('#FF9966'))
self.setBrush(brush)
rectOut = QRectF(-radiusOut, -radiusOut, radiusOut*2.0, radiusOut*2.0)
rectIn = QRectF(-raiusIn, -raiusIn, raiusIn*2.0, raiusIn*2.0)
startAngle = angle - arcLen/2.0
endAngle = angle + arcLen/2.0
path = QPainterPath()
path.arcMoveTo(rectIn, startAngle)
path.arcTo(rectOut, startAngle, arcLen)
path.arcTo(rectIn, endAngle, 0)
path.arcTo(rectIn, endAngle, -arcLen)
self.setPath(path)
self._isHover = False
self._ioDragFirstPos = None
def ioType(self):
return self._ioType
def setIsHover(self, isHover):
self._isHover = isHover
pen = self._hoverPen if isHover else self._pen
self.setPen(pen)
self.update()
def hoverEnterEvent(self, event):
event.accept()
self.setIsHover(True)
QGraphicsPathItem.hoverEnterEvent(self, event)
def hoverLeaveEvent(self, event):
event.accept()
self.setIsHover(False)
QGraphicsPathItem.hoverLeaveEvent(self, event)
def __init__(self, startComponent):
position = startComponent.center()
super(SfLine, self).__init__(QLineF(position, position))
self._start = startComponent
self._end = None
pen = QPen()
pen.setWidth(SfLine.ARROW_WIDTH)
self.setPen(pen)
self.setZValue(-1)
def paintEvent(self, event):
super(DetailedProgress, self).paintEvent(event)
if not self._current_progress:
return
painter = QPainter(self)
width = self.width()
height = self.height()
aspect_ratio = float(width) / height
nr_realizations = max([iens
for iens, _, _ in self._current_progress]) + 1
fm_size = max(
[len(progress) for _, progress, _ in self._current_progress])
self.grid_height = math.ceil(math.sqrt(nr_realizations / aspect_ratio))
self.grid_width = math.ceil(self.grid_height * aspect_ratio)
sub_grid_size = math.ceil(math.sqrt(fm_size))
cell_height = height / self.grid_height
cell_width = width / self.grid_width
foreground_image = QImage(self.grid_width * sub_grid_size,
self.grid_height * sub_grid_size,
QImage.Format_ARGB32)
foreground_image.fill(QColor(0, 0, 0, 0))
for index, (iens, progress, _) in enumerate(self._current_progress):
y = int(iens / self.grid_width)
x = int(iens - (y * self.grid_width))
self.draw_window(x * sub_grid_size, y * sub_grid_size, progress,
foreground_image)
painter.drawImage(self.contentsRect(), foreground_image)
for index, (iens, progress,
state) in enumerate(self._current_progress):
y = int(iens / self.grid_width)
x = int(iens - (y * self.grid_width))
painter.setPen(QColor(80, 80, 80))
painter.drawText(x * cell_width, y * cell_height, cell_width,
cell_height, Qt.AlignHCenter | Qt.AlignVCenter,
str(iens))
if iens == self.selected_realization:
pen = QPen(QColor(240, 240, 240))
elif (self.has_realization_failed(progress)):
pen = QPen(QColor(*self.state_colors['Failure']))
elif (state == JobStatusType.JOB_QUEUE_RUNNING):
pen = QPen(QColor(*self.state_colors['Running']))
else:
pen = QPen(QColor(80, 80, 80))
thickness = 4
pen.setWidth(thickness)
painter.setPen(pen)
painter.drawRect((x * cell_width) + (thickness / 2),
(y * cell_height) + (thickness / 2),
cell_width - (thickness - 1),
cell_height - (thickness - 1))
def paint(self, painter):
opacity = 1.0 - float(self.anim.currentTime()) / self.anim.duration()
pen = QPen(QColor(255, 0, 0, opacity * 255))
pen.setWidth(3)
painter.setPen(pen)
painter.setBrush(Qt.transparent)
rect = QRect(0, 0, self.radius * 2, self.radius * 2)
rect.moveCenter(self.center)
painter.drawEllipse(rect)
def paint(self, QPainter, QStyleOptionGraphicsItem, QWidget_widget=None):
# setPen
pen = QPen()
pen.setWidth(5)
pen.setJoinStyle(Qt.MiterJoin) #让箭头变尖
QPainter.setPen(pen)
# draw line
QPainter.drawLine(self.line)
def paintEvent(self, paint_event):
# nastavíme pero na červenou barvu se šířkou 3px
pen = QPen(QColor("red"))
pen.setWidth(3)
painter = QPainter(self)
painter.setPen(pen)
# drawLine(x1, y1, x2, y2)
painter.drawLine(0, 0, 100, 100)
def make_pen(brush=Qt.black, width=1, style=Qt.SolidLine,
cap_style=Qt.SquareCap, join_style=Qt.BevelJoin,
cosmetic=False):
pen = QPen(brush)
pen.setWidth(width)
pen.setStyle(style)
pen.setCapStyle(cap_style)
pen.setJoinStyle(join_style)
pen.setCosmetic(cosmetic)
return pen
def paintRects(self, painter, rects):
"""Override this method to implement different drawing behaviour."""
pen = QPen(self.color())
pen.setWidth(self.lineWidth)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing, True)
rad = self.radius
for r in rects:
r.adjust(-rad, -rad, rad, rad)
painter.drawRoundedRect(r, rad, rad)
def paintRects(self, painter, rects):
"""Override this method to implement different drawing behaviour."""
pen = QPen(self.color())
pen.setWidth(self.lineWidth)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing, True)
rad = self.radius
for r in rects:
r.adjust(-rad, -rad, rad, rad)
painter.drawRoundedRect(r, rad, rad)
def paint( self, painter, option, widget ):
""" Draws a curve and then adds an arrow """
pen = QPen( QColor( 0, 0, 0) )
pen.setWidth( 2 )
self.setPen( pen )
painter.setRenderHint( QPainter.Antialiasing, True )
QGraphicsPathItem.paint( self, painter, option, widget )
return
def paint( self, painter, option, widget ):
""" Draws a curve and then adds an arrow """
pen = QPen( QColor( 0, 0, 0) )
pen.setWidth( 2 )
pen.setStyle( Qt.DotLine )
self.setPen( pen )
QGraphicsPathItem.paint( self, painter, option, widget )
return
def __init__(self):
QGraphicsScene.__init__(self)
self.__disableFocusRect = False
self._focusBoard = None
self.focusRect = QGraphicsRectItem()
pen = QPen(QColor(Qt.blue))
pen.setWidth(6)
self.focusRect.setPen(pen)
self.addItem(self.focusRect)
self.focusRect.setZValue(ZValues.marker)
self.focusRect.hide()
def drawPixmapForUnckecked(self):
self.pixmapUnckecked = QPixmap(self.itemWidth, self.itemHeight)
self.pixmapUnckecked.fill(Qt.transparent)
painter = QPainter()
painter.begin(self.pixmapUnckecked)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
painter.drawRect(QRect(5,5,self.itemWidth-10, self.itemHeight-10))
painter.end()
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 __init__(self):
QGraphicsScene.__init__(self)
self.__disableFocusRect = False
self._focusBoard = None
self.focusRect = QGraphicsRectItem()
pen = QPen(QColor(Qt.blue))
pen.setWidth(6)
self.focusRect.setPen(pen)
self.addItem(self.focusRect)
self.focusRect.setZValue(ZValues.marker)
self.focusRect.hide()
def paint(self, painter, xxx, xxx2):
if not self.position:
return
pen = QPen(self.color)
pen.setWidth(1)
painter.setPen(pen)
painter.drawLine(QPointF(0, 0),
QPointF(self.labelDistance, -self.labelDistance / 2))
painter.drawText(
QPointF(self.labelDistance + 2, -self.labelDistance / 2 + 2),
self.label)
def paintEvent(self, ev):
color = self._color
if not color or color.alpha() == 0:
return
painter = QPainter(self)
adj = self.lineWidth / 2
rect = self.rect().adjusted(adj, adj, -adj, -adj)
pen = QPen(color)
pen.setWidth(self.lineWidth)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.drawRoundedRect(rect, self.radius, self.radius)
class LegendWidget(Ui_legendsWidget, QWidget):
showmap = pyqtSignal()
def __init__(self, parent=None):
super(LegendWidget, self).__init__(parent)
self.setupUi(self)
self.canvasimage = QImage()
self.items = {}
self.framerect = QRect()
self.legendareabrush = QBrush(QColor(255, 255, 255, 200))
self.legendareapen = QPen(QColor(255, 255, 255, 20))
self.legendareapen.setWidth(0.5)
self.previewImage.mousePressEvent = self.previewImagePressEvent
self.previewImage.resizeEvent = self.update
self.btnExpand.pressed.connect(self.layerTree.expandAllNodes)
self.btnCollapse.pressed.connect(self.layerTree.collapseAllNodes)
self.canvas = None
def init(self, canvas):
self.canvas = canvas
def previewImagePressEvent(self, event):
self.showmap.emit()
def showEvent(self, showevent):
self.canvas.renderStarting.connect(self.update)
self.update()
def hideEvent(self, hideevent):
self.canvas.renderStarting.disconnect(self.update)
def setRoot(self, root):
model = QgsLayerTreeModel(root, self)
model.setFlag(QgsLayerTreeModel.AllowNodeChangeVisibility)
model.setFlag(QgsLayerTreeModel.ShowLegendAsTree)
font = QFont()
font.setPointSize(20)
model.setLayerTreeNodeFont(QgsLayerTreeNode.NodeLayer, font)
model.setLayerTreeNodeFont(QgsLayerTreeNode.NodeGroup, font)
self.layerTree.setModel(model)
def _renderimage(self):
image = self.renderjob.renderedImage()
self.previewImage.setPixmap(QPixmap.fromImage(image))
def update(self, *__args):
settings = self.canvas.mapSettings()
settings.setOutputSize(self.previewImage.size())
self.renderjob = QgsMapRendererParallelJob(settings)
self.renderjob.finished.connect(self._renderimage)
self.renderjob.start()
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)) + "%")
