class BoardLayer : public Qk2dViewLayer{public: BoardLayer(); const QImage& image() const { return m_image; } QTransf._qt roi">
devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Qt图层结构——实现ROI选取、选框放缩移动、背景图像移动放缩_qt roi

作者：笔触狂放9 | 2024-03-23 20:23:32

赞

踩

qt roi

文件结构:

头文件boardlayer.h

  1. #ifndef BOARDLAYER_H
  2. #define BOARDLAYER_H
  3.  
  4. #include "qk2dview.h"
  5. #include <QImage>
  6.  
  7. class BoardLayer : public Qk2dViewLayer
  8. {
  9. public:
  10.     BoardLayer();
  11.  
  12.     const QImage& image() const { return m_image; }
  13.     QTransform imageToWorld() const { return m_imgToWorld; }
  14.     QTransform worldToImage() const { return m_worldToImg; }
  15.  
  16. private:
  17.     void draw_ex(QPainter &painter) override;
  18.     void calcTransform();
  19.  
  20. private:
  21.     QImage m_image;
  22.     QPointF m_origin;
  23.     double m_pixelSize;
  24.     QRectF m_worldRect; // image rect in world coordinate
  25.     QTransform m_imgToWorld; // convert image coordinate to world coordinate
  26.     QTransform m_worldToImg; // convert world coordinate to image coordinate
  27. };
  28.  
  29.  
  30.  
  31. #endif // BOARDLAYER_H

 component.h

  1. #ifndef COMPONENT_H
  2. #define COMPONENT_H
  3.  
  4. #include <QPointF>
  5. #include <QSizeF>
  6. #include <vector>
  7.  
  8. struct Component
  9. {
  10.     Component(const QPointF &center, const QSizeF &size, float angle = 0)
  11.         : m_pos(center)
  12.         , m_size(size)
  13.         , m_angle(angle)
  14.         , m_unitVecX()
  15.         , m_unitVecY()
  16.         , m_vertex()
  17.         , m_selected(false)
  18.     {
  19.         calcVertex();
  20.     }
  21.  
  22.     void calcVertex();
  23.     bool contains(const QPointF &point);
  24.  
  25.     QPointF m_pos;
  26.     QSizeF m_size;
  27.     float m_angle;
  28.  
  29.     QPointF m_unitVecX;
  30.     QPointF m_unitVecY;
  31.     QPointF m_vertex[8];
  32.  
  33.     bool m_selected;
  34. };
  35.  
  36. extern std::vector<Component> g_m_components;
  37.  
  38. #endif // COMPONENT_H

componentlayer.h

  1. #ifndef COMPONENTLAYER_H
  2. #define COMPONENTLAYER_H
  3.  
  4. #include "qk2dview.h"
  5. #include "component.h"
  6.  
  7. class ComponentLayer : public Qk2dViewLayer
  8. {
  9. public:
  10.     ComponentLayer();
  11.  
  12.     void mousePressEvent(QMouseEvent *event) override;
  13.     void mouseReleaseEvent(QMouseEvent *event) override;
  14.     void mouseMoveEvent(QMouseEvent *event) override;
  15.     void mouseDoubleClickEvent(QMouseEvent *event) override;
  16.  
  17. private:
  18.     void draw_ex(QPainter &painter) override;
  19.  
  20. private:
  21.     Component* m_component;
  22.     int m_hitVertex;
  23. };
  24.  
  25. #endif // COMPONENTLAYER_H

mainwindow.h

  1. #ifndef MAINWINDOW_H
  2. #define MAINWINDOW_H
  3.  
  4. #include <QMainWindow>
  5. #include "qk2dview.h"
  6.  
  7. QT_BEGIN_NAMESPACE
  8. namespace Ui { class MainWindow; }
  9. QT_END_NAMESPACE
  10.  
  11. class MainWindow : public QMainWindow
  12. {
  13.     Q_OBJECT
  14.  
  15. public:
  16.     MainWindow(QWidget *parent = nullptr);
  17.     ~MainWindow();
  18.  
  19. private:
  20.     Ui::MainWindow *ui;
  21.     Qk2dView m_view;
  22. };
  23. #endif // MAINWINDOW_H

qk2dview.h

