rdr2view/anpro/imagecropper.cpp

/*****************************************************************************
* ImageCropper Qt Widget for cropping images
* Copyright (C) 2013 Dimka Novikov, to@dimkanovikov.pro
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
*****************************************************************************/

#include "imagecropper.h"

#include <QMouseEvent>
#include <QPainter>

namespace {
    static const QSize WIDGET_MINIMUM_SIZE(470, 470);
}

ImageCropper::ImageCropper(QWidget* parent) :
	QWidget(parent),
	pimpl(new ImageCropperPrivate)
{
	setMinimumSize(WIDGET_MINIMUM_SIZE);
	setMouseTracking(true);
}

ImageCropper::~ImageCropper()
{
	delete pimpl;
}

void ImageCropper::setImage(const QPixmap& _image)
{
	pimpl->imageForCropping = _image;
	update();
}

void ImageCropper::setBackgroundColor(const QColor& _backgroundColor)
{
	pimpl->backgroundColor = _backgroundColor;
	update();
}

void ImageCropper::setCroppingRectBorderColor(const QColor& _borderColor)
{
	pimpl->croppingRectBorderColor = _borderColor;
	update();
}

void ImageCropper::setProportion(const QSizeF& _proportion)
{
	// Пропорции хранятся в коэффициентах приращения сторон
	// Таким образом, при изменении размера области выделения,
	// размеры сторон изменяются на размер зависящий от
	// коэффициентов приращения.

	// Сохраним пропорциональную зависимость области выделения в коэффициентах приращения сторон
	if (pimpl->proportion != _proportion) {
		pimpl->proportion = _proportion;
		// ... расчитаем коэффициенты
		float heightDelta = (float)_proportion.height() / _proportion.width();
		float widthDelta = (float)_proportion.width() / _proportion.height();
		// ... сохраним коэффициенты
		pimpl->deltas.setHeight(heightDelta);
		pimpl->deltas.setWidth(widthDelta);
	}

	// Обновим пропорции области выделения
	if ( pimpl->isProportionFixed ) {
		float croppintRectSideRelation =
				(float)pimpl->croppingRect.width() / pimpl->croppingRect.height();
		float proportionSideRelation =
				(float)pimpl->proportion.width() / pimpl->proportion.height();
		// Если область выделения не соответствует необходимым пропорциям обновим её
		if (croppintRectSideRelation != proportionSideRelation) {
			bool widthShotrerThenHeight =
					pimpl->croppingRect.width() < pimpl->croppingRect.height();
			// ... установим размер той стороны, что длиннее
			if (widthShotrerThenHeight) {
				pimpl->croppingRect.setHeight(
							pimpl->croppingRect.width() * pimpl->deltas.height());
			} else {
				pimpl->croppingRect.setWidth(
							pimpl->croppingRect.height() * pimpl->deltas.width());
			}
			// ... перерисуем виджет
			update();
		}
	}

}

void ImageCropper::setProportionFixed(const bool _isFixed)
{
	if (pimpl->isProportionFixed != _isFixed) {
		pimpl->isProportionFixed = _isFixed;
		setProportion(pimpl->proportion);
	}
}

const QPixmap ImageCropper::cropImage()
{
	// Получим размер отображаемого изображения
	QSize scaledImageSize =
			pimpl->imageForCropping.scaled(
				this->size(), Qt::KeepAspectRatio, Qt::FastTransformation
				).size();
	// Определим расстояние от левого и верхнего краёв
	float leftDelta = 0;
	float topDelta = 0;
	const float HALF_COUNT = 2;
	if (this->size().height() == scaledImageSize.height()) {
		leftDelta = (this->width() - scaledImageSize.width()) / HALF_COUNT;
	} else {
		topDelta = (this->height() - scaledImageSize.height()) / HALF_COUNT;
	}
	// Определим пропорцию области обрезки по отношению к исходному изображению
	float xScale = (float)pimpl->imageForCropping.width()  / scaledImageSize.width();
	float yScale = (float)pimpl->imageForCropping.height() / scaledImageSize.height();
	// Расчитаем область обрезки с учётом коррекции размеров исходного изображения
	QRectF realSizeRect(
				QPointF(pimpl->croppingRect.left() - leftDelta, pimpl->croppingRect.top() - topDelta),
				pimpl->croppingRect.size());
	// ... корректируем левый и верхний края
	realSizeRect.setLeft((pimpl->croppingRect.left() - leftDelta) * xScale);
	realSizeRect.setTop ((pimpl->croppingRect.top() - topDelta) * yScale);
	// ... корректируем размер
	realSizeRect.setWidth(pimpl->croppingRect.width() * xScale);
	realSizeRect.setHeight(pimpl->croppingRect.height() * yScale);
	// Получаем обрезанное изображение
	return pimpl->imageForCropping.copy(realSizeRect.toRect());
}

