[图形系统交互重构与帧率控制优化]: 重构图形项交互逻辑，新增帧率限制器，提升系统性能和用户体验

-**新增帧率控制**: 实现FrameRateLimiter类，通过事件过滤器智能控制绘制帧率，避免过度渲染
-**统一交互状态管理**: 将MouseRegion重构为枚举类，明确区分无选择、锚点、边缘区域和整体形状状态
-**优化图形项事件处理**: 重构圆弧、圆形、线段、多边形等所有基本图形项的鼠标移动和悬停事件
-**改进边缘检测算法**: 为各图形项实现detectEdgeRegion方法，提供更精确的边缘悬停识别和光标反馈
-**增强预览功能**: 新增updateHoverPreview统一处理悬停时的图形预览显示
-**简化类型定义**: 移除冗余type()方法，直接在头文件中返回形状类型枚举
-**完善边界检查**: 在pointsChanged中增加场景矩形验证，防止图形项超出有效范围
-**提升绘制性能**: 移除临时图形对象，直接使用几何缓存绘制，减少内存分配
-**优化旋转矩形交互**: 实现角点拖动调整大小，改进旋转控制和边缘拉伸行为
-**重构工具函数**: 用isPointNearEdge替代boundingFromLine，提供更准确的点线距离计算
-**整理初始化流程**: 提取GraphicsView初始化代码到独立方法，提高可读性

Author: RealChuan

examples/graphics/CMakeLists.txt

@@ -15,6 +15,8 @@ set(PROJECT_SOURCES
     drawscene.hpp
     drawwidget.cpp
     drawwidget.h
+    frameratelimiter.cc
+    frameratelimiter.hpp
     icoconverterwidget.cc
     icoconverterwidget.hpp
     imagecaptureview.cc

examples/graphics/customlineitem.cc

@@ -19,7 +19,7 @@ void CustomLineItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
     setClickedPos(point);
 
     switch (mouseRegion()) {
-    case All: pts_tmp.translate(dp); break;
+    case MouseRegion::EntireShape: pts_tmp.translate(dp); break;
     default: return;
     }
     pointsChanged(pts_tmp);

examples/graphics/frameratelimiter.cc

@@ -0,0 +1,56 @@
+#include "frameratelimiter.hpp"
+
+#include <QDebug>
+#include <QElapsedTimer>
+#include <QEvent>
+#include <QWidget>
+
+class FrameRateLimiter::FrameRateLimiterPrivate
+{
+public:
+    explicit FrameRateLimiterPrivate(FrameRateLimiter *q)
+        : q_ptr(q)
+    {}
+
+    FrameRateLimiter *q_ptr;
+
+    qint64 targetFrameTime = 1000 / 60; // 毫秒
+    QElapsedTimer frameTimer;
+};
+
+FrameRateLimiter::FrameRateLimiter(QObject *parent)
+    : QObject{parent}
+    , d_ptr(new FrameRateLimiterPrivate(this))
+{}
+
+FrameRateLimiter::~FrameRateLimiter() {}
+
+void FrameRateLimiter::setTargetFPS(int fps)
+{
+    d_ptr->targetFrameTime = 1000 / qMax(1, fps);
+}
+
+bool FrameRateLimiter::eventFilter(QObject *watched, QEvent *event)
+{
+    qDebug() << "FrameRateLimiter::eventFilter:" << event->type();
+    switch (event->type()) {
+    case QEvent::Paint:
+        if (!d_ptr->frameTimer.isValid()) {
+            d_ptr->frameTimer.start();
+        } else if (!d_ptr->frameTimer.hasExpired(d_ptr->targetFrameTime)) {
+            qDebug() << "Has not expired";
+            auto *widget = qobject_cast<QWidget *>(watched);
+            if (widget) {
+                QMetaObject::invokeMethod(
+                    widget, [widget] { widget->update(); }, Qt::QueuedConnection);
+            }
+            return true;
+        } else {
+            d_ptr->frameTimer.restart();
+        }
+        break;
+    default: break;
+    }
+
+    return QObject::eventFilter(watched, event);
+}

examples/graphics/frameratelimiter.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <QObject>
+
+class FrameRateLimiter : public QObject
+{
+    Q_OBJECT
+public:
+    explicit FrameRateLimiter(QObject *parent = nullptr);
+    ~FrameRateLimiter() override;
+
+    void setTargetFPS(int fps);
+
+protected:
+    bool eventFilter(QObject *watched, QEvent *event) override;
+
+private:
+    class FrameRateLimiterPrivate;
+    QScopedPointer<FrameRateLimiterPrivate> d_ptr;
+};

examples/graphics/graphics.pro

@@ -26,6 +26,7 @@ SOURCES += \
     customlineitem.cc \
     drawscene.cc \
     drawwidget.cpp \
+    frameratelimiter.cc \
     icoconverterwidget.cc \
     imagecaptureview.cc \
     imageviewer.cpp \
@@ -53,6 +54,7 @@ HEADERS += \
     customlineitem.hpp \
     drawscene.hpp \
     drawwidget.h \
+    frameratelimiter.hpp \
     icoconverterwidget.hpp \
     imagecaptureview.hpp \
     imageviewer.h \

src/graphics/graphicsarcitem.cpp

@@ -77,6 +77,14 @@ auto Arc::controlPoints() const -> QPolygonF
 class GraphicsArcItem::GraphicsArcItemPrivate
 {
 public:
+    enum class MouseEdgeRegion : int {
+        NoSelection,
+        InnerEdge,
+        OuterEdge,
+        StartAngleSide,
+        EndAngleSide
+    };
+
     explicit GraphicsArcItemPrivate(GraphicsArcItem *q)
         : q_ptr(q)
     {}
@@ -86,7 +94,7 @@ class GraphicsArcItem::GraphicsArcItemPrivate
     Arc arch;
     QPainterPath arcPath;
     QPainterPath cachePath;
-    GraphicsArcItem::MouseRegion mouseRegion = GraphicsArcItem::None;
+    MouseEdgeRegion mouseRegion = MouseEdgeRegion::NoSelection;
 };
 
 GraphicsArcItem::GraphicsArcItem(QGraphicsItem *parent)
@@ -136,11 +144,6 @@ auto GraphicsArcItem::arch() const -> Arc
     return d_ptr->arch;
 }
 