  1. #ifndef MAINWINDOW_H
  2. #define MAINWINDOW_H
  3.  
  4. #include <QMainWindow>
  5. #include "qk2dview.h"
  6.  
  7. QT_BEGIN_NAMESPACE
  8. namespace Ui { class MainWindow; }
  9. QT_END_NAMESPACE
  10.  
  11. class MainWindow : public QMainWindow
  12. {
  13.     Q_OBJECT
  14.  
  15. public:
  16.     MainWindow(QWidget *parent = nullptr);
  17.     ~MainWindow();
  18.  
  19. private:
  20.     Ui::MainWindow *ui;
  21.     Qk2dView m_view;
  22. };
  23. #endif // MAINWINDOW_H

recipelayer.h

  1. #ifndef RECIPELAYER_H
  2. #define RECIPELAYER_H
  3.  
  4. #include "qk2dview.h"
  5.  
  6. class RecipeLayer : public Qk2dViewLayer
  7. {
  8. public:
  9.     RecipeLayer();
  10.  
  11.     void mousePressEvent(QMouseEvent *event) override;
  12.     void mouseReleaseEvent(QMouseEvent *event) override;
  13.     void mouseMoveEvent(QMouseEvent *event) override;
  14.  
  15. private:
  16.     void draw_ex(QPainter &painter) override;
  17.  
  18. private:
  19.     bool m_selecting;
  20.     QPointF m_selectStartPos;
  21.     QPointF m_selectEndPos;
  22. };
  23.  
  24. #endif // RECIPELAYER_H

resultlayer.h

  1. #ifndef RESULTLAYER_H
  2. #define RESULTLAYER_H
  3.  
  4. #include "qk2dview.h"
  5.  
  6. class ResultLayer : public Qk2dViewLayer
  7. {
  8. public:
  9.     ResultLayer();
  10.  
  11.     void setText(const QString& text, bool status);
  12.  
  13. private:
  14.     void draw_ex(QPainter &painter) override;
  15.  
  16. private:
  17.     QString m_text;
  18.     bool m_status;
  19. };
  20.  
  21. #endif // RESULTLAYER_H

下面是源文件：

boardlayer.cpp

  1. #include "boardlayer.h"
  2. #include <QPointF>
  3. #include <QPainter>
  4. #include <QDebug>
  5.  
  6. BoardLayer::BoardLayer()
  7.     : Qk2dViewLayer()
  8.     , m_image("D:/testImage/0015.bmp")
  9.     , m_origin(650, 50) // origin at (650, 50)设置图片起始位置
  10.     , m_pixelSize(0.03) // 30 um / pixel收放比例
  11.     , m_worldRect()
  12.     , m_imgToWorld()
  13.     , m_worldToImg()
  14. {
  15.     calcTransform();
  16. }
  17.  
  18. void BoardLayer::draw_ex(QPainter &painter)
  19. {
  20.     QRectF rect = m_view->worldToWin().mapRect(m_worldRect);
  21.     painter.drawImage(rect, m_image);
  22. }
  23.  
  24. void BoardLayer::calcTransform()
  25. {
  26.     double trans_x = m_origin.x() - m_image.width()*m_pixelSize;
  27.     double trans_y = m_origin.y() + m_image.height()*m_pixelSize;
  28.  
  29.     m_imgToWorld = QTransform::fromScale(m_pixelSize, -m_pixelSize);//缩放
  30.     m_imgToWorld *= QTransform::fromTranslate(trans_x, trans_y);//平移
  31.     m_worldToImg = m_imgToWorld.inverted();//反转
  32.     m_worldRect = m_imgToWorld.mapRect(m_image.rect()).normalized();
  33. }
  34.

component.cpp

