QGraphicsRectItem美观实现缩放，旋转，平移

最新推荐文章于 2023-09-22 15:03:41 发布
最新推荐文章于 2023-09-22 15:03:41 发布
阅读量6.2k 收藏 66
点赞数 15
分类专栏： qt 文章标签： QGraphicsRect 缩放 旋转 qt 矩形
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaonuo911teamo/article/details/106075647
版权

在使用QGraphicsRectItem时，涉及到需要缩放控件，于是在网上查找相关代码。很幸运的很快就找到了一个python写的旋转方法，效果也正是我想要的，于是我将代码改为C++的，测试成功。后来增加旋转需求，很幸运，这部分代码同样支持旋转，即旋转后仍然可以进行缩放。至于界面效果，我大概完整地实现了同PS上操作矩形的方式。
python参考地址：http://www.chinaoc.com.cn/p/1177045.html

效果demo展示

在这里插入图片描述

接口文件及说明
实现思路

放缩部分：我只是对python原文进行了python到C++转译而已，思路参见http://www.chinaoc.com.cn/p/1177045.html。

旋转部分思路：在view的mouseMoveEvent中调用getRotateCursor，获取指针形状。针对item设置c_rotate_tolerance 旋转容忍度，只有接近item周围才会支持旋转。mousePressEvent中设置setRotateStart，表示鼠标已按下，开始旋转。同时为了实现动态旋转，在mouseMoveEvent重复调用setRotateEnd，设置鼠标实时位置。

注1：使用时，应将mapCursors中的地址换成正确有效的地址。
注2：由于上述的放缩是基于item内部坐标完成的放缩，所以旋转并不会影响其效果。所以，你大可以重新实现更好的旋转效果，如果可以的话，也可以分享给我你的想法。

#include <QGraphicsRectItem>
#include <QStyleOptionGraphicsItem>
#include <QStyleOption>
#include <QCursor>

const Qt::CursorShape handleCursors[] = {
	Qt::SizeFDiagCursor,
	Qt::SizeVerCursor,
	Qt::SizeBDiagCursor,
	Qt::SizeHorCursor,
	Qt::SizeFDiagCursor,
	Qt::SizeVerCursor,
	Qt::SizeBDiagCursor,
	Qt::SizeHorCursor,
};

const QString mapCursors[] = {
	"",
	":/QtGuiApplication4/Resources/rotate_top_left.png",
	":/QtGuiApplication4/Resources/rotate_top_middle.png",
	":/QtGuiApplication4/Resources/rotate_top_right.png",
	":/QtGuiApplication4/Resources/rotate_middle_right.png",
	":/QtGuiApplication4/Resources/rotate_bottom_right.png",
	":/QtGuiApplication4/Resources/rotate_bottom_middle.png",
	":/QtGuiApplication4/Resources/rotate_bottom_left.png",
	":/QtGuiApplication4/Resources/rotate_middle_left.png"
};

class CustomRectItem : public QGraphicsRectItem
{
	enum MOUSEHANDLE {
		handleNone = 0,
		handleTopLeft = 1,
		handleTopMiddle = 2,
		handleTopRight = 3,
		handleMiddleRight = 4,
		handleBottomRight = 5,
		handleBottomMiddle = 6,
		handleBottomLeft = 7,
		handleMiddleLeft = 8,
	};

	enum MOUSEROTATEHANDLE {
		handleRotateNone = 0,
		handleRotateTopLeft = 1,
		handleRotateTopMiddle = 2,
		handleRotateTopRight = 3,
		handleRotateMiddleRight = 4,
		handleRotateBottomRight = 5,
		handleRotateBottomMiddle = 6,
		handleRotateBottomLeft = 7,
		handleRotateMiddleLeft = 8,
	};

	const float c_handle_size = 8.0;
	const float c_handle_space = -4.0;

	const float c_rotate_tolerance = 20.0;
	const int c_handle_cursors_size = 8;	// handleCursors[] size
	const int c_rotate_cursors_size = 9;	// MOUSEROTATEHANDLE size
	const QSize c_rotate_cursor_size = QSize(20, 20);

public:
	CustomRectItem(QGraphicsItem *parent = Q_NULLPTR);
	~CustomRectItem();

	// Returns the shape of this item as a QPainterPath in local coordinates.
	QPainterPath shape() const override;

	// Returns the bounding rect of the shape (including the resize handles).
	QRectF boundingRect() const override;

	void updateHandlesPos();

	bool isHover();

	// point is scene coordinate
	QCursor getRotateCursor(const QPointF& point);
	// set point for start rorate
	// @note point is scene coordinate
	void setRotateStart(const QPointF& point);
	// set point for end rorate
	// @note point is scene coordinate
	void setRotateEnd(const QPointF& point);

protected:
	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) Q_DECL_OVERRIDE;

	void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
	
	//  Executed when the mouse leaves the shape (NOT PRESSED).
	void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);

	// Executed when the mouse moves over the shape (NOT PRESSED).
	void hoverMoveEvent(QGraphicsSceneHoverEvent *event);

	//  Executed when the mouse is being moved over the item while being pressed.
	void mouseMoveEvent(QGraphicsSceneMouseEvent *event);

	// Executed when the mouse is pressed on the item.
	void mousePressEvent(QGraphicsSceneMouseEvent *event);

	// Executed when the mouse is released from the item.
	void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);

	// Executed when the key is pressed on the item.
	void keyPressEvent(QKeyEvent *event);

