def tick_DC(self, u, i):
self.datau.pop(0)
self.datai.pop(0)
self.datau.append(u)
self.datai.append(i)
self.scene1 = QGraphicsScene()
self.scene2 = QGraphicsScene()
self.setup_scene(self.scene1)
self.setup_scene(self.scene2)
self.scene1.addSimpleText('[U/V]').moveBy(-39, 220-10)
self.scene2.addSimpleText('[I/mA]').moveBy(-39, 220-10)
self.scene1.addSimpleText('+4.0').moveBy(-40, 0-10)
self.scene1.addSimpleText('+2.0').moveBy(-40, 50-10)
self.scene1.addSimpleText(' 0.0').moveBy(-40, 100-10)
self.scene1.addSimpleText('-2.0').moveBy(-40, 150-10)
self.scene1.addSimpleText('-4.0').moveBy(-40, 200-10)
self.scene2.addSimpleText('+0.4').moveBy(-40, 0-10)
self.scene2.addSimpleText('+0.2').moveBy(-40, 50-10)
self.scene2.addSimpleText(' 0.0').moveBy(-40, 100-10)
self.scene2.addSimpleText('-0.2').moveBy(-40, 150-10)
self.scene2.addSimpleText('-0.4').moveBy(-40, 200-10)
path = QPainterPath()
path.moveTo(0,100-self.datau[0]*25)
for i in xrange(1,200):
path.lineTo(3*(i+1), 100-self.datau[i]*25)
self.scene1.addPath(path, QPen(QColor(0,0,255), 3))
path = QPainterPath()
path.moveTo(0,100-self.datai[0]*25)
for i in xrange(1,200):
path.lineTo(3*(i+1), 100-self.datai[i]*25)
self.scene2.addPath(path, QPen(QColor(0,0,255), 3))
self.ui.graph1.setScene(self.scene1)
self.ui.graph2.setScene(self.scene2)
def tick_DC(self, u, i):
self.datau.pop(0)
self.datai.pop(0)
self.datau.append(u)
self.datai.append(i)
self.scene1 = QGraphicsScene()
self.scene2 = QGraphicsScene()
self.setup_scene(self.scene1)
self.setup_scene(self.scene2)
self.scene1.addSimpleText('[U/V]').moveBy(-39, 220 - 10)
self.scene2.addSimpleText('[I/mA]').moveBy(-39, 220 - 10)
self.scene1.addSimpleText('+4.0').moveBy(-40, 0 - 10)
self.scene1.addSimpleText('+2.0').moveBy(-40, 50 - 10)
self.scene1.addSimpleText(' 0.0').moveBy(-40, 100 - 10)
self.scene1.addSimpleText('-2.0').moveBy(-40, 150 - 10)
self.scene1.addSimpleText('-4.0').moveBy(-40, 200 - 10)
self.scene2.addSimpleText('+0.4').moveBy(-40, 0 - 10)
self.scene2.addSimpleText('+0.2').moveBy(-40, 50 - 10)
self.scene2.addSimpleText(' 0.0').moveBy(-40, 100 - 10)
self.scene2.addSimpleText('-0.2').moveBy(-40, 150 - 10)
self.scene2.addSimpleText('-0.4').moveBy(-40, 200 - 10)
path = QPainterPath()
path.moveTo(0, 100 - self.datau[0] * 25)
for i in xrange(1, 200):
path.lineTo(3 * (i + 1), 100 - self.datau[i] * 25)
self.scene1.addPath(path, QPen(QColor(0, 0, 255), 3))
path = QPainterPath()
path.moveTo(0, 100 - self.datai[0] * 25)
for i in xrange(1, 200):
path.lineTo(3 * (i + 1), 100 - self.datai[i] * 25)
self.scene2.addPath(path, QPen(QColor(0, 0, 255), 3))
self.ui.graph1.setScene(self.scene1)
self.ui.graph2.setScene(self.scene2)
def toQPainterPath(self):
"""Return a QPainterPath containing all segments of this path.
"""
if not self.isValid():
raise Path2dException('invalid path')
p = QPainterPath()
sx, sy = self._elements[0]
if len(self._elements[1]) == 2:
# Only add a start point if the QPainterPath will start with a
# line, not an arc.
p.moveTo(sx, sy)
for e in self._elements[1:]:
if len(e) == 2:
p.lineTo(*e)
sx, sy = e
else:
(ex, ey), (cx, cy), arcDir = e
r = hypot(ex-cx, ey-cy)
d = r*2
sa = degrees(atan2(sy-cy, sx-cx)) % 360.0
ea = degrees(atan2(ey-cy, ex-cx)) % 360.0
# NOTE: machtool uses a right-handed cartesian coordinate
# system with the Y+ up. Because of this, the QRectF
# used to define the arc has a negative height. This
# makes a positive arc angle sweep cclw as it should.
rect = QRectF(cx - r, cy + r, d, -d)
if arcDir == 'cclw':
span = (ea + 360.0 if ea < sa else ea) - sa
else:
span = -((sa + 360.0 if sa < ea else sa) - ea)
p.arcMoveTo(rect, sa)
p.arcTo(rect, sa, span)
sx, sy = ex, ey
return p
def mouseMoveEvent(self, event):
"""
Normally our base class (QGraphicsScene) distributes mouse events to the
various QGraphicsItems in the scene. But when the mouse is being dragged,
it only sends events to the one object that was under the mouse when the
button was first pressed.
Here, we forward all events to QGraphicsItems on the drag path, even if
they're just brushed by the mouse incidentally.
"""
super(ImageScene2D, self).mouseMoveEvent(event)
if not event.isAccepted() and event.buttons() != Qt.NoButton:
if self.last_drag_pos is None:
self.last_drag_pos = event.scenePos()
# As a special feature, find the item and send it this event.
path = QPainterPath(self.last_drag_pos)
path.lineTo(event.scenePos())
items = self.items(path)
for item in items:
item.mouseMoveEvent(event)
self.last_drag_pos = event.scenePos()
else:
self.last_drag_pos = None
def draw_into(self, scene, incremental=False):
for subbranch in self.branches:
subbranch.draw_into(scene, incremental)
start = self.already_drawn if incremental else None
points = [QPointF(np.real(x), -np.imag(x)) for x in self.history[start:]]
gens = float(self.params["painter_generations"])
scale_factor = (self.params["scale"] - 1) * 3 + 1
pen_width = max(0, gens-self.generation) / gens * self.params["painter_thickness"] * scale_factor
if self.generation == 0 and len(self.history) < 30:
intensity = 126/30.0 * len(self.history)
else:
intensity = 17 + 99 * max(0, gens-self.generation) / gens
color = self.params["color"].darker(85 + (127 - intensity) * 4)
outline = color.darker(500)
pen = QPen(color)
pen.setWidthF(pen_width)
darkPen = QPen(outline)
darkPen.setWidthF(pen_width)
depth = self.params["depth"]
path = QPainterPath()
path.moveTo(points[0])
for index in range(1, len(points) - 1):
path.lineTo(points[index])
scene.addPath(path, pen)
if incremental:
self.already_drawn = max(0, len(self.history) - 1)
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 drawArrow(self, paint, x1, y1, x2, y2):
m = paint.worldMatrix()
paint.translate(x1, y1)
pi = 3.1415926
if abs(x2 - x1) > 0:
alpha = math.atan(abs(y2 - y1) / abs(x2 - x1)) * 180 / pi
else:
alpha = 90
if y2 > y1:
if x2 > x1:
paint.rotate(alpha)
else:
paint.rotate(180 - alpha)
else:
if x2 > x1:
paint.rotate(-alpha)
else:
paint.rotate(alpha - 180)
endcoord = math.sqrt((x2 - x1)**2 + (y2 - y1)**2) - self.size / 2
p1 = QPointF(endcoord, 0)
paint.drawLine(0, 0, p1.x(), 0)
coord = math.sqrt(9**2 - 6**2)
p2 = QPointF(endcoord - coord, 6)
p3 = QPointF(endcoord - coord, -6)
path = QPainterPath()
path.moveTo(p1)
path.lineTo(p2)
path.lineTo(p3)
path.lineTo(p1)
paint.fillPath(path, paint.pen().color())
paint.setWorldMatrix(m)
def __init__(self, edge):
QGraphicsPathItem.__init__(self)
self.__edge = edge
startPoint = QPointF(edge.points[0][0], edge.points[0][1])
painterPath = QPainterPath(startPoint)
index = 1
while index + 3 <= len(edge.points):
painterPath.cubicTo(edge.points[index][0], edge.points[index][1],
edge.points[index + 1][0],
edge.points[index + 1][1],
edge.points[index + 2][0],
edge.points[index + 2][1])
index = index + 3
if index + 2 <= len(edge.points):
painterPath.quadTo(edge.points[index + 1][0],
edge.points[index + 1][1],
edge.points[index + 2][0],
edge.points[index + 2][1])
index = index + 2
if index + 1 <= len(edge.points):
painterPath.lineTo(edge.points[index + 1][0],
edge.points[index + 1][1])
if edge.head != edge.tail:
lastIndex = len(edge.points) - 1
self.addArrow(painterPath, edge.points[lastIndex - 1][0],
edge.points[lastIndex - 1][1],
edge.points[lastIndex][0], edge.points[lastIndex][1])
self.setPath(painterPath)
return
def toQPainterPath(self):
"""Return a QPainterPath containing all segments of this path.
"""
if not self.isValid():
raise Path2dException('invalid path')
p = QPainterPath()
sx, sy = self._elements[0]
if len(self._elements[1]) == 2:
# Only add a start point if the QPainterPath will start with a
# line, not an arc.
p.moveTo(sx, sy)
for e in self._elements[1:]:
if len(e) == 2:
p.lineTo(*e)
sx, sy = e
else:
(ex, ey), (cx, cy), arcDir = e
r = hypot(ex - cx, ey - cy)
d = r * 2
sa = degrees(atan2(sy - cy, sx - cx)) % 360.0
ea = degrees(atan2(ey - cy, ex - cx)) % 360.0
# NOTE: machtool uses a right-handed cartesian coordinate
# system with the Y+ up. Because of this, the QRectF
# used to define the arc has a negative height. This
# makes a positive arc angle sweep cclw as it should.
rect = QRectF(cx - r, cy + r, d, -d)
if arcDir == 'cclw':
span = (ea + 360.0 if ea < sa else ea) - sa
else:
span = -((sa + 360.0 if sa < ea else sa) - ea)
p.arcMoveTo(rect, sa)
p.arcTo(rect, sa, span)
sx, sy = ex, ey
return p
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 __init__(self, edge, modObj):
QGraphicsPathItem.__init__(self)
self.__edge = edge
self.__modObj = modObj
startPoint = QPointF(edge.points[0][0], edge.points[0][1])
painterPath = QPainterPath(startPoint)
index = 1
while index + 3 <= len(edge.points):
painterPath.cubicTo(edge.points[index][0], edge.points[index][1],
edge.points[index + 1][0],
edge.points[index + 1][1],
edge.points[index + 2][0],
edge.points[index + 2][1])
index = index + 3
if index + 2 <= len(edge.points):
painterPath.quadTo(edge.points[index + 1][0],
edge.points[index + 1][1],
edge.points[index + 2][0],
edge.points[index + 2][1])
index = index + 2
if index + 1 <= len(edge.points):
painterPath.lineTo(edge.points[index + 1][0],
edge.points[index + 1][1])
self.setPath(painterPath)
return
def rebuild(self, gridRect):
"""
Rebuilds the tracker item.
"""
scene = self.scene()
if (not scene):
return
self.setVisible(gridRect.contains(self.pos()))
self.setZValue(100)
path = QPainterPath()
path.moveTo(0, 0)
path.lineTo(0, gridRect.height())
tip = ''
tip_point = None
self._ellipses = []
items = scene.collidingItems(self)
self._basePath = QPainterPath(path)
for item in items:
item_path = item.path()
found = None
for y in range(int(gridRect.top()), int(gridRect.bottom())):
point = QPointF(self.pos().x(), y)
if (item_path.contains(point)):
found = QPointF(0, y - self.pos().y())
break
if (found):
path.addEllipse(found, 6, 6)
self._ellipses.append(found)
# update the value information
value = scene.valueAt(self.mapToScene(found))
tip_point = self.mapToScene(found)
hruler = scene.horizontalRuler()
vruler = scene.verticalRuler()
x_value = hruler.formatValue(value[0])
y_value = vruler.formatValue(value[1])
tip = '<b>x:</b> %s<br/><b>y:</b> %s' % (x_value, y_value)
self.setPath(path)
self.setVisible(True)
# show the popup widget
if (tip):
anchor = XPopupWidget.Anchor.RightCenter
widget = self.scene().chartWidget()
tip_point = widget.mapToGlobal(widget.mapFromScene(tip_point))
XPopupWidget.showToolTip(tip,
anchor=anchor,
parent=widget,
point=tip_point,
foreground=QColor('blue'),
background=QColor(148, 148, 255))
def __init__( self, edge, modObj, connObj ):
QGraphicsPathItem.__init__( self )
self.__edge = edge
self.__modObj = modObj
self.__connObj = connObj
startPoint = QPointF( edge.points[ 0 ][ 0 ], edge.points[ 0 ][ 1 ] )
painterPath = QPainterPath( startPoint )
index = 1
while index + 3 <= len( edge.points ):
painterPath.cubicTo(edge.points[index][0], edge.points[index][1],
edge.points[index+1][0],edge.points[index+1][1],
edge.points[index+2][0],edge.points[index+2][1])
index = index + 3
if index + 2 <= len( edge.points ):
painterPath.quadTo(edge.points[index+1][0], edge.points[index+1][1],
edge.points[index+2][0], edge.points[index+2][1])
index = index + 2
if index + 1 <= len( edge.points ):
painterPath.lineTo(edge.points[index+1][0], edge.points[index+1][1])
lastIndex = len( edge.points ) - 1
self.addArrow( painterPath,
edge.points[lastIndex-1][0],
edge.points[lastIndex-1][1],
edge.points[lastIndex][0],
edge.points[lastIndex][1] )
self.setPath( painterPath )
return
def __init__(self, parent, pos, angle):
Sector.__init__(self, parent, pos, angle)
self.setZValue(1)
path = QPainterPath()
path.lineTo(_pitDistance, 0)
self.setPath(path)
self.setPen(QPen(_pitColor, _pitWidth))
def __init_corner(self):
path = QPainterPath()
path.moveTo(-Block.padding, -15 - Block.padding)
path.lineTo(-15 - Block.padding, -Block.padding)
path.lineTo(-Block.padding, -Block.padding)
path.closeSubpath()
self.__corner_path = path
def rebuild( self, gridRect ):
"""
Rebuilds the tracker item.
"""
scene = self.scene()
if ( not scene ):
return
self.setVisible(gridRect.contains(self.pos()))
self.setZValue(100)
path = QPainterPath()
path.moveTo(0, 0)
path.lineTo(0, gridRect.height())
tip = ''
tip_point = None
self._ellipses = []
items = scene.collidingItems(self)
self._basePath = QPainterPath(path)
for item in items:
item_path = item.path()
found = None
for y in range(int(gridRect.top()), int(gridRect.bottom())):
point = QPointF(self.pos().x(), y)
if ( item_path.contains(point) ):
found = QPointF(0, y - self.pos().y())
break
if ( found ):
path.addEllipse(found, 6, 6)
self._ellipses.append(found)
# update the value information
value = scene.valueAt(self.mapToScene(found))
tip_point = self.mapToScene(found)
hruler = scene.horizontalRuler()
vruler = scene.verticalRuler()
x_value = hruler.formatValue(value[0])
y_value = vruler.formatValue(value[1])
tip = '<b>x:</b> %s<br/><b>y:</b> %s' % (x_value, y_value)
self.setPath(path)
self.setVisible(True)
# show the popup widget
if ( tip ):
anchor = XPopupWidget.Anchor.RightCenter
widget = self.scene().chartWidget()
tip_point = widget.mapToGlobal(widget.mapFromScene(tip_point))
XPopupWidget.showToolTip(tip,
anchor = anchor,
parent = widget,
point = tip_point,
foreground = QColor('blue'),
background = QColor(148, 148, 255))
def __init_corner(self):
path = QPainterPath()
dpi = Info.dpi
path.moveTo(-OIBlock.padding * 1.2 * dpi, (-.15 - OIBlock.padding * 1.2) * dpi)
path.lineTo((-.15 - OIBlock.padding * 1.2) * dpi, -OIBlock.padding * 1.2 * dpi)
path.lineTo(-OIBlock.padding * 1.2 * dpi, -OIBlock.padding * 1.2 * dpi)
path.closeSubpath()
self.__corner_path = path
def tile_path(self, cx, cy):
path = QPainterPath()
path.moveTo((cx - self.r_hex), cy)
for i in range(1, 6):
x = cx + (self.r_hex * cos(((3 - i) * pi) / 3))
y = cy + (self.r_hex * sin(((3 - i) * pi) / 3))
path.lineTo(x, y)
path.closeSubpath()
return path
def shape(self):
params = parameters.instance
path = QPainterPath()
scale = self.scale
half_size = params.old_point_size / 2.
path.moveTo(0, -half_size * scale[1])
path.lineTo(0, half_size * scale[1])
path.moveTo(-half_size * scale[0], 0)
path.lineTo(half_size * scale[0], 0)
return path
def shape(self):
params = parameters.instance
path = QPainterPath()
scale = self.scale
half_size = params.old_point_size/2.
path.moveTo(0, -half_size*scale[1])
path.lineTo(0, half_size*scale[1])
path.moveTo(-half_size*scale[0], 0)
path.lineTo(half_size*scale[0], 0)
return path
def __init_corner(self):
path = QPainterPath()
dpi = Info.dpi
path.moveTo(-OIBlock.padding * 1.2 * dpi,
(-.15 - OIBlock.padding * 1.2) * dpi)
path.lineTo((-.15 - OIBlock.padding * 1.2) * dpi,
-OIBlock.padding * 1.2 * dpi)
path.lineTo(-OIBlock.padding * 1.2 * dpi, -OIBlock.padding * 1.2 * dpi)
path.closeSubpath()
self.__corner_path = path
def paint(self, painter, option, widget):
params = parameters.instance
pen = QPen(QColor(Qt.black))
scale = self.scale
ms = min(scale)
pen.setWidth(params.cell_thickness)
sel_thick = 2*params.cell_thickness
if sel_thick == 0:
sel_thick = 2*ms
col = None
if self.current:
col = QColor(params.selected_cell_color)
elif self.hover:
col = QColor(params.cell_hover_color)
else:
col = QColor(params.cell_color)
painter.setBrush(col)
if self.hover_contour:
pen1 = QPen(QColor(Qt.white))
pen1.setWidth(sel_thick)
painter.setPen(pen1)
else:
painter.setPen(pen)
if isinstance(self.polygon, QPolygonF):
painter.drawPolygon(self.polygon_shape)
elif isinstance(self.polygon, QLineF):
painter.drawLine(self.polygon)
pen.setWidth(0)
painter.setPen(pen)
painter.drawPolygon(self.hexagon)
if self.hover_side is not None:
pen = QPen(QColor(Qt.red))
pen.setWidth(sel_thick)
side = self.sides[self.hover_side]
painter.setPen(pen)
pp = QPainterPath()
pp.moveTo(side[0])
for p in side[1:]:
pp.lineTo(p)
painter.drawPath(pp)
elif self.division_line is not None:
pen = QPen(params.division_wall_color)
pen.setWidth(sel_thick)
painter.setPen(pen)
painter.drawLine(self.division_line)
elif self.dragging_line:
pen = QPen(QColor(Qt.red))
pen.setWidth(sel_thick)
painter.setPen(pen)
polygon = self.polygon
dg = self.drag_side
p1 = polygon[dg]
p2 = polygon[dg+1]
painter.drawLine(p1, self.moving_point)
painter.drawLine(self.moving_point, p2)
def calculateDatasets(self, scene, axes, datasets):
"""
Builds the datasets for this renderer. Each renderer will need to
subclass and implemenent this method, otherwise, no data will be
shown in the chart.
:param scene | <XChartScene>
axes | [<
datasets | [<XChartDataset>, ..]
"""
items = self.calculateDatasetItems(scene, datasets)
if not items:
scene.clear()
return
rect = self.buildData('axis_rect')
half_size = self.maximumBarSize() / 2.0
for dataset, item in items.items():
path = QPainterPath()
subpaths = []
for value in dataset.values():
pos = self.pointAt(axes, value)
radius = min(rect.bottom() - pos.y(), 8)
subpath = QPainterPath()
# create a vertical bar graph
if self.orientation() == Qt.Vertical:
subpath.moveTo(pos.x() - half_size, rect.bottom())
subpath.lineTo(pos.x() - half_size, pos.y() + radius)
subpath.quadTo(pos.x() - half_size, pos.y(),
pos.x() - half_size + radius, pos.y())
subpath.lineTo(pos.x() + half_size - radius, pos.y())
subpath.quadTo(pos.x() + half_size, pos.y(),
pos.x() + half_size,
pos.y() + radius)
subpath.lineTo(pos.x() + half_size, rect.bottom())
subpath.lineTo(pos.x() - half_size, rect.bottom())
# create a horizontal bar graph
else:
subpath.moveTo(rect.left(), pos.y() - half_size)
subpath.lineTo(pos.x(), pos.y() - half_size)
subpath.lineTo(pos.x(), pos.y() + half_size)
subpath.lineTo(rect.left(), pos.y() + half_size)
subpath.lineTo(rect.left(), pos.y() - half_size)
path.addPath(subpath)
subpaths.append(subpath)
item.setPath(path)
item.setBuildData('subpaths', subpaths)
def paint(self, painter, option, widget):
params = parameters.instance
pen = QPen(QColor(Qt.black))
scale = self.scale
ms = min(scale)
pen.setWidth(params.cell_thickness)
sel_thick = 2 * params.cell_thickness
if sel_thick == 0:
sel_thick = 2 * ms
col = None
if self.current:
col = QColor(params.selected_cell_color)
elif self.hover:
col = QColor(params.cell_hover_color)
else:
col = QColor(params.cell_color)
painter.setBrush(col)
if self.hover_contour:
pen1 = QPen(QColor(Qt.white))
pen1.setWidth(sel_thick)
painter.setPen(pen1)
else:
painter.setPen(pen)
if isinstance(self.polygon, QPolygonF):
painter.drawPolygon(self.polygon_shape)
elif isinstance(self.polygon, QLineF):
painter.drawLine(self.polygon)
pen.setWidth(0)
painter.setPen(pen)
painter.drawPolygon(self.hexagon)
if self.hover_side is not None:
pen = QPen(QColor(Qt.red))
pen.setWidth(sel_thick)
side = self.sides[self.hover_side]
painter.setPen(pen)
pp = QPainterPath()
pp.moveTo(side[0])
for p in side[1:]:
pp.lineTo(p)
painter.drawPath(pp)
elif self.division_line is not None:
pen = QPen(params.division_wall_color)
pen.setWidth(sel_thick)
painter.setPen(pen)
painter.drawLine(self.division_line)
elif self.dragging_line:
pen = QPen(QColor(Qt.red))
pen.setWidth(sel_thick)
painter.setPen(pen)
polygon = self.polygon
dg = self.drag_side
p1 = polygon[dg]
p2 = polygon[dg + 1]
painter.drawLine(p1, self.moving_point)
painter.drawLine(self.moving_point, p2)
def calculateDatasets(self, scene, axes, datasets):
"""
Builds the datasets for this renderer. Each renderer will need to
subclass and implemenent this method, otherwise, no data will be
shown in the chart.
:param scene | <XChartScene>
axes | [<
datasets | [<XChartDataset>, ..]
"""
items = self.calculateDatasetItems(scene, datasets)
if not items:
scene.clear()
return
rect = self.buildData('axis_rect')
half_size = self.maximumBarSize() / 2.0
for dataset, item in items.items():
path = QPainterPath()
subpaths = []
for value in dataset.values():
pos = self.pointAt(axes, value)
radius = min(rect.bottom() - pos.y(), 8)
subpath = QPainterPath()
# create a vertical bar graph
if self.orientation() == Qt.Vertical:
subpath.moveTo(pos.x() - half_size, rect.bottom())
subpath.lineTo(pos.x() - half_size, pos.y() + radius)
subpath.quadTo(pos.x() - half_size, pos.y(),
pos.x() - half_size + radius, pos.y())
subpath.lineTo(pos.x() + half_size - radius, pos.y())
subpath.quadTo(pos.x() + half_size, pos.y(),
pos.x() + half_size, pos.y() + radius)
subpath.lineTo(pos.x() + half_size, rect.bottom())
subpath.lineTo(pos.x() - half_size, rect.bottom())
# create a horizontal bar graph
else:
subpath.moveTo(rect.left(), pos.y() - half_size)
subpath.lineTo(pos.x(), pos.y() - half_size)
subpath.lineTo(pos.x(), pos.y() + half_size)
subpath.lineTo(rect.left(), pos.y() + half_size)
subpath.lineTo(rect.left(), pos.y() - half_size)
path.addPath(subpath)
subpaths.append(subpath)
item.setPath(path)
item.setBuildData('subpaths', subpaths)
def rebuildSmooth( self ):
"""
Rebuilds a smooth path based on the inputed points and set \
parameters for this item.
:return <QPainterPath>
"""
# collect the control points
points = self.controlPoints()
# create the path
path = QPainterPath()
if ( len(points) == 3 ):
x0, y0 = points[0]
x1, y1 = points[1]
xN, yN = points[2]
path.moveTo(x0, y0)
path.quadTo(x1, y1, xN, yN)
elif ( len(points) == 4 ):
x0, y0 = points[0]
x1, y1 = points[1]
x2, y2 = points[2]
xN, yN = points[3]
path.moveTo(x0, y0)
path.cubicTo(x1, y1, x2, y2, xN, yN)
elif ( len(points) == 6 ):
x0, y0 = points[0]
x1, y1 = points[1]
x2, y2 = points[2]
x3, y3 = points[3]
x4, y4 = points[4]
xN, yN = points[5]
xC = (x2+x3) / 2.0
yC = (y2+y3) / 2.0
path.moveTo(x0, y0)
path.cubicTo(x1, y1, x2, y2, xC, yC)
path.cubicTo(x3, y3, x4, y4, xN, yN)
else:
x0, y0 = points[0]
xN, yN = points[-1]
path.moveTo(x0, y0)
path.lineTo(xN, yN)
return path
def make_painter_path(self):
"""Return a new QPainterPath used for drawing the shape."""
path = QPainterPath()
points = self._points
if points:
point = points[0]
path.moveTo(point[0], point[1])
for i in range(1, len(self._points)):
point = points[i]
path.lineTo(point[0], point[1])
path.closeSubpath()
return path;
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
class DataPipe(QtDeclarative.QDeclarativeItem):
def __init__(self, color):
super(DataPipe, self).__init__()
self.color = color
self.sourcePoint = QPoint(0,0,0)
self.destinationPoint = QPoint(0,0,0)
self.rect = QRectF(0, -20, 30, 40)
self.path = QPainterPath()
self.change = 1
self.angle = 0
def setSourcePoint(self,srcp):
self.sourcePoint = srcp
def setDestinationPoint(self,dstp):
self.destinationPoint = dstp
def boundingRect(self):
return self.path.boundingRect()
def shape(self):
return self.path
def paint(self, painter, option, widget=None):
painter.setPen(QPen(QColor(0,0,0)))
painter.setBrush(QBrush(self.color))
painter.pen().setWidth(4);
painter.setBrush(Qt.NoBrush);
painter.drawPath(self.path);
self.path.moveTo(sourcePoint);
self.path.lineTo(self.destinationPoint);
#self.path.cubicTo(cp1.x(),cp1.y(),cp2.x(),cp2.y(),destPoint.x(),destPoint.y());
painter.drawPath(self.path);
def advance(self, phase):
if phase == 0:
matrix = self.matrix()
matrix.reset()
self.setMatrix(matrix)
self.angle += self.change * random.random()
if self.angle > 4.5:
self.change = -1
self.angle -= 0.00001
elif self.angle < -4.5:
self.change = 1
self.angle += 0.00001
elif phase == 1:
self.rotate(self.angle)
class ParallelCoordinatesCurve(OWCurve):
def __init__(self, n_attributes, y_values, color, name=""):
OWCurve.__init__(self, tooltip=name)
self._item = QGraphicsPathItem(self)
self.path = QPainterPath()
self.fitted = False
self.n_attributes = n_attributes
self.n_rows = int(len(y_values) / n_attributes)
self.set_style(OWCurve.Lines)
if isinstance(color, tuple):
self.set_pen(QPen(QColor(*color)))
else:
self.set_pen(QPen(QColor(color)))
x_values = list(range(n_attributes)) * self.n_rows
self.set_data(x_values, y_values)
def update_properties(self):
self.redraw_path()
def redraw_path(self):
self.path = QPainterPath()
for segment in self.segment(self.data()):
if self.fitted:
self.draw_cubic_path(segment)
else:
self.draw_normal_path(segment)
self._item.setPath(self.graph_transform().map(self.path))
self._item.setPen(self.pen())
def segment(self, data):
for i in range(self.n_rows):
yield data[i * self.n_attributes:(i + 1) * self.n_attributes]
def draw_cubic_path(self, segment):
for (x1, y1), (x2, y2) in zip(segment, segment[1:]):
self.path.moveTo(x1, y1)
self.path.cubicTo(QPointF(x1 + 0.5, y1),
QPointF(x2 - 0.5, y2), QPointF(x2, y2))
def draw_normal_path(self, segment):
if not segment:
return
x, y = segment[0]
self.path.moveTo(x, y)
for x, y in segment[1:]:
self.path.lineTo(x, y)
class ParallelCoordinatesCurve(OWCurve):
def __init__(self, n_attributes, y_values, color, name=""):
OWCurve.__init__(self, tooltip=name)
self._item = QGraphicsPathItem(self)
self.path = QPainterPath()
self.fitted = False
self.n_attributes = n_attributes
self.n_rows = int(len(y_values) / n_attributes)
self.set_style(OWCurve.Lines)
if isinstance(color, tuple):
self.set_pen(QPen(QColor(*color)))
else:
self.set_pen(QPen(QColor(color)))
x_values = list(range(n_attributes)) * self.n_rows
self.set_data(x_values, y_values)
def update_properties(self):
self.redraw_path()
def redraw_path(self):
self.path = QPainterPath()
for segment in self.segment(self.data()):
if self.fitted:
self.draw_cubic_path(segment)
else:
self.draw_normal_path(segment)
self._item.setPath(self.graph_transform().map(self.path))
self._item.setPen(self.pen())
def segment(self, data):
for i in range(self.n_rows):
yield data[i * self.n_attributes:(i + 1) * self.n_attributes]
def draw_cubic_path(self, segment):
for (x1, y1), (x2, y2) in zip(segment, segment[1:]):
self.path.moveTo(x1, y1)
self.path.cubicTo(QPointF(x1 + 0.5, y1), QPointF(x2 - 0.5, y2),
QPointF(x2, y2))
def draw_normal_path(self, segment):
if not segment:
return
x, y = segment[0]
self.path.moveTo(x, y)
for x, y in segment[1:]:
self.path.lineTo(x, y)
def updatePosition(self, scene):
path = QPainterPath()
self.prepareGeometryChange()
count = len(self._longitudes)
if count > 0:
x, y = scene.posFromLonLat(self._longitudes, self._latitudes)
dx = x - x[0]
dy = y - y[0]
for i in range(1, count):
path.lineTo(dx[i], dy[i])
self.setPos(x[0], y[0])
self.setPath(path)
def drawValue(self, p, baseRect, value, delta):
if value == self.m_min:
return
dataPath = QPainterPath()
dataPath.setFillRule(Qt.WindingFill)
if value == self.m_max:
dataPath.addEllipse(baseRect)
else:
arcLength = 360 / delta
dataPath.moveTo(baseRect.center())
dataPath.arcTo(baseRect, self.m_nullPosition, -arcLength)
dataPath.lineTo(baseRect.center())
p.setBrush(self.palette().highlight())
p.setPen(QPen(self.palette().shadow().color(), self.m_dataPenWidth))
p.drawPath(dataPath)
def path_for(points):
path = QPainterPath(points[0])
for point in points[1:]:
path.lineTo(point)
path.lineTo(points[-1].x(), 0)
path.lineTo(points[0].x(), 0)
path.lineTo(points[0])
return path
def updatePosition(self, scene):
path = QPainterPath()
self.prepareGeometryChange()
count = len(self._longitudes)
if count > 0:
x, y = scene.posFromLonLat(self._longitudes, self._latitudes)
dx = x - x[0]
dy = y - y[0]
for i in range(1, count):
path.lineTo(dx[i], dy[i])
self.setPos(x[0], y[0])
self.setPath(path)
def update_properties(self):
p = self.plot()
if p is None:
return
x_id, y_id = self.axes()
rect = p.data_rect_for_axes(x_id, y_id)
path = QPainterPath()
if self._x_enabled and x_id in p.axes:
for pos, label, size, _w in p.axes[x_id].ticks():
path.moveTo(pos, rect.bottom())
path.lineTo(pos, rect.top())
if self._y_enabled and y_id in p.axes:
for pos, label, size, _w in p.axes[y_id].ticks():
path.moveTo(rect.left(), pos)
path.lineTo(rect.right(), pos)
self._path_item.setPath(self.graph_transform().map(path))
def Path_toQtPath(geom):
p = QPainterPath()
anchor, points = geom
if len(points) > 1:
p.moveTo(*points[0])
for (x, y) in points[1:]:
p.lineTo(x, y)
elif len(points) == 1:
r = QRectF(0, 0, 1e-0, 1e-9)
r.moveCenter(*points[0])
p.addRect(r)
elif len(points) == 0:
r = QRectF(0, 0, 1e-16, 1e-16)
r.moveCenter(QPointF(*anchor))
p.addRect(r)
return p
def update_properties(self):
p = self.plot()
if p is None:
return
x_id, y_id = self.axes()
rect = p.data_rect_for_axes(x_id, y_id)
path = QPainterPath()
if self._x_enabled and x_id in p.axes:
for pos, label, size, _w in p.axes[x_id].ticks():
path.moveTo(pos, rect.bottom())
path.lineTo(pos, rect.top())
if self._y_enabled and y_id in p.axes:
for pos, label, size, _w in p.axes[y_id].ticks():
path.moveTo(rect.left(), pos)
path.lineTo(rect.right(), pos)
self._path_item.setPath(self.graph_transform().map(path))
def Path_toQtPath(geom):
p = QPainterPath()
anchor, points = geom
if len(points) > 1:
p.moveTo(*points[0])
for (x, y) in points[1:]:
p.lineTo(x, y)
elif len(points) == 1:
r = QRectF(0, 0, 1e-0, 1e-9)
r.moveCenter(*points[0])
p.addRect(r)
elif len(points) == 0:
r = QRectF(0, 0, 1e-16, 1e-16)
r.moveCenter(QPointF(*anchor))
p.addRect(r)
return p
def arrow_path_concave(line, width):
"""
Return a :class:`QPainterPath` of a pretty looking arrow.
"""
path = QPainterPath()
p1, p2 = line.p1(), line.p2()
if p1 == p2:
return path
baseline = QLineF(line)
# Require some minimum length.
baseline.setLength(max(line.length() - width * 3, width * 3))
start, end = baseline.p1(), baseline.p2()
mid = (start + end) / 2.0
normal = QLineF.fromPolar(1.0, baseline.angle() + 90).p2()
path.moveTo(start)
path.lineTo(start + (normal * width / 4.0))
path.quadTo(mid + (normal * width / 4.0),
end + (normal * width / 1.5))
path.lineTo(end - (normal * width / 1.5))
path.quadTo(mid - (normal * width / 4.0),
start - (normal * width / 4.0))
path.closeSubpath()
arrow_head_len = width * 4
arrow_head_angle = 50
line_angle = line.angle() - 180
angle_1 = line_angle - arrow_head_angle / 2.0
angle_2 = line_angle + arrow_head_angle / 2.0
points = [p2,
p2 + QLineF.fromPolar(arrow_head_len, angle_1).p2(),
baseline.p2(),
p2 + QLineF.fromPolar(arrow_head_len, angle_2).p2(),
p2]
poly = QPolygonF(points)
path_head = QPainterPath()
path_head.addPolygon(poly)
path = path.united(path_head)
return path
def updateShape(self, point=None, pos=None):
# Main arrow direction
params = parameters.instance
scale = self.scale
ms = min(scale)
head_size = params.arrow_head_size * ms
width = params.arrow_line_size * ms
self.prepareGeometryChange()
if point == self.source:
p1 = pos
else:
p1 = self.source.pos()
self.setPos(p1)
if point == self.target:
p2 = pos
else:
p2 = self.target.pos()
tip = p2 - p1
if abs(tip.x()) > 0.001 or abs(tip.y()) > 0.001:
# Normalised
#ntip = tip/stip
ntip = tip
# Arrow head base
orth = QPointF(ntip.y(), -ntip.x()) * (head_size * 0.5)
base_center = tip * (1 - 2 * head_size)
base1 = base_center + orth
base2 = base_center - orth
base_center = tip * (1 - head_size * 1.50)
else:
ntip = tip
base_center = tip
base1 = tip
base2 = tip
self.tip = tip
self.base_center = base_center
self.base1 = base1
self.base2 = base2
path = QPainterPath()
path.lineTo(base_center)
path.addPolygon(QPolygonF([base_center, base1, tip, base2]))
path.closeSubpath()
self.rect = path.controlPointRect().adjusted(-width, -width, 2 * width,
2 * width)
self.path = path
self.update()
def majorGridPainterPath(self):
"""
Returns a QPainterPath object for the major grid lines.
This is separated from the minor grid lines so different
pens can be used for each.
"""
if self._majorGridPainterPath:
return self._majorGridPainterPath
path = QPainterPath()
canvasSize = self._vhelix.part().numBases()
# major tick marks FIX: 7 is honeycomb-specific
for i in range(0, canvasSize + 1, 7):
x = round(self.baseWidth * i) + .5
path.moveTo(x, .5)
path.lineTo(x, 2 * self.baseWidth - .5)
self._majorGridPainterPath = path
return path
def updateShape(self, point=None, pos=None):
# Main arrow direction
params = parameters.instance
scale = self.scale
ms = min(scale)
head_size = params.arrow_head_size*ms
width = params.arrow_line_size*ms
self.prepareGeometryChange()
if point == self.source:
p1 = pos
else:
p1 = self.source.pos()
self.setPos(p1)
if point == self.target:
p2 = pos
else:
p2 = self.target.pos()
tip = p2-p1
if abs(tip.x()) > 0.001 or abs(tip.y()) > 0.001:
# Normalised
#ntip = tip/stip
ntip = tip
# Arrow head base
orth = QPointF(ntip.y(), -ntip.x())*(head_size*0.5)
base_center = tip*(1-2*head_size)
base1 = base_center + orth
base2 = base_center - orth
base_center = tip*(1-head_size*1.50)
else:
ntip = tip
base_center = tip
base1 = tip
base2 = tip
self.tip = tip
self.base_center = base_center
self.base1 = base1
self.base2 = base2
path = QPainterPath()
path.lineTo(base_center)
path.addPolygon(QPolygonF([base_center, base1, tip, base2]))
path.closeSubpath()
self.rect = path.controlPointRect().adjusted(-width, -width, 2*width, 2*width)
self.path = path
self.update()
def _define_symbols():
"""
Add symbol ? to ScatterPlotItemSymbols,
reflect the triangle to point upwards
"""
symbols = pyqtgraph.graphicsItems.ScatterPlotItem.Symbols
path = QPainterPath()
path.addEllipse(QRectF(-0.35, -0.35, 0.7, 0.7))
path.moveTo(-0.5, 0.5)
path.lineTo(0.5, -0.5)
path.moveTo(-0.5, -0.5)
path.lineTo(0.5, 0.5)
symbols["?"] = path
tr = QTransform()
tr.rotate(180)
symbols['t'] = tr.map(symbols['t'])
def _define_symbols():
"""
Add symbol ? to ScatterPlotItemSymbols,
reflect the triangle to point upwards
"""
symbols = pyqtgraph.graphicsItems.ScatterPlotItem.Symbols
path = QPainterPath()
path.addEllipse(QRectF(-0.35, -0.35, 0.7, 0.7))
path.moveTo(-0.5, 0.5)
path.lineTo(0.5, -0.5)
path.moveTo(-0.5, -0.5)
path.lineTo(0.5, 0.5)
symbols["?"] = path
tr = QTransform()
tr.rotate(180)
symbols['t'] = tr.map(symbols['t'])
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 piece_sign_path(self, tile):
if tile.piece.sign == "N":
return QPainterPath()
else:
path = QPainterPath()
path.moveTo(tile.pos.x() - self.r_hex / 2, tile.pos.y())
path.lineTo(tile.pos.x() + self.r_hex / 2, tile.pos.y())
if tile.piece.sign == "E":
return path
else:
vertical_line = QPainterPath()
vertical_line.moveTo(tile.pos.x(),
tile.pos.y() - self.r_hex / 2)
vertical_line.lineTo(tile.pos.x(),
tile.pos.y() + self.r_hex / 2)
path += vertical_line
return path
def rebuildBlock( self ):
"""
Rebuilds a blocked path from the output to input points.
:return <QPainterPath>
"""
# collect the control points
points = self.controlPoints()
# create the path
path = QPainterPath()
for i, point in enumerate(points):
if ( not i ):
path.moveTo( point[0], point[1] )
else:
path.lineTo( point[0], point[1] )
return path
def arrow_path_concave(line, width):
"""
Return a :class:`QPainterPath` of a pretty looking arrow.
"""
path = QPainterPath()
p1, p2 = line.p1(), line.p2()
if p1 == p2:
return path
baseline = QLineF(line)
# Require some minimum length.
baseline.setLength(max(line.length() - width * 3, width * 3))
start, end = baseline.p1(), baseline.p2()
mid = (start + end) / 2.0
normal = QLineF.fromPolar(1.0, baseline.angle() + 90).p2()
path.moveTo(start)
path.lineTo(start + (normal * width / 4.0))
path.quadTo(mid + (normal * width / 4.0), end + (normal * width / 1.5))
path.lineTo(end - (normal * width / 1.5))
path.quadTo(mid - (normal * width / 4.0), start - (normal * width / 4.0))
path.closeSubpath()
arrow_head_len = width * 4
arrow_head_angle = 50
line_angle = line.angle() - 180
angle_1 = line_angle - arrow_head_angle / 2.0
angle_2 = line_angle + arrow_head_angle / 2.0
points = [
p2, p2 + QLineF.fromPolar(arrow_head_len, angle_1).p2(),
baseline.p2(), p2 + QLineF.fromPolar(arrow_head_len, angle_2).p2(), p2
]
poly = QPolygonF(points)
path_head = QPainterPath()
path_head.addPolygon(poly)
path = path.united(path_head)
return path
def rebuildLinear( self ):
"""
Rebuilds a linear path from the output to input points.
:return <QPainterPath>
"""
points = self.controlPoints()
x0, y0 = points[0]
xN, yN = points[-1]
# create a simple line between the output and
# input points
path = QPainterPath()
path.moveTo(x0, y0)
path.lineTo(xN, yN)
return path
def paint(self, painter, option, widget=None):
painter.setBrush(QBrush(self.color))
my_pen = QPen(self.color, 1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin);
my_pen.setWidth(5)
painter.setPen(my_pen)
painter.setBrush(Qt.NoBrush);
path = QPainterPath()
#path.moveTo(self.sourcePoint)
#path.lineTo(self.destinationPoint);
# lookup the output port position by using the object name to index to the object type, then look in outputOffsets
startx = self.sourceObject.pos().x()+outputOffsets[operationsType[self.sourceObject.objectName()]][0]
starty = self.sourceObject.pos().y()+outputOffsets[operationsType[self.sourceObject.objectName()]][1]
# lookup the input port position by converting object name to type and looking in inputOffsets
endx = self.destinationObject.pos().x() + inputOffsets[operationsType[self.destinationObject.objectName()]][0]
endy = self.destinationObject.pos().y() + inputOffsets[operationsType[self.destinationObject.objectName()]][1]
path.moveTo(QPointF(startx,starty));
path.lineTo(QPointF(endx,endy));
#self.path.cubicTo(cp1.x(),cp1.y(),cp2.x(),cp2.y(),destPoint.x(),destPoint.y());
painter.drawPath(path);
def paintMilestone(self, painter):
"""
Paints this item as the milestone look.
:param painter | <QPainter>
"""
# generate the rect
rect = self.rect()
padding = self.padding()
gantt = self.scene().ganttWidget()
cell_w = gantt.cellWidth()
cell_h = gantt.cellHeight()
x = rect.width() - cell_w
y = self.padding()
w = cell_w
h = rect.height() - padding - 2
# grab the color options
color = self.color()
alt_color = self.alternateColor()
if (self.isSelected()):
color = self.highlightColor()
alt_color = self.alternateHighlightColor()
# create the background brush
gradient = QLinearGradient()
gradient.setStart(0, 0)
gradient.setFinalStop(0, h)
gradient.setColorAt(0, color)
gradient.setColorAt(0.8, alt_color)
gradient.setColorAt(1, color)
painter.setPen(self.borderColor())
painter.setBrush(QBrush(gradient))
pen = painter.pen()
pen.setWidthF(0.5)
painter.setPen(pen)
painter.setRenderHint(painter.Antialiasing)
path = QPainterPath()
path.moveTo(x - cell_w / 3.0, y + h / 2.0)
path.lineTo(x, y)
path.lineTo(x + cell_w / 3.0, y + h / 2.0)
path.lineTo(x, y + h)
path.lineTo(x - cell_w / 3.0, y + h / 2.0)
painter.drawPath(path)
def chart(self, v1, v2):
self.data1.pop(0)
self.data2.pop(0)
self.data1.append(v1)
self.data2.append(v2)
self.scene1 = QGraphicsScene()
self.scene2 = QGraphicsScene()
self.setup_scene(self.scene1)
self.setup_scene(self.scene2)
path = QPainterPath()
path.moveTo(0,-self.data1[0]/6)
for i in xrange(1,100):
path.lineTo(2*(i+1), -self.data1[i]/6)
self.scene1.addPath(path, QPen(QColor(0,0,255), 3))
path = QPainterPath()
path.moveTo(0,-self.data2[0]/6)
for i in xrange(1,100):
path.lineTo(2*(i+1), -self.data2[i]/6)
self.scene2.addPath(path, QPen(QColor(0,0,255), 3))
self.ui.chart1.setScene(self.scene1)
self.ui.chart2.setScene(self.scene2)
def chart(self, v1, v2):
self.data1.pop(0)
self.data2.pop(0)
self.data1.append(v1)
self.data2.append(v2)
self.scene1 = QGraphicsScene()
self.scene2 = QGraphicsScene()
self.setup_scene(self.scene1)
self.setup_scene(self.scene2)
path = QPainterPath()
path.moveTo(0, -self.data1[0] / 6)
for i in xrange(1, 100):
path.lineTo(2 * (i + 1), -self.data1[i] / 6)
self.scene1.addPath(path, QPen(QColor(0, 0, 255), 3))
path = QPainterPath()
path.moveTo(0, -self.data2[0] / 6)
for i in xrange(1, 100):
path.lineTo(2 * (i + 1), -self.data2[i] / 6)
self.scene2.addPath(path, QPen(QColor(0, 0, 255), 3))
self.ui.chart1.setScene(self.scene1)
self.ui.chart2.setScene(self.scene2)
def paintEvent(self, e):
self._plotter.begin(self)
if self._reaction.GetCatalyst().GetUsed():
change = self._reaction.GetCatalyst().GetEfficacy()
else:
change = 1
eqmpoint = 150 / change
if change > 1:
eqmpoint -= 0.1 * self._reaction.GetCatalyst().GetInitialMoles()
elif change < 1:
eqmpoint += 0.1 * self._reaction.GetCatalyst().GetInitialMoles()
pen = QPen(Qt.black, 2, Qt.SolidLine)
self._plotter.setPen(pen)
self._plotter.drawLine(80, 20, 80, 220)
self._plotter.drawLine(80, 220, 400, 220)
self._plotter.setPen(QPen(self._reaction.GetReactantColour()))
reactionpath = QPainterPath()
reactionpath.moveTo(QPointF(80, 20))
reactionpath.arcTo(80, -80 + self._plotter.GetFinalY(), eqmpoint * 2,
200 - (2 * self._plotter.GetFinalY()), 180, 90)
reactionpath.lineTo(400, 120 - self._plotter.GetFinalY())
self._plotter.drawPath(reactionpath)
self._plotter.setPen(QPen(self._reaction.GetProductColour()))
productpath = QPainterPath()
productpath.moveTo(QPointF(80, 220))
productpath.arcTo(80, 120 + self._plotter.GetFinalY(), eqmpoint * 2,
200 - (2 * self._plotter.GetFinalY()), 180, -90)
productpath.lineTo(400, 120 + self._plotter.GetFinalY())
self._plotter.drawPath(productpath)
if not self._forprinting:
white = QColor(240, 240, 240)
self._plotter.setPen(QPen(white))
self._plotter.setBrush(white)
self._plotter.drawRect(82 + self.parent().GetAnimUpdates() * 0.23,
20, 320, 198)
self._plotter.setPen(QColor(0, 0, 0))
self._plotter.drawText(180, 235, "Time")
self._plotter.drawText(0, 120, self._graphof)
self._plotter.end()
def drawGraph(self, plotter, change):
pen = QPen(Qt.black, 2, Qt.SolidLine)
plotter.setPen(pen)
plotter.drawLine(20, 20, 20, 220)
plotter.drawLine(20, 220, 220, 220)
reactants = self._reaction.GetReactants()
AverageReactantConc = 0
for x in range(self._reaction.REACTING_SPECIES_LIMIT):
AverageReactantConc += reactants[x].GetInitialMoles()
AverageReactantConc /= (len(reactants) * self._reaction.GetVolume())
plotter.setPen(QPen(plotter.GetReactantColour(), 2, Qt.SolidLine))
reactionpath = QPainterPath()
reactionpath.moveTo(QPointF(20, 20))
reactionpath.arcTo(20, -70, 300 * change, 180, 180, 90)
reactionpath.lineTo(220, 110)
plotter.drawPath(reactionpath)
plotter.setPen(QPen(plotter.GetProductColour(), 2, Qt.SolidLine))
productpath = QPainterPath()
productpath.moveTo(QPointF(20, 220))
productpath.arcTo(20, 130, 300 * change, 180, 180, -90)
productpath.lineTo(220, 130)
plotter.drawPath(productpath)
def __call__(o, gridfunc, piece_count, image_width, image_height):
p = QPainterPath(QPointF(0.0, 0.0))
p.lineTo(QPointF(image_width, 0.0))
p.lineTo(QPointF(image_width, image_height))
p.lineTo(QPointF(0.0, image_height))
p.closeSubpath()
o._boundary_path = p
gridfunc(o, piece_count, image_width, image_height)
def arrow_path_plain(line, width):
"""
Return an :class:`QPainterPath` of a plain looking arrow.
"""
path = QPainterPath()
p1, p2 = line.p1(), line.p2()
if p1 == p2:
return path
baseline = QLineF(line)
# Require some minimum length.
baseline.setLength(max(line.length() - width * 3, width * 3))
path.moveTo(baseline.p1())
path.lineTo(baseline.p2())
stroker = QPainterPathStroker()
stroker.setWidth(width)
path = stroker.createStroke(path)
arrow_head_len = width * 4
arrow_head_angle = 50
line_angle = line.angle() - 180
angle_1 = line_angle - arrow_head_angle / 2.0
angle_2 = line_angle + arrow_head_angle / 2.0
points = [
p2, p2 + QLineF.fromPolar(arrow_head_len, angle_1).p2(),
p2 + QLineF.fromPolar(arrow_head_len, angle_2).p2(), p2
]
poly = QPolygonF(points)
path_head = QPainterPath()
path_head.addPolygon(poly)
path = path.united(path_head)
return path