  1. #include "component.h"
  2.  
  3. const static double PI = 3.1415926;
  4.  
  5. std::vector<Component> g_m_components = {
  6.     Component(QPointF(393.5, 198), QSizeF(33, 33), 45),
  7.     Component(QPointF(562.5, 198), QSizeF(33, 33)),
  8.     Component(QPointF(398.5, 140), QSizeF(23, 23), 120),
  9.     Component(QPointF(567, 140), QSizeF(23, 23))
  10. };
  11.  
  12. void Component::calcVertex()
  13. {
  14.     double radAngle = m_angle * PI / 180;
  15.  
  16.     m_unitVecX = QPointF(cos(radAngle), sin(radAngle));
  17.     m_unitVecY = QPointF(-sin(radAngle), cos(radAngle));
  18.  
  19.     QPointF vecx = m_unitVecX*m_size.width()/2;
  20.     QPointF vecY = m_unitVecY*m_size.height()/2;
  21.  
  22.     m_vertex[0] = m_pos - vecx - vecY;
  23.     m_vertex[1] = m_pos - vecY;
  24.     m_vertex[2] = m_pos + vecx - vecY;
  25.     m_vertex[3] = m_pos + vecx;
  26.     m_vertex[4] = m_pos + vecx + vecY;
  27.     m_vertex[5] = m_pos + vecY;
  28.     m_vertex[6] = m_pos - vecx + vecY;
  29.     m_vertex[7] = m_pos - vecx;
  30. }
  31.  
  32. bool Component::contains(const QPointF &point)
  33. {
  34.     bool result(false);
  35.  
  36.     int i = 0, j = 3;
  37.     for(; i < 4; j = i++)
  38.     {
  39.         if(((m_vertex[2*i].y()>point.y()) != (m_vertex[2*j].y()>point.y())) &&
  40.                 (point.x() < (m_vertex[2*j].x()-m_vertex[2*i].x()) * (point.y()-m_vertex[2*i].y())
  41.                  / (m_vertex[2*j].y()-m_vertex[2*i].y()) + m_vertex[2*i].x()))
  42.         {
  43.             result = !result;
  44.         }
  45.     }
  46.  
  47.     return result;
  48. }

componentlayer.cpp

