[图形框架优化]: 添加帧率限制器并重构图形项交互逻辑

-**新增帧率限制器**: 添加FrameRateLimiter类，通过事件过滤器控制绘制频率，支持设置目标FPS
-**重构图形项基类**: 统一hover预览和边缘检测逻辑，新增updateHoverPreview和detectEdgeRegion虚函数
-**优化圆弧项交互**: 移除临时路径计算，改进边缘区域检测和光标反馈
-**改进圆形项**: 简化悬停预览逻辑，增强边缘区域识别精度
-**重构线形项**: 整合预览绘制逻辑，移除临时线条存储
-**优化多边形项**: 统一预览绘制机制，改进边界检查
-**完善圆环项**: 重构边缘检测逻辑，提升交互体验
-**改进旋转矩形**: 重构角点移动逻辑，增强旋转控制线交互
-**优化圆角矩形**: 简化预览绘制，改进边缘检测算法
-**增强工具函数**: 添加isPointNearEdge函数，支持精确的边缘距离检测
-**调整视图初始化**: 提取initializeView方法，统一视图设置逻辑

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/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

@@ -165,7 +165,7 @@ void GraphicsArcItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 
     switch (mouseRegion()) {
     case GraphicsBasicItem::MouseRegion::All: pts_tmp.translate(dp); break;
-    case GraphicsBasicItem::MouseRegion::None: {
+    case GraphicsBasicItem::MouseRegion::Edge: {
         switch (d_ptr->mouseRegion) {
         case InEdge0:
             setMyCursor(d_ptr->arch.center, event->scenePos());
@@ -206,71 +206,22 @@ void GraphicsArcItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
     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();
-    }
-}
-
 void GraphicsArcItem::drawContent(QPainter *painter)
 {
     painter->drawPath(isValid() ? d_ptr->arcPath : d_ptr->cachePath);
 }
 
 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 +230,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 +246,69 @@ 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 marginValue = margin() / 2.0;
+    auto controlPoints = geometryCache()->controlPoints();
+    auto p1 = Utils::pointFromCenter(d_ptr->arch.center,
+                                     d_ptr->arch.maxRadius,
+                                     d_ptr->arch.startAngle);
+    auto p2 = Utils::pointFromCenter(d_ptr->arch.center,
+                                     d_ptr->arch.maxRadius,
+                                     d_ptr->arch.endAngle);
+    QLineF line1(p1, controlPoints[0]);
+    QLineF line2(p2, controlPoints[1]);
+
+    if (qAbs(Utils::distance(scenePos, d_ptr->arch.center) - d_ptr->arch.minRadius) < marginValue) {
+        d_ptr->mouseRegion = InEdge0;
+        setMyCursor(d_ptr->arch.center, scenePos);
+    } else if (qAbs(Utils::distance(scenePos, d_ptr->arch.center) - d_ptr->arch.maxRadius)
+               < marginValue) {
+        d_ptr->mouseRegion = InEdge1;
+        setMyCursor(d_ptr->arch.center, scenePos);
+    } else if (Utils::isPointNearEdge(scenePos, line1, marginValue)) {
+        d_ptr->mouseRegion = InEdgeL;
+        setCursor(Utils::cursorForDirection(line1.angle()));
+    } else if (Utils::isPointNearEdge(scenePos, line2, marginValue)) {
+        d_ptr->mouseRegion = InEdgeH;
+        setCursor(Utils::cursorForDirection(line2.angle()));
+    } else if (d_ptr->arcPath.contains(scenePos)) {
+        setMouseRegion(GraphicsBasicItem::MouseRegion::All);
+        setCursor(Qt::SizeAllCursor);
+    } else {
+        d_ptr->mouseRegion = None;
+        setMouseRegion(GraphicsBasicItem::MouseRegion::None);
+        return GraphicsBasicItem::MouseRegion::None;
+    }
+
+    setMouseRegion(GraphicsBasicItem::MouseRegion::Edge);
+    return GraphicsBasicItem::MouseRegion::Edge;
+}
+
 } // namespace Graphics

src/graphics/graphicsarcitem.h

@@ -32,14 +32,13 @@ class GRAPHICS_EXPORT GraphicsArcItem : public GraphicsBasicItem
 
 protected:
     void mouseMoveEvent(QGraphicsSceneMouseEvent *event) override;
-    void hoverMoveEvent(QGraphicsSceneHoverEvent *event) override;
 
     void drawContent(QPainter *painter) override;
     void pointsChanged(const QPolygonF &ply) override;
+    void updateHoverPreview(const QPointF &scenePos) override;
+    GraphicsBasicItem::MouseRegion detectEdgeRegion(const QPointF &scenePos) override;
 
 private:
-    void showHoverArc(const QPolygonF &ply);
-
     class GraphicsArcItemPrivate;
     QScopedPointer<GraphicsArcItemPrivate> d_ptr;
 };

src/graphics/graphicsbasicitem.cpp

@@ -120,23 +120,6 @@ bool GraphicsBasicItem::showBoundingRect() const
     return d_ptr->showBoundingRect;
 }
 
-//QVariant BasicGraphicsItem::itemChange(QGraphicsItem::GraphicsItemChange change,
-//                                       const QVariant &value)
-//{
-//    if (change == ItemPositionChange && scene()) {
-//        // value is the new position.
-//        QPointF newPos = value.toPointF();
-//        QRectF rect = scene()->sceneRect();
-//        if (!rect.contains(newPos)) {
-//            // Keep the item inside the scene rect.
-//            newPos.setX(qMin(rect.right(), qMax(newPos.x(), rect.left())));
-//            newPos.setY(qMin(rect.bottom(), qMax(newPos.y(), rect.top())));
-//            return newPos;
-//        }
-//    }
-//    return QGraphicsItem::itemChange(change, value);
-//}
-
 void GraphicsBasicItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
     if (event->button() != Qt::LeftButton) {
@@ -146,21 +129,33 @@ void GraphicsBasicItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
     if (isValid()) {
         return;
     }
-    auto pts_tmp = d_ptr->geometryCachePtr->controlPoints();
-    pts_tmp.append(event->pos());
-    pointsChanged(pts_tmp);
+
+    auto pos = event->pos();
+    if (!scene()->sceneRect().contains(pos)) {
+        return;
+    }
+
+    auto controlPoints = d_ptr->geometryCachePtr->controlPoints();
+    controlPoints.append(pos);
+    pointsChanged(controlPoints);
 }
 
 void GraphicsBasicItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
 {
     QAbstractGraphicsShapeItem::hoverMoveEvent(event);
+
+    auto scenePos = event->scenePos();
+    if (!scene()->sceneRect().contains(scenePos)) {
+        return;
+    }
+
     if (!isValid()) {
+        updateHoverPreview(scenePos);
         return;
     }
 
     d_ptr->mouseRegin = MouseRegion::None;
     d_ptr->hoveredDotIndex = -1;
-    const auto scenePos = event->scenePos();
     const auto &anchorPoints = d_ptr->geometryCachePtr->controlPoints();
     const qreal halfMargin = d_ptr->margin * 0.5;
     const QPointF marginOffset(halfMargin, halfMargin);
@@ -177,6 +172,10 @@ void GraphicsBasicItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
         }
     }
 
+    if (detectEdgeRegion(scenePos) == MouseRegion::Edge) {
+        return;
+    }
+
     if (shape().contains(scenePos)) {
         d_ptr->mouseRegin = MouseRegion::All;
         setCursor(Qt::SizeAllCursor);
@@ -284,4 +283,15 @@ void GraphicsBasicItem::setMyCursor(const QPointF &center, const QPointF &pos)
     setCursor(Utils::cursorForDirection(angle - 90));
 }
 
+void GraphicsBasicItem::updateHoverPreview(const QPointF &scenePos)
+{
+    Q_UNUSED(scenePos);
+}
+
+GraphicsBasicItem::MouseRegion GraphicsBasicItem::detectEdgeRegion(const QPointF &scenePos)
+{
+    Q_UNUSED(scenePos);
+    return MouseRegion::None;
+}
+
 } // namespace Graphics

src/graphics/graphicsbasicitem.h

@@ -42,7 +42,6 @@ class GRAPHICS_EXPORT GraphicsBasicItem : public QObject, public QAbstractGraphi
     bool showBoundingRect() const;
 
 protected:
-    //QVariant itemChange(GraphicsItemChange change, const QVariant &value) override;
     void mousePressEvent(QGraphicsSceneMouseEvent *event) override;
     void hoverMoveEvent(QGraphicsSceneHoverEvent *event) override;
     void hoverLeaveEvent(QGraphicsSceneHoverEvent *event) override;
@@ -69,6 +68,8 @@ class GRAPHICS_EXPORT GraphicsBasicItem : public QObject, public QAbstractGraphi
     void drawShape(QPainter *painter);
 
     virtual void pointsChanged(const QPolygonF &ply) = 0;
+    virtual void updateHoverPreview(const QPointF &scenePos);
+    virtual MouseRegion detectEdgeRegion(const QPointF &scenePos);
 
 private:
     class GraphicsBasicItemPrivate;