-auto GraphicsArcItem::type() const -> int
-{
-    return GraphicsBasicItem::Shape::ARC;
-}
-
 inline auto lineSetLength(const QPointF p1, const QPointF p2, const double len) -> QPointF
 {
     QLineF line(p1, p2);
@@ -150,41 +153,41 @@ inline auto lineSetLength(const QPointF p1, const QPointF p2, const double len)
 
 void GraphicsArcItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 {
-    if (!isValid()) {
+    if ((event->buttons() & Qt::LeftButton) == 0 || !isValid()) {
         return;
     }
     if (!isSelected()) {
         setSelected(true);
     }
+    auto scenePos = event->scenePos();
+    auto dp = scenePos - clickedPos();
+    setClickedPos(scenePos);
 
-    QPointF point = event->scenePos();
-    QPointF dp = point - clickedPos();
-    setClickedPos(event->scenePos());
-    auto pts_tmp = geometryCache()->controlPoints();
-    double distance = Utils::distance(d_ptr->arch.center, point);
+    auto controlPoints = geometryCache()->controlPoints();
+    double distance = Utils::distance(d_ptr->arch.center, scenePos);
 
     switch (mouseRegion()) {
-    case GraphicsBasicItem::MouseRegion::All: pts_tmp.translate(dp); break;
-    case GraphicsBasicItem::MouseRegion::None: {
+    case GraphicsBasicItem::MouseRegion::EntireShape: controlPoints.translate(dp); break;
+    case GraphicsBasicItem::MouseRegion::EdgeArea: {
         switch (d_ptr->mouseRegion) {
-        case InEdge0:
-            setMyCursor(d_ptr->arch.center, event->scenePos());
+        case GraphicsArcItemPrivate::MouseEdgeRegion::InnerEdge:
+            setMyCursor(d_ptr->arch.center, scenePos);
             for (int i = 0; i < 3; ++i) {
-                pts_tmp[i] = lineSetLength(d_ptr->arch.center, pts_tmp[i], distance);
+                controlPoints[i] = lineSetLength(d_ptr->arch.center, controlPoints[i], distance);
             }
             break;
-        case InEdge1:
-            setMyCursor(d_ptr->arch.center, event->scenePos());
-            pts_tmp[3] = lineSetLength(d_ptr->arch.center, pts_tmp[3], distance);
+        case GraphicsArcItemPrivate::MouseEdgeRegion::OuterEdge:
+            setMyCursor(d_ptr->arch.center, scenePos);
+            controlPoints[3] = lineSetLength(d_ptr->arch.center, controlPoints[3], distance);
             break;
-        case InEdgeH:
-        case InEdgeL: {
+        case GraphicsArcItemPrivate::MouseEdgeRegion::EndAngleSide:
+        case GraphicsArcItemPrivate::MouseEdgeRegion::StartAngleSide: {
             Arc arch = d_ptr->arch;
-            if (d_ptr->mouseRegion == InEdgeL) {
-                arch.startAngle = QLineF(arch.center, event->scenePos()).angle();
+            if (d_ptr->mouseRegion == GraphicsArcItemPrivate::MouseEdgeRegion::StartAngleSide) {
+                arch.startAngle = QLineF(arch.center, scenePos).angle();
                 setCursor(Utils::cursorForDirection(arch.startAngle));
             } else {
-                arch.endAngle = QLineF(arch.center, event->scenePos()).angle();
+                arch.endAngle = QLineF(arch.center, scenePos).angle();
                 setCursor(Utils::cursorForDirection(arch.endAngle));
             }
             while (arch.startAngle > arch.endAngle) {
@@ -193,63 +196,17 @@ void GraphicsArcItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
             if (arch.endAngle - arch.startAngle > 360) {
                 arch.endAngle -= 360;
             }
-            pts_tmp = arch.controlPoints();
+            controlPoints = arch.controlPoints();
         } break;
         default: return;
         }
         break;
     }
-    case GraphicsBasicItem::MouseRegion::DotRegion: pts_tmp[hoveredDotIndex()] += dp; break;
+    case GraphicsBasicItem::MouseRegion::AnchorPoint: controlPoints[hoveredDotIndex()] += dp; break;
     default: return;
     }
 
-    pointsChanged(pts_tmp);
-}
-
-void GraphicsArcItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
-{
-    auto pts_tmp = geometryCache()->controlPoints();
-    QPointF point = event->scenePos();
-    if (pts_tmp.size() == 2 || pts_tmp.size() == 3) {
-        pts_tmp.append(point);
-        showHoverArc(pts_tmp);
-    }
-    if (!isValid()) {
-        return;
-    }
-    GraphicsBasicItem::hoverMoveEvent(event);
-    if (mouseRegion() == GraphicsBasicItem::MouseRegion::DotRegion) {
-        return;
-    }
-    setMouseRegion(GraphicsBasicItem::MouseRegion::None);
-
-    QPointF p1 = Utils::pointFromCenter(d_ptr->arch.center,
-                                        d_ptr->arch.maxRadius,
-                                        d_ptr->arch.startAngle);
-    QPointF p2 = Utils::pointFromCenter(d_ptr->arch.center,
-                                        d_ptr->arch.maxRadius,
-                                        d_ptr->arch.endAngle);
-    QLineF line1(p1, pts_tmp.at(0));
-    QLineF line2(p2, pts_tmp.at(1));
-    if (qAbs(Utils::distance(point, d_ptr->arch.center) - d_ptr->arch.minRadius) < margin() / 3) {
-        d_ptr->mouseRegion = InEdge0;
-        setMyCursor(d_ptr->arch.center, point);
-    } else if (qAbs(Utils::distance(point, d_ptr->arch.center) - d_ptr->arch.maxRadius)
-               < margin() / 3) {
-        d_ptr->mouseRegion = InEdge1;
-        setMyCursor(d_ptr->arch.center, point);
-    } else if (Utils::boundingFromLine(line1, margin() / 4).containsPoint(point, Qt::OddEvenFill)) {
-        d_ptr->mouseRegion = InEdgeL;
-        setCursor(Utils::cursorForDirection(line1.angle()));
-    } else if (Utils::boundingFromLine(line2, margin() / 4).containsPoint(point, Qt::OddEvenFill)) {
-        d_ptr->mouseRegion = InEdgeH;
-        setCursor(Utils::cursorForDirection(line2.angle()));
-    } else if (d_ptr->arcPath.contains(point)) {
-        setMouseRegion(GraphicsBasicItem::MouseRegion::All);
-        setCursor(Qt::SizeAllCursor);
-    } else {
-        unsetCursor();
-    }
+    pointsChanged(controlPoints);
 }
 
 void GraphicsArcItem::drawContent(QPainter *painter)
@@ -259,18 +216,15 @@ void GraphicsArcItem::drawContent(QPainter *painter)
 
 void GraphicsArcItem::pointsChanged(const QPolygonF &ply)
 {
-    auto rect = scene()->sceneRect();
-    if (!rect.contains(ply.last())) {
-        return;
-    }
-
     if (ply.size() == 3) {
         double deltaAngle = QLineF(ply[0], ply[1]).angleTo(QLineF(ply[0], ply[2]));
         if (deltaAngle < 0.00001 || deltaAngle > 355.99999) {
             return;
         }
     }
 
+    auto sceneRect = scene()->sceneRect();
+
     switch (ply.size()) {
     case 1:
     case 2: geometryCache()->setControlPoints(ply); break;
@@ -279,7 +233,7 @@ void GraphicsArcItem::pointsChanged(const QPolygonF &ply)
             return;
         }
         QPolygonF polygon = d_ptr->cachePath.toFillPolygon() + ply;
-        if (!rect.contains(polygon.boundingRect())) {
+        if (!sceneRect.contains(polygon.boundingRect())) {
             return;
         }
         geometryCache()->setControlPoints(ply);
@@ -295,21 +249,83 @@ void GraphicsArcItem::pointsChanged(const QPolygonF &ply)
     update();
 }
 
-void GraphicsArcItem::showHoverArc(const QPolygonF &ply)
+void GraphicsArcItem::updateHoverPreview(const QPointF &scenePos)
 {
-    switch (ply.size()) {
+    auto controlPoints = geometryCache()->controlPoints();
+    auto size = controlPoints.size();
+    if (size < 2 || size > 3) {
+        return;
+    }
+
+    controlPoints.append(scenePos);
+    size = controlPoints.size();
+
+    switch (size) {
     case 3:
         // QPainterPath::arcTo: Adding point with invalid coordinates, ignoring call
-        if (Utils::distance(ply[1], ply[2]) < margin()) {
+        if (Utils::distance(controlPoints[1], controlPoints[2]) < margin()) {
             return;
         }
-        Utils::calculateHalfArc(ply, d_ptr->cachePath);
+        Utils::calculateHalfArc(controlPoints, d_ptr->cachePath);
         break;
-    case 4: Utils::calculateAllArc(ply, d_ptr->cachePath, margin()); break;
+    case 4: Utils::calculateAllArc(controlPoints, d_ptr->cachePath, margin()); break;
     default: return;
     }
 
     update();
 }
 
+GraphicsBasicItem::MouseRegion GraphicsArcItem::detectEdgeRegion(const QPointF &scenePos)
+{
+    const double edgeMargin = margin() / 2.0;
+    const Arc &arc = d_ptr->arch;
+
+    // 计算点到圆心的距离
+    const double distanceToCenter = Utils::distance(scenePos, arc.center);
+
+    // 分别检查内外圆弧边缘 - 更清晰的逻辑
+    if (qAbs(distanceToCenter - arc.minRadius) < edgeMargin) {
+        d_ptr->mouseRegion = GraphicsArcItemPrivate::MouseEdgeRegion::InnerEdge;
+        setMyCursor(arc.center, scenePos);
+        setMouseRegion(GraphicsBasicItem::MouseRegion::EdgeArea);
+        return GraphicsBasicItem::MouseRegion::EdgeArea;
+    }
+
+    if (qAbs(distanceToCenter - arc.maxRadius) < edgeMargin) {
+        d_ptr->mouseRegion = GraphicsArcItemPrivate::MouseEdgeRegion::OuterEdge;
+        setMyCursor(arc.center, scenePos);
+        setMouseRegion(GraphicsBasicItem::MouseRegion::EdgeArea);
+        return GraphicsBasicItem::MouseRegion::EdgeArea;
+    }
+
+    // 计算侧边端点
+    const QPointF innerStart = Utils::pointFromCenter(arc.center, arc.minRadius, arc.startAngle);
+    const QPointF outerStart = Utils::pointFromCenter(arc.center, arc.maxRadius, arc.startAngle);
+
+    // 分别检查两个侧边
+    const QLineF startEdge(innerStart, outerStart);
+    if (Utils::isPointNearEdge(scenePos, startEdge, edgeMargin)) {
+        d_ptr->mouseRegion = GraphicsArcItemPrivate::MouseEdgeRegion::StartAngleSide;
+        setCursor(Utils::cursorForDirection(startEdge.angle()));
+        setMouseRegion(GraphicsBasicItem::MouseRegion::EdgeArea);
+        return GraphicsBasicItem::MouseRegion::EdgeArea;
+    }
+
+    const QPointF innerEnd = Utils::pointFromCenter(arc.center, arc.minRadius, arc.endAngle);
+    const QPointF outerEnd = Utils::pointFromCenter(arc.center, arc.maxRadius, arc.endAngle);
+
+    const QLineF endEdge(innerEnd, outerEnd);
+    if (Utils::isPointNearEdge(scenePos, endEdge, edgeMargin)) {
+        d_ptr->mouseRegion = GraphicsArcItemPrivate::MouseEdgeRegion::EndAngleSide;
+        setCursor(Utils::cursorForDirection(endEdge.angle()));
+        setMouseRegion(GraphicsBasicItem::MouseRegion::EdgeArea);
+        return GraphicsBasicItem::MouseRegion::EdgeArea;
+    }
+
+    // 不在任何区域
+    d_ptr->mouseRegion = GraphicsArcItemPrivate::MouseEdgeRegion::NoSelection;
+    setMouseRegion(GraphicsBasicItem::MouseRegion::NoSelection);
+    return GraphicsBasicItem::MouseRegion::NoSelection;
+}
+
 } // namespace Graphics