Что нужно сделать, чтобы прямоугольная область фигуры, появлялась только после нажатия на фигуру?

Question

Что нужно сделать, чтобы прямоугольная область фигуры, появлялась только после нажатия на фигуру? (Чтобы желтые точки появлялись только при нажатии на фигуру)

Исходный код:

 import sys
    import random
    from PyQt5.QtCore import Qt, QRectF, QPointF, QTimer
    from PyQt5.QtGui import QBrush, QPainterPath, QPainter, QColor, QPen, QPixmap
    from PyQt5.QtWidgets import (QGraphicsRectItem, QApplication, QGraphicsView,
                                 QGraphicsScene, QGraphicsItem)
    
    
    class GraphicsRectItem(QGraphicsRectItem):
        handleTopLeft = 1
        handleTopMiddle = 2
        handleTopRight = 3
        handleMiddleLeft = 4
        handleMiddleRight = 5
        handleBottomLeft = 6
        handleBottomMiddle = 7
        handleBottomRight = 8
    
        handleSize = +8.0
        handleSpace = -4.0
    
        handleCursors = {
            handleTopLeft: Qt.SizeFDiagCursor,
            handleTopMiddle: Qt.SizeVerCursor,
            handleTopRight: Qt.SizeBDiagCursor,
            handleMiddleLeft: Qt.SizeHorCursor,
            handleMiddleRight: Qt.SizeHorCursor,
            handleBottomLeft: Qt.SizeBDiagCursor,
            handleBottomMiddle: Qt.SizeVerCursor,
            handleBottomRight: Qt.SizeFDiagCursor,
        }
    
        def __init__(self, *args):
            super().__init__(*args)
            self.handles = {}
            self.handleSelected = None
            self.mousePressPos = None
            self.mousePressRect = None
            self.setAcceptHoverEvents(True)
            self.setFlag(QGraphicsItem.ItemIsMovable, True)
            self.setFlag(QGraphicsItem.ItemIsSelectable, True)
            self.setFlag(QGraphicsItem.ItemSendsGeometryChanges, True)
            self.setFlag(QGraphicsItem.ItemIsFocusable, True)
            self.updateHandlesPos()
    
        def handleAt(self, point):
            """  Возвращает маркер изменения размера ниже заданной точки.
            """
            for k, v, in self.handles.items():
                if v.contains(point):
                    return k
            return None
    
        def hoverMoveEvent(self, moveEvent):
            if self.isSelected():
                handle = self.handleAt(moveEvent.pos())
                cursor = Qt.ArrowCursor if handle is None else self.handleCursors[handle]
                self.setCursor(cursor)
    
            super().hoverMoveEvent(moveEvent)
    
    
        def hoverLeaveEvent(self, moveEvent):
            self.setCursor(Qt.ArrowCursor)
    
            super().hoverLeaveEvent(moveEvent)
    
        def mousePressEvent(self, mouseEvent):
            """ Выполняется при нажатии мыши на item.
            """
            self.handleSelected = self.handleAt(mouseEvent.pos())
            if self.handleSelected:
                self.mousePressPos = mouseEvent.pos()
                self.mousePressRect = self.boundingRect()
    
            super().mousePressEvent(mouseEvent)
    
        def mouseMoveEvent(self, mouseEvent):
            """ Выполняется, когда мышь перемещается по элементу при нажатии.
            """
    
            if self.handleSelected is not None:
                self.interactiveResize(mouseEvent.pos())
            else:
                super().mouseMoveEvent(mouseEvent)
    
        def mouseReleaseEvent(self, mouseEvent):
            """ Выполняется, когда мышь is released from the item.
            """
    
            super().mouseReleaseEvent(mouseEvent)
            self.handleSelected = None
            self.mousePressPos = None
            self.mousePressRect = None
            self.update()
    
        def boundingRect(self):
            """ Возвращает ограничивающий прямоугольник фигуры
            (включая маркеры изменения размера).
            """
            o = self.handleSize + self.handleSpace
            return self.rect().adjusted(-o, -o, o, o)
    
        def updateHandlesPos(self):
            """ Обновите текущие маркеры изменения размера
            в соответствии с размером и положением фигуры.
            """
            s = self.handleSize
            b = self.boundingRect()
            self.handles[self.handleTopLeft] = QRectF(b.left(), b.top(), s, s)
            self.handles[self.handleTopMiddle] = QRectF(b.center().x() - s / 2, b.top(), s, s)
            self.handles[self.handleTopRight] = QRectF(b.right() - s, b.top(), s, s)
            self.handles[self.handleMiddleLeft] = QRectF(b.left(), b.center().y() - s / 2, s, s)
            self.handles[self.handleMiddleRight] = QRectF(b.right() - s, b.center().y() - s / 2, s, s)
            self.handles[self.handleBottomLeft] = QRectF(b.left(), b.bottom() - s, s, s)
            self.handles[self.handleBottomMiddle] = QRectF(b.center().x() - s / 2, b.bottom() - s, s, s)
            self.handles[self.handleBottomRight] = QRectF(b.right() - s, b.bottom() - s, s, s)
    
        def interactiveResize(self, mousePos):
            """ Выполните интерактивное изменение размера формы.
            """
            offset = self.handleSize + self.handleSpace
            boundingRect = self.boundingRect()
            rect = self.rect()
            diff = QPointF(0, 0)
    
            self.prepareGeometryChange()
    
            if self.handleSelected == self.handleTopLeft:
                fromX = self.mousePressRect.left()
                fromY = self.mousePressRect.top()
                toX = fromX + mousePos.x() - self.mousePressPos.x()
                toY = fromY + mousePos.y() - self.mousePressPos.y()
                diff.setX(toX - fromX)
                diff.setY(toY - fromY)
                boundingRect.setLeft(toX)
                boundingRect.setTop(toY)
                rect.setLeft(boundingRect.left() + offset)
                rect.setTop(boundingRect.top() + offset)
                self.setRect(rect)
            elif self.handleSelected == self.handleTopMiddle:
                fromY = self.mousePressRect.top()
                toY = fromY + mousePos.y() - self.mousePressPos.y()
                diff.setY(toY - fromY)
                boundingRect.setTop(toY)
                rect.setTop(boundingRect.top() + offset)
                self.setRect(rect)
            elif self.handleSelected == self.handleTopRight:
                fromX = self.mousePressRect.right()
                fromY = self.mousePressRect.top()
                toX = fromX + mousePos.x() - self.mousePressPos.x()
                toY = fromY + mousePos.y() - self.mousePressPos.y()
                diff.setX(toX - fromX)
                diff.setY(toY - fromY)
                boundingRect.setRight(toX)
                boundingRect.setTop(toY)
                rect.setRight(boundingRect.right() - offset)
                rect.setTop(boundingRect.top() + offset)
                self.setRect(rect)
            elif self.handleSelected == self.handleMiddleLeft:
                fromX = self.mousePressRect.left()
                toX = fromX + mousePos.x() - self.mousePressPos.x()
                diff.setX(toX - fromX)
                boundingRect.setLeft(toX)
                rect.setLeft(boundingRect.left() + offset)
                self.setRect(rect)
            elif self.handleSelected == self.handleMiddleRight:
                fromX = self.mousePressRect.right()
                toX = fromX + mousePos.x() - self.mousePressPos.x()
                diff.setX(toX - fromX)
                boundingRect.setRight(toX)
                rect.setRight(boundingRect.right() - offset)
                self.setRect(rect)
            elif self.handleSelected == self.handleBottomLeft:
                fromX = self.mousePressRect.left()
                fromY = self.mousePressRect.bottom()
                toX = fromX + mousePos.x() - self.mousePressPos.x()
                toY = fromY + mousePos.y() - self.mousePressPos.y()
                diff.setX(toX - fromX)
                diff.setY(toY - fromY)
                boundingRect.setLeft(toX)
                boundingRect.setBottom(toY)
                rect.setLeft(boundingRect.left() + offset)
                rect.setBottom(boundingRect.bottom() - offset)
                self.setRect(rect)
            elif self.handleSelected == self.handleBottomMiddle:
                fromY = self.mousePressRect.bottom()
                toY = fromY + mousePos.y() - self.mousePressPos.y()
                diff.setY(toY - fromY)
                boundingRect.setBottom(toY)
                rect.setBottom(boundingRect.bottom() - offset)
                self.setRect(rect)
            elif self.handleSelected == self.handleBottomRight:
                fromX = self.mousePressRect.right()
                fromY = self.mousePressRect.bottom()
                toX = fromX + mousePos.x() - self.mousePressPos.x()
                toY = fromY + mousePos.y() - self.mousePressPos.y()
                diff.setX(toX - fromX)
                diff.setY(toY - fromY)
                boundingRect.setRight(toX)
                boundingRect.setBottom(toY)
                rect.setRight(boundingRect.right() - offset)
                rect.setBottom(boundingRect.bottom() - offset)
                self.setRect(rect)
    
            self.updateHandlesPos()
    
        def shape(self):
            """ Возвращает форму этого элемента в виде QPainterPath в локальных координатах.
            """
            path = QPainterPath()
            path.addRect(self.rect())
            if self.isSelected():
                for shape in self.handles.values():
                    path.addEllipse(shape)
            return path
    
        def paint(self, painter, option, widget=None):
            """ Нарисуйте узел в графическом представлении.
            """
            painter.setBrush(QBrush(QColor(255, 0, 0, 100)))
            painter.setPen(QPen(QColor(0, 0, 0), 1.0, Qt.SolidLine))
            painter.drawRect(self.rect())
            painter.setRenderHint(QPainter.Antialiasing)
            painter.setBrush(QBrush(QColor(255, 255, 0, 255)))  # маркеры
            painter.setPen(QPen(QColor(0, 0, 0, 255), 1.0, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
            for handle, rect in self.handles.items():
                if self.handleSelected is None or handle == self.handleSelected:
                    painter.drawEllipse(rect)
    
    
    if __name__ == '__main__':
        app = QApplication(sys.argv)
    
        grview = QGraphicsView()
        scene = QGraphicsScene(grview)
        scene.setSceneRect(0, 0, 680, 459)
        grview.setScene(scene)
    
        for _ in range(10):
            item = GraphicsRectItem(*random.sample(range(100), 4))
            scene.addItem(item)
    
    
        grview.show()
        sys.exit(app.exec_())

Все прямоугольники выделены, а должен быть выделен тот, на который мы нажали для масштабирования:

Answer 1

я не совсем понял ваш вопрос, но приведу пример о чем я подумал. Пожалуйста ВСЕГДА предоставляйте минимально-воспроизводимый пример!

from PyQt5 import QtWidgets, QtGui, QtCore


class GripItem(QtWidgets.QGraphicsPathItem):
    circle = QtGui.QPainterPath()
    circle.addEllipse(QtCore.QRectF(-5, -5, 10, 10))
    square = QtGui.QPainterPath()
    square.addRect(QtCore.QRectF(-10, -10, 20, 20))

    def __init__(self, annotation_item, index):
        super(GripItem, self).__init__()
        self.m_annotation_item = annotation_item
        self.m_index = index

        self.setPath(GripItem.circle)
        self.setBrush(QtGui.QColor("green"))
        self.setPen(QtGui.QPen(QtGui.QColor("green"), 2))
        self.setFlag(QtWidgets.QGraphicsItem.ItemIsSelectable, True)
        self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable, True)
        self.setFlag(QtWidgets.QGraphicsItem.ItemSendsGeometryChanges, True)
        self.setAcceptHoverEvents(True)
        self.setZValue(11)
        self.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))

    def hoverEnterEvent(self, event):
        self.setPath(GripItem.square)
        self.setBrush(QtGui.QColor("red"))
        super(GripItem, self).hoverEnterEvent(event)

    def hoverLeaveEvent(self, event):
        self.setPath(GripItem.circle)
        self.setBrush(QtGui.QColor("green"))
        super(GripItem, self).hoverLeaveEvent(event)

    def mouseReleaseEvent(self, event):
        self.setSelected(False)
        super(GripItem, self).mouseReleaseEvent(event)

    def itemChange(self, change, value):
        if change == QtWidgets.QGraphicsItem.ItemPositionChange and self.isEnabled():
            self.m_annotation_item.movePoint(self.m_index, value)
        return super(GripItem, self).itemChange(change, value)


