def __init__(self, graph, enable_menu=False):
ViewBox.__init__(self, enableMenu=enable_menu)
self.graph = graph
self.setMouseMode(self.PanMode)
pen = mkPen(LinePlotStyle.SELECTION_LINE_COLOR,
width=LinePlotStyle.SELECTION_LINE_WIDTH)
self.selection_line = QGraphicsLineItem()
self.selection_line.setPen(pen)
self.selection_line.setZValue(1e9)
self.addItem(self.selection_line, ignoreBounds=True)
def __init__(self,
id,
title='',
title_above=False,
title_location=AxisMiddle,
line=None,
arrows=0,
plot=None,
bounds=None):
QGraphicsItem.__init__(self)
self.setFlag(QGraphicsItem.ItemHasNoContents)
self.setZValue(AxisZValue)
self.id = id
self.title = title
self.title_location = title_location
self.data_line = line
self.plot = plot
self.graph_line = None
self.size = None
self.scale = None
self.tick_length = (10, 5, 0)
self.arrows = arrows
self.title_above = title_above
self.line_item = QGraphicsLineItem(self)
self.title_item = QGraphicsTextItem(self)
self.end_arrow_item = None
self.start_arrow_item = None
self.show_title = False
self.scale = None
path = QPainterPath()
path.setFillRule(Qt.WindingFill)
path.moveTo(0, 3.09)
path.lineTo(0, -3.09)
path.lineTo(9.51, 0)
path.closeSubpath()
self.arrow_path = path
self.label_items = []
self.label_bg_items = []
self.tick_items = []
self._ticks = []
self.zoom_transform = QTransform()
self.labels = None
self.values = None
self._bounds = bounds
self.auto_range = None
self.auto_scale = True
self.zoomable = False
self.update_callback = None
self.max_text_width = 50
self.text_margin = 5
self.always_horizontal_text = False
def __init__(self):
super().__init__(enableMenu=False)
self._profile_items = None
self._can_select = True
self._graph_state = SELECT
self.setMouseMode(self.PanMode)
pen = mkPen(LinePlotStyle.SELECTION_LINE_COLOR,
width=LinePlotStyle.SELECTION_LINE_WIDTH)
self.selection_line = QGraphicsLineItem()
self.selection_line.setPen(pen)
self.selection_line.setZValue(1e9)
self.addItem(self.selection_line, ignoreBounds=True)
def __init__(self):
super().__init__()
self.__violin_column_width = self.VIOLIN_COLUMN_WIDTH # type: int
self.__range = None # type: Optional[Tuple[float, float]]
self.__violin_items = [] # type: List[ViolinItem]
self.__bottom_axis = pg.AxisItem(parent=self, orientation="bottom",
maxTickLength=7, pen=QPen(Qt.black))
self.__bottom_axis.setLabel("Impact on model output")
self.__vertical_line = QGraphicsLineItem(self.__bottom_axis)
self.__vertical_line.setPen(QPen(Qt.gray))
self.__legend = Legend(self)
self.__layout = QGraphicsGridLayout()
self.__layout.addItem(self.__legend, 0, ViolinPlot.LEGEND_COLUMN)
self.__layout.setVerticalSpacing(0)
self.setLayout(self.__layout)
def __init__(self, parent=None, line=QLineF(), text="", **kwargs):
super().__init__(None, **kwargs)
self._text = text
self.setFlag(pg.GraphicsObject.ItemHasNoContents)
self._spine = QGraphicsLineItem(line, self)
angle = line.angle()
self._arrow = pg.ArrowItem(parent=self, angle=0)
self._arrow.setPos(self._spine.line().p2())
self._arrow.setRotation(angle)
self._label = TextItem(text=text, color=(10, 10, 10))
self._label.setParentItem(self)
self._label.setPos(self._spine.line().p2())
if parent is not None:
self.setParentItem(parent)
def __init__(self):
super().__init__()
self._item_column_width = self.ITEM_COLUMN_WIDTH
self._range: Optional[Tuple[float, float]] = None
self._items: List[FeatureItem] = []
self._variable_items: List[VariableItem] = []
self._bottom_axis = AxisItem(parent=self,
orientation="bottom",
maxTickLength=7,
pen=QPen(Qt.black))
self._bottom_axis.setLabel(self.BOTTOM_AXIS_LABEL)
self._vertical_line = QGraphicsLineItem(self._bottom_axis)
self._vertical_line.setPen(QPen(Qt.gray))
self._layout = QGraphicsGridLayout()
self._layout.setVerticalSpacing(0)
self.setLayout(self._layout)
self.parameter_setter = BaseParameterSetter(self)
def test_controlpointline(self):
control = ControlPointLine()
line = QGraphicsLineItem(10, 10, 200, 200)
self.scene.addItem(line)
self.scene.addItem(control)
control.setLine(line.line())
control.setFocus()
control.lineChanged.connect(line.setLine)
control.setLine(QLineF(30, 30, 180, 180))
self.assertEqual(control.line(), line.line())
self.assertEqual(line.line(), QLineF(30, 30, 180, 180))
control.lineEdited.connect(line.setLine)
self.view.show()
self.app.exec_()
self.assertEqual(control.line(), line.line())
def addLink(self, output, input):
"""
Add a link between `output` (:class:`OutputSignal`) and `input`
(:class:`InputSignal`).
"""
if not compatible_channels(output, input):
return
if output not in self.source.output_channels():
raise ValueError("%r is not an output channel of %r" % \
(output, self.source))
if input not in self.sink.input_channels():
raise ValueError("%r is not an input channel of %r" % \
(input, self.sink))
if input.single:
# Remove existing link if it exists.
for s1, s2, _ in self.__links:
if s2 == input:
self.removeLink(s1, s2)
line = QGraphicsLineItem(self)
source_anchor = self.sourceNodeWidget.anchor(output)
sink_anchor = self.sinkNodeWidget.anchor(input)
source_pos = source_anchor.boundingRect().center()
source_pos = self.mapFromItem(source_anchor, source_pos)
sink_pos = sink_anchor.boundingRect().center()
sink_pos = self.mapFromItem(sink_anchor, sink_pos)
line.setLine(source_pos.x(), source_pos.y(), sink_pos.x(),
sink_pos.y())
pen = QPen(self.palette().color(QPalette.Foreground), 4)
pen.setCapStyle(Qt.RoundCap)
line.setPen(pen)
self.__links.append(_Link(output, input, line))
def line(x0, y0, x1, y1, *args):
return QGraphicsLineItem(x0 * scale_x, y0, x1 * scale_x, y1, *args)
def line(x, down=1):
QGraphicsLineItem(x, 12 * down, x, 20 * down, labels)
def line(x1, y1, x2, y2):
r = QGraphicsLineItem(x1, y1, x2, y2, None)
self.canvas.addItem(r)
r.setPen(QPen(Qt.white, 2))
r.setZValue(30)
def __init__(self, name, data_extremes, values, scale, name_offset, offset,
coef):
super().__init__()
data_start, data_stop = data_extremes[0], data_extremes[1]
self.name = name.toPlainText()
self.diff = (data_stop - data_start) * coef
labels = [
str(
np.round(
data_start + (data_stop - data_start) * i /
(self.n_tck - 1), 1)) for i in range(self.n_tck)
]
# leading label
font = name.document().defaultFont()
name.setFont(font)
name.setPos(name_offset, -10)
name.setParentItem(self)
# labels
ascending = data_start < data_stop
y_start, y_stop = (self.y_diff, 0) if ascending else (0, self.y_diff)
for i in range(self.n_tck):
text = QGraphicsSimpleTextItem(labels[i])
w = text.boundingRect().width()
y = y_start + (y_stop - y_start) / (self.n_tck - 1) * i
text.setPos(-5 - w, y - 8)
text.setParentItem(self)
tick = QGraphicsLineItem(-2, y, 2, y)
tick.setParentItem(self)
# prediction marker
self.dot = Continuous2DMovableDotItem(self.dot_r, scale, offset,
values[0], values[-1], y_start,
y_stop)
self.dot.tooltip_labels = labels
self.dot.tooltip_values = values
self.dot.setParentItem(self)
h_line = QGraphicsLineItem(values[0] * scale + offset, self.y_diff / 2,
values[-1] * scale + offset,
self.y_diff / 2)
pen = QPen(Qt.DashLine)
pen.setBrush(QColor(Qt.red))
h_line.setPen(pen)
h_line.setParentItem(self)
self.dot.horizontal_line = h_line
# line
line = QGraphicsLineItem(values[0] * scale + offset, y_start,
values[-1] * scale + offset, y_stop)
line.setParentItem(self)
# ticks
for value in values:
diff_ = np.nan_to_num(values[-1] - values[0])
k = (value - values[0]) / diff_ if diff_ else 0
y_tick = (y_stop - y_start) * k + y_start - self.tick_height / 2
x_tick = value * scale - self.tick_width / 2 + offset
tick = QGraphicsRectItem(x_tick, y_tick, self.tick_width,
self.tick_height)
tick.setBrush(QColor(Qt.black))
tick.setParentItem(self)
# rect
rect = QGraphicsRectItem(values[0] * scale + offset,
-self.y_diff * 0.125,
values[-1] * scale + offset,
self.y_diff * 1.25)
pen = QPen(Qt.DotLine)
pen.setBrush(QColor(50, 150, 200, 255))
rect.setPen(pen)
rect.setParentItem(self)
self.setPreferredSize(self.preferredWidth(), self.y_diff * 1.5)
def _offseted_line(ax, ay):
r = QGraphicsLineItem(x + ax, y + ay, x + (ax or w),
y + (ay or h))
self.canvas.addItem(r)
r.setPen(pen)
def __init__(
self,
name,
values,
scale,
name_offset,
offset,
get_points,
title,
get_probabilities,
):
super().__init__()
self.scale = scale
self.offset = offset
self.get_points = get_points
self.min_val = min(values)
self.max_val = max(values)
# leading labels
font = name.document().defaultFont()
font.setWeight(QFont.Bold)
name_total = QGraphicsTextItem("Total", self)
name_total.setFont(font)
name_total.setPos(name_offset, -25)
name.setFont(font)
name.setPos(name_offset, 10)
name.setParentItem(self)
# prediction marker
self.dot = ProbabilitiesDotItem(
self.DOT_RADIUS,
scale,
offset,
values[0],
values[-1],
title,
get_probabilities,
)
self.dot.setPos(0, (-self.DOT_RADIUS + self.y_diff) / 2)
self.dot.setParentItem(self)
# pylint: disable=unused-variable
# two lines
t_line = QGraphicsLineItem(self.min_val * scale + offset, 0,
self.max_val * scale + offset, 0, self)
p_line = QGraphicsLineItem(
self.min_val * scale + offset,
self.y_diff,
self.max_val * scale + offset,
self.y_diff,
self,
)
# ticks and labels
old_x_tick = values[0] * scale + offset
for i, value in enumerate(values[1:]):
x_tick = value * scale + offset
x = x_tick - (x_tick - old_x_tick) / 2
half_tick = QGraphicsLineItem(x, -self.tick_height / 2, x, 0, self)
old_x_tick = x_tick
if i == len(values) - 2:
break
text = QGraphicsTextItem(str(abs(value) if value == -0 else value),
self)
x_text = value * scale - text.boundingRect().width() / 2 + offset
y_text = -text.boundingRect().height() - self.DOT_RADIUS * 0.7
text.setPos(x_text, y_text)
tick = QGraphicsLineItem(x_tick, -self.tick_height, x_tick, 0,
self)
self.prob_items = [(
i / 10,
QGraphicsTextItem(" " + str(i * 10) + " "),
QGraphicsLineItem(0, 0, 0, 0),
) for i in range(1, 10)]