private:
	//  Returns the resize handle below the given point.
	MOUSEHANDLE handleAt(const QPointF& point);
	//  Perform shape interactive resize.
	void interactiveResize(const QPointF& mousePos);

	// the length2 with point1 and point2
	float getLength2(const QPointF& point1, const QPointF& point2);

private:
	std::map<MOUSEROTATEHANDLE, QPointF> m_points;
	std::map<MOUSEROTATEHANDLE, QCursor> m_cursorRotate;
	std::map<MOUSEHANDLE, QRectF> m_handles;
	MOUSEHANDLE m_handle;
	QCursor m_cursor;
	QPointF m_mousePressPos;
	QRectF m_mousePressRect;

	QPointF m_mouseRotateStart;
	float m_fLastAngle;

	MOUSEHANDLE m_bhandleSelected;
	
	bool m_isHover;
};
源文件代码参考

分步介绍我就不加头文件咯！另外，我是摘出来的这段代码，有小错误的话，自己纠正一下就行咯！

重载paint函数，绘制了选中时的，边角矩形和去掉了选中状态（那种难看的虚线框）。

void CustomRectItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
	QStyleOptionGraphicsItem op;

	if (widget == nullptr)
		op = *option;
	else
		op.initFrom(widget);

	if (option->state & QStyle::State_Selected)
		op.state = QStyle::State_None;

	QGraphicsRectItem::paint(painter, &op, widget);

	if (isSelected() == true)
	{
		painter->setRenderHint(QPainter::Antialiasing);
		painter->setBrush(QBrush(QColor(255, 255, 255, 255)));
		painter->setPen(QPen(QColor(0x293a56ff), 1.0, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
		for (auto it : m_handles)
		{
			if (m_bhandleSelected == MOUSEHANDLE::handleNone || it.first == m_bhandleSelected)
				painter->drawRect(it.second);
		}
	}
}

初始化部分，不做介绍。

CustomRectItem::CustomRectItem(QGraphicsItem * parent)
	: QGraphicsRectItem(parent)
	, m_points()
	, m_cursorRotate()
	, m_handles()
	, m_handle(MOUSEHANDLE::handleNone)
	, m_cursor(Qt::ArrowCursor)
	, m_mousePressPos()
	, m_mousePressRect()
	, m_mouseRotateStart()
	, m_fLastAngle(0.0)
	, m_bhandleSelected(MOUSEHANDLE::handleNone)
	, m_isHover(false)
{
	setAcceptHoverEvents(true);
	setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsFocusable 
		| QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemSendsGeometryChanges);

	m_handles.insert(std::make_pair(MOUSEHANDLE::handleTopLeft, QRectF()));
	m_handles.insert(std::make_pair(MOUSEHANDLE::handleTopMiddle, QRectF()));
	m_handles.insert(std::make_pair(MOUSEHANDLE::handleTopRight, QRectF()));
	m_handles.insert(std::make_pair(MOUSEHANDLE::handleMiddleLeft, QRectF()));
	m_handles.insert(std::make_pair(MOUSEHANDLE::handleMiddleRight, QRectF()));
	m_handles.insert(std::make_pair(MOUSEHANDLE::handleBottomLeft, QRectF()));
	m_handles.insert(std::make_pair(MOUSEHANDLE::handleBottomMiddle, QRectF()));
	m_handles.insert(std::make_pair(MOUSEHANDLE::handleBottomRight, QRectF()));

	m_points.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateTopLeft, QPointF()));
	m_points.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateTopMiddle, QPointF()));
	m_points.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateTopRight, QPointF()));
	m_points.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateMiddleRight, QPointF()));
	m_points.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateBottomRight, QPointF()));
	m_points.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateBottomMiddle, QPointF()));
	m_points.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateBottomLeft, QPointF()));
	m_points.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateMiddleLeft, QPointF()));

	m_cursorRotate.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateTopLeft, QCursor(QPixmap(mapCursors[MOUSEROTATEHANDLE::handleRotateTopLeft]).scaled(c_rotate_cursor_size))));
	m_cursorRotate.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateTopMiddle, QCursor(QPixmap(mapCursors[MOUSEROTATEHANDLE::handleRotateTopMiddle]).scaled(c_rotate_cursor_size))));
	m_cursorRotate.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateTopRight, QCursor(QPixmap(mapCursors[MOUSEROTATEHANDLE::handleRotateTopRight]).scaled(c_rotate_cursor_size))));
	m_cursorRotate.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateMiddleRight, QCursor(QPixmap(mapCursors[MOUSEROTATEHANDLE::handleRotateMiddleRight]).scaled(c_rotate_cursor_size))));
	m_cursorRotate.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateBottomRight, QCursor(QPixmap(mapCursors[MOUSEROTATEHANDLE::handleRotateBottomRight]).scaled(c_rotate_cursor_size))));
	m_cursorRotate.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateBottomMiddle, QCursor(QPixmap(mapCursors[MOUSEROTATEHANDLE::handleRotateBottomMiddle]).scaled(c_rotate_cursor_size))));
	m_cursorRotate.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateBottomLeft, QCursor(QPixmap(mapCursors[MOUSEROTATEHANDLE::handleRotateBottomLeft]).scaled(c_rotate_cursor_size))));
	m_cursorRotate.insert(std::make_pair(MOUSEROTATEHANDLE::handleRotateMiddleLeft, QCursor(QPixmap(mapCursors[MOUSEROTATEHANDLE::handleRotateMiddleLeft]).scaled(c_rotate_cursor_size))));

	updateHandlesPos();
}
CustomRectItem::~CustomRectItem()
{
}