class DirectionGripItem(GripItem):
    def __init__(self, annotation_item, direction=QtCore.Qt.Horizontal, parent=None):
        super(DirectionGripItem, self).__init__(annotation_item, parent)
        self._direction = direction

    @property
    def direction(self):
        return self._direction

    def itemChange(self, change, value):
        if change == QtWidgets.QGraphicsItem.ItemPositionChange and self.isEnabled():
            p = QtCore.QPointF(self.pos())
            if self.direction == QtCore.Qt.Horizontal:
                p.setX(value.x())
            elif self.direction == QtCore.Qt.Vertical:
                p.setY(value.y())
            self.m_annotation_item.movePoint(self.m_index, p)
            return p
        return super(DirectionGripItem, self).itemChange(change, value)


class CircleAnnotation(QtWidgets.QGraphicsEllipseItem):
    def __init__(self, radius=1, parent=None):
        super(CircleAnnotation, self).__init__(parent)
        self.setZValue(11)
        self.m_items = []

        self.setPen(QtGui.QPen(QtGui.QColor("green"), 4))

        self.setFlag(QtWidgets.QGraphicsItem.ItemIsSelectable, True)
        self.setFlag(QtWidgets.QGraphicsItem.ItemIsMovable, True)
        self.setFlag(QtWidgets.QGraphicsItem.ItemSendsGeometryChanges, True)

        self.setAcceptHoverEvents(True)

        self.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))

        self._radius = radius
        self.update_rect()

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, r):
        if r <= 0:
            raise ValueError("радиус должен быть положительным")
        self._radius = r
        self.update_rect()
        self.add_grip_items()
        self.update_items_positions()

    def update_rect(self):
        rect = QtCore.QRectF(0, 0, 2 * self.radius, 2 * self.radius)
        rect.moveCenter(self.rect().center())
        self.setRect(rect)

    def add_grip_items(self):
        if self.scene() and not self.m_items:
            for i, (direction) in enumerate(
                (
                    QtCore.Qt.Vertical,
                    QtCore.Qt.Horizontal,
                    QtCore.Qt.Vertical,
                    QtCore.Qt.Horizontal,
                )
            ):
                item = DirectionGripItem(self, direction, i)
                self.scene().addItem(item)
                self.m_items.append(item)

    def movePoint(self, i, p):
        if 0 <= i < min(4, len(self.m_items)):
            item_selected = self.m_items[i]
            lp = self.mapFromScene(p)
            self._radius = (lp - self.rect().center()).manhattanLength()
            k = self.indexOf(lp)
            if k is not None:
                self.m_items = [item for item in self.m_items if not item.isSelected()]
                self.m_items.insert(k, item_selected)
                self.update_items_positions([k])
                self.update_rect()

    def update_items_positions(self, index_no_updates=None):
        index_no_updates = index_no_updates or []
        for i, (item, direction) in enumerate(
            zip(
                self.m_items,
                (
                    QtCore.Qt.Vertical,
                    QtCore.Qt.Horizontal,
                    QtCore.Qt.Vertical,
                    QtCore.Qt.Horizontal,
                ),
            ),
        ):
            item.m_index = i
            if i not in index_no_updates:
                pos = self.mapToScene(self.point(i))
                item = self.m_items[i]
                item._direction = direction
                item.setEnabled(False)
                item.setPos(pos)
                item.setEnabled(True)

    def indexOf(self, p):
        for i in range(4):
            if p == self.point(i):
                return i

    def point(self, index):
        if 0 <= index < 4:
            return [
                QtCore.QPointF(0, -self.radius),
                QtCore.QPointF(self.radius, 0),
                QtCore.QPointF(0, self.radius),
                QtCore.QPointF(-self.radius, 0),
            ][index]

    def itemChange(self, change, value):
        if change == QtWidgets.QGraphicsItem.ItemPositionHasChanged:
            self.update_items_positions()
            return
        if change == QtWidgets.QGraphicsItem.ItemSceneHasChanged:
            self.add_grip_items()
            self.update_items_positions()
            return
        return super(CircleAnnotation, self).itemChange(change, value)

    def hoverEnterEvent(self, event):
        self.setBrush(QtGui.QColor(255, 0, 0, 100))
        super(CircleAnnotation, self).hoverEnterEvent(event)

    def hoverLeaveEvent(self, event):
        self.setBrush(QtGui.QBrush(QtCore.Qt.NoBrush))
        super(CircleAnnotation, self).hoverLeaveEvent(event)


if __name__ == "__main__":
    import sys

    app = QtWidgets.QApplication(sys.argv)

    scene = QtWidgets.QGraphicsScene()
    view = QtWidgets.QGraphicsView(scene)
    view.setRenderHints(QtGui.QPainter.Antialiasing)
    item = CircleAnnotation()
    item.radius = 100
    scene.addItem(item)
    view.showMaximized()

    sys.exit(app.exec_())

БЛОГ НА HUSL

Что нужно сделать, чтобы прямоугольная область фигуры, появлялась только после нажатия на фигуру?

Ответы (1 шт):