  1. #include "componentlayer.h"
  2.  
  3. ComponentLayer::ComponentLayer()
  4.     : m_component()
  5.     , m_hitVertex(-1)
  6. {
  7. }
  8.  
  9. void ComponentLayer::mousePressEvent(QMouseEvent *event)
  10. {
  11.     if(m_component)
  12.     {
  13.         event->accept();
  14.         QPointF pos = m_view->winToWorld().map(event->localPos());
  15.  
  16.         // control points hit test
  17.         m_hitVertex = -1;
  18.         QPointF dist = pos - m_component->m_pos;
  19.         if(fabs(dist.x()) <= 1 && fabs(dist.y()) <= 1)
  20.         {
  21.             m_hitVertex = 8;
  22.             return;
  23.         }
  24.  
  25.         for(int i = 0; i < 8; ++i)
  26.         {
  27.             QPointF dist = pos - m_component->m_vertex[i];
  28.             if(fabs(dist.x()) <= 1 && fabs(dist.y()) <= 1)
  29.             {
  30.                 m_hitVertex = i;
  31.                 return; // hit one of the control posints
  32.             }
  33.         }
  34.     }
  35. }
  36.  
  37. void ComponentLayer::mouseReleaseEvent(QMouseEvent *event)
  38. {
  39.     if(m_component) // clear ROI editing hit vertex
  40.     {
  41.         event->accept();
  42.         if(m_hitVertex != -1)
  43.         {
  44.             m_hitVertex = -1;
  45.         }
  46.     }
  47. }
  48.  
  49. void ComponentLayer::mouseMoveEvent(QMouseEvent *event)
  50. {
  51.     if(m_component) // editing component ROI
  52.     {
  53.         event->accept();
  54.         if(m_hitVertex != -1)
  55.         {
  56.             QPointF pos = m_view->winToWorld().map(event->localPos());
  57.             QPointF vec = pos - m_component->m_pos;
  58.  
  59.             switch(m_hitVertex)
  60.             {
  61.             case 0:
  62.             case 2:
  63.             case 4:
  64.             case 6:
  65.             {
  66.                 double width = fabs(QPointF::dotProduct(vec, m_component->m_unitVecX)) * 2;
  67.                 double height = fabs(QPointF::dotProduct(vec, m_component->m_unitVecY)) * 2;
  68.                 m_component->m_size.setWidth(width);
  69.                 m_component->m_size.setHeight(height);
  70.             }break;
  71.  
  72.             case 1:
  73.             case 5:
  74.             {
  75.                 double height = fabs(QPointF::dotProduct(vec, m_component->m_unitVecY)) * 2;
  76.                 m_component->m_size.setHeight(height);
  77.             }break;
  78.  
  79.             case 3:
  80.             case 7:
  81.             {
  82.                 double width = fabs(QPointF::dotProduct(vec, m_component->m_unitVecX)) * 2;
  83.                 m_component->m_size.setWidth(width);
  84.             }break;
  85.  
  86.             case 8:
  87.             {
  88.                 m_component->m_pos = pos;
  89.             }break;
  90.             }
  91.  
  92.             m_component->calcVertex();
  93.             m_view->update();
  94.         }
  95.     }
  96. }
  97.  
  98. void ComponentLayer::mouseDoubleClickEvent(QMouseEvent *event)
  99. {
  100.     if(event->button() == Qt::LeftButton)
  101.     {
  102.         QPointF pos = m_view->winToWorld().map(event->localPos());
  103.  
  104.         m_component = nullptr;
  105.         for(auto & compnent : g_m_components)
  106.         {
  107.             if(compnent.contains(pos))
  108.             {
  109.                 m_component = &compnent;
  110.                 event->accept();
  111.                 break;
  112.             }
  113.         }
  114.  
  115.         m_view->update();
  116.     }
  117. }
  118.  
  119. void ComponentLayer::draw_ex(QPainter &painter)
  120. {
  121.     if(m_component)
  122.     {
  123.         QPen pen;
  124.         pen.setWidth(2);
  125.         pen.setCosmetic(true);
  126.         pen.setColor(Qt::yellow);
  127.  
  128.         painter.setPen(pen);
  129.         painter.setTransform(m_view->worldToWin());
  130.  
  131.         // draw roi rect
  132.         painter.drawLine(m_component->m_vertex[0], m_component->m_vertex[2]);
  133.         painter.drawLine(m_component->m_vertex[2], m_component->m_vertex[4]);
  134.         painter.drawLine(m_component->m_vertex[4], m_component->m_vertex[6]);
  135.         painter.drawLine(m_component->m_vertex[6], m_component->m_vertex[0]);
  136.         // draw polarity
  137.         painter.drawLine(m_component->m_vertex[1] + 0.3*(m_component->m_vertex[5] - m_component->m_vertex[1]),
  138.                 m_component->m_vertex[0] + 0.3*(m_component->m_vertex[2]-m_component->m_vertex[0]));
  139.         painter.drawLine(m_component->m_vertex[1] + 0.3*(m_component->m_vertex[5] - m_component->m_vertex[1]),
  140.                 m_component->m_vertex[0] + 0.7*(m_component->m_vertex[2]-m_component->m_vertex[0]));
  141.  
  142.         painter.setBrush(Qt::yellow);
  143.         for(int i = 0; i < 8; ++i)
  144.         {
  145.             painter.drawEllipse(m_component->m_vertex[i], 0.5, 0.5);
  146.         }
  147.  
  148.         painter.drawLine(m_component->m_pos-QPointF(0.5, 0), m_component->m_pos+QPointF(0.5, 0));
  149.         painter.drawLine(m_component->m_pos-QPointF(0, 0.5), m_component->m_pos+QPointF(0, 0.5));
  150.     }
  151. }

main.cpp

  1. #include "mainwindow.h"
  2.  
  3. #include <QApplication>
  4.  
  5. int main(int argc, char *argv[])
  6. {
  7.     QApplication a(argc, argv);
  8.     MainWindow w;
  9.     w.show();
  10.     return a.exec();
  11. }

mainwindow.cpp

