def scaledBoundingRect(self, sx, sy): """ Calculate the target rectangle for scaling the graphic :param float sx: Horizontal scaling factor :param float sy: Vertical scaling factor :return: Scaled bounding rectangle .. note:: In case of paths that are painted with a cosmetic pen (see :py:meth:`QPen.isCosmetic()`) the target rectangle is different to multiplying the bounding rectangle. .. seealso:: :py:meth:`boundingRect()`, :py:meth:`controlPointRect()` """ if sx == 1.0 and sy == 1.0: return self.__data.boundingRect transform = QTransform() transform.scale(sx, sy) rect = transform.mapRect(self.__data.pointRect) for pathInfo in self.__data.pathInfos: rect |= pathInfo.scaledBoundingRect( sx, sy, not bool(self.__data.renderHints & self.RenderPensUnscaled)) return rect
def updatePosition(self, scene): # 1. Get pix coords for each lat/lon point pos0 = scene.posFromLonLat(self._lon0, self._lat0) pos1 = scene.posFromLonLat(self._lon1, self._lat1) pos2 = scene.posFromLonLat(self._lon2, self._lat2) pos3 = scene.posFromLonLat(self._lon3, self._lat3) self.prepareGeometryChange() # Set the image to 0, 0, then use a transform to # to translate, rotate and warp it to the map # tranfsorm and scale self.setPos(0, 0) t = QTransform() poly1 = QPolygonF() w = self.pixmap().width() h = self.pixmap().height() poly1.append(QPointF(0, 0)) poly1.append(QPointF(w, 0)) poly1.append(QPointF(w, h)) poly1.append(QPointF(0, h)) poly2 = QPolygonF() poly2.append(QPointF(pos0[0], pos0[1])) poly2.append(QPointF(pos1[0], pos1[1])) poly2.append(QPointF(pos2[0], pos2[1])) poly2.append(QPointF(pos3[0], pos3[1])) success = QTransform.quadToQuad(poly1, poly2, t) if not success: logging.error('Unable to register image') self.setTransform(t)
def port_scene_position(self, port_type: PortType, index: int, t: QTransform = None) -> QPointF: """ Port scene position Parameters ---------- port_type : PortType index : int t : QTransform Returns ------- value : QPointF """ if t is None: t = QTransform() step = self._entry_height + self._spacing total_height = float(self.caption_height) + step * index # TODO_UPSTREAM: why? total_height += step / 2.0 if port_type == PortType.output: x = self._width + self._style.connection_point_diameter result = QPointF(x, total_height) elif port_type == PortType.input: x = -float(self._style.connection_point_diameter) result = QPointF(x, total_height) else: raise ValueError(port_type) return t.map(result)
def draw_icon(self, painter): path = QPainterPath(QPointF(0, 0.3)) path.lineTo(0, 0.9) path.lineTo(1, 0.3) path.lineTo(1, 0.9) path.closeSubpath() painter.drawPath(path) painter.drawLine(QPointF(0.5, 0.6), QPointF(0.5, 0.15)) # Draw the arrow end-caps painter.setBrush(QBrush(QColor(0, 0, 0))) top_arrow_point = QPointF(0.65, 0.36) arrow = QPolygonF([ QPointF(-0.09, 0.0), QPointF(-0.005, 0.0), QPointF(-0.005, 0.8), QPointF(0.005, 0.8), QPointF(0.005, 0.0), QPointF(0.09, 0.0), QPointF(0.00, -0.25) ]) t = QTransform() t.rotate(35) top_arrow_r = t.map(arrow) arrow_l = top_arrow_r.translated(top_arrow_point) painter.drawPolygon(arrow_l) painter.setBrush(self._interlock_brush) painter.drawRect(QRectF(0.3, 0, 0.4, 0.15))
def transform(self, img=None): if not self._geometry or not self.displaymode == DisplayMode.remesh: return super(EwaldCorrected, self).transform( img) # Do pixel space transform when not calibrated from camsaxs import remesh_bbox img, q_x, q_z = remesh_bbox.remesh(np.squeeze(img), self._geometry, reflection=False, alphai=None) # Build Quads shape = img.shape a = shape[-2] - 1, 0 # bottom-left b = shape[-2] - 1, shape[-1] - 1 # bottom-right c = 0, shape[-1] - 1 # top-right d = 0, 0 # top-left quad1 = QPolygonF() quad2 = QPolygonF() for p, q in zip([a, b, c, d], [a, b, c, d]): # the zip does the flip :P quad1.append(QPointF(*p[::-1])) quad2.append(QPointF(q_x[q], q_z[q])) transform = QTransform() QTransform.quadToQuad(quad1, quad2, transform) for item in self.view.items: if isinstance(item, ImageItem): item.setTransform(transform) self._transform = transform return img, self._transform
def setData(self, data): xvals = data.coords[data.dims[-1]] yvals = data.coords[data.dims[-2]] xmin = float(xvals.min()) xmax = float(xvals.max()) ymin = float(yvals.min()) ymax = float(yvals.max()) # Position the image according to coords shape = data.shape a = [(0, shape[-1]), (shape[-2] - 1, shape[-1]), (shape[-2] - 1, 1), (0, 1)] # b = [(ymin, xmax), (ymax, xmax), (ymax, xmin), (ymin, xmin)] b = [(xmax, ymin), (xmax, ymax), (xmin, ymax), (xmin, ymin)] quad1 = QPolygonF() quad2 = QPolygonF() for p, q in zip(a, b): quad1.append(QPointF(*p)) quad2.append(QPointF(*q)) transform = QTransform() QTransform.quadToQuad(quad1, quad2, transform) # Bind coords from the xarray to the timeline axis # super(SliceableGraphicsView, self).setImage(img, autoRange, autoLevels, levels, axes, np.asarray(img.coords[img.dims[0]]), pos, scale, transform, autoHistogramRange, levelMode) self.image_item.setImage(np.asarray(data), autoLevels=False) self.image_item.setTransform(transform) # Label the image axes self.view.setLabel('left', data.dims[-2]) self.view.setLabel('bottom', data.dims[-1])
def updateZoom(self, zx, zy): trans = QTransform() trans.scale(1.0 / zx, 1.0 / zy) # self.setTransform( trans ) self.VP.setTransform(trans) self.preBP.setTransform(trans) self.postBP.setTransform(trans) self.updateTPPos()
def setZoom(self, x, y): self.zx = x self.zy = y trans = QTransform() trans.scale(self.zx, self.zy) self.setTransform(trans) for vert in self.vertItems: vert.updateZoom(self.zx, self.zy)
def updateTransfrom(self): if self.updating: return self.updating = True trans = QTransform() tx = self.valueToX(-self.scrollX) + self.offsetX ty = self.valueToY(-self.scrollY) # if ty > 20000: # raise "wtf" trans.translate(tx, ty) self.setTransform(trans) self.update() self.updating = False
def pixmap(self, viewer_policy, max_w, max_h): if not self._image: self._load_image() image = self._image # Scale scale = viewer_policy["scale"] if scale == 'fit_auto': image = image.scaled(max_w, max_h, Qt.KeepAspectRatio) elif scale == 'fit_to_window': image = image.scaled(max_w, max_h) elif scale == 'fit_to_width': image = image.scaledToWidth(max_w) elif scale == 'fit_to_height': image = image.scaledToHeight(max_h) # Else Original # Zoom zoom = self.image_policy["zoom"] if zoom != 0: new_size = image.size() if zoom > 0: for i in range(abs(zoom)): new_size *= 1.3 else: for i in range(abs(zoom)): new_size /= 1.3 image = image.scaled(new_size, Qt.KeepAspectRatio) # Vertical Flipping v_flipping = (abs(self.image_policy["flip_v"]) % 2) * (1 if self.image_policy["flip_v"] >= 0 else -1) if v_flipping != 0: v_transform = QTransform().scale(1, -1) image = image.transformed(v_transform) # Horizontal Flipping h_flipping = (abs(self.image_policy["flip_h"]) % 2) * (1 if self.image_policy["flip_h"] >= 0 else -1) if h_flipping != 0: h_transform = QTransform().scale(-1, 1) image = image.transformed(h_transform) # Rotation rotation = 90 * (abs(self.image_policy["rotate"]) % 4) * (1 if self.image_policy["rotate"] >= 0 else -1) if rotation != 0: r_transform = QTransform().rotate(rotation) image = image.transformed(r_transform) return image
def setImage(self, imgdata): self.imageitem.clear() self.textitem.hide() self.imgdata = imgdata self.imageitem.setImage(np.log(self.imgdata * (self.imgdata > 0) + (self.imgdata < 1)), autoLevels=True) self.imageitem.setTransform(QTransform(1, 0, 0, -1, 0, self.imgdata.shape[-2])) self.view.autoRange()
def setImage(self, img, **kwargs): if hasattr(img, 'coords'): if 'transform' not in kwargs: xvals = img.coords[img.dims[-2]] yvals = img.coords[img.dims[-1]] xmin = float(xvals.min()) xmax = float(xvals.max()) ymin = float(yvals.min()) ymax = float(yvals.max()) # Position the image according to coords shape = img.shape a = [(0, shape[-2]), (shape[-1] - 1, shape[-2]), (shape[-1] - 1, 1), (0, 1)] b = [(ymin, xmin), (ymax, xmin), (ymax, xmax), (ymin, xmax)] quad1 = QPolygonF() quad2 = QPolygonF() for p, q in zip(a, b): quad1.append(QPointF(*p)) quad2.append(QPointF(*q)) transform = QTransform() QTransform.quadToQuad(quad1, quad2, transform) kwargs['transform'] = transform if 'xvals' not in kwargs: kwargs['xvals'] = np.asarray(img.coords[img.dims[0]]) # Set the timeline axis label from dims self.ui.roiPlot.setLabel('bottom', img.dims[0]) # Label the image axes self.axesItem.setLabel('left', img.dims[-2]) self.axesItem.setLabel('bottom', img.dims[-1]) # Add a bit more size self.ui.roiPlot.setMinimumSize(QSize(0, 70)) # Bind coords from the xarray to the timeline axis super(XArrayView, self).setImage(img, **kwargs)
def qwtDrawPixmapSymbols(painter, points, numPoints, symbol): size = symbol.size() if size.isEmpty(): size = symbol.pixmap().size() transform = QTransform(painter.transform()) if transform.isScaling(): r = QRect(0, 0, size.width(), size.height()) size = transform.mapRect(r).size() pm = QPixmap(symbol.pixmap()) if pm.size() != size: pm = pm.scaled(size) pinPoint = QPointF(0.5 * size.width(), 0.5 * size.height()) if symbol.isPinPointEnabled(): pinPoint = symbol.pinPoint() painter.resetTransform() for pos in points: pos = QPointF(transform.map(pos)) - pinPoint QwtPainter.drawPixmap(painter, QRect(pos.toPoint(), pm.size()), pm)
def paintEvent(self, event): super(DataGraphWidget, self).paintEvent(event) if not self.text_adjusted: for node in self.nodes: width = node.label.boundingRect().width() height = node.label.boundingRect().height() transform = QTransform() if node in self.left_nodes: transform.translate(-width, -height / 2) else: transform.translate(0, -height / 2) node.label.setTransform(transform) self.text_adjusted = True
def transform(self, img=None): # Build Quads shape = img.shape a = [(0, shape[-2] - 1), (shape[-1] - 1, shape[-2] - 1), (shape[-1] - 1, 0), (0, 0)] b = [(0, 1), (shape[-1] - 1, 1), (shape[-1] - 1, shape[-2]), (0, shape[-2])] quad1 = QPolygonF() quad2 = QPolygonF() for p, q in zip(a, b): quad1.append(QPointF(*p)) quad2.append(QPointF(*q)) transform = QTransform() QTransform.quadToQuad(quad1, quad2, transform) for item in self.view.items: if isinstance(item, ImageItem): item.setTransform(transform) self._transform = transform return img, transform
def setData(self, data): # Constrain squareness when units match is_square = data.dims[-2].split('(')[-1] == data.dims[-1].split( '(')[-1] self.view.vb.setAspectLocked(is_square) xvals = data.coords[data.dims[-1]] yvals = data.coords[data.dims[-2]] xmin = float(xvals.min()) xmax = float(xvals.max()) ymin = float(yvals.min()) ymax = float(yvals.max()) # Position the image according to coords shape = data.shape a = [(0, shape[-2]), (shape[-1], shape[-2]), (shape[-1], 0), (0, 0)] # b = [(ymin, xmax), (ymax, xmax), (ymax, xmin), (ymin, xmin)] if self.slice_direction in ['horizontal', 'depth']: b = [(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax)] elif self.slice_direction == 'vertical': b = [(xmax, ymax), (xmin, ymax), (xmin, ymin), (xmax, ymin)] quad1 = QPolygonF() quad2 = QPolygonF() for p, q in zip(a, b): quad1.append(QPointF(*p)) quad2.append(QPointF(*q)) transform = QTransform() QTransform.quadToQuad(quad1, quad2, transform) # Bind coords from the xarray to the timeline axis # super(SliceableGraphicsView, self).setImage(img, autoRange, autoLevels, levels, axes, np.asarray(img.coords[img.dims[0]]), pos, scale, transform, autoHistogramRange, levelMode) self.image_item.setImage(np.asarray(data), autoLevels=False) self.image_item.setTransform(transform) # Label the image axes self.view.setLabel('left', data.dims[-2]) self.view.setLabel('bottom', data.dims[-1])
def __init__(self, image, name="", invertY=False, xlabel: str = None, ylabel: str = None, transform=None, z: int = None, **kwargs): self._name = name super(ImageHint, self).__init__() self.count = next(self.ref_count) self.image = image self.invertY = invertY self.xlabel = xlabel self.ylabel = ylabel self.transform = transform if transform is None: transform = QTransform() transform.translate(0, -1) transform.scale(0, -1) self.transform = transform self.z = z self.kwargs = kwargs self.enabled = False self.canvas = None
def draw(self, painter, rect, flags, text): """ Draw the text in a clipping rectangle :param QPainter painter: Painter :param QRectF rect: Clipping rectangle :param int flags: Bitwise OR of the flags like in for QPainter::drawText() :param str text: Text to be rendered """ txt = QwtRichTextDocument(text, flags, painter.font()) painter.save() unscaledRect = QRectF(rect) if painter.font().pixelSize() < 0: res = qwtScreenResolution() pd = painter.device() if pd.logicalDpiX() != res.width() or pd.logicalDpiY( ) != res.height(): transform = QTransform() transform.scale( res.width() / float(pd.logicalDpiX()), res.height() / float(pd.logicalDpiY()), ) painter.setWorldTransform(transform, True) invtrans, _ok = transform.inverted() unscaledRect = invtrans.mapRect(rect) txt.setDefaultFont(painter.font()) txt.setPageSize(QSizeF(unscaledRect.width(), QWIDGETSIZE_MAX)) layout = txt.documentLayout() height = layout.documentSize().height() y = unscaledRect.y() if flags & Qt.AlignBottom: y += unscaledRect.height() - height elif flags & Qt.AlignVCenter: y += (unscaledRect.height() - height) / 2 context = QAbstractTextDocumentLayout.PaintContext() context.palette.setColor(QPalette.Text, painter.pen().color()) painter.translate(unscaledRect.x(), y) layout.draw(painter, context) painter.restore()
def __init__(self, *args, **kwargs): # Add axes self.axesItem = PlotItem() self.axesItem.axes["left"]["item"].setZValue(10) self.axesItem.axes["top"]["item"].setZValue(10) if "view" not in kwargs: kwargs["view"] = self.axesItem self._transform = QTransform() super(PixelSpace, self).__init__(*args, **kwargs) self.imageItem.sigImageChanged.connect(self.updateAxes)
def draw_icon(self, painter): painter.drawEllipse(QPointF(0.5, 0.5), 0.5, 0.5) painter.drawChord(QRectF(0.0, 0.0, 1.0, 1.0), 45 * 16, -120 * 16) painter.drawChord(QRectF(0.0, 0.0, 1.0, 1.0), 135 * 16, 120 * 16) bottom_arrow_point = QPointF(0.5, 0.8) painter.drawLine(bottom_arrow_point, QPointF(0.5, 0.7)) curve_start = QPointF(0.5, 0.7) bend_angle = 25 curve_end_l = QPointF( 0.4 * math.cos(math.radians(90 + bend_angle)) + 0.5, -0.4 * math.sin(math.radians(90 + bend_angle)) + 0.5) c1 = QPointF(0.5, 0.4) path = QPainterPath(curve_start) path.quadTo(c1, curve_end_l) painter.drawPath(path) curve_end_r = QPointF( 0.4 * math.cos(math.radians(90 - bend_angle)) + 0.5, -0.4 * math.sin(math.radians(90 - bend_angle)) + 0.5) path = QPainterPath(curve_start) path.quadTo(c1, curve_end_r) painter.drawPath(path) # Draw the arrow end-caps painter.setBrush(QBrush(QColor(0, 0, 0))) arrow = QPolygonF( [QPointF(-0.025, 0.0), QPointF(0.025, 0.0), QPointF(0.0, 0.025)]) painter.drawPolygon(arrow.translated(bottom_arrow_point)) t = QTransform() t.rotate(180.0 - 25.0) arrow_l = t.map(arrow) arrow_l = arrow_l.translated(curve_end_l) painter.drawPolygon(arrow_l) t = QTransform() t.rotate(180.0 + 25.0) arrow_r = t.map(arrow) arrow_r = arrow_r.translated(curve_end_r) painter.drawPolygon(arrow_r)
def qwtDrawGraphicSymbols(painter, points, numPoint, graphic, symbol): pointRect = QRectF(graphic.controlPointRect()) if pointRect.isEmpty(): return sx = 1.0 sy = 1.0 sz = symbol.size() if sz.isValid(): sx = sz.width() / pointRect.width() sy = sz.height() / pointRect.height() pinPoint = QPointF(pointRect.center()) if symbol.isPinPointEnabled(): pinPoint = symbol.pinPoint() transform = QTransform(painter.transform()) for pos in points: tr = QTransform(transform) tr.translate(pos.x(), pos.y()) tr.scale(sx, sy) tr.translate(-pinPoint.x(), -pinPoint.y()) painter.setTransform(tr) graphic.render(painter) painter.setTransform(transform)
def scaledBoundingRect(self, sx, sy, scalePens): if sx == 1.0 and sy == 1.0: return self.__boundingRect transform = QTransform() transform.scale(sx, sy) if scalePens and self.__scalablePen: rect = transform.mapRect(self.__boundingRect) else: rect = transform.mapRect(self.__pointRect) l = abs(self.__pointRect.left() - self.__boundingRect.left()) r = abs(self.__pointRect.right() - self.__boundingRect.right()) t = abs(self.__pointRect.top() - self.__boundingRect.top()) b = abs(self.__pointRect.bottom() - self.__boundingRect.bottom()) rect.adjust(-l, -t, r, b) return rect
def labelTransformation(self, pos, size): """ Calculate the transformation that is needed to paint a label depending on its alignment and rotation. :param QPointF pos: Position where to paint the label :param QSizeF size: Size of the label :return: Transformation matrix .. seealso:: :py:meth:`setLabelAlignment()`, :py:meth:`setLabelRotation()` """ transform = QTransform() transform.translate(pos.x(), pos.y()) transform.rotate(self.labelRotation()) flags = self.labelAlignment() if flags == 0: flags = self.Flags[self.alignment()] if flags & Qt.AlignLeft: x = -size.width() elif flags & Qt.AlignRight: x = 0.0 else: x = -(0.5 * size.width()) if flags & Qt.AlignTop: y = -size.height() elif flags & Qt.AlignBottom: y = 0 else: y = -(0.5 * size.height()) transform.translate(x, y) return transform
def monitor_images(self): while self.active: if self.last_frame: image_array = self.style.stylize(self.last_frame) image = QImage(image_array.data, image_array.shape[1], image_array.shape[0], image_array.strides[0], QImage.Format_RGB888) rotating = QTransform() rotating.scale(-1, 1) # mirror rotating.rotate(settings.ROTATE_IMAGE) image = image.transformed(rotating) self.image_signal.emit(StyledCapture(image, self.style.name)) # check for stop/changes QApplication.processEvents()
def _paint_icon(self, iconic, painter, rect, mode, state, options): """Paint a single icon.""" painter.save() color = options['color'] char = options['char'] color_options = { QIcon.On: { QIcon.Normal: (options['color_on'], options['on']), QIcon.Disabled: (options['color_on_disabled'], options['on_disabled']), QIcon.Active: (options['color_on_active'], options['on_active']), QIcon.Selected: (options['color_on_selected'], options['on_selected']) }, QIcon.Off: { QIcon.Normal: (options['color_off'], options['off']), QIcon.Disabled: (options['color_off_disabled'], options['off_disabled']), QIcon.Active: (options['color_off_active'], options['off_active']), QIcon.Selected: (options['color_off_selected'], options['off_selected']) } } color, char = color_options[state][mode] painter.setPen(QColor(color)) # A 16 pixel-high icon yields a font size of 14, which is pixel perfect # for font-awesome. 16 * 0.875 = 14 # The reason why the glyph size is smaller than the icon size is to # account for font bearing. draw_size = round(0.875 * rect.height() * options['scale_factor']) prefix = options['prefix'] # Animation setup hook animation = options.get('animation') if animation is not None: animation.setup(self, painter, rect) painter.setFont(iconic.font(prefix, draw_size)) if 'offset' in options: rect = QRect(rect) rect.translate(round(options['offset'][0] * rect.width()), round(options['offset'][1] * rect.height())) if 'vflip' in options and options['vflip'] == True: x_center = rect.width() * 0.5 y_center = rect.height() * 0.5 painter.translate(x_center, y_center) transfrom = QTransform() transfrom.scale(1, -1) painter.setTransform(transfrom, True) painter.translate(-x_center, -y_center) if 'hflip' in options and options['hflip'] == True: x_center = rect.width() * 0.5 y_center = rect.height() * 0.5 painter.translate(x_center, y_center) transfrom = QTransform() transfrom.scale(-1, 1) painter.setTransform(transfrom, True) painter.translate(-x_center, -y_center) if 'rotated' in options: x_center = rect.width() * 0.5 y_center = rect.height() * 0.5 painter.translate(x_center, y_center) painter.rotate(options['rotated']) painter.translate(-x_center, -y_center) painter.setOpacity(options.get('opacity', 1.0)) painter.drawText(rect, int(Qt.AlignCenter | Qt.AlignVCenter), char) painter.restore()
def setCommands(self, commands): self.reset() painter = QPainter(self) for cmd in commands: qwtExecCommand(painter, cmd, 0, QTransform(), None) painter.end()
def paintEvent(self, event): """ Adds a frame and the splitters internal id to the UI if debug is enabled. :param event: paint event """ painter = QPainter(self) if CONFIG.debug_layout: painter.setPen(QPen(Qt.yellow, 4.0)) painter.drawRect(self.rect().adjusted(1, 1, -2, -2)) painter.setPen(QPen(Qt.black, 1.0)) painter.drawText(QPointF(5, 12), str(self)) # Relative drop cross and icons dock_center_x = self.width() / 2.0 dock_center_y = self.height() / 2.0 d_transform = QTransform() transform = d_transform.fromTranslate(dock_center_x, dock_center_y) painter.setTransform(transform) self._paintBackgroundCross(painter) transform = d_transform.fromTranslate(dock_center_x - 34, dock_center_y) painter.setTransform(transform) self._paintRefDropIcon(painter, Placement.LEFT) transform = d_transform.fromTranslate(dock_center_x - 68, dock_center_y) painter.setTransform(transform) self._paintAbsDropIcon(painter, Placement.LEFT) transform = d_transform.fromTranslate(dock_center_x, dock_center_y - 34) painter.setTransform(transform) self._paintRefDropIcon(painter, Placement.TOP) transform = d_transform.fromTranslate(dock_center_x, dock_center_y - 68) painter.setTransform(transform) self._paintAbsDropIcon(painter, Placement.TOP) transform = d_transform.fromTranslate(dock_center_x + 34, dock_center_y) painter.setTransform(transform) self._paintRefDropIcon(painter, Placement.RIGHT) transform = d_transform.fromTranslate(dock_center_x + 68, dock_center_y) painter.setTransform(transform) self._paintAbsDropIcon(painter, Placement.RIGHT) transform = d_transform.fromTranslate(dock_center_x, dock_center_y + 34) painter.setTransform(transform) self._paintRefDropIcon(painter, Placement.BOTTOM) transform = d_transform.fromTranslate(dock_center_x, dock_center_y + 68) painter.setTransform(transform) self._paintAbsDropIcon(painter, Placement.BOTTOM) transform = d_transform.fromTranslate(dock_center_x, dock_center_y) painter.setTransform(transform) self._paintRefDropIcon(painter, Placement.TAB)
def zoomOriginal(self): self._ui.view.setTransform(QTransform())
def boundingRect(self): """ Calculate the bounding rectangle for a symbol at position (0,0). :return: Bounding rectangle """ rect = QRectF() pinPointTranslation = False if self.__data.style in (QwtSymbol.Ellipse, QwtSymbol.Rect, QwtSymbol.Hexagon): pw = 0.0 if self.__data.pen.style() != Qt.NoPen: pw = max([self.__data.pen.widthF(), 1.0]) rect.setSize(self.__data.size + QSizeF(pw, pw)) rect.moveCenter(QPointF(0.0, 0.0)) elif self.__data.style in ( QwtSymbol.XCross, QwtSymbol.Diamond, QwtSymbol.Triangle, QwtSymbol.UTriangle, QwtSymbol.DTriangle, QwtSymbol.RTriangle, QwtSymbol.LTriangle, QwtSymbol.Star1, QwtSymbol.Star2, ): pw = 0.0 if self.__data.pen.style() != Qt.NoPen: pw = max([self.__data.pen.widthF(), 1.0]) rect.setSize(QSizeF(self.__data.size) + QSizeF(2 * pw, 2 * pw)) rect.moveCenter(QPointF(0.0, 0.0)) elif self.__data.style == QwtSymbol.Path: if self.__data.path.graphic.isNull(): self.__data.path.graphic = qwtPathGraphic( self.__data.path.path, self.__data.pen, self.__data.brush) rect = qwtScaleBoundingRect(self.__data.path.graphic, self.__data.size) pinPointTranslation = True elif self.__data.style == QwtSymbol.Pixmap: if self.__data.size.isEmpty(): rect.setSize(self.__data.pixmap.pixmap.size()) else: rect.setSize(self.__data.size) pinPointTranslation = True elif self.__data.style == QwtSymbol.Graphic: rect = qwtScaleBoundingRect(self.__data.graphic.graphic, self.__data.size) pinPointTranslation = True elif self.__data.style == QwtSymbol.SvgDocument: if self.__data.svg.renderer is not None: rect = self.__data.svg.renderer.viewBoxF() if self.__data.size.isValid() and not rect.isEmpty(): sz = QSizeF(rect.size()) sx = self.__data.size.width() / sz.width() sy = self.__data.size.height() / sz.height() transform = QTransform() transform.scale(sx, sy) rect = transform.mapRect(rect) pinPointTranslation = True else: rect.setSize(self.__data.size) rect.moveCenter(QPointF(0.0, 0.0)) if pinPointTranslation: pinPoint = QPointF(0.0, 0.0) if self.__data.isPinPointEnabled: pinPoint = rect.center() - self.__data.pinPoint rect.moveCenter(pinPoint) r = QRect() r.setLeft(np.floor(rect.left())) r.setTop(np.floor(rect.top())) r.setRight(np.floor(rect.right())) r.setBottom(np.floor(rect.bottom())) if self.__data.style != QwtSymbol.Pixmap: r.adjust(-1, -1, 1, 1) return r
def draw_icon(self, painter): painter.drawEllipse(QPointF(0.5, 0.5), 0.5, 0.5) painter.drawChord(QRectF(0.0, 0.0, 1.0, 1.0), 90 * 16, -100 * 16) painter.drawChord(QRectF(0.0, 0.0, 1.0, 1.0), 135 * 16, 100 * 16) # Draw the arrow end-caps painter.setBrush(QBrush(QColor(0, 0, 0))) top_arrow_point = QPointF(0.35, 0.15) arrow = QPolygonF([ QPointF(-0.08, 0.0), QPointF(-0.005, 0.0), QPointF(-0.005, 0.15), QPointF(0.005, 0.15), QPointF(0.005, 0.0), QPointF(0.08, 0.0), QPointF(0.00, -0.08) ]) t = QTransform() t.rotate(-25) top_arrow_r = t.map(arrow) arrow_l = top_arrow_r.translated(top_arrow_point) painter.drawPolygon(arrow_l) bottom_left_arrow_point = QPointF(0.35, 0.89) t = QTransform() t.rotate(180.0 + 25.0) arrow_r = t.map(arrow) arrow_r = arrow_r.translated(bottom_left_arrow_point) painter.drawPolygon(arrow_r) bottom_right_arrow_point = QPointF(0.85, 0.65) t = QTransform() t.rotate(180.0 - 65.0) arrow_r = t.map(arrow) arrow_r = arrow_r.translated(bottom_right_arrow_point) painter.drawPolygon(arrow_r)