def __updateCurve(self): self.prepareGeometryChange() if self.sourceAnchor and self.sinkAnchor: source_pos = self.sourceAnchor.anchorScenePos() sink_pos = self.sinkAnchor.anchorScenePos() source_pos = self.curveItem.mapFromScene(source_pos) sink_pos = self.curveItem.mapFromScene(sink_pos) # Adaptive offset for the curve control points to avoid a # cusp when the two points have the same y coordinate # and are close together delta = source_pos - sink_pos dist = math.sqrt(delta.x() ** 2 + delta.y() ** 2) cp_offset = min(dist / 2.0, 60.0) # TODO: make the curve tangent orthogonal to the anchors path. path = QPainterPath() path.moveTo(source_pos) path.cubicTo(source_pos + QPointF(cp_offset, 0), sink_pos - QPointF(cp_offset, 0), sink_pos) self.curveItem.setPath(path) self.sourceIndicator.setPos(source_pos) self.sinkIndicator.setPos(sink_pos) self.__updateText() else: self.setHoverState(False) self.curveItem.setPath(QPainterPath())
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, 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 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 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 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 __updateCurve(self): self.prepareGeometryChange() if self.sourceAnchor and self.sinkAnchor: source_pos = self.sourceAnchor.anchorScenePos() sink_pos = self.sinkAnchor.anchorScenePos() source_pos = self.curveItem.mapFromScene(source_pos) sink_pos = self.curveItem.mapFromScene(sink_pos) # Adaptive offset for the curve control points to avoid a # cusp when the two points have the same y coordinate # and are close together delta = source_pos - sink_pos dist = math.sqrt(delta.x()**2 + delta.y()**2) cp_offset = min(dist / 2.0, 60.0) # TODO: make the curve tangent orthogonal to the anchors path. path = QPainterPath() path.moveTo(source_pos) path.cubicTo(source_pos + QPointF(cp_offset, 0), sink_pos - QPointF(cp_offset, 0), sink_pos) self.curveItem.setPath(path) self.sourceIndicator.setPos(source_pos) self.sinkIndicator.setPos(sink_pos) self.__updateText() else: self.setHoverState(False) self.curveItem.setPath(QPainterPath())
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 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 itemRegion(self, index): if not index.isValid() or not self.model(): return QRegion() return QRegion() # TODO: what to do with this code? if index.column != 1: return self.itemRect(index) if self.model().data(index).toDouble()[0] <= 0.0: return QRegion() startAngle = 0.0 for row in xrange(self.model().rowCount(self.rootIndex())): sliceIndex = self.model().index(row, 1, self.rootIndex()) value = self.model().data(sliceIndex).toDouble()[0] if value > 0.0: angle = 360*value/self.totalValue if sliceIndex == index: slicePath = QPainterPath() slicePath.moveTo(self.totalSize/2, self.totalSize/2) slicePath.arcTo(self.margin, self.margin, self.margin+self.histogramSize, self.margin+self.histogramSize, startAngle, angle) slicePath.closeSubpath() return QRegion(slicePath.toFillPolygon().toPolygon()) startAngle += angle return QRegion()
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 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 __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 compute_path(self): p1 = self.p1 if self.p1.x() < self.p2.x() else self.p2 p2 = self.p2 if self.p1.x() < self.p2.x() else self.p1 path = QPainterPath() path.moveTo(p1) dx = p2.x() - p1.x() path.cubicTo(QPoint(p1.x() + dx / 3, p1.y()), QPoint(p2.x() - dx / 3, p2.y()), p2) self.__path = path
class RobotView(QGraphicsItem): def __init__(self, robot): super(RobotView, self).__init__() self.robot = robot self.outline = QPainterPath() self.cut_angle = 0.0 self.setFlags(QGraphicsItem.ItemIsSelectable) @property def uuid(self): return self.robot.uuid @property def color(self): if self.isSelected(): return GREEN elif self.robot.is_blue: return BLUE elif self.robot.is_yellow: return YELLOW else: return BLACK def position(self): x, y, width, height = s(self.robot.x, self.robot.y, self.robot.world.length, self.robot.world.width) radius = s(self.robot.radius) self.cut_angle = acos(self.robot.front_cut / self.robot.radius) self.outline = QPainterPath() self.outline.moveTo(radius, 0) self.outline.arcTo(-radius, -radius, 2 * radius, 2 * radius, 0, 360 - 2 * self.cut_angle) self.outline.closeSubpath() self.setPos(x, -y) def boundingRect(self): radius = s(self.robot.radius) return QRectF(-radius, -radius, 2 * radius, 2 * radius) def paint(self, painter, option, widget=None): # Save transformation: painter.save() color = self.color # Change position painter.setBrush(color) painter.setPen(color) robot_rotation = self.robot.angle or 0.0 # Draw robot shape painter.rotate(-self.cut_angle - robot_rotation) painter.drawPath(self.outline) painter.rotate(self.cut_angle + robot_rotation) # Reset transformation painter.restore()
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 draw_arc(x, y, radius_in, radius_out, angle_init, angle_end, painter): path = QPainterPath() path.moveTo(x + radius_in * cos(angle_init), y + radius_in * sin(angle_init)) path.arcTo(x - radius_out, y - radius_out, 2 * radius_out, 2 * radius_out, angle_init, angle_end - angle_init) path.arcTo(x - radius_in, y - radius_in, 2 * radius_in, 2 * radius_in, angle_end, angle_init - angle_end) path.closeSubpath() painter.drawPath(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 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 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 _updatePath(self): p0 = self._p0 p1 = self._p1 path = QPainterPath() path.moveTo(p0) dx = p1.x() - p0.x() x0 = p0.x() + 0.7 * dx x1 = p1.x() - 0.7 * dx path.cubicTo(QPointF(x0, p0.y()), QPointF(x1, p1.y()), p1) self.setPath(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 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 __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 _updatePath(self): p0 = self._startPos p1 = self._endPos if p0 is None or p1 is None: return path = QPainterPath() path.moveTo(p0) dx = p1.x() - p0.x() x0 = p0.x() + 0.7 * dx x1 = p1.x() - 0.7 * dx path.cubicTo(QPointF(x0, p0.y()), QPointF(x1, p1.y()), p1) self.setPath(path)
def _addPath(self): iNode = 2 * model._nodes.index(self.__node) x0,y0 = record.states[0][iNode:iNode+2] path = QPainterPath() path.moveTo(x0,-y0) item = QGraphicsPathItem() item.setPen( QPen( QColor(0,0,255), 0 ) ) item.setPath(path) self._path = item for state in record.states[1:]: self._addPoint(state) if hasattr(record,'changeListeners'): record.changeListeners.append(self._addPoint) groupCurves.addToGroup(item)
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 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)
def paint(self, painter, option, widget=None): myPen = self.pen() myPen.setColor(self.myColor) painter.setPen(myPen) painter.setBrush(self.myColor) controlPoints = [] endPt = self.endItem.getLinkPointForParameter(self.endIndex) startPt = self.startItem.getLinkPointForOutput(self.startIndex) if isinstance(self.startItem.element, Algorithm): if self.startIndex != -1: controlPoints.append(self.startItem.pos() + startPt) controlPoints.append(self.startItem.pos() + startPt + QPointF(ModelerGraphicItem.BOX_WIDTH / 2, 0)) controlPoints.append(self.endItem.pos() + endPt - QPointF(ModelerGraphicItem.BOX_WIDTH / 2, 0)) controlPoints.append(self.endItem.pos() + endPt) pt = QPointF(self.startItem.pos() + startPt + QPointF(-3, -3)) painter.drawEllipse(pt.x(), pt.y(), 6, 6) pt = QPointF(self.endItem.pos() + endPt + QPointF(-3, -3)) painter.drawEllipse(pt.x(), pt.y(), 6, 6) else: # Case where there is a dependency on an algorithm not # on an output controlPoints.append(self.startItem.pos() + startPt) controlPoints.append(self.startItem.pos() + startPt + QPointF(ModelerGraphicItem.BOX_WIDTH / 2, 0)) controlPoints.append(self.endItem.pos() + endPt - QPointF(ModelerGraphicItem.BOX_WIDTH / 2, 0)) controlPoints.append(self.endItem.pos() + endPt) else: controlPoints.append(self.startItem.pos()) controlPoints.append(self.startItem.pos() + QPointF(ModelerGraphicItem.BOX_WIDTH / 2, 0)) controlPoints.append(self.endItem.pos() + endPt - QPointF(ModelerGraphicItem.BOX_WIDTH / 2, 0)) controlPoints.append(self.endItem.pos() + endPt) pt = QPointF(self.endItem.pos() + endPt + QPointF(-3, -3)) painter.drawEllipse(pt.x(), pt.y(), 6, 6) path = QPainterPath() path.moveTo(controlPoints[0]) path.cubicTo(*controlPoints[1:]) painter.strokePath(path, painter.pen()) 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 paintEvent(self, QPaintEvent): back = (numpy.ones((100, 200, 300)) * 0).astype(numpy.uint8) back[0:60, 0:60, 0:60] = 255 ol = (numpy.zeros((100, 200, 300))).astype(numpy.uint8) ol[0:99, 0:99, 0:99] = 120 ol[0:99, 120:140, 0:99] = 255 path = QPainterPath() path.addRect(20, 20, 60, 60) path.moveTo(0, 0) path.cubicTo(99, 0, 50, 50, 99, 99) path.cubicTo(0, 99, 50, 50, 0, 0) painter = QPainter(self) painter.fillRect(0, 0, 100, 100, Qt.Qt.red)
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 _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 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 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 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 updatePath(self): self.endPoints = [] controlPoints = [] endPt = self.endItem.getLinkPointForParameter(self.endIndex) startPt = self.startItem.getLinkPointForOutput(self.startIndex) if isinstance(self.startItem.element, Algorithm): if self.startIndex != -1: controlPoints.append(self.startItem.pos() + startPt) controlPoints.append(self.startItem.pos() + startPt + QPointF(ModelerGraphicItem.BOX_WIDTH / 3, 0)) controlPoints.append(self.endItem.pos() + endPt - QPointF(ModelerGraphicItem.BOX_WIDTH / 3, 0)) controlPoints.append(self.endItem.pos() + endPt) pt = QPointF(self.startItem.pos() + startPt + QPointF(-3, -3)) self.endPoints.append(pt) pt = QPointF(self.endItem.pos() + endPt + QPointF(-3, -3)) self.endPoints.append(pt) else: # Case where there is a dependency on an algorithm not # on an output controlPoints.append(self.startItem.pos() + startPt) controlPoints.append(self.startItem.pos() + startPt + QPointF(ModelerGraphicItem.BOX_WIDTH / 3, 0)) controlPoints.append(self.endItem.pos() + endPt - QPointF(ModelerGraphicItem.BOX_WIDTH / 3, 0)) controlPoints.append(self.endItem.pos() + endPt) else: controlPoints.append(self.startItem.pos()) controlPoints.append(self.startItem.pos() + QPointF(ModelerGraphicItem.BOX_WIDTH / 3, 0)) controlPoints.append(self.endItem.pos() + endPt - QPointF(ModelerGraphicItem.BOX_WIDTH / 3, 0)) controlPoints.append(self.endItem.pos() + endPt) pt = QPointF(self.endItem.pos() + endPt + QPointF(-3, -3)) self.endPoints.append(pt) path = QPainterPath() path.moveTo(controlPoints[0]) path.cubicTo(*controlPoints[1:]) self.setPath(path)
def __updateCurve(self): self.prepareGeometryChange() if self.sourceAnchor and self.sinkAnchor: source_pos = self.sourceAnchor.anchorScenePos() sink_pos = self.sinkAnchor.anchorScenePos() source_pos = self.curveItem.mapFromScene(source_pos) sink_pos = self.curveItem.mapFromScene(sink_pos) # TODO: get the orthogonal angle to the anchors path. path = QPainterPath() path.moveTo(source_pos) path.cubicTo(source_pos + QPointF(60, 0), sink_pos - QPointF(60, 0), sink_pos) self.curveItem.setPath(path) self.sourceIndicator.setPos(source_pos) self.sinkIndicator.setPos(sink_pos) self.__updateText() else: self.setHoverState(False) self.curveItem.setPath(QPainterPath())
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 _test__2piece_simple(o, image_width, image_height): id1, id2 = 1, 2 from PyQt4.QtCore import QPointF from PyQt4.QtGui import QPainterPath path1 = QPainterPath() path1.moveTo(QPointF(0, 0)) path1.lineTo(QPointF(image_width * .3, 0)) path1.lineTo(QPointF(image_width * 0.7, image_height)) path1.lineTo(QPointF(0, image_height)) path1.lineTo(QPointF(0, 0)) o.make_piece_from_path(id1, path1) path2 = QPainterPath() path2.moveTo(QPointF(image_width, 0)) path2.lineTo(QPointF(image_width, image_height)) path2.lineTo(QPointF(image_width * 0.7, image_height)) path2.lineTo(QPointF(image_width * .3, 0)) path2.lineTo(QPointF(image_width, 0)) o.make_piece_from_path(id2, path2) o.add_relation(id1, id2)
def paint(self, painter, style, widget): painter.setRenderHint(QPainter.Antialiasing, True) rect = self.boundingRect() pen = QPen(self.borderColor) pen.setWidthF(10) pen.setJoinStyle(Qt.RoundJoin) path = QPainterPath() if (self.parentItem().property('direction') == 1): path.moveTo(5, rect.height() - 5) path.lineTo(rect.width() / 2, 5) path.lineTo(rect.width() - 5, rect.height() - 5) path.lineTo(5, rect.height() - 5) else: path.moveTo(5, 5) path.lineTo(rect.width() / 2, rect.height() - 5) path.lineTo(rect.width() - 5, 5) path.lineTo(5, 5) painter.fillPath(path, self.color) painter.strokePath(path, pen)
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)