// ********
// Protected section

void ImageCropper::paintEvent(QPaintEvent* _event)
{
	QWidget::paintEvent( _event );
	//
	QPainter widgetPainter(this);
	// Рисуем изображение по центру виджета
	{
		// ... подгоним изображение для отображения по размеру виджета
		QPixmap scaledImage =
				pimpl->imageForCropping.scaled(this->size(), Qt::KeepAspectRatio, Qt::FastTransformation);
		// ... заливаем фон
		widgetPainter.fillRect( this->rect(), pimpl->backgroundColor );
		// ... рисуем изображение по центру виджета
		if ( this->size().height() == scaledImage.height() ) {
			widgetPainter.drawPixmap( ( this->width() - scaledImage.width() ) / 2, 0, scaledImage );
		} else {
			widgetPainter.drawPixmap( 0, ( this->height() - scaledImage.height() ) / 2, scaledImage );
		}
	}
	// Рисуем область обрезки
	{
		// ... если это первое отображение после инициилизации, то центруем областо обрезки
		if (pimpl->croppingRect.isNull()) {
			const int width = WIDGET_MINIMUM_SIZE.width()/2;
			const int height = WIDGET_MINIMUM_SIZE.height()/2;
			pimpl->croppingRect.setSize(QSize(width, height));
			float x = (this->width() - pimpl->croppingRect.width())/2;
			float y = (this->height() - pimpl->croppingRect.height())/2;
			pimpl->croppingRect.moveTo(x, y);
		}

		// ... рисуем затемненную область
		QPainterPath p;
		p.addRect(pimpl->croppingRect);
		p.addRect(this->rect());
		widgetPainter.setBrush(QBrush(QColor(0,0,0,120)));
		widgetPainter.setPen(Qt::transparent);
		widgetPainter.drawPath(p);
		// Рамка и контрольные точки
		widgetPainter.setPen(pimpl->croppingRectBorderColor);
		// ... рисуем прямоугольник области обрезки
		{
			widgetPainter.setBrush(QBrush(Qt::transparent));
			widgetPainter.drawRect(pimpl->croppingRect);
		}
		// ... рисуем контрольные точки
		{
			widgetPainter.setBrush(QBrush(pimpl->croppingRectBorderColor));
			// Вспомогательные X координаты
			int leftXCoord   = pimpl->croppingRect.left() - 2;
			int centerXCoord = pimpl->croppingRect.center().x() - 3;
			int rightXCoord  = pimpl->croppingRect.right() - 2;
			// Вспомогательные Y координаты
			int topYCoord    = pimpl->croppingRect.top() - 2;
			int middleYCoord = pimpl->croppingRect.center().y() - 3;
			int bottomYCoord = pimpl->croppingRect.bottom() - 2;
			//
			const QSize pointSize(6, 6);
			//
			QVector<QRect> points;
			points
					// левая сторона
					<< QRect( QPoint(leftXCoord, topYCoord), pointSize )
					<< QRect( QPoint(leftXCoord, middleYCoord), pointSize )
					<< QRect( QPoint(leftXCoord, bottomYCoord), pointSize )
					// центр
					<< QRect( QPoint(centerXCoord, topYCoord), pointSize )
					<< QRect( QPoint(centerXCoord, middleYCoord), pointSize )
					<< QRect( QPoint(centerXCoord, bottomYCoord), pointSize )
					// правая сторона
					<< QRect( QPoint(rightXCoord, topYCoord), pointSize )
					<< QRect( QPoint(rightXCoord, middleYCoord), pointSize )
					<< QRect( QPoint(rightXCoord, bottomYCoord), pointSize );
			//
			widgetPainter.drawRects( points );
		}
		// ... рисуем пунктирные линии
		{
			QPen dashPen(pimpl->croppingRectBorderColor);
			dashPen.setStyle(Qt::DashLine);
			widgetPainter.setPen(dashPen);
			// ... вертикальная
			widgetPainter.drawLine(
						QPoint(pimpl->croppingRect.center().x(), pimpl->croppingRect.top()),
						QPoint(pimpl->croppingRect.center().x(), pimpl->croppingRect.bottom()) );
			// ... горизонтальная
			widgetPainter.drawLine(
						QPoint(pimpl->croppingRect.left(), pimpl->croppingRect.center().y()),
						QPoint(pimpl->croppingRect.right(), pimpl->croppingRect.center().y()) );
		}
	}
	//
	widgetPainter.end();
}