  1. #include "mainwindow.h"
  2. #include "ui_mainwindow.h"
  3. #include "boardlayer.h"
  4. #include "recipelayer.h"
  5. #include "componentlayer.h"
  6. #include "resultlayer.h"
  7.  
  8. MainWindow::MainWindow(QWidget *parent)
  9.     : QMainWindow(parent)
  10.     , ui(new Ui::MainWindow)
  11.     , m_view(this)
  12. {
  13.     ui->setupUi(this);
  14.     setCentralWidget(&m_view);
  15.  
  16.     std::shared_ptr<BoardLayer> boardLayer = std::make_shared<BoardLayer>();
  17.     m_view.setDrawer(Qk2dView::BoardLayer, boardLayer);
  18.  
  19. //    std::shared_ptr<RecipeLayer> recipeLayer = std::make_shared<RecipeLayer>();
  20. //    m_view.setDrawer(Qk2dView::RecipeLayer, recipeLayer);
  21.  
  22. //    std::shared_ptr<ComponentLayer> compLayer = std::make_shared<ComponentLayer>();
  23. //    m_view.setDrawer(Qk2dView::ComponentLayer, compLayer);
  24.  
  25. //    std::shared_ptr<ResultLayer> resultLayer = std::make_shared<ResultLayer>();
  26. //    m_view.setDrawer(Qk2dView::ResultLayer, resultLayer);
  27.  
  28. //    resultLayer->setText("OK", true);
  29.  
  30. //    resultLayer->setVisiable(false);
  31.  
  32. }
  33.  
  34. MainWindow::~MainWindow()
  35. {
  36.     delete ui;
  37. }
  38.

qk2dview.cpp