这部分我也不清楚什么意思。

QPainterPath CustomRectItem::shape() const
{
	QPainterPath path = QPainterPath();
	path.addRect(this->rect());
	if (this->isSelected())
	{
		for (auto shape : m_handles)
			path.addEllipse(shape.second);
	}
			
	return path;
}

调整了下有效边界，这影响着hoverEnterEvent，hoverLeaveEvent生效的范围。c_handle_size 是调整大小的方框的大小，c_handle_space表示方框嵌入item的宽度，是个负数，正常为c_handle_size 的一半。

QRectF CustomRectItem::boundingRect() const
{
	auto o = c_handle_size + c_handle_space;
	return this->rect().adjusted(-o, -o, o, o);
}

m_isHover 表示鼠标是否在item上。当进行放缩时，鼠标可能会出界，导致view捕捉到，并且修改指针形状，通过判断该参数可纠正。

void CustomRectItem::hoverEnterEvent(QGraphicsSceneHoverEvent * event)
{
	QGraphicsRectItem::hoverEnterEvent(event);
	m_isHover = true;
}
void CustomRectItem::hoverLeaveEvent(QGraphicsSceneHoverEvent * event)
{
	setCursor(Qt::ArrowCursor);
	QGraphicsRectItem::hoverLeaveEvent(event);
	m_isHover = false;
}

这里基于python的原文，进行了适当修改。当item进行了旋转后，鼠标指针的方向也应该跟着改变。而且这里有个22.5度的逆向偏移。如果不理解可以运行demo，去掉试试。比如，旋转角度为44度，46度时，会有一个看着别扭。

void CustomRectItem::hoverMoveEvent(QGraphicsSceneHoverEvent * event)
{
	if (isSelected())
	{
		m_handle = handleAt(event->pos());

		if (MOUSEHANDLE::handleNone == m_handle)
			m_cursor = Qt::SizeAllCursor;
		else
		{
			float angle = this->rotation() + 22.5;
			while (angle >= 360.0)
				angle -= 360;
			// choose the right cursor
			m_cursor = handleCursors[((int)m_handle + (int)(angle / 45) - 1) % c_handle_cursors_size];
		}
		setCursor(m_cursor);
	}	
	QGraphicsRectItem::hoverMoveEvent(event);
}

判断鼠标指针的状态，进行调整大小。

void CustomRectItem::mouseMoveEvent(QGraphicsSceneMouseEvent * event)
{
	if (MOUSEHANDLE::handleNone != m_bhandleSelected)
		interactiveResize(event->pos());
	else
		QGraphicsRectItem::mouseMoveEvent(event);
}

void CustomRectItem::mousePressEvent(QGraphicsSceneMouseEvent * event)
{
	m_bhandleSelected = handleAt(event->pos());
	if (MOUSEHANDLE::handleNone != m_bhandleSelected)
	{
		m_mousePressPos = event->pos();
		m_mousePressRect = boundingRect();
	}
	QGraphicsRectItem::mousePressEvent(event);
}

<这里前半部分是个重点>
目的是解决有旋转角度的矩形，拉伸之后，再次旋转，旋转中心该仍然为之前坐标，手动设置为中心，会产生漂移的问题。如果不需要解决该问题，可注掉该部分代码。原理参见子章节：https://blog.csdn.net/xiaonuo911teamo/article/details/106129696

