From b5db01588a3572dc16de0d8ceb85da67f82b871a Mon Sep 17 00:00:00 2001 From: RCi <15089880081@163.com> Date: Mon, 3 Jun 2024 03:20:35 +0800 Subject: [PATCH] =?UTF-8?q?=E5=AE=8C=E5=96=84rpy=E8=AE=A1=E7=AE=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../HandleAiUi-new/algo/ALGO_Correction.h | 408 ++++++++++++++++++ .../HandleAiUi-new/back/triggerManager.cpp | 2 +- HanddleAI/HandleAiUi-new/globalStruct.h | 8 +- HanddleAI/HandleAiUi-new/mainwindow.cpp | 4 +- HanddleAI/HandleAiUi-new/mainwindow.h | 63 ++- 5 files changed, 471 insertions(+), 14 deletions(-) diff --git a/HanddleAI/HandleAiUi-new/algo/ALGO_Correction.h b/HanddleAI/HandleAiUi-new/algo/ALGO_Correction.h index ea42aae0..dc11c1f0 100644 --- a/HanddleAI/HandleAiUi-new/algo/ALGO_Correction.h +++ b/HanddleAI/HandleAiUi-new/algo/ALGO_Correction.h @@ -1,7 +1,415 @@ #include #include +#include +struct Points +{ + double OriginX, OriginY, OriginZ; + double xX, xY, xZ; + double yX, yY, yZ; + double zX, zY, zZ; +}; +struct CorrectionPoints +{ + std::vector Origin;//X Y Z + std::vector Result_X;//X Y Z + std::vector Result_Y;//X Y Z + std::vector Result_Z;//X Y Z + + double AngleZX = -1; + double AngleYZ = -1; + double AngleXY = -1; + + double ofx1, ofx2, ofx3; + double ofy1, ofy2, ofy3; + double ofz1, ofz2, ofz3; +}; +using namespace cv; +void calculateRotationMatrix(const Points& points, double rotationMatrix[3][3]) { + rotationMatrix[0][0] = points.xX; + rotationMatrix[0][1] = points.yX; + rotationMatrix[0][2] = points.zX; + rotationMatrix[1][0] = points.xY; + rotationMatrix[1][1] = points.yY; + rotationMatrix[1][2] = points.zY; + rotationMatrix[2][0] = points.xZ; + rotationMatrix[2][1] = points.yZ; + rotationMatrix[2][2] = points.zZ; +} + +// 从旋转矩阵中提取RPY值 +void extractRPY(const double rotationMatrix[3][3], double& roll, double& pitch, double& yaw) { + // 计算pitch + pitch = atan2(-rotationMatrix[2][0], sqrt(rotationMatrix[2][1] * rotationMatrix[2][1] + rotationMatrix[2][2] * rotationMatrix[2][2])) * (180.0 / M_PI); + + // 计算yaw + yaw = atan2(rotationMatrix[1][0], rotationMatrix[0][0]) * (180.0 / M_PI); + + // 计算roll + roll = atan2(rotationMatrix[2][1], rotationMatrix[2][2]) * (180.0 / M_PI); + + +} +// 计算旋转角度 +Point3d calculateRotationAngles(const Points& point1, const Points& point2) +{ + // 构建两个旋转矩阵 + cv::Mat R1 = (cv::Mat_(3, 3) << + point1.xX, point1.yX, point1.zX, + point1.xY, point1.yY, point1.zY, + point1.xZ, point1.yZ, point1.zZ); + + cv::Mat R2 = (cv::Mat_(3, 3) << + point2.xX, point2.yX, point2.zX, + point2.xY, point2.yY, point2.zY, + point2.xZ, point2.yZ, point2.zZ); + + // 计算从旋转矩阵R1到R2的旋转矩阵 + cv::Mat rotation = R2 * R1.t(); // 转置矩阵R1 + + // 使用OpenCV的Rodrigues函数将旋转矩阵转换为旋转向量 + cv::Mat rvec; + cv::Rodrigues(rotation, rvec); + + // 将旋转向量转换为欧拉角 + cv::Mat euler; + cv::Mat_ euler_angles(3, 1); + cv::Rodrigues(rvec, euler); + euler_angles = euler * (180.0 / CV_PI); // 转换为度数 + + return Point3d(euler_angles.at(0), euler_angles.at(1), euler_angles.at(2)); +} +std::vector getoffsetPos(CorrectionPoints& originPoints, CorrectionPoints& newPoints) +{ + //CorrectionPoints returnPoints; + //returnPoints.Origin.push_back(originPoints.Origin[0] - newPoints.Origin[0]); + //returnPoints.Origin.push_back(originPoints.Origin[1] - newPoints.Origin[1]); + //returnPoints.Origin.push_back(originPoints.Origin[2] - newPoints.Origin[2]); + + //returnPoints.Result_X.push_back(originPoints.Result_X[0] - newPoints.Result_X[0]); + //returnPoints.Result_X.push_back(originPoints.Result_X[1] - newPoints.Result_X[1]); + //returnPoints.Result_X.push_back(originPoints.Result_X[2] - newPoints.Result_X[2]); + + //returnPoints.Result_Y.push_back(originPoints.Result_Y[0] - newPoints.Result_Y[0]); + //returnPoints.Result_Y.push_back(originPoints.Result_Y[1] - newPoints.Result_Y[1]); + //returnPoints.Result_Y.push_back(originPoints.Result_Y[2] - newPoints.Result_Y[2]); + + //returnPoints.Result_Z.push_back(originPoints.Result_Z[0] - newPoints.Result_Z[0]); + //returnPoints.Result_Z.push_back(originPoints.Result_Z[1] - newPoints.Result_Z[1]); + //returnPoints.Result_Z.push_back(originPoints.Result_Z[2] - newPoints.Result_Z[2]); + + //returnPoints.AngleZX = originPoints.AngleZX - newPoints.AngleZX; + //returnPoints.AngleYZ = originPoints.AngleYZ - newPoints.AngleYZ; + //returnPoints.AngleXY = originPoints.AngleXY - newPoints.AngleXY; + + //// 第一次校准的数据 + cv::Point3d origin1(0.0, 0.0, 0.0); // 原点坐标 + cv::Point3d dir1_1(originPoints.ofx1, originPoints.ofx2, originPoints.ofx3); // 第一个方向的点 + cv::Point3d dir1_2(originPoints.ofy1, originPoints.ofy2, originPoints.ofy3); // 第二个方向的点 + cv::Point3d dir1_3(originPoints.ofz1, originPoints.ofz2, originPoints.ofz3); // 第三个方向的点 + + // 第二次校准的数据 + cv::Point3d origin2(0.0, 0.0, 0.0); // 新的原点坐标 + cv::Point3d dir2_1(newPoints.ofx1, newPoints.ofx2, newPoints.ofx3); // 第一个方向的点 + cv::Point3d dir2_2(newPoints.ofy1, newPoints.ofy2, newPoints.ofy3); // 第二个方向的点 + cv::Point3d dir2_3(newPoints.ofz1, newPoints.ofz2, newPoints.ofz3); // 第三个方向的点 + // 创建矩阵来保存方向向量 + cv::Mat R1 = (cv::Mat_(3, 3) << dir1_1.x, dir1_2.x, dir1_3.x, + dir1_1.y, dir1_2.y, dir1_3.y, + dir1_1.z, dir1_2.z, dir1_3.z); + + cv::Mat R2 = (cv::Mat_(3, 3) << dir2_1.x, dir2_2.x, dir2_3.x, + dir2_1.y, dir2_2.y, dir2_3.y, + dir2_1.z, dir2_2.z, dir2_3.z); + + // 计算旋转矩阵 + cv::Mat R = R2 * R1.inv(); + + // 计算平移向量 + cv::Mat T = (cv::Mat_(3, 1) << origin2.x - origin1.x, origin2.y - origin1.y, origin2.z - origin1.z); + + // 构建4x4变换矩阵 + cv::Mat transformationMatrix = cv::Mat::eye(4, 4, CV_64F); + R.copyTo(transformationMatrix(cv::Rect(0, 0, 3, 3))); + T.copyTo(transformationMatrix(cv::Rect(3, 0, 1, 3))); + std::vector basePoints = { cv::Point3d(0, 0, 0), + cv::Point3d(100, 0, 0), + cv::Point3d(0, 100, 0), + cv::Point3d(0, 0, 100) }; + + std::vector transformedPoints; + for (const auto& point : basePoints) { + cv::Mat pointMat = (cv::Mat_(4, 1) << point.x, point.y, point.z, 1.0); + cv::Mat transformedPointMat = transformationMatrix * pointMat; + cv::Point3d transformedPoint; + transformedPoint.x = transformedPointMat.at(0, 0) / transformedPointMat.at(3, 0); + transformedPoint.y = transformedPointMat.at(1, 0) / transformedPointMat.at(3, 0); + transformedPoint.z = transformedPointMat.at(2, 0) / transformedPointMat.at(3, 0); + + + transformedPoints.push_back(transformedPoint); + } + + return transformedPoints; +} + +bool HalconCorrection(correctionStruct* correctionData, CorrectionPoints& result) +{ +#pragma region XOY_DEFINE + HTuple hv_in_X_X0Y; + for (auto rangeData : correctionData->in_X_X0Y) + hv_in_X_X0Y.Append(rangeData); + + HTuple hv_in_Y_X0Y; + for (auto rangeData : correctionData->in_Y_X0Y) + hv_in_Y_X0Y.Append(rangeData); + + HTuple hv_in_Z_X0Y; + for (auto rangeData : correctionData->in_Z_X0Y) + hv_in_Z_X0Y.Append(rangeData); + + HTuple hv_in_Z_X0Y_Value; + for (auto rangeData : correctionData->in_Z_X0Y_Value) + hv_in_Z_X0Y_Value.Append(rangeData); +#pragma endregion + +#pragma region XOZ_DEFINE + HTuple hv_in_X_X0Z; + for (auto rangeData : correctionData->in_X_X0Z) + hv_in_X_X0Z.Append(rangeData); + + HTuple hv_in_Y_X0Z; + for (auto rangeData : correctionData->in_Y_X0Z) + hv_in_Y_X0Z.Append(rangeData); + + HTuple hv_in_Z_X0Z; + for (auto rangeData : correctionData->in_Z_X0Z) + hv_in_Z_X0Z.Append(rangeData); + + HTuple hv_in_Y_X0Z_Value; + for (auto rangeData : correctionData->in_Y_X0Z_Value) + hv_in_Y_X0Z_Value.Append(rangeData); +#pragma endregion + +#pragma region YOZ_DEFINE + HTuple hv_in_X_Y0Z; + for (auto rangeData : correctionData->in_X_Y0Z) + hv_in_X_Y0Z.Append(rangeData); + + HTuple hv_in_Y_Y0Z; + for (auto rangeData : correctionData->in_Y_Y0Z) + hv_in_Y_Y0Z.Append(rangeData); + + HTuple hv_in_Z_Y0Z; + for (auto rangeData : correctionData->in_Z_Y0Z) + hv_in_Z_Y0Z.Append(rangeData); + + HTuple hv_in_X_Y0Z_Value; + for (auto rangeData : correctionData->in_X_Y0Z_Value) + hv_in_X_Y0Z_Value.Append(rangeData); +#pragma endregion + HTuple hv_out_Origin; + HTuple hv_out_Result_X; + HTuple hv_out_Result_Y; + HTuple hv_out_Result_Z; + HTuple hv_out_AngleZX; + HTuple hv_out_AngleYZ; + HTuple hv_out_AngleXY; + HTuple hv_out_Flag; + halcon_Correction( + hv_in_X_X0Y, hv_in_Y_X0Y, hv_in_Z_X0Y, hv_in_Z_X0Y_Value, + hv_in_X_X0Z, hv_in_Y_X0Z, hv_in_Z_X0Z, hv_in_Y_X0Z_Value, + hv_in_X_Y0Z, hv_in_Y_Y0Z, hv_in_Z_Y0Z, hv_in_X_Y0Z_Value, + &hv_out_Origin, &hv_out_Result_X, &hv_out_Result_Y, &hv_out_Result_Z, + &hv_out_AngleZX, &hv_out_AngleYZ, &hv_out_AngleXY, &hv_out_Flag); + + int ok_Flag = 0; + + if (hv_out_Flag.Length() == 1) + if (hv_out_Flag[0].D() == 1) + { + if (hv_out_Origin.Length() == 3) + { + result.Origin = { hv_out_Origin[0].D(),hv_out_Origin[1].D(), hv_out_Origin[2].D() }; + ok_Flag++; + } + if (hv_out_Result_X.Length() == 3) + { + result.Result_X = { hv_out_Result_X[0].D(),hv_out_Result_X[1].D(), hv_out_Result_X[2].D() }; + ok_Flag++; + } + if (hv_out_Result_Y.Length() == 3) + { + result.Result_Y = { hv_out_Result_Y[0].D(),hv_out_Result_Y[1].D(), hv_out_Result_Y[2].D() }; + ok_Flag++; + } + if (hv_out_Result_Z.Length() == 3) + { + result.Result_Z = { hv_out_Result_Z[0].D(),hv_out_Result_Z[1].D(), hv_out_Result_Z[2].D() }; + ok_Flag++; + } + if (hv_out_AngleZX.Length() == 1) + { + result.AngleZX = hv_out_AngleZX[0].D(); + ok_Flag++; + } + if (hv_out_AngleYZ.Length() == 1) + { + result.AngleYZ = hv_out_AngleYZ[0].D(); + ok_Flag++; + } + if (hv_out_AngleXY.Length() == 1) + { + result.AngleXY = hv_out_AngleXY[0].D(); + ok_Flag++; + } + } + else + { + std::cout << "error"; + } + + if (ok_Flag != 7) + { + //qDebug() + return false; + } + result.ofx1 = result.Result_X[0] - result.Origin[0]; + result.ofx2 = result.Result_X[1] - result.Origin[1]; + result.ofx3 = result.Result_X[2] - result.Origin[2]; + + result.ofy1 = result.Result_Y[0] - result.Origin[0]; + result.ofy2 = result.Result_Y[1] - result.Origin[1]; + result.ofy3 = result.Result_Y[2] - result.Origin[2]; + + result.ofz1 = result.Result_Z[0] - result.Origin[0]; + result.ofz2 = result.Result_Z[1] - result.Origin[1]; + result.ofz3 = result.Result_Z[2] - result.Origin[2]; + + + return true; +} + +void test() +{ + correctionStruct* correctionData1 = new correctionStruct(); + correctionData1->in_X_X0Y = { 536.38,666.22,369.58 }; + correctionData1->in_Y_X0Y = { -1383.24,-1228.4,-1228.4 }; + correctionData1->in_Z_X0Y = { -131.81,-130.16,-130.15 }; + correctionData1->in_Z_X0Y_Value = { -75.9252,-76.9252,-77.9252 }; + + correctionData1->in_X_X0Z = { 615.24,191.45,197.34 }; + correctionData1->in_Y_X0Z = { -372.66,-372.85,-372.89 }; + correctionData1->in_Z_X0Z = { -925.76,-933.44,-1001.14 }; + correctionData1->in_Y_X0Z_Value = { -74.1117,-77.9532,-79.273 }; + + correctionData1->in_X_Y0Z = { -213.84,-213.9,-213.85 }; + correctionData1->in_Y_Y0Z = { -1007.81,-1072.33,-999.51 }; + correctionData1->in_Z_Y0Z = { -601.31,-601.34,-693.32 }; + correctionData1->in_X_Y0Z_Value = { 80.9952,80.223,80.8002 }; + + correctionStruct* correctionData2 = new correctionStruct(); + correctionData2->in_X_X0Y = { 536.38,666.22,369.58 }; + correctionData2->in_Y_X0Y = { -1383.24,-1228.4,-1228.4 }; + correctionData2->in_Z_X0Y = { -131.81,-130.16,-130.15 }; + correctionData2->in_Z_X0Y_Value = { -75.9252,-76.9252,-77.9252 }; + + correctionData2->in_X_X0Z = { 615.24,191.45,197.34 }; + correctionData2->in_Y_X0Z = { -372.66,-372.85,-372.89 }; + correctionData2->in_Z_X0Z = { -925.76,-933.44,-1001.14 }; + correctionData2->in_Y_X0Z_Value = { -74.1117,-77.9532,-79.273 }; + + correctionData2->in_X_Y0Z = { -213.84,-213.9,-213.85 }; + correctionData2->in_Y_Y0Z = { -1007.81,-1072.33,-999.51 }; + correctionData2->in_Z_Y0Z = { -601.31,-601.34,-693.32 }; + correctionData2->in_X_Y0Z_Value = { 80.9952,80.223,80.8002 }; + CorrectionPoints oldPoints; + HalconCorrection(correctionData1, oldPoints); + CorrectionPoints newPoints; + HalconCorrection(correctionData2, newPoints); + + Points point1; + point1.OriginX = 0; + point1.OriginY = 0; + point1.OriginZ = 0; + + /*point1.xX = oldPoints.ofx1; + point1.xY = oldPoints.ofx2; + point1.xZ = oldPoints.ofx3; + + point1.yX = oldPoints.ofy1; + point1.yY = oldPoints.ofy2; + point1.yZ = oldPoints.ofy3; + + point1.zX = oldPoints.ofz1; + point1.zY = oldPoints.ofz2; + point1.zZ = oldPoints.ofz3;*/ + point1.xX = 0; + point1.xY = 100; + point1.xZ = 0; + + point1.yX = 0; + point1.yY = 0; + point1.yZ = 100; + + point1.zX = 100; + point1.zY = 0; + point1.zZ = 0; + Points point2; + point2.OriginX = 0; + point2.OriginY = 0; + point2.OriginZ = 0; + + point2.xX = newPoints.ofx1; + point2.xY = newPoints.ofx2; + point2.xZ = newPoints.ofx3; + + point2.yX = newPoints.ofy1; + point2.yY = newPoints.ofy2; + point2.yZ = newPoints.ofy3; + + point2.zX = newPoints.ofz1; + point2.zY = newPoints.ofz2; + point2.zZ = newPoints.ofz3; + + Points point3; + point3.OriginX = 0; + point3.OriginY = 0; + point3.OriginZ = 0; + + point3.xX = 100; + point3.xY = 100; + point3.xZ = 0; + + point3.yX = 0; + point3.yY = 0; + point3.yZ = 100; + + point3.zX = 100; + point3.zY = 0; + point3.zZ = 0; + + double rotationMatrix[3][3]; + calculateRotationMatrix(point1, rotationMatrix); + + double roll, pitch, yaw; + extractRPY(rotationMatrix, roll, pitch, yaw); + + double rotationMatrix2[3][3]; + calculateRotationMatrix(point3, rotationMatrix2); + + double roll2, pitch2, yaw2; + extractRPY(rotationMatrix2, roll2, pitch2, yaw2); + //Point3d rotationAngles = calculateRotationAngles(point1, point3); + //Points newPoint = applyAngleDifference(angleDifference, point3); + //std::vector result=getoffsetPos(oldPoints, oldPoints); + QThread::msleep(100); +} + + + void ALGO_Correction(std::shared_ptr data) { + test(); if (data->correctionData == nullptr) return; #pragma region XOY_DEFINE diff --git a/HanddleAI/HandleAiUi-new/back/triggerManager.cpp b/HanddleAI/HandleAiUi-new/back/triggerManager.cpp index 3d3aea24..6a0459ee 100644 --- a/HanddleAI/HandleAiUi-new/back/triggerManager.cpp +++ b/HanddleAI/HandleAiUi-new/back/triggerManager.cpp @@ -4,7 +4,7 @@ #include #include #include -#define debugTesting 0 +#define debugTesting 1 static correctionStruct* correctionData; void triggerManager::initialization(backEndManager* input) { diff --git a/HanddleAI/HandleAiUi-new/globalStruct.h b/HanddleAI/HandleAiUi-new/globalStruct.h index 6e43fa1b..ccb304ec 100644 --- a/HanddleAI/HandleAiUi-new/globalStruct.h +++ b/HanddleAI/HandleAiUi-new/globalStruct.h @@ -17,8 +17,12 @@ #define sColor_Black "22, 22, 22" #define sColor_BlackWithWhite "45, 45, 45" -#define enableHandleAiModel 1 -#define disableBackEndCheck 0 +#define enableHandleAiModel 0 +#define disableBackEndCheck 1 + +//绐楀彛璁剧疆 +#define windowMoveFreshRate 100//绐楀彛绉诲姩姣忕鐨勫埛鏂扮巼 + enum backEndError { dllNotFound, diff --git a/HanddleAI/HandleAiUi-new/mainwindow.cpp b/HanddleAI/HandleAiUi-new/mainwindow.cpp index 2bcdbec5..2d9ff458 100644 --- a/HanddleAI/HandleAiUi-new/mainwindow.cpp +++ b/HanddleAI/HandleAiUi-new/mainwindow.cpp @@ -56,6 +56,7 @@ MainWindow::MainWindow(QWidget* parent) blurEffectAnimation->setEndValue(0); blurEffectAnimation->start(); + showMaximized(); } MainWindow::~MainWindow() @@ -145,7 +146,8 @@ void MainWindow::topBarInit() "QPushButton:hover { background-color: rgb(%1); }").arg(sColor_Gold)); // 设置透明背景和悬停时的背景色 maximizeRestoreButton->setFixedHeight(topBarHeight); maximizeRestoreButton->setFixedWidth(buttonWidth); - QObject::connect(maximizeRestoreButton, &QPushButton::clicked, this, &MainWindow::toggleMaximize); // 点击最大化/还原按钮 + //QObject::connect(maximizeRestoreButton, &QPushButton::clicked, this, &MainWindow::toggleMaximize); // 点击最大化/还原按钮 + QObject::connect(maximizeRestoreButton, &QPushButton::clicked, this, [=]() {toggleMaximize(reverse); }); // 点击最大化/还原按钮 rightLayout->addWidget(maximizeRestoreButton); //关闭窗口 diff --git a/HanddleAI/HandleAiUi-new/mainwindow.h b/HanddleAI/HandleAiUi-new/mainwindow.h index 2462c22e..e242d881 100644 --- a/HanddleAI/HandleAiUi-new/mainwindow.h +++ b/HanddleAI/HandleAiUi-new/mainwindow.h @@ -73,21 +73,54 @@ private: void topBarInit(); void leftBarInit(); + //绐楀彛绉诲姩 +#pragma region 绐楀彛绉诲姩鍙橀噺 + QTime lastWindowMoveTime; + int freshDelay = 1000 / windowMoveFreshRate; + bool setNormalAndMove = false;//鍒ゆ柇鏄惁浠庢渶澶у寲寮濮嬬Щ鍔 +#pragma endregion + //绐楀彛缂╂斁 +#pragma region 绐楀彛缂╂斁鍙橀噺 + enum toggleMaximizeEnum + { + reverse, + normal, + max + }; +#pragma endregion + + public slots: void minimizeWindow() { showMinimized(); } - void toggleMaximize() + + + void toggleMaximize(toggleMaximizeEnum toggleMaximizeEnumIn = reverse) { - if (isMaximized()) { + switch (toggleMaximizeEnumIn) + { + case reverse: + if (isMaximized()) { + showNormal(); + maximizeRestoreButton->setIcon(QPixmap(":/topBar/icon/fullscreen.png")); + } + else { + showMaximized(); + maximizeRestoreButton->setIcon(QPixmap(":/topBar/icon/fullscreen-exit.png")); + } + break; + case normal: showNormal(); - maximizeRestoreButton->setIcon(QPixmap(":/topBar/icon/fullscreen.png")); // 璁剧疆鍥炬爣 - } - else { + maximizeRestoreButton->setIcon(QPixmap(":/topBar/icon/fullscreen.png")); + break; + case max: showMaximized(); - maximizeRestoreButton->setIcon(QPixmap(":/topBar/icon/fullscreen-exit.png")); // 璁剧疆鍥炬爣 + maximizeRestoreButton->setIcon(QPixmap(":/topBar/icon/fullscreen-exit.png")); + break; } + _displayWidget->windowChanged(); } void switchstackedWidgets(int index) @@ -148,7 +181,6 @@ public slots: blurEffectAnimation->start(); } } - void recvPixmapImageWidget(showImgPack* pack) { _displayWidget->_ImageWidgetManager.showImg(pack->img, pack->type, pack->index); @@ -175,21 +207,32 @@ public slots: _loadingWidget.initLog->append(strIn); } } - signals: void reInitSignal(); protected: + void mouseDoubleClickEvent(QMouseEvent* event) override + { + toggleMaximize(reverse); + QMainWindow::mouseDoubleClickEvent(event); + } void mousePressEvent(QMouseEvent* event) override { - if (event->buttons() == Qt::LeftButton) { + if (event->button() == Qt::LeftButton) { startPos = event->globalPos(); startFrameGeometry = frameGeometry(); isMoving = true; + lastWindowMoveTime.start(); // 鎸変笅鏃跺紑濮嬭鏃 } QMainWindow::mousePressEvent(event); } void mouseMoveEvent(QMouseEvent* event) override { if (event->buttons() == Qt::LeftButton && isMoving) { - move(startFrameGeometry.topLeft() + (event->globalPos() - startPos)); + QPoint pos = event->globalPos(); + if (std::max(std::abs(pos.x()- startPos.x()), std::abs(pos.y() - startPos.y()))>10) + if(lastWindowMoveTime.elapsed()> freshDelay)//姣忕鍒锋柊100娆 + { + lastWindowMoveTime.restart(); + move(startFrameGeometry.topLeft() + (event->globalPos() - startPos)); + } } QMainWindow::mouseMoveEvent(event); }