  1. #include "qk2dview.h"
  2. #include <QWheelEvent>
  3. #include <QPainter>
  4. #include <QTransform>
  5. #include <QDebug>
  6.  
  7. Qk2dViewLayer::Qk2dViewLayer()
  8.     : m_view(nullptr)
  9.     , m_visiable(true)
  10. {
  11. }
  12.  
  13. void Qk2dViewLayer::setView(Qk2dView *view)
  14. {
  15.     m_view = view;
  16. }
  17.  
  18. void Qk2dViewLayer::setVisiable(bool visiable)
  19. {
  20.     m_visiable = visiable;
  21. }
  22.  
  23. bool Qk2dViewLayer::visiable() const
  24. {
  25.     return m_visiable;
  26. }
  27.  
  28. void Qk2dViewLayer::draw(QPainter &painter)
  29. {
  30.     painter.save();
  31.     draw_ex(painter);
  32.     painter.restore();
  33. }
  34.  
  35.  
  36. Qk2dView::Qk2dView(QWidget *parent)
  37.     : QWidget(parent)
  38.     , m_layers()
  39.     , m_roiRect()
  40.     , m_winToWorld()
  41.     , m_worldToWin()
  42.     , m_isDragging(false)
  43.     , m_dragStartPos()
  44. {
  45.     m_layers.fill(nullptr);
  46.  
  47.     setMouseTracking(true);
  48.     setRoiRect(QRectF(270, 30, 410, 290));
  49. }
  50.  
  51. void Qk2dView::setRoiRect(const QRectF &roi)
  52. {
  53.     m_roiRect = roi.normalized();
  54.     calcTransform();
  55.     update();
  56. }
  57.  
  58. void Qk2dView::setDrawer(Layer layer, std::shared_ptr<Qk2dViewLayer> drawer)
  59. {
  60.     if(m_layers[layer])
  61.     {
  62.         m_layers[layer]->setView(nullptr);
  63.     }
  64.  
  65.     if(drawer)
  66.     {
  67.         drawer->setView(this);
  68.     }
  69.  
  70.     m_layers[layer] = drawer;
  71.     update();
  72. }
  73.  
  74. std::shared_ptr<Qk2dViewLayer> Qk2dView::getDrawer(Layer layer)
  75. {
  76.     return m_layers[layer];
  77. }
  78.  
  79. void Qk2dView::setDrawerVisiable(Layer layer, bool visiable)
  80. {
  81.     if(m_layers[layer])
  82.     {
  83.         m_layers[layer]->setVisiable(visiable);
  84.         update();
  85.     }
  86. }
  87.  
  88. void Qk2dView::mousePressEvent(QMouseEvent *event)
  89. {
  90.     if(event->type() == QEvent::MouseButtonDblClick)
  91.     {
  92.         event->setAccepted(false);
  93.         return;
  94.     }
  95.     else
  96.     {
  97.         QWidget::mousePressEvent(event);
  98.  
  99.         if(event->button() == Qt::MidButton)
  100.         {
  101.             m_isDragging = true;
  102.             m_dragStartPos = event->localPos();
  103.         }
  104.  
  105.         for(auto it = m_layers.rbegin(); it != m_layers.rend(); ++it)
  106.         {
  107.             if((*it) && (*it)->visiable())
  108.             {
  109.                 (*it)->mousePressEvent(event);
  110.  
  111.                 if(event->isAccepted())
  112.                 {
  113.                     break;
  114.                 }
  115.             }
  116.         }
  117.  
  118.     }
  119. }
  120.  
  121. void Qk2dView::mouseReleaseEvent(QMouseEvent *event)
  122. {
  123.     QWidget::mouseReleaseEvent(event);
  124.  
  125.     if(m_isDragging)
  126.     {
  127.         m_isDragging = false;
  128.     }
  129.  
  130.     for(auto it = m_layers.rbegin(); it != m_layers.rend(); ++it)
  131.     {
  132.         if((*it) && (*it)->visiable())
  133.         {
  134.             (*it)->mouseReleaseEvent(event);
  135.  
  136.             if(event->isAccepted())
  137.             {
  138.                 break;
  139.             }
  140.         }
  141.     }
  142. }
  143.  
  144. void Qk2dView::mouseMoveEvent(QMouseEvent *event)
  145. {
  146.     QWidget::mouseMoveEvent(event);
  147.  
  148.     if(m_isDragging)
  149.     {
  150.         QPointF pos = event->localPos();
  151.         QPointF trans = pos - m_dragStartPos;
  152.         m_dragStartPos = pos;
  153.  
  154.         setRoiRect(m_roiRect.translated(-trans.x() * m_winToWorld.m11(), -trans.y() * m_winToWorld.m22()));
  155.     }
  156.  
  157.     for(auto it = m_layers.rbegin(); it != m_layers.rend(); ++it)
  158.     {
  159.         if((*it) && (*it)->visiable())
  160.         {
  161.             (*it)->mouseMoveEvent(event);
  162.  
  163.             if(event->isAccepted())
  164.             {
  165.                 break;
  166.             }
  167.         }
  168.     }
  169. }
  170.  
  171. void Qk2dView::mouseDoubleClickEvent(QMouseEvent *event)
  172. {
  173.     QWidget::mouseDoubleClickEvent(event);
  174.  
  175.     for(auto it = m_layers.rbegin(); it != m_layers.rend(); ++it)
  176.     {
  177.         if((*it) && (*it)->visiable())
  178.         {
  179.             (*it)->mouseDoubleClickEvent(event);
  180.             if(event->isAccepted())
  181.             {
  182.                 break;
  183.             }
  184.         }
  185.     }
  186. }
  187.  
  188. void Qk2dView::paintEvent(QPaintEvent *event)
  189. {
  190.     QWidget::paintEvent(event);
  191.  
  192.     QPainter painter(this);
  193.     painter.setRenderHint(QPainter::Antialiasing, true);
  194.     painter.fillRect(rect(), QColor(20, 20, 20));
  195.  
  196.     for(auto it = m_layers.begin(); it != m_layers.end(); ++it)
  197.     {
  198.         if(*it && (*it)->visiable())
  199.         {
  200.             (*it)->draw(painter);
  201.         }
  202.     }
  203. }
  204.  
  205. void Qk2dView::wheelEvent(QWheelEvent *event)
  206. {
  207.     QWidget::wheelEvent(event);
  208.  
  209.     int numDegrees = event->angleDelta().y() / 8;
  210.     double zoomFactor = 1 - numDegrees / 15.0 * 0.1;
  211.     QRectF viewRect = m_winToWorld.mapRect(QRectF(rect()));
  212.     QPointF pos = m_winToWorld.map(event->position());
  213.  
  214.     double top = pos.y() + (viewRect.top() - pos.y()) * zoomFactor;
  215.     double bottom = pos.y() + (viewRect.bottom() - pos.y()) * zoomFactor;
  216.     double left = pos.x() + (viewRect.left() - pos.x()) * zoomFactor;
  217.     double right = pos.x() + (viewRect.right() - pos.x()) * zoomFactor;
  218.  
  219.     QRectF rect(left, top, right-left, bottom-top);
  220.     setRoiRect(rect);
  221. }
  222.  
  223. void Qk2dView::resizeEvent(QResizeEvent *event)
  224. {
  225.     QWidget::resizeEvent(event);
  226.     calcTransform();
  227. }
  228.  
  229. void Qk2dView::calcTransform()
  230. {
  231.     double w2hRatio = m_roiRect.width() / m_roiRect.height();
  232.  
  233.     double w(width()), h(height());
  234.     double tempWidth = height() * w2hRatio;
  235.  
  236.     QRectF windowRect; // in window coordinate system
  237.     if(tempWidth <= width())
  238.     {
  239.         w = tempWidth;
  240.         windowRect = QRectF((width()-w)/2.0, 0, w, h);
  241.     }
  242.     else
  243.     {
  244.         h = width() / w2hRatio;
  245.         windowRect = QRectF(0, (height()-h) / 2.0, w, h);
  246.     }
  247.  
  248.     double scale_x, scale_y, trans_x, trans_y;
  249.     scale_x = windowRect.width()/m_roiRect.width();
  250.     scale_y = -windowRect.height()/m_roiRect.height();
  251.     trans_x = windowRect.left() - scale_x*m_roiRect.left();
  252.     trans_y = windowRect.bottom() - scale_y*m_roiRect.top();
  253.  
  254.     m_worldToWin = QTransform::fromScale(scale_x, scale_y);
  255.     m_worldToWin *= QTransform::fromTranslate(trans_x, trans_y);
  256.     m_winToWorld = m_worldToWin.inverted();
  257. }

recipelayer.cpp