void CustomRectItem::mouseReleaseEvent(QGraphicsSceneMouseEvent * event)
{
	auto rr = this->rect();
	auto angle = qDegreesToRadians(this->rotation());

	auto p1 = rr.center();
	auto origin = this->transformOriginPoint();
	QPointF p2 = QPointF(0, 0);

	p2.setX(origin.x() + qCos(angle)*(p1.x() - origin.x()) - qSin(angle)*(p1.y() - origin.y()));
	p2.setY(origin.y() + qSin(angle)*(p1.x() - origin.x()) + qCos(angle)*(p1.y() - origin.y()));

	auto diff = p1 - p2;
	this->setRect(rr.adjusted(-diff.x(), -diff.y(), -diff.x(), -diff.y()));
	setTransformOriginPoint(this->rect().center());

	updateHandlesPos();
	
	m_bhandleSelected = MOUSEHANDLE::handleNone;
	m_mousePressPos = QPointF();
	m_mousePressRect = QRectF();
	this->update();
	QGraphicsRectItem::mouseReleaseEvent(event);
}

键盘控制平移的简单实现。

void CustomRectItem::keyPressEvent(QKeyEvent * event)
{
	switch (event->key())
	{
	case Qt::Key_Up:
		this->moveBy(0, -1);
		event->setAccepted(true);
		break;
	case Qt::Key_Down:
		this->moveBy(0, 1);
		event->setAccepted(true);
		break;
	case Qt::Key_Left:
		this->moveBy(-1, 0);
		event->setAccepted(true);
		break;
	case Qt::Key_Right:
		this->moveBy(1, 0);
		event->setAccepted(true);
		break;
	default:
		event->setAccepted(false);
		break;
	}
	//QGraphicsRectItem::keyPressEvent(event);
}

调整四周小矩形的位置和大小。

void CustomRectItem::updateHandlesPos()
{
	auto s = c_handle_size;
	auto b = boundingRect();

	m_handles[MOUSEHANDLE::handleTopLeft] = QRectF(b.left(), b.top(), s, s);
	m_handles[MOUSEHANDLE::handleTopMiddle] = QRectF(b.center().x() - s / 2, b.top(), s, s);
	m_handles[MOUSEHANDLE::handleTopRight] = QRectF(b.right() - s, b.top(), s, s);
	m_handles[MOUSEHANDLE::handleMiddleLeft] = QRectF(b.left(), b.center().y() - s / 2, s, s);
	m_handles[MOUSEHANDLE::handleMiddleRight] = QRectF(b.right() - s, b.center().y() - s / 2, s, s);
	m_handles[MOUSEHANDLE::handleBottomLeft] = QRectF(b.left(), b.bottom() - s, s, s);
	m_handles[MOUSEHANDLE::handleBottomMiddle] = QRectF(b.center().x() - s / 2, b.bottom() - s, s, s);
	m_handles[MOUSEHANDLE::handleBottomRight] = QRectF(b.right() - s, b.bottom() - s, s, s);
}

bool CustomRectItem::isHover()
{
	return m_isHover;
}

判断是否在可旋转范围内，是则返回对应的QCursor。计算应当返回什么QCursor的思路是，先在item坐标下，计算出距离最近的是哪个小方块，然后再加上旋转角度的偏移量，就得到了应该在视觉上看到的正确的鼠标形状。或许有更方便的实现方法。

QCursor CustomRectItem::getRotateCursor(const QPointF & point)
{
	if (m_isHover == true || !isSelected())
		return QCursor();

	if (boundingRect().contains(mapFromScene(point)))
		return QCursor();

	auto srcRect = rect();
	auto frameRect = srcRect.adjusted(-c_rotate_tolerance, -c_rotate_tolerance, c_rotate_tolerance, c_rotate_tolerance);

	QPointF innerPoint = mapFromScene(point);

	if (!frameRect.contains(innerPoint))
		return QCursor();

	m_points[MOUSEROTATEHANDLE::handleRotateTopLeft] = srcRect.topLeft();
	m_points[MOUSEROTATEHANDLE::handleRotateTopMiddle] = QPointF(srcRect.center().x(), srcRect.top());
	m_points[MOUSEROTATEHANDLE::handleRotateTopRight] = srcRect.topRight();
	m_points[MOUSEROTATEHANDLE::handleRotateMiddleRight] = QPointF(srcRect.right(), srcRect.center().y());
	m_points[MOUSEROTATEHANDLE::handleRotateBottomRight] = srcRect.bottomRight();
	m_points[MOUSEROTATEHANDLE::handleRotateBottomMiddle] = QPointF(srcRect.center().x(), srcRect.bottom());
	m_points[MOUSEROTATEHANDLE::handleRotateBottomLeft] = srcRect.bottomLeft();
	m_points[MOUSEROTATEHANDLE::handleRotateMiddleLeft] = QPointF(srcRect.left(), srcRect.center().y());

	auto ret = MOUSEROTATEHANDLE::handleRotateNone;
	float l = 3.4028235E38;
	for (auto& iter : m_points)
	{
		auto length = getLength2(iter.second, innerPoint);
		if (length < l)
		{
			l = length;
			ret = iter.first;
		}
	}

	if (ret == MOUSEROTATEHANDLE::handleRotateNone)
		return QCursor();
	float angle = this->rotation() + 22.5;
	while (angle >= 360.0)
		angle -= 360;
	ret = MOUSEROTATEHANDLE(((int)ret + (int)( angle/ 45)) % c_rotate_cursors_size);
	if (ret == MOUSEROTATEHANDLE::handleRotateNone)
		ret = MOUSEROTATEHANDLE::handleRotateTopLeft;

	return m_cursorRotate[ret];
}