void ImageCropper::mousePressEvent(QMouseEvent* _event)
{
	if (_event->button() == Qt::LeftButton) {
		pimpl->isMousePressed = true;
		pimpl->startMousePos = _event->pos();
		pimpl->lastStaticCroppingRect = pimpl->croppingRect;
	}
	//
	updateCursorIcon(_event->pos());
}

void ImageCropper::mouseMoveEvent(QMouseEvent* _event)
{
	QPointF mousePos = _event->pos(); // относительно себя (виджета)
	//
	if (!pimpl->isMousePressed) {
		// Обработка обычного состояния, т.е. не изменяется размер
		// области обрезки, и она не перемещается по виджету
		pimpl->cursorPosition = cursorPosition(pimpl->croppingRect, mousePos);
		updateCursorIcon(mousePos);
	} else if (pimpl->cursorPosition != CursorPositionUndefined) {
		// Обработка действий над областью обрезки
		// ... определим смещение курсора мышки
		QPointF mouseDelta;
		mouseDelta.setX( mousePos.x() - pimpl->startMousePos.x() );
		mouseDelta.setY( mousePos.y() - pimpl->startMousePos.y() );
		//
		if (pimpl->cursorPosition != CursorPositionMiddle) {
			// ... изменяем размер области обрезки
			QRectF newGeometry =
					calculateGeometry(
						pimpl->lastStaticCroppingRect,
						pimpl->cursorPosition,
						mouseDelta);
			// ... пользователь пытается вывернуть область обрезки наизнанку
			if (!newGeometry.isNull()) {
				pimpl->croppingRect = newGeometry;
			}
		} else {
			// ... перемещаем область обрезки
			pimpl->croppingRect.moveTo( pimpl->lastStaticCroppingRect.topLeft() + mouseDelta );
		}
		// Перерисуем виджет
		update();
	}
}

void ImageCropper::mouseReleaseEvent(QMouseEvent* _event)
{
	pimpl->isMousePressed = false;
	updateCursorIcon(_event->pos());
}

// ********
// Private section

namespace {
	// Находится ли точка рядом с координатой стороны
	static bool isPointNearSide (const int _sideCoordinate, const int _pointCoordinate)
	{
		static const int indent = 10;
		return (_sideCoordinate - indent) < _pointCoordinate && _pointCoordinate < (_sideCoordinate + indent);
	}
}

CursorPosition ImageCropper::cursorPosition(const QRectF& _cropRect, const QPointF& _mousePosition)
{
	CursorPosition cursorPosition = CursorPositionUndefined;
	//
	if ( _cropRect.contains( _mousePosition ) ) {
		// Двухстороннее направление
		if (isPointNearSide(_cropRect.top(), _mousePosition.y()) &&
			isPointNearSide(_cropRect.left(), _mousePosition.x())) {
			cursorPosition = CursorPositionTopLeft;
		} else if (isPointNearSide(_cropRect.bottom(), _mousePosition.y()) &&
				   isPointNearSide(_cropRect.left(), _mousePosition.x())) {
			cursorPosition = CursorPositionBottomLeft;
		} else if (isPointNearSide(_cropRect.top(), _mousePosition.y()) &&
				   isPointNearSide(_cropRect.right(), _mousePosition.x())) {
			cursorPosition = CursorPositionTopRight;
		} else if (isPointNearSide(_cropRect.bottom(), _mousePosition.y()) &&
				   isPointNearSide(_cropRect.right(), _mousePosition.x())) {
			cursorPosition = CursorPositionBottomRight;
		// Одностороннее направление
		} else if (isPointNearSide(_cropRect.left(), _mousePosition.x())) {
			cursorPosition = CursorPositionLeft;
		} else if (isPointNearSide(_cropRect.right(), _mousePosition.x())) {
			cursorPosition = CursorPositionRight;
		} else if (isPointNearSide(_cropRect.top(), _mousePosition.y())) {
			cursorPosition = CursorPositionTop;
		} else if (isPointNearSide(_cropRect.bottom(), _mousePosition.y())) {
			cursorPosition = CursorPositionBottom;
		// Без направления
		} else {
			cursorPosition = CursorPositionMiddle;
		}
	}
	//
	return cursorPosition;
}

