def loadGrids(self):
""" Reads and sets the major and minor grid pens and visibility.
@return None
"""
name = self.plotName()
grid = self.grid
getv = self.settings.value
pen = getv('%s/major/pen' % name, defaults.majorGridPen())
grid.setMajPen(QPen(pen))
pen = getv('%s/minor/pen' % name, defaults.minorGridPen())
grid.setMinPen(QPen(pen))
items = [('%s/major/x/enabled', self.actionDrawMajorX),
('%s/major/y/enabled', self.actionDrawMajorY),
('%s/minor/x/enabled', self.actionDrawMinorX),
('%s/minor/y/enabled', self.actionDrawMinorY)]
for key, action in items:
v = getv(key % name)
if not v.isValid() or v.toBool():
action.trigger()
class SegmentationEdgesLayer(Layer):
"""
A layer that displays segmentation edge boundaries using vector graphics.
(See imagesources.SegmentationEdgesItem.)
"""
DEFAULT_PEN = QPen()
DEFAULT_PEN.setCosmetic(True)
DEFAULT_PEN.setCapStyle(Qt.RoundCap)
DEFAULT_PEN.setColor(Qt.white)
DEFAULT_PEN.setWidth(2)
@property
def pen_table(self):
"""
Items in the colortable can be added/replaced/deleted, but the
colortable object itself cannot be overwritten with a different dict object.
The SegmentationEdgesItem(s) associated witht this layer will react
immediately to any changes you make to this colortable dict.
"""
return self._pen_table
def __init__(self, datasource, default_pen=DEFAULT_PEN, direct=False):
"""
datasource: A single-channel label image.
default_pen: The initial pen style for each edge.
"""
super(SegmentationEdgesLayer, self).__init__([datasource],
direct=direct)
# Changes to this colortable will be detected automatically in the QGraphicsItem
self._pen_table = SignalingDefaultDict(
parent=self, default_factory=lambda: default_pen)
def handle_edge_clicked(self, id_pair, event):
"""
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
event.accept()
def handle_edge_swiped(self, id_pair, event):
pass
def paint(self, painter, option, widget):
gradient = QRadialGradient(-3, -3, 10)
if option.state & QStyle.State_Sunken:
gradient.setCenter(3, 3)
gradient.setFocalPoint(3, 3)
gradient.setColorAt(0, QColor(Qt.yellow).light(120))
else:
gradient.setColorAt(0, QColor(Qt.yellow).light(120))
painter.setBrush(gradient)
painter.setPen(QPen(Qt.black, 0))
painter.drawRoundedRect(self.boundingRect(), 3, 3)
def paint(self, painter, option, widget=None):
painter.save()
palette = self.palette()
border = palette.brush(QPalette.Mid)
pen = QPen(border, 1)
pen.setCosmetic(True)
painter.setPen(pen)
painter.setBrush(palette.brush(QPalette.Window))
brect = self.boundingRect()
painter.drawRoundedRect(brect, 4, 4)
painter.restore()
def imprimer(self):
self.liste_action()
printer = QtGui.QPrinter()
printer.setOutputFileName("listingAction.pdf")
painter = QtGui.QPainter()
painter.begin(printer)
pen = QPen(Qt.black, 1, Qt.SolidLine)
painter.setPen(pen)
marge = 20
col1 = 100
posCol2 = marge + col1
col2 = 250
posCol3 = posCol2 + col2
col3 = 250
posCol4 = posCol3 + col3
col4 = 100
fin = posCol4 + col4
pasY = 20
line = 0
posY = line * pasY
painter.drawLine(marge, posY,fin, posY)
painter.setFont(QtGui.QFont('Decorative', 10))
painter.drawText(marge + 5, posY + 15, 'Num semaine')
painter.drawText(posCol2 + 5, posY + 15, 'Planche')
painter.drawText(posCol3 + 5, posY + 15, 'Action')
painter.drawText(posCol4 + 5, posY + 15, 'Retrait')
for id in self.tableAction:
posY = (line + 1) * pasY
painter.drawLine(marge, posY,fin, posY)
painter.setFont(QtGui.QFont('Decorative', 10))
painter.drawText(marge + 5, posY + 15, str(self.tableAction[line][0]))
painter.drawText(posCol2 + 5, posY + 15, str(self.tableAction[line][1]))
painter.drawText(posCol3 + 5, posY + 15, str(self.tableAction[line][2]))
painter.drawText(posCol4 + 5, posY + 15, str(self.tableAction[line][3]))
line = line + 1
painter.drawLine(marge, 0,marge, (line + 1) * pasY)
painter.drawLine(posCol2, 0,posCol2, (line + 1) * pasY)
painter.drawLine(posCol3, 0,posCol3, (line + 1) * pasY)
painter.drawLine(posCol4, 0,posCol4, (line + 1) * pasY)
painter.drawLine(fin, 0,fin, (line + 1) * pasY)
painter.drawLine(marge, (line + 1) * pasY,fin, (line + 1) * pasY)
painter.end()
def paintEvent(self, event):
"""Paint over the widget to overlay its content."""
if not ACTIVATE_OPACITY:
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.TextAntialiasing, True)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 80)))
painter.setPen(QPen(Qt.NoPen))
painter.end()
super(SliderArea, self).paintEvent(event)
def expaint(self, painter, option, index):
painter.save()
content = index.model().data(index, Qt.EditRole)
column = index.column()
row = index.row()
parentNode = index.model().data(index.parent(), Qt.EditRole)
if parentNode:
painter.fillRect(option.rect, QBrush(QColor(200, 200, 200)))
painter.setPen(QPen(Qt.black))
painter.drawText(option.rect, Qt.AlignLeft, content)
painter.restore()
def __init__(self, parent=None):
super(LegendWidget, self).__init__(parent)
self.setupUi(self)
self.canvasimage = QImage()
self.items = {}
self.framerect = QRect()
self._lastextent = None
self.legendareabrush = QBrush(QColor(255, 255, 255, 200))
self.legendareapen = QPen(QColor(255, 255, 255, 20))
self.legendareapen.setWidth(0.5)
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 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 __DrawDisCircle(self, p):
pen = QPen(QColor(0, 150, 0))
p.setPen(pen)
p.setBrush(Qt.NoBrush)
r = self.mRadius
rHalf = 0.5 * r
rHalfOne = 1.5 * r
self.__DrawCircle(p, self.mCenter, r)
self.__DrawCircle(p, self.mCenter, rHalf)
self.__DrawCircle(p, self.mCenter, rHalfOne)
def __init__(self, parent=None, text=""):
super(QGraphicsPathItem, self).__init__(parent)
self.setAcceptHoverEvents(True)
self.setPen(QPen(Qt.NoPen))
self.text = QGraphicsTextItem(self)
layout = self.text.document().documentLayout()
layout.documentSizeChanged.connect(self._onLayoutChanged)
self._text = ""
self._anchor = QPointF()
def __DrawShadeLine(self, p, i):
pen = QPen(QColor(0, 0, 0))
angle = i / gEchoLineCountAFrame * 2 * gPI - 90 * g1Deg + g1Deg
xStart = int(self.mCenter.x())
yStart = int(self.mCenter.y())
xEnd = int(self.mRadius * math.cos(angle) + xStart)
yEnd = int(self.mRadius * math.sin(angle) + yStart)
p.setPen(pen)
p.drawLine(xStart, yStart, xEnd, yEnd)
def __init__(self,
pen=QPen(Qt.black),
brush=QBrush(Qt.white),
xData=[],
yData=[],
tooltip=None):
OWCurve.__init__(self, xData, yData, tooltip=tooltip)
self._data_polygon = self.polygon_from_data(xData, yData)
self._polygon_item = QGraphicsPolygonItem(self)
self.set_pen(pen)
self.set_brush(brush)
def __init__(self, canvas, parent=None):
super(ScaleBarItem, self).__init__(parent)
self.canvas = canvas
self.realsize = 100
black = QColor(Qt.black)
black.setAlpha(150)
white = QColor(Qt.white)
white.setAlpha(150)
blackpen = QPen(black, 4)
whitepen = QPen(white, 8)
self.pens = [whitepen, blackpen]
self.whitepen = QPen(white, 1)
self.blackbrush = QBrush(black)
self.ticksize = 10
self.fontsize = 15
self.font = QFont()
self.font.setPointSize(self.fontsize)
self.font.setStyleHint(QFont.Times, QFont.PreferAntialias)
self.font.setBold(True)
self.metrics = QFontMetrics(self.font)
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 addRectIndependencePearson(self, rect, x, y, w, h, xAttr_xVal, yAttr_yVal, actual, sum):
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), 1); 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), 1)
rect.setPen(pen)
r = 255
b = g = 255 + intPearson*20
b = g = max(b, 55)
else:
pen = QPen(QColor(255,255,255), 1)
r = g = b = 255 # white
color = QColor(r,g,b)
brush = QBrush(color); rect.setBrush(brush)
if self.showCases and w > 6 and h > 6:
if self.showInColor:
if pearson > 0: c = QColor(0,0,255)
else: c = QColor(255, 0,0)
else: c = Qt.black
for i in range(int(actual)):
OWCanvasEllipse(self.canvas, random.randint(x+1, x + w-4), random.randint(y+1, y + h-4), 3, 3, penColor = c, brushColor = c, z = 100)
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
self.addLines(x,y,w,h, kvoc, pen)
def drawAsciiDump(self, painter, offset, row, size, row_data) :
ascii_dump_left = self.asciiDumpLeft()
#// i is the byte index
chars_per_row = self.bytesPerRow()
for i in range(0,chars_per_row) :
index = offset + i
if(index < size) :
ch = row_data[i]
drawLeft = ascii_dump_left + i * self.font_width
printable = self.is_printable(ch)
#// drawing a selected character
if(self.isSelected(index)) :
painter.fillRect(
drawLeft,
row,
self.font_width,
self.font_height,
self.palette().highlight()
)
painter.setPen(QPen(self.palette().highlightedText().color()))
else :
if printable:
painter.setPen(QPen(self.palette().text().color()))
else:
painter.setPen(QPen(self.non_printable_text))
if printable:
byteBuffer = str(ch)
else:
byteBuffer = str(self.unprintable_char)
painter.drawText(
drawLeft,
row,
self.font_width,
self.font_height,
Qt.AlignTop,
byteBuffer
)
else :
break
return
def paint(self, painter, option, widget=None):
"""
Paint a single line of the slice intersection marker.
"""
width = self._parent._width
height = self._parent._height
thickness = self._parent.PEN_THICKNESS
# Our pen thickness is consistent across zoom levels because the pen is "cosmetic"
# However, that doesn't ensure a consistent-size dash pattern.
# Determine the inverse scaling factor from scene to view to set a consistent dash pattern at all scales.
view = self.scene().views()[0]
inverted_transform, has_inverse = view.transform().inverted()
dash_length = 4 / inverted_transform.m11()
dash_length = max(0.5, dash_length)
# Draw the line with two pens to get a black-and-white dashed line.
#pen_white = QPen( Qt.white, thickness )
pen_white = QPen(self._parent._cropColor, thickness)
pen_white.setDashPattern([dash_length, dash_length])
pen_white.setCosmetic(True)
pen_black = QPen(Qt.black, thickness)
pen_black.setDashPattern([dash_length, dash_length])
pen_black.setCosmetic(True)
pen_black.setDashOffset(dash_length)
with painter_context(painter):
t = painter.transform()
painter.setTransform(self.scene().data2scene * t)
# Draw the line with two pens to get a black-and-white dashed line.
for pen in [pen_white, pen_black]:
painter.setPen(pen)
if self._direction == 'horizontal':
painter.drawLine(QPointF(0.0, self.position),
QPointF(width, self.position))
else:
painter.drawLine(QPointF(self.position, 0.0),
QPointF(self.position, height))
def paint(self, painter, option, index):
filePath = self.model.filePath(index)
fileName = self.model.fileName(index)
r = option.rect
img = QPixmap(filePath)
if img.isNull():
# If not image file, try to load icon with QFileIconProvider
# according to file type (extension name).
# Currently not work as intended.
fileInfo = self.model.fileInfo(index)
icon = QFileIconProvider().icon(fileInfo)
img = icon.pixmap(QSize(32, 32))
# Scale to height, align center horizontally, align bottom vertically.
if img.height() > self.thumbHeight:
img = img.scaledToHeight(self.thumbHeight, Qt.SmoothTransformation)
if img.width() > self.thumbHeight:
img = img.scaledToWidth(self.thumbHeight, Qt.SmoothTransformation)
imgLeft = (self.width - img.width()) / 2
imgTop = self.thumbHeight - img.height()
painter.drawPixmap(r.left() + imgLeft, r.top() + imgTop, img)
rect = QRect(r.left(),
r.top() + self.thumbHeight, self.width, self.nameHeight)
flag = Qt.AlignHCenter | Qt.TextWrapAnywhere
# get the bounding rectangle of the fileName
bdRect = painter.boundingRect(rect, flag, fileName)
if bdRect.height() < rect.height():
rect = bdRect
if option.state & QStyle.State_Selected:
painter.setBrush(self.parent().palette().highlight())
painter.drawRoundedRect(rect, 5, 5)
pen = QPen(self.parent().palette().highlightedText(), 1,
Qt.SolidLine)
else:
pen = QPen(self.parent().palette().text(), 1, Qt.SolidLine)
painter.setPen(pen)
painter.drawText(rect, flag, fileName)
def paintEvent(self, e):
super(QFrame, self).paintEvent(e)
p = QPainter(self)
p.fillRect(self.contentsRect(), self.palette().button())
r = self.rect()
offset = 1 if self.frameShadow() == self.Sunken else 0
pen = QPen(self.palette().buttonText(), 1)
p.setPen(pen)
p.drawRect(r.center().x() + offset - 4, r.center().y() + offset, 1, 1)
p.drawRect(r.center().x() + offset, r.center().y() + offset, 1, 1)
p.drawRect(r.center().x() + offset + 4, r.center().y() + offset, 1, 1)
if self.hasFocus():
p.setPen(QPen(Qt.black, 0, Qt.SolidLine))
p.drawRect(0, 0, self.width() - 1, self.height() - 1)
p.end()
def updateColor(self):
iconSize = self.iconSize()
width = iconSize.width()
height = iconSize.height()
pixmap = QPixmap(iconSize)
pixmap.fill(self._color)
painter = QPainter()
painter.begin(pixmap)
painter.setPen(QPen(QColor("#777777")))
painter.drawRect(QRect(0, 0, width - 1, height - 1))
painter.end()
self.setIcon(QIcon(pixmap))
def __init__(self, edge_count=3, radius=20):
super(PolygonItem, self).__init__()
# edge_count çokgenin kaç kenarı olduğunu
# radius ise çokgenin herhangi bir köşesinin
# merkeze olan mesafesini belirliyor.
# bir önceki görseldeki 'r' değeri
self.edge_count = edge_count
self.radius = radius
self.polygon = self.calculate_polygon_points()
self._pen = QPen(Qt.black)
self._brush = QBrush(Qt.NoBrush)
def paint(self, p: QPainter):
if not self.n1.parent.isVisible() or (self.n2 is not None and not self.n2.parent.isVisible()):
return
if self.__path is None:
self.compute_path()
c = Block.border_color
if self.selected:
c = c.lighter().lighter()
if not self.__status:
c = QColor(255, 100, 100, 180)
p.setPen(QPen(c, 4))
p.drawPath(self.__path)
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 addCurve(self, curveId, curveName):
curveId = str(curveId)
if self.curves.get(curveId):
return
curveObject = Qwt.QwtPlotCurve(curveName)
curveObject.attach(self)
curveObject.setPen(QPen(self.colors[len(self.curves.keys()) % len(self.colors)]))
self.curves[curveId] = {
'name': curveName,
'data': zeros(self.dataNumValuesSaved),
'object': curveObject,
}
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)
def __init__(self, start, end, pen=QPen(QColor(0, 0, 0, 255))):
self.pen = pen
QGraphicsItem.__init__(self)
self.starting_line = QLineF(start, end)
self.bounds = QRectF(start - (end - start), end + (end - start))
self.steps = 4
self.smooth = 50
self.dampen = 100
self.update_lines()
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.colors = []
self._curve_data = {}
box = gui.widgetBox(self.controlArea, "Plot")
tbox = gui.widgetBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(
tbox, self, "target_index", callback=self._on_target_changed,
contentsLength=8)
cbox = gui.widgetBox(box, "Classifiers")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
cbox, self, "selected_classifiers", "classifier_names",
selectionMode=QtGui.QListView.MultiSelection,
callback=self._on_classifiers_changed)
gui.checkBox(box, self, "display_convex_hull",
"Show lift convex hull", callback=self._replot)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QtGui.QFrame.StyledPanel)
self.plot = pg.PlotItem()
self.plot.getViewBox().setMenuEnabled(False)
pen = QPen(self.palette().color(QtGui.QPalette.Text))
tickfont = QtGui.QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("P Rate")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate")
self.plot.showGrid(True, True, alpha=0.1)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0))
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
self.graphButton.clicked.connect(self.save_graph)
def draw_needle(self):
painter = QPainter(self)
# painter.setRenderHint(QtGui.QPainter.HighQualityAntialiasing)
painter.setRenderHint(QPainter.Antialiasing)
# Koordinatenursprung in die Mitte der Flaeche legen
painter.translate(self.width() / 2, self.height() / 2)
painter.setPen(QPen(Qt.black, 2, Qt.SolidLine))
painter.setBrush(self.NeedleColor)
painter.rotate(((self.value - self.value_offset - self.value_min) * self.scale_angle_size /
(self.value_max - self.value_min)) + 90 + self.scale_angle_start_value)
painter.drawConvexPolygon(self.value_needle[0])