设置setRotateStart，表示开始旋转，记录此时的鼠标落点和角度。
设置setRotateEnd，基于上次设置的Start，进行旋转。并且始终保持rotation在[0,360)之间。
注：point是场景坐标。

void CustomRectItem::setRotateStart(const QPointF & point)
{
	m_mouseRotateStart = point;
	m_fLastAngle = rotation();
}
void CustomRectItem::setRotateEnd(const QPointF & point)
{
	QPointF ori = mapToScene(transformOriginPoint());
	QPointF v1 = m_mouseRotateStart - ori;
	QPointF v2 = point - ori;

	float angle = std::atan2f(v2.y(), v2.x()) - std::atan2f(v1.y(), v1.x());
	
	angle = m_fLastAngle + angle * 180 / 3.1415926;

	// angle = [0,360)
	while (angle < 0.0)
		angle += 360;
	while (angle >= 360.0)
		angle -= 360;

	setRotation(angle);
}

判断鼠标位置，应为的鼠标状态。

CustomRectItem::MOUSEHANDLE CustomRectItem::handleAt(const QPointF& point)
{
	for (auto it : m_handles)
	{
		if (it.second.contains(point))
			return it.first;
	}
	return MOUSEHANDLE::handleNone;
}

调整大小

void CustomRectItem::interactiveResize(const QPointF & mousePos)
{
	auto offset = c_handle_size + c_handle_space;
	auto bRect = boundingRect();
	auto rr = this->rect();
	auto diff = QPointF(0, 0);

	prepareGeometryChange();

	if (m_bhandleSelected == MOUSEHANDLE::handleTopLeft)
	{
		auto fromX = m_mousePressRect.left();
		auto fromY = m_mousePressRect.top();
		auto toX = fromX + mousePos.x() - m_mousePressRect.x();
		auto toY = fromY + mousePos.y() - m_mousePressRect.y();

		if (!(toX - fromX >= rr.width() || toY - fromY >= rr.height()))
		{
			diff.setX(toX - fromX);
			diff.setY(toY - fromY);
			bRect.setLeft(toX);
			bRect.setTop(toY);
			rr.setLeft(bRect.left() + offset);
			rr.setTop(bRect.top() + offset);
			this->setRect(rr);
		}		
	}
	else if (m_bhandleSelected == MOUSEHANDLE::handleTopMiddle)
	{
		auto fromY = m_mousePressRect.top();
		auto toY = fromY + mousePos.y() - m_mousePressPos.y();

		if (!(toY - fromY >= rr.height()))
		{
			diff.setY(toY - fromY);
			bRect.setTop(toY);
			rr.setTop(bRect.top() + offset);
			this->setRect(rr);
		}	
	}
	else if (m_bhandleSelected == MOUSEHANDLE::handleTopRight)
	{
		auto fromX = m_mousePressRect.right();
		auto fromY = m_mousePressRect.top();
		auto toX = fromX + mousePos.x() - m_mousePressPos.x();
		auto toY = fromY + mousePos.y() - m_mousePressPos.y();

		if (!(fromX - toX >= rr.width() || toY - fromY >= rr.height()))
		{
			diff.setX(toX - fromX);
			diff.setY(toY - fromY);
			bRect.setRight(toX);
			bRect.setTop(toY);
			rr.setRight(bRect.right() - offset);
			rr.setTop(bRect.top() + offset);
			this->setRect(rr);
		}
	}
	else if (m_bhandleSelected == MOUSEHANDLE::handleMiddleLeft)
	{
		auto fromX = m_mousePressRect.left();
		auto toX = fromX + mousePos.x() - m_mousePressPos.x();

		if (!(toX - fromX >= rr.width()))
		{
			diff.setX(toX - fromX);
			bRect.setLeft(toX);
			rr.setLeft(bRect.left() + offset);
			this->setRect(rr);
		}		
	}
	else if (m_bhandleSelected == MOUSEHANDLE::handleMiddleRight)
	{
		auto fromX = m_mousePressRect.right();
		auto toX = fromX + mousePos.x() - m_mousePressPos.x();

		if (!(fromX - toX >= rr.width()))
		{
			diff.setX(toX - fromX);
			bRect.setRight(toX);
			rr.setRight(bRect.right() - offset);
			this->setRect(rr);
		}
	}
	else if (m_bhandleSelected == MOUSEHANDLE::handleBottomLeft)
	{
		auto fromX = m_mousePressRect.left();
		auto fromY = m_mousePressRect.bottom();
		auto toX = fromX + mousePos.x() - m_mousePressPos.x();
		auto toY = fromY + mousePos.y() - m_mousePressPos.y();

		if (!(toX - fromX >= rr.width() || fromY - toY >= rr.height()))
		{
			diff.setX(toX - fromX);
			diff.setY(toY - fromY);
			bRect.setLeft(toX);
			bRect.setBottom(toY);
			rr.setLeft(bRect.left() + offset);
			rr.setBottom(bRect.bottom() - offset);
			this->setRect(rr);
		}	
	}
	else if (m_bhandleSelected == MOUSEHANDLE::handleBottomMiddle)
	{
		auto fromY = m_mousePressRect.bottom();
		auto toY = fromY + mousePos.y() - m_mousePressPos.y();

		if (!(fromY - toY >= rr.height()))
		{
			diff.setY(toY - fromY);
			bRect.setBottom(toY);
			rr.setBottom(bRect.bottom() - offset);
			this->setRect(rr);
		}
	}
	else if (m_bhandleSelected == MOUSEHANDLE::handleBottomRight)
	{
		auto fromX = m_mousePressRect.right();
		auto fromY = m_mousePressRect.bottom();
		auto toX = fromX + mousePos.x() - m_mousePressPos.x();
		auto toY = fromY + mousePos.y() - m_mousePressPos.y();

		if (!(fromX - toX >= rr.width() || fromY - toY >= rr.height()))
		{
			diff.setX(toX - fromX);
			diff.setY(toY - fromY);
			bRect.setRight(toX);
			bRect.setBottom(toY);
			rr.setRight(bRect.right() - offset);
			rr.setBottom(bRect.bottom() - offset);
			this->setRect(rr);
		}
	}
	updateHandlesPos();
}