void ImageCropper::updateCursorIcon(const QPointF& _mousePosition)
{
	QCursor cursorIcon;
	//
	switch (cursorPosition(pimpl->croppingRect, _mousePosition))
	{
		case CursorPositionTopRight:
		case CursorPositionBottomLeft:
			cursorIcon = QCursor(Qt::SizeBDiagCursor);
			break;
		case CursorPositionTopLeft:
		case CursorPositionBottomRight:
			cursorIcon = QCursor(Qt::SizeFDiagCursor);
			break;
		case CursorPositionTop:
		case CursorPositionBottom:
			cursorIcon = QCursor(Qt::SizeVerCursor);
			break;
		case CursorPositionLeft:
		case CursorPositionRight:
			cursorIcon = QCursor(Qt::SizeHorCursor);
			break;
		case CursorPositionMiddle:
			cursorIcon = pimpl->isMousePressed ?
						QCursor(Qt::ClosedHandCursor) :
						QCursor(Qt::OpenHandCursor);
			break;
		case CursorPositionUndefined:
		default:
			cursorIcon = QCursor(Qt::ArrowCursor);
			break;
	}
	//
	this->setCursor(cursorIcon);
}

const QRectF ImageCropper::calculateGeometry(
		const QRectF& _sourceGeometry,
		const CursorPosition _cursorPosition,
		const QPointF& _mouseDelta
		)
{
	QRectF resultGeometry;
	//
	if ( pimpl->isProportionFixed ) {
		resultGeometry =
				calculateGeometryWithFixedProportions(
					_sourceGeometry, _cursorPosition, _mouseDelta, pimpl->deltas);
	} else {
		resultGeometry =
				calculateGeometryWithCustomProportions(
					_sourceGeometry, _cursorPosition, _mouseDelta);
	}
	// Если пользователь пытается вывернуть область обрезки наизнанку,
	// возвращаем null-прямоугольник
	if ((resultGeometry.left() >= resultGeometry.right()) ||
		(resultGeometry.top() >= resultGeometry.bottom())) {
		resultGeometry = QRect();
	}
	//
	return resultGeometry;
}

const QRectF ImageCropper::calculateGeometryWithCustomProportions(
		const QRectF& _sourceGeometry,
		const CursorPosition _cursorPosition,
		const QPointF& _mouseDelta
		)
{
	QRectF resultGeometry = _sourceGeometry;
	//
	switch ( _cursorPosition )
	{
		case CursorPositionTopLeft:
			resultGeometry.setLeft( _sourceGeometry.left() + _mouseDelta.x() );
			resultGeometry.setTop ( _sourceGeometry.top()  + _mouseDelta.y() );
			break;
		case CursorPositionTopRight:
			resultGeometry.setTop  ( _sourceGeometry.top()   + _mouseDelta.y() );
			resultGeometry.setRight( _sourceGeometry.right() + _mouseDelta.x() );
			break;
		case CursorPositionBottomLeft:
			resultGeometry.setBottom( _sourceGeometry.bottom() + _mouseDelta.y() );
			resultGeometry.setLeft  ( _sourceGeometry.left()   + _mouseDelta.x() );
			break;
		case CursorPositionBottomRight:
			resultGeometry.setBottom( _sourceGeometry.bottom() + _mouseDelta.y() );
			resultGeometry.setRight ( _sourceGeometry.right()  + _mouseDelta.x() );
			break;
		case CursorPositionTop:
			resultGeometry.setTop( _sourceGeometry.top() + _mouseDelta.y() );
			break;
		case CursorPositionBottom:
			resultGeometry.setBottom( _sourceGeometry.bottom() + _mouseDelta.y() );
			break;
		case CursorPositionLeft:
			resultGeometry.setLeft( _sourceGeometry.left() + _mouseDelta.x() );
			break;
		case CursorPositionRight:
			resultGeometry.setRight( _sourceGeometry.right() + _mouseDelta.x() );
			break;
		default:
			break;
	}
	//
	return resultGeometry;
}