  1. #include "recipelayer.h"
  2. #include "component.h"
  3. #include <QDebug>
  4.  
  5.  
  6. RecipeLayer::RecipeLayer()
  7.     : Qk2dViewLayer()
  8.     , m_selecting(false)
  9.     , m_selectStartPos()
  10.     , m_selectEndPos()
  11. {
  12. }
  13.  
  14. void RecipeLayer::mousePressEvent(QMouseEvent *event)
  15. {
  16.     if(event->button() == Qt::LeftButton)//判断是否按下左键
  17.     {
  18.         QPointF pos = m_view->winToWorld().map(event->localPos());
  19.  
  20.         m_selecting = true;
  21.         m_selectStartPos = pos;
  22.         m_selectEndPos = pos;
  23.     }
  24. }
  25.  
  26. void RecipeLayer::mouseReleaseEvent(QMouseEvent *event)
  27. {
  28.     if(event->button() == Qt::LeftButton)
  29.     {
  30.         if(m_selecting) // selecting
  31.         {
  32.             m_selecting = false;
  33.             QRectF rect = QRectF(m_selectStartPos, m_selectEndPos).normalized();
  34.  
  35.             for(auto & compnent : g_m_components)
  36.             {
  37.                 if(rect.contains(compnent.m_pos))
  38.                 {
  39.                     compnent.m_selected = true;
  40.                 }
  41.                 else if(!(event->modifiers() & Qt::ControlModifier))
  42.                 {
  43.                     compnent.m_selected = false;
  44.                 }
  45.             }
  46.         }
  47.     }
  48.  
  49.     m_view->update();
  50. }
  51.  
  52. void RecipeLayer::mouseMoveEvent(QMouseEvent *event)
  53. {
  54.     QPointF pos = m_view->winToWorld().map(event->localPos());
  55.  
  56.     if(m_selecting)
  57.     {
  58.         m_selectEndPos = pos;
  59.     }
  60.  
  61.     m_view->update();
  62. }
  63.  
  64. void RecipeLayer::draw_ex(QPainter &painter)
  65. {
  66.     QPen pen;
  67.     pen.setWidth(2);
  68.     pen.setCosmetic(true);
  69.     painter.setTransform(m_view->worldToWin());
  70.  
  71.     for(const auto & compnent : g_m_components)
  72.     {
  73.         if(compnent.m_selected)
  74.         {
  75.             pen.setColor(Qt::green);
  76.         }
  77.         else
  78.         {
  79.             pen.setColor(Qt::blue);
  80.         }
  81.  
  82.         painter.setPen(pen);
  83.         // draw roi rect
  84.         painter.drawLine(compnent.m_vertex[0], compnent.m_vertex[2]);
  85.         painter.drawLine(compnent.m_vertex[2], compnent.m_vertex[4]);
  86.         painter.drawLine(compnent.m_vertex[4], compnent.m_vertex[6]);
  87.         painter.drawLine(compnent.m_vertex[6], compnent.m_vertex[0]);
  88.         // draw polarity
  89.         painter.drawLine(compnent.m_vertex[1] + 0.3*(compnent.m_vertex[5] - compnent.m_vertex[1]),
  90.                 compnent.m_vertex[0] + 0.3*(compnent.m_vertex[2]-compnent.m_vertex[0]));
  91.         painter.drawLine(compnent.m_vertex[1] + 0.3*(compnent.m_vertex[5] - compnent.m_vertex[1]),
  92.                 compnent.m_vertex[0] + 0.7*(compnent.m_vertex[2]-compnent.m_vertex[0]));
  93.     }
  94.  
  95.     if(m_selecting)
  96.     {
  97.         pen.setColor(Qt::yellow);
  98.         painter.setPen(pen);
  99.         painter.setBrush(QColor(255, 255, 255, 100));
  100.         painter.drawRect(QRectF(m_selectStartPos, m_selectEndPos));
  101.     }
  102. }

resultlayer.cpp