简单的求两点距离平方的函数。因为这不属于这个类的附属功能，所以没有开放。当然，声明为static private会更好。

float CustomRectItem::getLength2(const QPointF & point1, const QPointF & point2)
{
	return (point1.x() - point2.x()) * (point1.x() - point2.x()) + (point1.y() - point2.y()) * (point1.y() - point2.y());
}
使用实例
#pragma once

#include <QtWidgets/QWidget>
#include <QGraphicsView>
#include "CustomRectItem.h"
#include "ui_QtGuiApplication4.h"

class QtGuiApplication4 : public QGraphicsView
{
	Q_OBJECT

public:
	QtGuiApplication4(QWidget *parent = Q_NULLPTR);

	void mouseMoveEvent(QMouseEvent* event) override;
	void mousePressEvent(QMouseEvent* event) override;
	void mouseReleaseEvent(QMouseEvent* event) override;

private:
	// the length2 with point1 and point2
	float getLength2(const QPointF& point1, const QPointF& point2);

private:
	Ui::QtGuiApplication4Class ui;
	QGraphicsScene* m_scene;
	CustomRectItem* m_rect;

	volatile bool m_bTurn;
};

#include "QtGuiApplication4.h"
#include <QDebug>
#include <QMouseEvent>
#include <QTimer>
#include <QBitmap>

QtGuiApplication4::QtGuiApplication4(QWidget *parent)
	: QGraphicsView(parent)
	, m_rect(nullptr)
	, m_scene(nullptr)
	, m_bTurn(false)
{
	ui.setupUi(this);

	m_scene = new QGraphicsScene();
	setScene(m_scene);
	resize(400, 400);

	QTimer::singleShot(1000, [this]() {
		m_rect = new CustomRectItem();
		m_rect->setPos(50, 50);
		m_scene->addItem(m_rect);

		m_rect->setRect(0, 0, 50, 50);
		m_rect->setTransformOriginPoint(25, 25);
		m_rect->setRotation(45);
	});
}

void QtGuiApplication4::mouseMoveEvent(QMouseEvent * event)
{
	if (m_bTurn != true)
	{
		QCursor cursor = m_rect->getRotateCursor(mapToScene(event->pos()));
		if (!cursor.pixmap().isNull())
		{
			viewport()->setCursor(cursor);
		}
		else if (!m_rect->isHover())
		{
			viewport()->setCursor(Qt::ArrowCursor);
		}
	}
	else
	{
		m_rect->setRotateEnd(mapToScene(event->pos()));
	}

	QGraphicsView::mouseMoveEvent(event);
}

void QtGuiApplication4::mousePressEvent(QMouseEvent * event)
{
	if (!m_rect->getRotateCursor(mapToScene(event->pos())).pixmap().isNull())
	{
		m_rect->setRotateStart(mapToScene(event->pos()));
		m_bTurn = true;
	}

	QGraphicsView::mousePressEvent(event);
}

void QtGuiApplication4::mouseReleaseEvent(QMouseEvent * event)
{
	if (true == m_bTurn)
	{
		m_bTurn = false;
	}
	QGraphicsView::mouseReleaseEvent(event);
}