const QRectF ImageCropper::calculateGeometryWithFixedProportions(
		const QRectF& _sourceGeometry,
		const CursorPosition _cursorPosition,
		const QPointF& _mouseDelta,
		const QSizeF& _deltas
		)
{
	QRectF resultGeometry = _sourceGeometry;
	//
	switch (_cursorPosition)
	{
		case CursorPositionLeft:
			resultGeometry.setTop(_sourceGeometry.top() + _mouseDelta.x() * _deltas.height());
			resultGeometry.setLeft(_sourceGeometry.left() + _mouseDelta.x());
			break;
		case CursorPositionRight:
			resultGeometry.setTop(_sourceGeometry.top() - _mouseDelta.x() * _deltas.height());
			resultGeometry.setRight(_sourceGeometry.right() + _mouseDelta.x());
			break;
		case CursorPositionTop:
			resultGeometry.setTop(_sourceGeometry.top() + _mouseDelta.y());
			resultGeometry.setRight(_sourceGeometry.right() - _mouseDelta.y() * _deltas.width());
			break;
		case CursorPositionBottom:
			resultGeometry.setBottom(_sourceGeometry.bottom() + _mouseDelta.y());
			resultGeometry.setRight(_sourceGeometry.right() + _mouseDelta.y() * _deltas.width());
			break;
		case CursorPositionTopLeft:
			if ((_mouseDelta.x() * _deltas.height()) < (_mouseDelta.y())) {
				resultGeometry.setTop(_sourceGeometry.top() + _mouseDelta.x() * _deltas.height());
				resultGeometry.setLeft(_sourceGeometry.left() + _mouseDelta.x());
			} else {
				resultGeometry.setTop(_sourceGeometry.top() + _mouseDelta.y());
				resultGeometry.setLeft(_sourceGeometry.left() + _mouseDelta.y() * _deltas.width());
			}
			break;
		case CursorPositionTopRight:
			if ((_mouseDelta.x() * _deltas.height() * -1) < (_mouseDelta.y())) {
				resultGeometry.setTop(_sourceGeometry.top() - _mouseDelta.x() * _deltas.height());
				resultGeometry.setRight(_sourceGeometry.right() + _mouseDelta.x() );
			} else {
				resultGeometry.setTop(_sourceGeometry.top() + _mouseDelta.y());
				resultGeometry.setRight(_sourceGeometry.right() - _mouseDelta.y() * _deltas.width());
			}
			break;
		case CursorPositionBottomLeft:
			if ((_mouseDelta.x() * _deltas.height()) < (_mouseDelta.y() * -1)) {
				resultGeometry.setBottom(_sourceGeometry.bottom() - _mouseDelta.x() * _deltas.height());
				resultGeometry.setLeft(_sourceGeometry.left() + _mouseDelta.x());
			} else {
				resultGeometry.setBottom(_sourceGeometry.bottom() + _mouseDelta.y());
				resultGeometry.setLeft(_sourceGeometry.left() - _mouseDelta.y() * _deltas.width());
			}
			break;
		case CursorPositionBottomRight:
			if ((_mouseDelta.x() * _deltas.height()) > (_mouseDelta.y())) {
				resultGeometry.setBottom(_sourceGeometry.bottom() + _mouseDelta.x() * _deltas.height());
				resultGeometry.setRight(_sourceGeometry.right() + _mouseDelta.x());
			} else {
				resultGeometry.setBottom(_sourceGeometry.bottom() + _mouseDelta.y());
				resultGeometry.setRight(_sourceGeometry.right() + _mouseDelta.y() * _deltas.width());
			}
			break;
		default:
			break;
	}
	//
	return resultGeometry;
}