def paint(self, painter, option, widget=None): """QGraphicsRectItem virtual """ # TODO LH Is there a way to clip to overlapping # QAbstractGraphicsItems with a larger zorder # TODO LH Get pixmap without tight coupling to scene if not self.has_mouse(): painter.drawPixmap(self.boundingRect(), self.scene().pixmap, self.sceneBoundingRect()) with painter_state(painter): outline_colour, fill_colour = self.colours # Cosmetic pens "...draw strokes that have a constant width # regardless of any transformations applied to the QPainter they are # used with." pen = QPen(outline_colour, self.BOX_WIDTH, Qt.SolidLine) pen.setCosmetic(True) painter.setPen(pen) r = self.boundingRect() painter.drawRect(r) if fill_colour: painter.fillRect(r, fill_colour)
def drawGrid(self, painter, rect, gridColor): tileWidth = self.map().tileWidth() tileHeight = self.map().tileHeight() if (tileWidth <= 0 or tileHeight <= 0): return startX = max(0, int(rect.x() / tileWidth) * tileWidth) startY = max(0, int(rect.y() / tileHeight) * tileHeight) endX = min(math.ceil(rect.right()), self.map().width() * tileWidth + 1) endY = min(math.ceil(rect.bottom()), self.map().height() * tileHeight + 1) gridColor.setAlpha(128) gridPen = QPen(gridColor) gridPen.setCosmetic(True) _x = QVector() _x.append(2) _x.append(2) gridPen.setDashPattern(_x) if (startY < endY): gridPen.setDashOffset(startY) painter.setPen(gridPen) for x in range(startX, endX, tileWidth): painter.drawLine(x, startY, x, endY - 1) if (startX < endX): gridPen.setDashOffset(startX) painter.setPen(gridPen) for y in range(startY, endY, tileHeight): painter.drawLine(startX, y, endX - 1, y)
def paintEvent(self, event): _size = self.size() - QSize(2, 2) if (_size.isEmpty()): return origX = (_size.width() - self.mNewSize.width() * self.mScale) / 2 + 0.5 origY = (_size.height() - self.mNewSize.height() * self.mScale) / 2 + 0.5 oldRect = QRect(self.mOffset, self.mOldSize) painter = QPainter(self) painter.translate(origX, origY) painter.scale(self.mScale, self.mScale) pen = QPen(Qt.black) pen.setCosmetic(True) painter.setPen(pen) painter.drawRect(QRect(QPoint(0, 0), self.mNewSize)) pen.setColor(Qt.white) painter.setPen(pen) painter.setBrush(Qt.white) painter.setOpacity(0.5) painter.drawRect(oldRect) pen.setColor(Qt.black) pen.setStyle(Qt.DashLine) painter.setOpacity(1.0) painter.setBrush(Qt.NoBrush) painter.setPen(pen) painter.drawRect(oldRect) painter.end()
def drawRuler(self, annotations): # warging! this might move the pick points to the centroids of the blobs, redraw! measure = self.computeMeasure(annotations) tmp = self.pick_points.points.copy() self.pick_points.reset() self.pick_points.addPoint(tmp[0][0], tmp[0][1], self.pick_style) self.pick_points.addPoint(tmp[1][0], tmp[1][1], self.pick_style) # pick points number is now 2 pen = QPen(Qt.blue) pen.setWidth(2) pen.setCosmetic(True) start = self.pick_points.points[0] end = self.pick_points.points[1] line = self.scene.addLine(start[0], start[1], end[0], end[1], pen) line.setZValue(5) self.pick_points.markers.append(line) middle_x = (start[0] + end[0]) / 2.0 middle_y = (start[1] + end[1]) / 2.0 middle = self.scene.addEllipse(middle_x, middle_y, 0, 0) middle.setZValue(5) ruler_text = self.scene.addText('%.1f cm' % measure) ruler_text.setFont(QFont("Calibri", 12, QFont.Bold)) ruler_text.setDefaultTextColor(Qt.white) ruler_text.setPos(middle_x, middle_y) ruler_text.setParentItem(middle) ruler_text.setFlag(QGraphicsItem.ItemIgnoresTransformations) ruler_text.setZValue(5) self.pick_points.markers.append(ruler_text) self.pick_points.markers.append(middle) self.log.emit("[TOOL][RULER] Measure taken.")
def __init__( self, strand_item: PathStrandItemT, cap_type: str, # low, high, dual is_drawn5to3: bool): """The parent should be a StrandItem.""" super(EndpointItem, self).__init__(strand_item.virtualHelixItem()) self._strand_item = strand_item self._getActiveTool = strand_item._getActiveTool self.cap_type = cap_type self._low_drag_bound = None self._high_drag_bound = None self._mod_item = None self._isdrawn5to3 = is_drawn5to3 self._initCapSpecificState(is_drawn5to3) p = QPen() p.setCosmetic(True) self.setPen(p) # for easier mouseclick self._click_area = cA = QGraphicsRectItem(_DEFAULT_RECT, self) self._click_area.setAcceptHoverEvents(True) cA.hoverMoveEvent = self.hoverMoveEvent cA.mousePressEvent = self.mousePressEvent cA.mouseMoveEvent = self.mouseMoveEvent cA.setPen(_NO_PEN) self.setFlag(QGraphicsItem.ItemIsSelectable)
def initPainter(self): pen = QPen() pen.setWidth(1) pen.setJoinStyle(Qt.RoundJoin) pen.setCapStyle(Qt.RoundCap) pen.setCosmetic(True) self.setPen(pen)
def paint (self, painter, style, widget): if widget is not self.treeview.viewport(): pen = QPen(FlPalette.light) pen.setCosmetic(True) painter.setPen(pen) painter.setBrush(QBrush()) painter.drawRect(self.boundingRect())
def paintEvent(self, ev: QtGui.QPaintEvent): painter = QPainter(self) pen = QPen(Qt.blue) pen.setCosmetic(True) painter.setPen(pen) painter.drawPath(self.path)
def drawGrid(self, painter, rect, gridColor): tileWidth = self.map().tileWidth() tileHeight = self.map().tileHeight() r = rect.toAlignedRect() r.adjust(-tileWidth / 2, -tileHeight / 2, tileWidth / 2, tileHeight / 2) startX = int(max(0.0, self.screenToTileCoords_(r.topLeft()).x())) startY = int(max(0.0, self.screenToTileCoords_(r.topRight()).y())) endX = int( min(self.map().width(), self.screenToTileCoords_(r.bottomRight()).x())) endY = int( min(self.map().height(), self.screenToTileCoords_(r.bottomLeft()).y())) gridColor.setAlpha(128) gridPen = QPen(gridColor) gridPen.setCosmetic(True) _x = QVector() _x.append(2) _x.append(2) gridPen.setDashPattern(_x) painter.setPen(gridPen) for y in range(startY, endY + 1): start = self.tileToScreenCoords(startX, y) end = self.tileToScreenCoords(endX, y) painter.drawLine(start, end) for x in range(startX, endX + 1): start = self.tileToScreenCoords(x, startY) end = self.tileToScreenCoords(x, endY) painter.drawLine(start, end)
def draw(self, p: QPainter, scale: float): p.save() if self.selected: pen = QPen(QColor("red")) pen.setWidthF(2) else: pen = QPen(QColor("black")) pen.setWidthF(1) pen.setCosmetic(True) p.setPen(pen) brush = QBrush(QColor("black")) brush.setStyle(Qt.Dense7Pattern) brush.setTransform(QTransform().scale(1 / scale, 1 / scale)) p.setBrush(brush) if self.v_support and self.h_support: p.drawRect( QRectF(self.x - self.radius, self.y - self.radius, self.radius * 2, self.radius * 2)) elif self.h_support: self.drawSupport(p, 3) elif self.v_support: self.drawSupport(p, 2) else: p.drawEllipse( QRectF(self.x - self.radius, self.y - self.radius, self.radius * 2, self.radius * 2)) p.drawLine(QPointF(self.x - 0.125, self.y), QPointF(self.x + 0.125, self.y)) p.drawLine(QPointF(self.x, self.y - 0.125), QPointF(self.x, self.y + 0.125)) p.restore()
def __init__(self, part_item, model_virtual_helix, viewroot): super(VirtualHelixItem, self).__init__(part_item.proxy()) self._part_item = part_item self._model_virtual_helix = model_virtual_helix self._viewroot = viewroot self._getActiveTool = part_item._getActiveTool self._controller = VirtualHelixItemController(self, model_virtual_helix) self._handle = VirtualHelixHandleItem(model_virtual_helix, part_item, viewroot) self._last_strand_set = None self._last_idx = None self._scaffoldBackground = None self.setFlag(QGraphicsItem.ItemUsesExtendedStyleOption) self.setCacheMode(QGraphicsItem.DeviceCoordinateCache) self.setBrush(QBrush(Qt.NoBrush)) view = viewroot.scene().views()[0] view.levelOfDetailChangedSignal.connect(self.levelOfDetailChangedSlot) shouldShowDetails = view.shouldShowDetails() pen = QPen(styles.MINOR_GRID_STROKE, styles.MINOR_GRID_STROKE_WIDTH) pen.setCosmetic(shouldShowDetails) self.setPen(pen) self.refreshPath() self.setAcceptHoverEvents(True) # for pathtools self.setZValue(styles.ZPATHHELIX)
def __init__(self, strand_item: PathStrandItemT, cap_type: str, # low, high, dual is_drawn5to3: bool): """The parent should be a StrandItem.""" super(EndpointItem, self).__init__(strand_item.virtualHelixItem()) self._strand_item = strand_item self._getActiveTool = strand_item._getActiveTool self.cap_type = cap_type self._low_drag_bound = None self._high_drag_bound = None self._mod_item = None self._isdrawn5to3 = is_drawn5to3 self._initCapSpecificState(is_drawn5to3) p = QPen() p.setCosmetic(True) self.setPen(p) # for easier mouseclick self._click_area = cA = QGraphicsRectItem(_DEFAULT_RECT, self) self._click_area.setAcceptHoverEvents(True) cA.hoverMoveEvent = self.hoverMoveEvent cA.mousePressEvent = self.mousePressEvent cA.mouseMoveEvent = self.mouseMoveEvent cA.setPen(_NO_PEN) self.setFlag(QGraphicsItem.ItemIsSelectable)
class EditPoints(QObject): log = pyqtSignal(str) def __init__(self, scene): super(EditPoints, self).__init__() self.scene = scene self.points = [] self.border_pen = QPen(Qt.black, 3) # pen.setJoinStyle(Qt.MiterJoin) # pen.setCapStyle(Qt.RoundCap) self.border_pen.setCosmetic(True) self.qpath_gitem = self.scene.addPath(QPainterPath(), self.border_pen) self.qpath_gitem.setZValue(5) self.last_editborder_points = [] self.last_blob = None def reset(self): self.qpath_gitem.setPath(QPainterPath()) self.points = [] #return true if the first points for a tool def startDrawing(self, x, y): first_start = False if len(self.points) == 0: # first point, initialize self.qpath_gitem.setPath(QPainterPath()) first_start = True message = "[TOOL] DRAWING starts.." self.log.emit(message) self.points.append(np.array([[x, y]])) path = self.qpath_gitem.path() path.moveTo(QPointF(x, y)) self.qpath_gitem.setPath(path) self.scene.invalidate() return first_start def move(self, x, y): if len(self.points) == 0: return # check that a move didn't happen before a press last_line = self.points[-1] last_point = self.points[-1][-1] if x != last_point[0] or y != last_point[1]: self.points[-1] = np.append(last_line, [[x, y]], axis=0) path = self.qpath_gitem.path() path.lineTo(QPointF(x, y)) self.qpath_gitem.setPath(path) self.scene.invalidate()
def paint(self, painter, option, widget=None): """Draw a Bezier curve connecting selected Nodes""" qp = painter qp.setRenderHint(QPainter.HighQualityAntialiasing) from_point = self.start.get_pos() posn1 = self.handle1.scenePos() posn2 = self.handle2.scenePos() path = QPainterPath(from_point) if self.end_term: self.end_point = self.end_term.get_pos() # Draw path path.cubicTo(posn1, posn2, self.end_point) wire_pen = QPen(QColor('#aa00ff'), 2) wire_pen.setCosmetic(True) qp.setPen(wire_pen) qp.drawPath(path) if self.parent.vis: #if self.isSelected(): # Draw helper lines (https://gist.github.com/Alquimista/1274149) control_points = ((from_point.x(), from_point.y()), (posn1.x(), posn1.y()), (posn2.x(), posn2.y()), (self.end_point.x(), self.end_point.y())) old_point = control_points[0] helper_pen = QPen(Qt.darkGreen, 1, Qt.DashLine) for i, point in enumerate(control_points[1:]): i += 2 qp.setPen(helper_pen) qp.drawLine(old_point[0], old_point[1], point[0], point[1]) old_point = point
def drawGrid(self, painter, rect, gridColor): tileWidth = self.map().tileWidth() tileHeight = self.map().tileHeight() r = rect.toAlignedRect() r.adjust(-tileWidth / 2, -tileHeight / 2, tileWidth / 2, tileHeight / 2) startX = int(max(0.0, self.screenToTileCoords_(r.topLeft()).x())) startY = int(max(0.0, self.screenToTileCoords_(r.topRight()).y())) endX = int(min(self.map().width(), self.screenToTileCoords_(r.bottomRight()).x())) endY = int(min(self.map().height(), self.screenToTileCoords_(r.bottomLeft()).y())) gridColor.setAlpha(128) gridPen = QPen(gridColor) gridPen.setCosmetic(True) _x = QVector() _x.append(2) _x.append(2) gridPen.setDashPattern(_x) painter.setPen(gridPen) for y in range(startY, endY+1): start = self.tileToScreenCoords(startX, y) end = self.tileToScreenCoords(endX, y) painter.drawLine(start, end) for x in range(startX, endX+1): start = self.tileToScreenCoords(x, startY) end = self.tileToScreenCoords(x, endY) painter.drawLine(start, end)
def __init__(self, parent=None): super(MainWindow, self).__init__(parent) self.setupUi(self) pen = QPen(Qt.red) pen.setWidth(3) pen.setCapStyle(Qt.RoundCap) scene = QtWidgets.QGraphicsScene() pen.setCosmetic(True) scene.addPixmap(QPixmap('back.png')) self.item = scene.addLine(60, 170, 97, 97, pen) pen = QtGui.QPen(QtGui.QColor(QtCore.Qt.gray)) brush = QtGui.QBrush(pen.color().darker(100)) scene.addEllipse(87, 87, 20, 20, pen, brush) self.item.setTransformOriginPoint(97, 97) self.Grafik.setScene(scene) self.stop_flag_time = Event() self.stop_flag_RS232 = Event() self.getController = Controller(self.stop_flag_time) self.getController.start() self.getController.newTime.connect(self.updateTime) self.getArduino = ControlArduino(self.stop_flag_RS232) self.getArduino.newValue.connect(self.updatePoti) self.getArduino.testRS232.connect(self.updateInfoRS232) self.getArduino.start()
def paint(self, painter: QtGui.QPainter, option: QStyleOptionGraphicsItem, widget: typing.Optional[QWidget] = ...): # Set level of detail # print(option.levelOfDetailFromTransform(painter.worldTransform())) # draw plus line painter.save() pen = QPen() pen.setColor(QColor("#496856")) pen.setCosmetic(True) painter.setPen(pen) # painter.setRenderHint(painter.Antialiasing) self.print_cache_path(painter.drawPath, 'plus_line_path', 1000) # draw minus line pen.setColor(QColor("#6F3541")) painter.setPen(pen) self.print_cache_path(painter.drawPath, 'minus_line_path', 1000) # draw plus bar self.print_cache_path(painter.fillPath, 'plus_bar_path', 1000, QColor('#7BB888')) # draw minus bar self.print_cache_path(painter.fillPath, 'minus_bar_path', 1000, QColor('#CC4E5C')) painter.restore()
def paint(self, painter: QtGui.QPainter, option: 'QStyleOptionGraphicsItem', widget: QWidget = ...): close = self.data['close'].reset_index()['close'] close = close - close.min() close_max = close.max() close_min = close.min() if not self.cached: for i in range(close.size - 1): self.path.moveTo(i, close[i]) self.path.lineTo(i + 1, close[i + 1]) self.cached = True pen = QPen(Qt.white) pen.setCosmetic(True) painter.setPen(pen) painter.drawRect(0, 0, close.size, close_max - close_min) pen.setColor(Qt.yellow) painter.setPen(pen) painter.drawPath(self.path) if not self.printed: rec_item = self.scene().addPath(self.path, QPen(Qt.red)) rec_item.setZValue(-10) self.printed = True
def drawRaster(self, renderContext): painter = renderContext.painter() painter.setRenderHint(QPainter.SmoothPixmapTransform, True) self.map2pixel = renderContext.mapToPixel() scaleX = self.xScale / self.map2pixel.mapUnitsPerPixel() scaleY = self.yScale / self.map2pixel.mapUnitsPerPixel() rect = QRectF( QPointF(-self.image.width() / 2.0, -self.image.height() / 2.0), QPointF(self.image.width() / 2.0, self.image.height() / 2.0), ) mapCenter = self.map2pixel.transform(self.center) # draw the image on the map canvas painter.translate(QPointF(mapCenter.x(), mapCenter.y())) painter.rotate(self.rotation) painter.scale(scaleX, scaleY) painter.drawImage(rect, self.image) painter.setOpacity(1.0) painter.setBrush(Qt.NoBrush) pen = QPen() pen.setColor(QColor(0, 0, 0)) pen.setWidth(3) pen.setCosmetic(True) painter.setPen(pen) painter.drawRect(rect)
def _default_pen(): pen = QPen(QColor('white')) pen.setStyle(Qt.SolidLine) pen.setWidth(3) pen.setCapStyle(Qt.RoundCap) pen.setJoinStyle(Qt.RoundJoin) pen.setCosmetic(True) return pen
def drawForeground(self, painter, rect): if self.showCrossair: painter.setClipRect(rect) pen = QPen(Qt.white, 1) pen.setCosmetic(True) painter.setPen(pen) painter.drawLine(self.mouseCoords.x(), rect.top(), self.mouseCoords.x(), rect.bottom()) painter.drawLine(rect.left(), self.mouseCoords.y(), rect.right(), self.mouseCoords.y())
def getEraserEllipse(self): brush = QBrush(QColor(0, 0, 0, alpha=64), Qt.SolidPattern) pen = QPen(brush, 2, Qt.DashDotLine, Qt.RoundCap, Qt.RoundJoin) pen.setCosmetic(True) ellipse = QGraphicsEllipseItem(0, 0, self._eraserSize, self._eraserSize) ellipse.setPen(pen) return ellipse
def paint(self, painter: QtGui.QPainter, option: 'QStyleOptionGraphicsItem', widget: QWidget = ...): pen = QPen() pen.setCosmetic(True) pen.setColor(Qt.green) painter.setPen(pen) painter.drawPath(self.path)
def set_pen(self, width: int = 3, color: str or QColor = 'white'): if isinstance(color, str): color = QColor(color) pen = QPen(color) pen.setStyle(Qt.SolidLine) pen.setWidth(width) pen.setCapStyle(Qt.RoundCap) pen.setJoinStyle(Qt.RoundJoin) pen.setCosmetic(True) self.plot.setPen(pen)
def _plot_baseline(self): if not self.baseline_plot: self.baseline_plot = self.parent.image_view.plot_item.plot() pen = QPen(QColor('red')) pen.setStyle(Qt.DashDotLine) pen.setWidth(4) pen.setCapStyle(Qt.RoundCap) pen.setJoinStyle(Qt.RoundJoin) pen.setCosmetic(True) self.baseline_plot.setData(self._x_axis, self._baseline, pen=pen)
def paintEvent(self, ev: QtGui.QPaintEvent): painter = QPainter(self) pen = QPen(Qt.blue) pen.setCosmetic(True) painter.setPen(pen) for i in range(data_range): painter.fillRect( QRectF(i / data_range * width, i / data_range * height, (i + 10) / width, (i + 10) / height), Qt.green)
def paint_poly_points(self, painter): dot_pen = QPen() dot_pen.setWidth(4) dot_pen.setCosmetic(True) dot_pen.setColor(QColor(255, 0, 255)) painter.setPen(dot_pen) for i in range(0, self.polygon().size() - 3): # Don't paint dots on the arrow head p = self.polygon().value(i)
def __init__(self, lastpos): super(My_lineitem, self).__init__() self.setFlag(QGraphicsItem.ItemIsMovable, True) self.setFlag(QGraphicsItem.ItemIsSelectable, True) pen = QPen(Qt.green) pen.setWidth(2) pen.setCosmetic(True) self.setPen(pen) self.lastpos = lastpos self.pos = None
def __init__(self, opt_model, field_num, start_offset): super().__init__() fld, wvl, foc = opt_model.optical_spec.lookup_fld_wvl_focus(field_num) self.rb = layout.RayBundle(opt_model, fld, wvl, start_offset) self.update_shape() self.setBrush(QColor(254, 197, 254, 64)) # magenta, 25% pen = QPen() pen.setCosmetic(True) self.setPen(pen)
def new_pen(colour, width=0, style=Qt.SolidLine): ''' Returns a cosmetic (unaffected by zoom) pen with given colour, width and style. Default is thin solid line. ''' pen = QPen(style) pen.setColor(colour) pen.setWidth(width) pen.setCosmetic(True) return pen
def paint(self, painter, option, widget=None): painter.save() palette = self.palette() border = palette.brush(QPalette.Mid) pen = QPen(border, 1) pen.setCosmetic(True) painter.setPen(pen) painter.setBrush(palette.brush(QPalette.Window)) brect = self.boundingRect() painter.drawRoundedRect(brect, 4, 4) painter.restore()
def initPainter(self): pen_component_edge = QPen() pen_component_edge.setWidth(2) pen_component_edge.setJoinStyle(Qt.RoundJoin) pen_component_edge.setCosmetic(True) pen_component_edge.setColor(QColor(192, 192, 192)) brush_component_fill = QBrush() brush_component_fill.setColor(QColor(0, 0, 64)) brush_component_fill.setStyle(Qt.SolidPattern) self.setPen(pen_component_edge) self.setBrush(brush_component_fill)
def __init__(self, element): super().__init__() self.oe = layout.OpticalElement(element) self.update_shape() color = self.oe.render_color() self.setBrush(QColor(*color)) pen = QPen() pen.setCosmetic(True) self.setPen(pen)
def _updateColor(self, strand): oligo = strand.oligo() color = self.pen().color() if self.isSelected() else QColor(oligo.color()) # print "update xover color", color.value(), self.isSelected(), self.group(), self.parentItem() if oligo.shouldHighlight(): pen_width = styles.PATH_STRAND_HIGHLIGHT_STROKE_WIDTH color.setAlpha(128) else: pen_width = styles.PATH_STRAND_STROKE_WIDTH pen = QPen(color, pen_width) pen.setCosmetic(False) pen.setCapStyle(Qt.FlatCap) self.setPen(pen)
def __init__(self, id_pair, painter_path, initial_pen=None): super(SingleEdgeItem, self).__init__() self.parent = None # Should be initialized with set_parent() self.id_pair = id_pair if not initial_pen: initial_pen = QPen() initial_pen.setCosmetic(True) initial_pen.setCapStyle(Qt.RoundCap) initial_pen.setColor(Qt.white) initial_pen.setWidth(3) self.setPen(initial_pen) self.setPath(painter_path)
def __init__(self, parent, child): ''' Create a new connection between a parent and a child item ''' super(Connection, self).__init__(parent) self.parent = parent self.child = child self._start_point = None self._end_point = None self._middle_points = [] pen = QPen() pen.setColor(Qt.blue) pen.setCosmetic(False) self.setPen(pen) self.parent_rect = parent.sceneBoundingRect() self.childRect = child.sceneBoundingRect() # Activate cache mode to boost rendering by calling paint less often self.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
def paint(self, painter, option, widget = None): if (self.mRectangle.isNull()): return # Draw a shadow black = QColor(Qt.black) black.setAlpha(128) pen = QPen(black, 2, Qt.DotLine) pen.setCosmetic(True) painter.setPen(pen) painter.drawRect(self.mRectangle.translated(1, 1)) # Draw a rectangle in the highlight color highlight = QApplication.palette().highlight().color() pen.setColor(highlight) highlight.setAlpha(32) painter.setPen(pen) painter.setBrush(highlight) painter.drawRect(self.mRectangle)
def paint(self, painter, arg2, arg3): horizontal = [ QLineF(self.mBoundingRect.topRight(), self.mBoundingRect.topLeft()), QLineF(self.mBoundingRect.bottomRight(), self.mBoundingRect.bottomLeft())] vertical = [ QLineF(self.mBoundingRect.bottomLeft(), self.mBoundingRect.topLeft()), QLineF(self.mBoundingRect.bottomRight(), self.mBoundingRect.topRight())] dashPen = QPen(Qt.DashLine) dashPen.setCosmetic(True) dashPen.setDashOffset(max(0.0, self.x())) painter.setPen(dashPen) painter.drawLines(horizontal) dashPen.setDashOffset(max(0.0, self.y())) painter.setPen(dashPen) painter.drawLines(vertical)
def openFile(self, svg_file): if not svg_file.exists(): return s = self.scene() if self.backgroundItem: drawBackground = self.backgroundItem.isVisible() else: drawBackground = False if self.outlineItem: drawOutline = self.outlineItem.isVisible() else: drawOutline = True s.clear() self.resetTransform() self.svgItem = QGraphicsSvgItem(svg_file.fileName()) self.svgItem.setFlags(QGraphicsItem.ItemClipsToShape) self.svgItem.setCacheMode(QGraphicsItem.NoCache) self.svgItem.setZValue(0) self.backgroundItem = QGraphicsRectItem(self.svgItem.boundingRect()) self.backgroundItem.setBrush(Qt.white) self.backgroundItem.setPen(QPen(Qt.NoPen)) self.backgroundItem.setVisible(drawBackground) self.backgroundItem.setZValue(-1) self.outlineItem = QGraphicsRectItem(self.svgItem.boundingRect()) outline = QPen(Qt.black, 2, Qt.DashLine) outline.setCosmetic(True) self.outlineItem.setPen(outline) self.outlineItem.setBrush(QBrush(Qt.NoBrush)) self.outlineItem.setVisible(drawOutline) self.outlineItem.setZValue(1) s.addItem(self.backgroundItem) s.addItem(self.svgItem) s.addItem(self.outlineItem) s.setSceneRect(self.outlineItem.boundingRect().adjusted(-10, -10, 10, 10))
def createPen(style=Qt.SolidLine, color='black', width=1): """ Use this function to conveniently create a cosmetic pen with specified width. Integer widths create cosmetic pens (default) and float widths create scaling pens (this way you can set the figure style by changing a number). This is particularly important on PyQt5 where the default pen blacks out large areas of the figure if not being careful. """ pen = QPen(style) pen.setColor(QColor(color)) if isinstance(width, int): pen.setWidth(width) pen.setCosmetic(True) else: pen.setWidthF(width) pen.setCosmetic(False) return pen
def paint(self, painter, option, widget=None): """ Paint a single line of the slice intersection marker. """ width = self._parent._width height = self._parent._height thickness = self._parent.PEN_THICKNESS # Our pen thickness is consistent across zoom levels because the pen is "cosmetic" # However, that doesn't ensure a consistent-size dash pattern. # Determine the inverse scaling factor from scene to view to set a consistent dash pattern at all scales. view = self.scene().views()[0] inverted_transform, has_inverse = view.transform().inverted() dash_length = old_div(4, inverted_transform.m11()) dash_length = max(0.5, dash_length) # Draw the line with two pens to get a black-and-white dashed line. # pen_white = QPen( Qt.white, thickness ) pen_white = QPen(self._parent._cropColor, thickness) pen_white.setDashPattern([dash_length, dash_length]) pen_white.setCosmetic(True) pen_black = QPen(Qt.black, thickness) pen_black.setDashPattern([dash_length, dash_length]) pen_black.setCosmetic(True) pen_black.setDashOffset(dash_length) with painter_context(painter): t = painter.transform() painter.setTransform(self.scene().data2scene * t) # Draw the line with two pens to get a black-and-white dashed line. for pen in [pen_white, pen_black]: painter.setPen(pen) if self._direction == "horizontal": painter.drawLine(QPointF(0.0, self.position), QPointF(width, self.position)) else: painter.drawLine(QPointF(self.position, 0.0), QPointF(self.position, height))
def _updateHighlight(self, color): """ """ #TODO: called when oligo is highlighted oligo = self._model_strand.oligo() pen_width = styles.PATH_STRAND_STROKE_WIDTH if oligo.shouldHighlight(): color.setAlpha(128) pen_width = styles.PATH_STRAND_HIGHLIGHT_STROKE_WIDTH pen = QPen(color, pen_width) pen.setCosmetic(False) brush = QBrush(color) pen.setCapStyle(QtCore.Qt.FlatCap) self.setPen(pen) self._low_cap.updateHighlight(brush) self._high_cap.updateHighlight(brush) self._dual_cap.updateHighlight(brush) self._tick.updateHighlight(brush) self.toeholdCap3p().updateHighlight(brush) self.toeholdCap5p().updateHighlight(brush)
def __init__ (self, source): super().__init__() self.setCacheMode(QGraphicsItem.DeviceCoordinateCache) self.childpos = [] self.source = source self.sourceright = 0 source.setedge(self) self.style = FlGlob.mainwindow.style self.arrowsize = self.style.arrowsize self.pensize = self.style.pensize pen = QPen(FlPalette.light, self.pensize, cap = Qt.FlatCap, join=Qt.MiterJoin) pen.setCosmetic(False) brush = QBrush(FlPalette.light) pen2 = QPen(pen) pen2.setColor(FlPalette.dark) brush2 = QBrush(FlPalette.dark) visuals = dict() visuals[True] = (pen, brush) visuals[False] = (pen2, brush2) self.visuals = visuals
def draw(self, painter, height, factor): painter.save() painter.translate(0, -CURVE_Y_OFFSET_COMPENSATION) painter.scale(1, -factor) painter.translate(0, -self.value_min) pen = QPen() pen.setCosmetic(True) pen.setWidth(0) pen.setColor(Qt.black) painter.setPen(pen) if DEBUG: painter.fillRect(QRectF(0, self.value_min, -self.axis_line_thickness - self.tick_mark_size_large, self.value_max - self.value_min), Qt.cyan) # axis line painter.drawLine(QLineF(-self.axis_line_thickness, self.value_min, -self.axis_line_thickness, self.value_max)) # ticks tick_text_values = [] value = self.value_min while fuzzy_leq(value, self.value_max): tick_text_values.append(value) painter.drawLine(QLineF(-self.axis_line_thickness, value, -self.axis_line_thickness - self.tick_mark_size_large, value)) for i in range(1, self.step_subdivision_count): subvalue = value + (self.step_size * i / self.step_subdivision_count) if not fuzzy_leq(subvalue, self.value_max): break if i % 2 == 0 and self.step_subdivision_count % 2 == 0: tick_mark_size = self.tick_mark_size_medium else: tick_mark_size = self.tick_mark_size_small painter.drawLine(QLineF(-self.axis_line_thickness, subvalue, -self.axis_line_thickness - tick_mark_size, subvalue)) value += self.step_size painter.restore() painter.setFont(self.tick_text_font) tick_text_x = -self.axis_line_thickness - \ self.tick_mark_size_large - \ self.tick_mark_to_tick_text - \ self.tick_text_max_width tick_text_width = self.tick_text_max_width tick_text_height = self.tick_text_height_half * 2 transform = QTransform() transform.translate(0, -CURVE_Y_OFFSET_COMPENSATION) transform.scale(1, -factor) transform.translate(0, -self.value_min) for value in tick_text_values: tick_text_point = transform.map(QPointF(tick_text_x, value)) tick_text_x = tick_text_point.x() tick_text_y = tick_text_point.y() - self.tick_text_height_half if DEBUG: painter.fillRect(tick_text_x, tick_text_y, tick_text_width, tick_text_height, Qt.yellow) painter.drawText(tick_text_x, tick_text_y, tick_text_width, tick_text_height, Qt.TextDontClip | Qt.AlignRight | Qt.AlignVCenter, self.tick_value_to_str(value)) # title title_width = height title_height = self.title_text_height if self.title_text_pixmap == None or self.title_text_pixmap.size() != QSize(title_width, title_height): self.title_text_pixmap = QPixmap(title_width + 100, title_height + 100) self.title_text_pixmap.fill(QColor(0, 0, 0, 0)) title_painter = QPainter(self.title_text_pixmap) if DEBUG: title_painter.fillRect(50, 50, title_width, title_height, Qt.yellow) title_painter.setFont(self.title_text_font) title_painter.drawText(50, 50, title_width, title_height, Qt.TextWordWrap | Qt.TextDontClip | Qt.AlignHCenter | Qt.AlignTop, self.title_text) title_painter = None painter.save() painter.rotate(-90) painter.translate(-50, -50) title_x = -1 title_y = -self.axis_line_thickness - \ self.tick_mark_size_large - \ self.tick_mark_to_tick_text - \ self.tick_text_max_width - \ self.tick_text_to_title_text - \ max(self.title_text_padding, 0) - \ title_height painter.drawPixmap(title_x, title_y, self.title_text_pixmap) painter.restore()
class CrossHairCursor(QGraphicsItem): """ A 2D cross-hair cursor centered around a point (x,y) on the scene. A cross hair cursor usually follows the mouse cursor and has a color and marks the size of the current brush. """ modeYPosition = 0 modeXPosition = 1 modeXYPosition = 2 def boundingRect(self): return self.scene().data2scene.mapRect(QRectF(0, 0, self._width, self._height)) def __init__(self): QGraphicsItem.__init__(self) self._width = 0 self._height = 0 self.penDotted = QPen(Qt.red, 2, Qt.DotLine, Qt.RoundCap, Qt.RoundJoin) self.penDotted.setCosmetic(True) self.penSolid = QPen(Qt.red, 2) self.penSolid.setCosmetic(True) self.x = 0 self.y = 0 self.brushSize = 0 self.mode = self.modeXYPosition self._enabled = True @property def enabled(self): return self._enabled @enabled.setter def enabled(self, v): if not v: self.setVisible(False) self._enabled = v def setVisible(self, visible): # TODO: though the crosshair is hidden, its position is still # updated. instead of just hiding it, we should # not instantiate it in the first place. if self._enabled: super(CrossHairCursor, self).setVisible(visible) # be careful: QGraphicsItem has a shape() method, which # we cannot override, therefore we choose this name @property def dataShape(self): return (self._width, self._height) @dataShape.setter def dataShape(self, shape2D): self._width = shape2D[0] self._height = shape2D[1] def setColor(self, color): self.penDotted = QPen(color, 2, Qt.DotLine, Qt.RoundCap, Qt.RoundJoin) self.penDotted.setCosmetic(True) self.penSolid = QPen(color, 2) self.penSolid.setCosmetic(True) self.update() def showXPosition(self, x, y): """only mark the x position by displaying a line f(y) = x""" self.setVisible(True) self.mode = self.modeXPosition self.setPos(x, y - int(y)) def showYPosition(self, y, x): """only mark the y position by displaying a line f(x) = y""" self.setVisible(True) self.mode = self.modeYPosition self.setPos(x - int(x), y) def showXYPosition(self, x, y): """mark the (x,y) position by displaying a cross hair cursor including a circle indicating the current brush size""" self.setVisible(True) self.mode = self.modeXYPosition self.setPos(x, y) def paint(self, painter, option, widget=None): painter.save() painter.setTransform(self.scene().data2scene * painter.transform()) painter.setPen(self.penDotted) if self.mode == self.modeXPosition: painter.drawLine(QPointF(self.x + 0.5, 0), QPointF(self.x + 0.5, self._height)) elif self.mode == self.modeYPosition: painter.drawLine(QPointF(0, self.y), QPointF(self.width, self.y)) else: painter.drawLine( QPointF(self.x - 0.5 * self.brushSize - 3, self.y), QPointF(self.x - 0.5 * self.brushSize, self.y) ) painter.drawLine( QPointF(self.x + 0.5 * self.brushSize, self.y), QPointF(self.x + 0.5 * self.brushSize + 3, self.y) ) painter.drawLine( QPointF(self.x, self.y - 0.5 * self.brushSize - 3), QPointF(self.x, self.y - 0.5 * self.brushSize) ) painter.drawLine( QPointF(self.x, self.y + 0.5 * self.brushSize), QPointF(self.x, self.y + 0.5 * self.brushSize + 3) ) painter.setPen(self.penSolid) painter.drawEllipse(QPointF(self.x, self.y), 0.5 * self.brushSize, 0.5 * self.brushSize) painter.restore() def setPos(self, x, y): self.x = x self.y = y self.update() def setBrushSize(self, size): self.brushSize = size self.update()
if __name__ == "__main__": import time import numpy as np from PyQt5.QtGui import QTransform from PyQt5.QtWidgets import QApplication, QGraphicsView, QGraphicsScene app = QApplication([]) import h5py with h5py.File("/magnetic/data/multicut-testdata/2d/256/Superpixels.h5", "r") as superpixels_f: labels_img = superpixels_f["data"][:] labels_img = labels_img[..., 0] # drop channel default_pen = QPen() default_pen.setCosmetic(True) default_pen.setCapStyle(Qt.RoundCap) default_pen.setColor(Qt.blue) default_pen.setWidth(3) # Changes to this pen table will be detected automatically in the QGraphicsItem pen_table = SignalingDict(None) start = time.time() path_items = generate_path_items_for_labels(pen_table, default_pen, labels_img, None) print("generate took {}".format(time.time() - start)) # 52 ms edges_item = SegmentationEdgesItem(path_items, pen_table, default_pen) def assign_random_color(id_pair, buttons): print("handling click: {}".format(id_pair))
class Arrow(QGraphicsLineItem): def __init__(self, startp=Point(), endp=None, length=60.0, angle=50.0, color=QtCore.Qt.red, pencolor=QtCore.Qt.green, startarrow=True): """ Initialisation of the class. """ self.sc = None super(Arrow, self).__init__() self.startp = QtCore.QPointF(startp.x, -startp.y) self.endp = endp self.length = length self.angle = angle self.startarrow = startarrow self.allwaysshow = False self.arrowHead = QPolygonF() self.setFlag(QGraphicsItem.ItemIsSelectable, False) self.myColor = color self.pen = QPen(pencolor, 1, QtCore.Qt.SolidLine) self.pen.setCosmetic(True) self.arrowSize = 8.0 def contains_point(self, point): """ Arrows cannot be selected. Return maximal distance """ return float(0x7fffffff) def setSelected(self, flag=True, blockSignals=True): """ Override inherited function to turn off selection of Arrows. @param flag: The flag to enable or disable Selection """ if self.allwaysshow: pass elif flag is True: self.show() else: self.hide() def setallwaysshow(self, flag=False): """ If the directions shall be allwaysshown the parameter will be set and all paths will be shown. @param flag: The flag to enable or disable Selection """ self.allwaysshow = flag if flag is True: self.show() elif flag is True and self.isSelected(): self.show() else: self.hide() def paint(self, painter, option, widget=None): """ Method for painting the arrow. """ demat = painter.deviceTransform() self.sc = demat.m11() if self.endp is None: dx = cos(self.angle) * self.length / self.sc dy = sin(self.angle) * self.length / self.sc endp = QtCore.QPointF(self.startp.x() - dx, self.startp.y() + dy) else: endp = QtCore.QPointF(self.endp.x, -self.endp.y) arrowSize = self.arrowSize / self.sc painter.setPen(self.pen) painter.setBrush(self.myColor) self.setLine(QtCore.QLineF(endp, self.startp)) line = self.line() if line.length() != 0: angle = acos(line.dx() / line.length()) if line.dy() >= 0: angle = (pi * 2.0) - angle if self.startarrow: arrowP1 = line.p2() - QtCore.QPointF(sin(angle + pi / 3.0) * arrowSize, cos(angle + pi / 3.0) * arrowSize) arrowP2 = line.p2() - QtCore.QPointF(sin(angle + pi - pi / 3.0) * arrowSize, cos(angle + pi - pi / 3.0) * arrowSize) self.arrowHead.clear() for Point in [line.p2(), arrowP1, arrowP2]: self.arrowHead.append(Point) else: arrowP1 = line.p1() + QtCore.QPointF(sin(angle + pi / 3.0) * arrowSize, cos(angle + pi / 3.0) * arrowSize) arrowP2 = line.p1() + QtCore.QPointF(sin(angle + pi - pi / 3.0) * arrowSize, cos(angle + pi - pi / 3.0) * arrowSize) self.arrowHead.clear() for Point in [line.p1(), arrowP1, arrowP2]: self.arrowHead.append(Point) painter.drawLine(line) painter.drawPolygon(self.arrowHead) def boundingRect(self): """ Override inherited function to enlarge selection of Arrow to include all @param flag: The flag to enable or disable Selection """ if not self.sc: # since this function is called before paint; and scale is unknown return QtCore.QRectF(self.startp.x(), self.startp.y(), 1e-9, 1e-9) arrowSize = self.arrowSize / self.sc extra = arrowSize # self.pen.width() + if self.endp is None: dx = cos(self.angle) * self.length / self.sc dy = sin(self.angle) * self.length / self.sc endp = QtCore.QPointF(self.startp.x() - dx, self.startp.y() + dy) else: endp = QtCore.QPointF(self.endp.x, -self.endp.y) brect = QtCore.QRectF(self.startp, QtCore.QSizeF(endp.x()-self.startp.x(), endp.y()-self.startp.y())).normalized().adjusted(-extra, -extra, extra, extra) return brect
class WpZero(QGraphicsItem): """ class WpZero """ def __init__(self, center, color=QtCore.Qt.gray): self.sc = None super(WpZero, self).__init__() self.center = center self.allwaysshow = False self.color = color self.pen = QPen(QtCore.Qt.darkGray, 1, QtCore.Qt.SolidLine) self.pen.setCosmetic(True) self.diameter = 23.0 def contains_point(self, point): """ WpZero cannot be selected. Return maximal distance """ return float(0x7fffffff) def setSelected(self, *args): """ Override inherited function - with possibility to be called with multiple arguments """ pass def paint(self, painter, option, widget=None): """ paint() """ painter.setPen(self.pen) demat = painter.deviceTransform() self.sc = demat.m11() diameter1 = self.diameter / self.sc diameter2 = (self.diameter - 4) / self.sc rectangle1 = QtCore.QRectF(-diameter1 / 2, -diameter1 / 2, diameter1, diameter1) rectangle2 = QtCore.QRectF(-diameter2 / 2, -diameter2 / 2, diameter2, diameter2) startAngle1 = 90 * 16 spanAngle = 90 * 16 startAngle2 = 270 * 16 painter.drawEllipse(rectangle1) painter.drawEllipse(rectangle2) painter.drawPie(rectangle2, startAngle1, spanAngle) painter.setBrush(self.color) painter.drawPie(rectangle2, startAngle2, spanAngle) def boundingRect(self): """ Override inherited function to enlarge selection of Arrow to include all @param flag: The flag to enable or disable Selection """ if not self.sc: # since this function is called before paint; and scale is unknown return QtCore.QRectF(0, 0, 1e-9, 1e-9) diameter = self.diameter / self.sc return QtCore.QRectF(-diameter / 2, -diameter / 2, diameter, diameter)
def drawMapObject(self, painter, object, color): painter.save() pen = QPen(Qt.black) pen.setCosmetic(True) cell = object.cell() if (not cell.isEmpty()): tile = cell.tile imgSize = tile.size() pos = self.pixelToScreenCoords_(object.position()) tileOffset = tile.offset() CellRenderer(painter).render(cell, pos, object.size(), CellRenderer.BottomCenter) if (self.testFlag(RenderFlag.ShowTileObjectOutlines)): rect = QRectF(QPointF(pos.x() - imgSize.width() / 2 + tileOffset.x(), pos.y() - imgSize.height() + tileOffset.y()), QSizeF(imgSize)) pen.setStyle(Qt.SolidLine) painter.setPen(pen) painter.drawRect(rect) pen.setStyle(Qt.DotLine) pen.setColor(color) painter.setPen(pen) painter.drawRect(rect) else: lineWidth = self.objectLineWidth() scale = self.painterScale() x = 1 if lineWidth != 0: x = lineWidth shadowOffset = x / scale brushColor = QColor(color) brushColor.setAlpha(50) brush = QBrush(brushColor) pen.setJoinStyle(Qt.RoundJoin) pen.setCapStyle(Qt.RoundCap) pen.setWidth(lineWidth) colorPen = QPen(pen) colorPen.setColor(color) painter.setPen(pen) painter.setRenderHint(QPainter.Antialiasing) # TODO: Do something sensible to make null-sized objects usable x = object.shape() if x==MapObject.Ellipse: polygon = self.pixelRectToScreenPolygon(object.bounds()) tw = self.map().tileWidth() th = self.map().tileHeight() transformScale = QPointF(1, 1) if (tw > th): transformScale = QPointF(1, th/tw) else: transformScale = QPointF(tw/th, 1) l1 = polygon.at(1) - polygon.at(0) l2 = polygon.at(3) - polygon.at(0) trans = QTransform() trans.scale(transformScale.x(), transformScale.y()) trans.rotate(45) iTrans, ok = trans.inverted() l1x = iTrans.map(l1) l2x = iTrans.map(l2) ellipseSize = QSizeF(l1x.manhattanLength(), l2x.manhattanLength()) if (ellipseSize.width() > 0 and ellipseSize.height() > 0): painter.save() painter.setPen(pen) painter.translate(polygon.at(0)) painter.scale(transformScale.x(), transformScale.y()) painter.rotate(45) painter.drawEllipse(QRectF(QPointF(0, 0), ellipseSize)) painter.restore() painter.setBrush(Qt.NoBrush) painter.drawPolygon(polygon) painter.setPen(colorPen) painter.setBrush(Qt.NoBrush) painter.translate(QPointF(0, -shadowOffset)) painter.drawPolygon(polygon) painter.setBrush(brush) if (ellipseSize.width() > 0 and ellipseSize.height() > 0): painter.save() painter.translate(polygon.at(0)) painter.scale(transformScale.x(), transformScale.y()) painter.rotate(45) painter.drawEllipse(QRectF(QPointF(0, 0), ellipseSize)) painter.restore() elif x==MapObject.Rectangle: polygon = self.pixelRectToScreenPolygon(object.bounds()) painter.drawPolygon(polygon) painter.setPen(colorPen) painter.setBrush(brush) polygon.translate(0, -shadowOffset) painter.drawPolygon(polygon) elif x==MapObject.Polygon: pos = object.position() polygon = object.polygon().translated(pos) screenPolygon = self.pixelToScreenCoords_(polygon) thickPen = QPen(pen) thickColorPen = QPen(colorPen) thickPen.setWidthF(thickPen.widthF() * 4) thickColorPen.setWidthF(thickColorPen.widthF() * 4) painter.drawPolygon(screenPolygon) painter.setPen(thickPen) painter.drawPoint(screenPolygon.first()) painter.setPen(colorPen) painter.setBrush(brush) screenPolygon.translate(0, -shadowOffset) painter.drawPolygon(screenPolygon) painter.setPen(thickColorPen) painter.drawPoint(screenPolygon.first()) elif x==MapObject.Polyline: pos = object.position() polygon = object.polygon().translated(pos) screenPolygon = self.pixelToScreenCoords_(polygon) thickPen = QPen(pen) thickColorPen = QPen(colorPen) thickPen.setWidthF(thickPen.widthF() * 4) thickColorPen.setWidthF(thickColorPen.widthF() * 4) painter.drawPolyline(screenPolygon) painter.setPen(thickPen) painter.drawPoint(screenPolygon.first()) painter.setPen(colorPen) screenPolygon.translate(0, -shadowOffset) painter.drawPolyline(screenPolygon) painter.setPen(thickColorPen) painter.drawPoint(screenPolygon.first()) painter.restore()
def paintEvent(self, event): painter = QPainter(self) width = self.width() height = self.height() if DEBUG: painter.fillRect(0, 0, width, height, Qt.blue) else: painter.fillRect(event.rect(), self.plot.canvas_color) y_min_scale = self.plot.y_scale.value_min y_max_scale = self.plot.y_scale.value_max factor_x = width / self.plot.x_diff factor_y = (height - CURVE_HEIGHT_COMPENSATION) / max(y_max_scale - y_min_scale, EPSILON) if self.plot.x_min != None and self.plot.x_max != None: x_min = self.plot.x_min x_max = self.plot.x_max if self.plot.curve_start == 'left': curve_x_offset = 0 else: curve_x_offset = round((self.plot.x_diff - (x_max - x_min)) * factor_x) transform = QTransform() transform.translate(curve_x_offset, height - CURVE_Y_OFFSET_COMPENSATION) transform.scale(factor_x, -factor_y) transform.translate(-x_min, -y_min_scale) self.plot.partial_update_width = math.ceil(transform.map(QLineF(0, 0, 1.5, 0)).length()) inverted_event_rect = transform.inverted()[0].mapRect(QRectF(event.rect())) painter.save() painter.setTransform(transform) pen = QPen() pen.setCosmetic(True) pen.setWidth(0) painter.setPen(pen) if False and self.plot.curves_visible[0]: # Currently unused support for bar graphs. # If we need this later on we should add an option to the # PlotWidget for it. # I tested this for the Sound Pressure Level Bricklet and it works, # but it didnt't look good. curve_x = self.plot.curves_x[0] curve_y = self.plot.curves_y[0] t = time.time() if self.max_points == None: self.max_points = [] for y in curve_y: self.max_points.append((t, y)) else: for i in range(len(curve_y)): if (curve_y[i] > self.max_points[i][1]) or ((t - self.max_points[i][0]) > 5): self.max_points[i] = (t, curve_y[i]) for i in range(len(self.plot.curves_x[0])): pen.setColor(self.plot.curve_configs[0].color) painter.setPen(pen) painter.drawLine(QPoint(curve_x[i], 0), QPoint(curve_x[i], curve_y[i])) pen.setColor(Qt.white) painter.setPen(pen) painter.drawLine(QPoint(curve_x[i], curve_y[i]), QPoint(curve_x[i], y_max_scale)) pen.setColor(Qt.darkGreen) painter.setPen(pen) painter.drawPoint(QPoint(curve_x[i], self.max_points[i][1])) else: for c in range(len(self.plot.curves_x)): if not self.plot.curves_visible[c]: continue curve_x = self.plot.curves_x[c] curve_y = self.plot.curves_y[c] curve_jump = self.plot.curves_jump[c] path = QPainterPath() lineTo = path.lineTo moveTo = path.moveTo start = max(min(bisect.bisect_left(curve_x, inverted_event_rect.left()), len(curve_x) - 1) - 1, 0) if start >= len(curve_x): continue moveTo(curve_x[start], curve_y[start]) for i in range(start + 1, len(curve_x)): if curve_jump[i]: curve_x_diff_half = (curve_x[i] - curve_x[i - 1]) / 2 lineTo(curve_x[i - 1] + curve_x_diff_half, curve_y[i - 1]) moveTo(curve_x[i] - curve_x_diff_half, curve_y[i]) lineTo(curve_x[i], curve_y[i]) pen.setColor(self.plot.curve_configs[c].color) painter.setPen(pen) painter.drawPath(path) painter.restore()
def drawMapObject(self, painter, object, color): painter.save() bounds = object.bounds() rect = QRectF(bounds) painter.translate(rect.topLeft()) rect.moveTopLeft(QPointF(0, 0)) cell = object.cell() if (not cell.isEmpty()): CellRenderer(painter).render(cell, QPointF(), object.size(), CellRenderer.BottomLeft) if (self.testFlag(RenderFlag.ShowTileObjectOutlines)): tile = cell.tile imgSize = tile.size() tileOffset = tile.offset() rect = QRectF(QPointF(tileOffset.x(), tileOffset.y() - imgSize.height()), QSizeF(imgSize)) pen = QPen(Qt.SolidLine) pen.setCosmetic(True) painter.setPen(pen) painter.drawRect(rect) pen.setStyle(Qt.DotLine) pen.setColor(color) painter.setPen(pen) painter.drawRect(rect) else: lineWidth = self.objectLineWidth() scale = self.painterScale() if lineWidth == 0: x = 1 else: x = lineWidth shadowDist = x / scale shadowOffset = QPointF(shadowDist * 0.5, shadowDist * 0.5) linePen = QPen(color, lineWidth, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin) #linePen.setCosmetic(True) shadowPen = QPen(linePen) shadowPen.setColor(Qt.black) brushColor = QColor(color) fillBrush = QBrush(brushColor) painter.setRenderHint(QPainter.Antialiasing) # Trying to draw an ellipse with 0-width is causing a hang in # CoreGraphics when drawing the path requested by the # QCoreGraphicsPaintEngine. Draw them as rectangle instead. shape = object.shape() if (shape == MapObject.Ellipse and ((rect.width() == 0.0) ^ (rect.height() == 0.0))): shape = MapObject.Rectangle x = shape if x==MapObject.Rectangle: if (rect.isNull()): rect = QRectF(QPointF(-10, -10), QSizeF(20, 20)) # Draw the shadow painter.setPen(shadowPen) painter.drawRect(rect.translated(shadowOffset)) painter.setPen(linePen) painter.setBrush(fillBrush) painter.drawRect(rect) elif x==MapObject.Polyline: screenPolygon = self.pixelToScreenCoords_(object.polygon()) thickShadowPen = QPen(shadowPen) thickLinePen = QPen(linePen) thickShadowPen.setWidthF(thickShadowPen.widthF() * 4) thickLinePen.setWidthF(thickLinePen.widthF() * 4) painter.setPen(shadowPen) painter.drawPolyline(screenPolygon.translated(shadowOffset)) painter.setPen(thickShadowPen) painter.drawPoint(screenPolygon.first() + shadowOffset) painter.setPen(linePen) painter.setBrush(fillBrush) painter.drawPolyline(screenPolygon) painter.setPen(thickLinePen) painter.drawPoint(screenPolygon.first()) elif x==MapObject.Polygon: screenPolygon = self.pixelToScreenCoords_(object.polygon()) thickShadowPen = QPen(shadowPen) thickLinePen = QPen(linePen) thickShadowPen.setWidthF(thickShadowPen.widthF() * 4) thickLinePen.setWidthF(thickLinePen.widthF() * 4) painter.setPen(shadowPen) painter.drawPolygon(screenPolygon.translated(shadowOffset)) painter.setPen(thickShadowPen) painter.drawPoint(screenPolygon.first() + shadowOffset) painter.setPen(linePen) painter.setBrush(fillBrush) painter.drawPolygon(screenPolygon) painter.setPen(thickLinePen) painter.drawPoint(screenPolygon.first()) elif x==MapObject.Ellipse: if (rect.isNull()): rect = QRectF(QPointF(-10, -10), QSizeF(20, 20)) # Draw the shadow painter.setPen(shadowPen) painter.drawEllipse(rect.translated(shadowOffset)) painter.setPen(linePen) painter.setBrush(fillBrush) painter.drawEllipse(rect) painter.restore()
def drawGrid(self, painter, exposed, gridColor): rect = exposed.toAlignedRect() if (rect.isNull()): return p = RenderParams(self.map()) # Determine the tile and pixel coordinates to start at startTile = self.screenToTileCoords_(rect.topLeft()).toPoint() startPos = self.tileToScreenCoords_(startTile).toPoint() ## Determine in which half of the tile the top-left corner of the area we # need to draw is. If we're in the upper half, we need to start one row # up due to those tiles being visible as well. How we go up one row # depends on whether we're in the left or right half of the tile. ## inUpperHalf = rect.y() - startPos.y() < p.sideOffsetY inLeftHalf = rect.x() - startPos.x() < p.sideOffsetX if (inUpperHalf): startTile.setY(startTile.y() - 1) if (inLeftHalf): startTile.setX(startTile.x() - 1) startTile.setX(max(0, startTile.x())) startTile.setY(max(0, startTile.y())) startPos = self.tileToScreenCoords_(startTile).toPoint() oct = [ QPoint(0, p.tileHeight - p.sideOffsetY), QPoint(0, p.sideOffsetY), QPoint(p.sideOffsetX, 0), QPoint(p.tileWidth - p.sideOffsetX, 0), QPoint(p.tileWidth, p.sideOffsetY), QPoint(p.tileWidth, p.tileHeight - p.sideOffsetY), QPoint(p.tileWidth - p.sideOffsetX, p.tileHeight), QPoint(p.sideOffsetX, p.tileHeight)] lines = QVector() #lines.reserve(8) gridColor.setAlpha(128) gridPen = QPen(gridColor) gridPen.setCosmetic(True) _x = QVector() _x.append(2) _x.append(2) gridPen.setDashPattern(_x) painter.setPen(gridPen) if (p.staggerX): # Odd row shifting is applied in the rendering loop, so un-apply it here if (p.doStaggerX(startTile.x())): startPos.setY(startPos.y() - p.rowHeight) while(startPos.x() <= rect.right() and startTile.x() < self.map().width()): rowTile = QPoint(startTile) rowPos = QPoint(startPos) if (p.doStaggerX(startTile.x())): rowPos.setY(rowPos.y() + p.rowHeight) while(rowPos.y() <= rect.bottom() and rowTile.y() < self.map().height()): lines.append(QLineF(rowPos + oct[1], rowPos + oct[2])) lines.append(QLineF(rowPos + oct[2], rowPos + oct[3])) lines.append(QLineF(rowPos + oct[3], rowPos + oct[4])) isStaggered = p.doStaggerX(startTile.x()) lastRow = rowTile.y() == self.map().height() - 1 lastColumn = rowTile.x() == self.map().width() - 1 bottomLeft = rowTile.x() == 0 or (lastRow and isStaggered) bottomRight = lastColumn or (lastRow and isStaggered) if (bottomRight): lines.append(QLineF(rowPos + oct[5], rowPos + oct[6])) if (lastRow): lines.append(QLineF(rowPos + oct[6], rowPos + oct[7])) if (bottomLeft): lines.append(QLineF(rowPos + oct[7], rowPos + oct[0])) painter.drawLines(lines) lines.resize(0) rowPos.setY(rowPos.y() + p.tileHeight + p.sideLengthY) rowTile.setY(rowTile.y() + 1) startPos.setX(startPos.x() + p.columnWidth) startTile.setX(startTile.x() + 1) else: # Odd row shifting is applied in the rendering loop, so un-apply it here if (p.doStaggerY(startTile.y())): startPos.setX(startPos.x() - p.columnWidth) while(startPos.y() <= rect.bottom() and startTile.y() < self.map().height()): rowTile = QPoint(startTile) rowPos = QPoint(startPos) if (p.doStaggerY(startTile.y())): rowPos.setX(rowPos.x() + p.columnWidth) while(rowPos.x() <= rect.right() and rowTile.x() < self.map().width()): lines.append(QLineF(rowPos + oct[0], rowPos + oct[1])) lines.append(QLineF(rowPos + oct[1], rowPos + oct[2])) lines.append(QLineF(rowPos + oct[3], rowPos + oct[4])) isStaggered = p.doStaggerY(startTile.y()) lastRow = rowTile.y() == self.map().height() - 1 lastColumn = rowTile.x() == self.map().width() - 1 bottomLeft = lastRow or (rowTile.x() == 0 and not isStaggered) bottomRight = lastRow or (lastColumn and isStaggered) if (lastColumn): lines.append(QLineF(rowPos + oct[4], rowPos + oct[5])) if (bottomRight): lines.append(QLineF(rowPos + oct[5], rowPos + oct[6])) if (bottomLeft): lines.append(QLineF(rowPos + oct[7], rowPos + oct[0])) painter.drawLines(lines) lines.resize(0) rowPos.setX(rowPos.x() + p.tileWidth + p.sideLengthX) rowTile.setX(rowTile.x() + 1) startPos.setY(startPos.y() + p.rowHeight) startTile.setY(startTile.y() + 1)
class StMoveGUI(QGraphicsLineItem, StMove): def __init__(self, shape): QGraphicsLineItem.__init__(self) StMove.__init__(self, shape) self.allwaysshow = False self.path = QPainterPath() self.setFlag(QGraphicsItem.ItemIsSelectable, False) self.pen = QPen(QColor(50, 100, 255), 1, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin) self.pen.setCosmetic(True) self.make_papath() def contains_point(self, point): """ StMove cannot be selected. Return maximal distance """ return float(0x7fffffff) def make_papath(self): """ To be called if a Shape shall be printed to the canvas @param canvas: The canvas to be printed in @param pospro: The color of the shape """ start = self.geos.abs_el(0).get_start_end_points(True) self.path = QPainterPath() self.path.moveTo(start.x, -start.y) drawHorLine = lambda caller, start, end: self.path.lineTo(end.x, -end.y) drawVerLine = lambda caller, start: None # Not used in 2D mode self.make_path(drawHorLine, drawVerLine) def setSelected(self, flag=True): """ Override inherited function to turn off selection of Arrows. @param flag: The flag to enable or disable Selection """ if self.allwaysshow: pass elif flag is True: self.show() else: self.hide() def setallwaysshow(self, flag=False): """ If the directions shall be allwaysshown the parameter will be set and all paths will be shown. @param flag: The flag to enable or disable Selection """ self.allwaysshow = flag if flag is True: self.show() elif flag is True and self.isSelected(): self.show() else: self.hide() def paint(self, painter, option, widget=None): """ Method will be triggered with each paint event. Possible to give options @param painter: Reference to std. painter @param option: Possible options here @param widget: The widget which is painted on. """ painter.setPen(self.pen) painter.drawPath(self.path) def boundingRect(self): """ Required method for painting. Inherited by Painterpath @return: Gives the Bounding Box """ return self.path.boundingRect()
class RouteText(QGraphicsItem): def __init__(self, text='S', startp=Point(x=0.0, y=0.0),): """ Initialisation of the class. """ QGraphicsItem.__init__(self) self.setFlag(QGraphicsItem.ItemIsSelectable, False) self.text = text self.sc = 1.0 self.startp = QtCore.QPointF(startp.x, -startp.y) pencolor = QColor(0, 200, 255) self.brush = QColor(0, 100, 255) self.pen = QPen(pencolor, 1, QtCore.Qt.SolidLine) self.pen.setCosmetic(True) self.path = QPainterPath() self.path.addText(QtCore.QPointF(0, 0), QFont("Arial", 10/self.sc), self.text) def contains_point(self, point): """ Text cannot be selected. Return maximal distance """ return float(0x7fffffff) def setSelected(self, *args): """ Override inherited function - with possibility to be called with multiple arguments """ def paint(self, painter, option, widget=None): """ Method for painting the arrow. """ demat = painter.deviceTransform() self.sc = demat.m11() # painter.setClipRect(self.boundingRect()) painter.setPen(self.pen) painter.setBrush(self.brush) painter.scale(1/self.sc, 1/self.sc) painter.translate(self.startp.x() * self.sc, self.startp.y() * self.sc) painter.drawPath(self.path) def shape(self): """ Reimplemented function to select outline only. @return: Returns the Outline only """ logger.debug("Hier sollte ich nicht sein") return super(RouteText, self).shape() def boundingRect(self): """ Required method for painting. Inherited by Painterpath @return: Gives the Bounding Box """ rect = self.path.boundingRect().getRect() newrect = QtCore.QRectF(self.startp.x()+rect[0]/self.sc, self.startp.y()+rect[1]/self.sc, rect[2]/self.sc, rect[3]/self.sc) return newrect