float QtGuiApplication4::getLength2(const QPointF & point1, const QPointF & point2)
{
	return (point1.x() - point2.x()) * (point1.x() - point2.x()) + (point1.y() - point2.y()) * (point1.y() - point2.y());
}
xiaonuo911teamo
关注
  • 15
    点赞
  • 踩
  • 66
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Qt QGraphicsView移动、缩放
QtCompany的博客
08-04 1446
首先需要明白，view在整个视图框架中的角色是用于显示scene的，所以决定了如何展示scene，包括scale()函数，用于放大缩小所展示的scene；centerOn()函数，决定scene的中心在何方。所有的操作，都不会直接改变scene，改变的只是如何展现scene。view就像窗户，我们可以透过窗户看到窗外的景色。scene就像窗外的景色，需要窗户作为媒介才能够让我们看到，只不过这里的景色（scene）不一定会比窗户（view）大。
QGraphicsItem选中后，出现边框，可以拉伸
01-10
QGraphicsItem选中后，出现边框，可以拉伸，在Qt5下测试通过，已经在实际中使用，希望可以帮助到需要的人
利用QGraphicsitem、QGraphicsView、QGraphicsScene绘制可以更改矩形大小、移动矩形、旋转矩形的功能
小北博客
09-22 1191
文章目录前言一、效果展示1.添加选择图元2.拖拽移动图元3.旋转图元二、实现步骤1.自定义图元2.图元移动3.图元缩放总结前言提示：这里可以添加本文要记录的大概内容：例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。在Scene上绘制自定义后的QGraphicsItem类图形，Scene图形的坐标系和Item的坐标系是分开的，他们是两个不同的坐标系。简单的继承一些鼠标的事件就可以，然后完成对Scene画布拖拽移动查看、缩放画布的操作。
Qt QGraphics 实现可移动缩放的矩形框
ShareProgress的博客
09-24 9462
做图像处理有时需要在图像中选择一个矩形区域，矩形框需要可移动、缩放、查找当前位置，最近查了些资料，使用Qt完成了这个功能，为简化说明，这里只使用鼠标操作，完成矩形框的移动和缩放，键盘等其他功能和鼠标原理基本一致。 效果展示 Qt 实现可移动缩放的矩形框效果展示概述实现缩放时用到的小矩形 概述 完成该功能选择Graphics View Framework这个框架，重写QGraphicsItem...
QGraphicsItem旋转后，改变大小会让item平移
qq996980215的博客
03-29 1012
本文章重点表述QGraphicsItem中，对于旋转后的坐标变化。 我在实现QGraphicsRectItem的缩放和旋转时，遇到了这样一个问题。原本实现的缩放，在旋转后也是能用的。但是涉及到旋转中心的问题，让人有些难以理解，最终分析实践得到下述结论。 进入正题 QGrahpicsItem 对于旋转仅仅是保存了旋转的角度与旋转中心，并不保存旋转之后的坐标。下面看一个例子(这里借用QGraphicsItem旋转后，坐标变化机制解析_xiaonuo911teamo的博客-CSDN博客_qgraphics.
【QT】自定义旋转矩形DyRotatedRectangle
俊俊的博客
08-16 2430
一、功能 1、改变大小，宽度，高度 2、旋转角度 3、中间切换，箭头改变方向 二、效果图 三、实现原理 1、角度的定义 2、求旋转后的四个点坐标 3、画箭头 四、关键代码 DyRotatedRectangle.h #ifndef DYROTATEDRECTANGLE_H #define DYROTATEDRECTANGLE_H #include "BaseGraphicsItem.h" class DyRotatedRectangle :...
Qt 视图框架QGraphicsItem
m0_73443478的博客
11-19 1524
Qt 视图框架QGraphicsItem
GraphicsView学习-基本图元使用（2）
mahuifa的博客
10-07 1971
演示QGraphicsView如何使用内置的 直线、矩形、椭圆、多边形、简单文本、富文本、图片、绘图路径、窗口部件等基本图元；
QT-绘制ROI、矩形框、椭圆框，机器视觉
机器视觉
07-10 4154
#ifndef DRAWQWIDGET_H #define DRAWQWIDGET_H #include <QWidget> #include <QKeyEvent> #include <qpoint.h> #include <qpen.h> /* * */ typedef enum draw_shap_e{ DRAW_RECT, //画矩形 DRAW_ELLIPSE, //画椭圆 DRAW_NO ...
基于QT实现的图元拖曳、定点滚轮旋转和缩放
毕业作品网站
05-30 1422
摘要: 本次设计实现了图元的生成和编辑算法，实现文件交互和用户交互接口。应用设计上，我完成了满足文件接口要求的命令行程序，完成了基于鼠标点击的图元绘制、基于鼠标拖曳的图元移动，和基于可视化锚点及鼠标滚轮的图元旋转、图元缩放，并将控制逻辑集成到 GUI 应用中。最终使用静态编译对 Qt 应用程序进行打包. 关键词: 图元生成算法；图元编辑算法；图形视图框架；图元管理 一、进度报告 在算法模块方面，实现了直线和多边形的 DDA、Bresenham 算法；实现了中点圆和中点椭圆算法；实现了图元平移、缩放、旋转和两
QT下实现图片的自适应显示、缩放（以鼠标位置为中心进行缩放）、拖动、以及重置并截图保存
12-22
以上就是QT环境下实现图片自适应显示、缩放、拖动和截图的基本步骤。`EditPic`项目应该包含了这些功能的具体实现，你可以通过查看源代码来深入理解。记住，QT提供的图形视图框架非常强大，可以实现更复杂的图像操作...
QGraphicsView以鼠标点实现放大缩小、拖拽
12-22
在`QGraphicsView`中，我们可以设置缩放因子或者响应用户的鼠标滚轮事件来实现图像的放大和缩小。下面是如何实现这一功能的步骤： 1. **设置可缩放性**：通过调用`setInteractive(true)`使`QGraphicsView`可交互，...
QT跨平台画图代码。缩放 皮筋
02-02
4. 重写`mouseMoveEvent`，在其中计算鼠标移动后的位置，创建一个`QGraphicsRectItem`表示缩放矩形，并将其添加到`QGraphicsScene`中。 5. 重写`mouseReleaseEvent`，移除缩放矩形，并根据缩放矩形的大小调整`...
鼠标移动旋转矩形代码
10-10
在QT库中，我们可以利用其丰富的图形视图框架（QGraphicsView）来实现鼠标操作，如移动和旋转矩形的功能。下面将详细讲解如何通过QT实现这个功能。 首先，我们需要包含必要的QT库，并创建一个继承自`QGraphicsView`...
QT实现图片的简单编辑工具，支持多种图形绘制，支持图元的简单缩放，旋转。(源码)
12-19
本项目是基于QT框架实现的一个简单的图片编辑工具，它允许用户进行图形的绘制以及对已有图形进行缩放和旋转操作。 首先，QT中的`QWidget`类是所有GUI组件的基础，`QGraphicsView`和`QGraphicsScene`是用于创建高级...
Qt3D C++实现鼠标左键控制摄像机旋转模型，六视图切换，模型自动旋转
qq_8421的博客
06-17 1641
模型围绕自身旋转
12-Qt中使用QPainter绘制可以旋转角度的矩形
Robert Zhang
10-08 6923
一、效果图 二、原理 因为QPainter只能绘制水平的矩形，而现在想要绘制旋转来一定角度的矩形，就需要使用QPainter的旋转功能了。 使用到的函数分别如下： painter.translate(x1, y1);//把参数(x1, y1)指定的点移动到绘图区的左上角（绘图原点），使得目标绘制坐标成为坐标系的原点(0,0) painter.rotate(angle); //以坐标原点为中...
Qt 通过重写QGraphicItem实现绘制、拖动、缩放、旋转矩形
richer_live的博客
01-26 5834
Qt 通过重写QGraphicItem实现绘制、拖动、缩放、旋转矩形 本例程通过重写了一个类，继承自QGraphicItem，来实现了在qgraphicsScene上绘制、拖动、缩放、旋转矩形。 效果如下： 其实要实现绘制、拖动、缩放矩形都不难，难的是在旋转之后还要支持缩放。 我的思路是： 1.实现绘制矩形：只要定义一个全局变量QRectF m_oldRect，在外面矩形大小传进来，然后在paint函数里面绘制这个矩形就行 2.实现拖动矩形：重写mousePressEvent，mouseMoveEvent
QGraphicsView实现局部缩放，平移，并且能进行选中数据
家俊的博客
07-20 1641
前一段时间项目上有个小功能，是加载大批量数据，并且进行绘图显示。以前使用的方法是使用opnegl来进行渲染，效果是有的，但是怎么说呢。总觉得有点大材小用。opengl渲染时，是使用显卡的，不排除有些机器没有显卡。那可能程序就会奔溃。 最新的使用方法是使用graphicview结合paintevent进行绘制图像。 这是绘制图像的代码，通过从文件中读取数据。 qreal scaleFactor = this->matrix().m11(); sence->clear(); QIma
qgraphicsrectitem 圆角
最新发布
02-01
QGraphicsRectItem是Qt框架中用于在图形场景中呈现矩形形状的类。通常情况下，QGraphicsRectItem绘制的矩形是直角的，即四个角都是直角的。但是有时候我们希望绘制的矩形有圆角，这时就可以通过设置QGraphicsRectItem的圆角属性来实现。 要设置QGraphicsRectItem的圆角属性，可以使用setRoundness方法并传入圆角的大小作为参数。圆角的大小是一个浮点数，表示圆角的半径。当这个值大于0时，QGraphicsRectItem就会绘制具有圆角的矩形。 例如，如果我们想要创建一个具有10像素圆角的矩形，可以这样做： ```cpp QGraphicsRectItem *rectItem = new QGraphicsRectItem(x, y, width, height); rectItem->setRoundness(10.0); ``` 这样就会在图形场景中创建一个具有圆角的矩形。这样的功能在用户界面设计中经常会用到，因为圆角矩形看起来更加柔和美观，也更符合现代设计的潮流。 总之，通过设置QGraphicsRectItem的圆角属性，我们可以轻松实现在图形场景中绘制具有圆角的矩形，让我们的界面看起来更加美观和时尚。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值