  1. #include "resultlayer.h"
  2.  
  3. ResultLayer::ResultLayer()
  4.     : Qk2dViewLayer()
  5.     , m_text("Good")
  6.     , m_status(true)
  7. {
  8. }
  9.  
  10. void ResultLayer::setText(const QString& text, bool status)
  11. {
  12.     m_text = text;
  13.     m_status = status;
  14.     if(m_view)
  15.     {
  16.         m_view->update();
  17.     }
  18. }
  19.  
  20. void ResultLayer::draw_ex(QPainter &painter)
  21. {
  22.     QPen pen;
  23.     pen.setWidth(2);
  24.     pen.setCosmetic(true);
  25.     QBrush brush;
  26.     QColor color;
  27.     if(m_status)
  28.     {
  29.         color = QColor(0, 255, 0, 150);
  30.     }
  31.     else
  32.     {
  33.         color = QColor(255, 0, 0, 150);
  34.     }
  35.  
  36.     pen.setColor(color);
  37.     brush.setColor(color);
  38.     painter.setPen(pen);
  39.     painter.setBrush(brush);
  40.  
  41.     QRectF winRect = m_view->rect();
  42.     QFont font = painter.font();
  43.     font.setBold(true);
  44.     font.setPixelSize(std::min(winRect.width(), winRect.height())/1.5);
  45.     painter.setFont(font);
  46.  
  47.     painter.drawText(winRect, Qt::AlignHCenter | Qt::AlignVCenter, m_text);
  48. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/297469
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号