KisCoordinatesConverter Class Reference

#include <kis_coordinates_converter.h>

Inheritance diagram for KisCoordinatesConverter:

Classes
struct	Private

Public Member Functions
void	beginRotation ()
qreal	clampZoom (qreal zoom) const
qreal	devicePixelRatio () const
QPoint	documentOffset () const
QPointF	documentOffsetF () const
template<class T >
_Private::Traits< T >::Result	documentToFlake (const T &obj) const
QTransform	documentToFlakeTransform () const
template<class T >
_Private::Traits< T >::Result	documentToImage (const T &obj) const
template<class T >
_Private::Traits< T >::Result	documentToWidget (const T &obj) const
QTransform	documentToWidgetTransform () const
qreal	effectivePhysicalZoom () const
qreal	effectiveZoom () const
void	enableNatureGestureFlag ()
void	endRotation ()
QPointF	flakeCenterPoint () const
template<class T >
_Private::Traits< T >::Result	flakeToDocument (const T &obj) const
template<class T >
_Private::Traits< T >::Result	flakeToWidget (const T &obj) const
QTransform	flakeToWidgetTransform () const
QSizeF	getCanvasWidgetSize () const
void	getOpenGLCheckersInfo (const QRectF &viewportRect, QTransform *textureTransform, QTransform *modelTransform, QRectF *textureRect, QRectF *modelRect, const bool scrollCheckers) const
void	getQPainterCheckersInfo (QTransform *transform, QPointF *brushOrigin, QPolygonF *polygon, const bool scrollCheckers) const
QPointF	imageCenterInWidgetPixel () const
void	imagePhysicalScale (qreal *scaleX, qreal *scaleY) const
QRectF	imageRectInDocumentPixels () const
QRect	imageRectInImagePixels () const
QRectF	imageRectInViewportPixels () const
QRectF	imageRectInWidgetPixels () const
void	imageScale (qreal *scaleX, qreal *scaleY) const
QSizeF	imageSizeInFlakePixels () const
template<class T >
_Private::Traits< T >::Result	imageToDocument (const T &obj) const
QTransform	imageToDocumentTransform () const
template<class T >
_Private::Traits< T >::Result	imageToViewport (const T &obj) const
QTransform	imageToViewportTransform () const
template<class T >
_Private::Traits< T >::Result	imageToWidget (const T &obj) const
QTransform	imageToWidgetTransform () const
	KisCoordinatesConverter ()
KoViewTransformStillPoint	makeDocStillPoint (const QPointF &docPoint) const override
	Creates a still point that links the docPoint of the image (in document pixels!) to the corresponding point on the screen (in the canvas widget).
KoViewTransformStillPoint	makeWidgetStillPoint (const QPointF &viewPoint) const override
	Creates a still point that links the viewPoint of the widget to the corresponding point of the image.
QPoint	maximumOffset () const
qreal	maxZoom () const
QPoint	minimumOffset () const
qreal	minZoom () const
void	mirror (const std::optional< KoViewTransformStillPoint > &stillPoint, bool mirrorXAxis, bool mirrorYAxis)
	mirrors the canvas
QPointF	preferredTransformationCenter () const
	returns the point in image coordinates which is supposed to be the default still point for the transformations of the canvas. It returns the point of the image that is "roughly" mapped to to the center of the canvas widget.
void	resetRotation (const std::optional< KoViewTransformStillPoint > &stillPoint)
	resets canvas rotation
void	rotate (const std::optional< KoViewTransformStillPoint > &stillPoint, qreal angle)
	rotates the canvas
qreal	rotationAngle () const
void	setCanvasWidgetSize (QSizeF size)
void	setCanvasWidgetSizeKeepZoom (const QSizeF &size)
void	setDevicePixelRatio (qreal value)
void	setDocumentOffset (const QPointF &offset)
void	setExtraReferencesBounds (const QRect &imageRect)
void	setImage (KisImageWSP image)
void	setImageBounds (const QRect &rect, const QPointF oldImageStillPoint, const QPointF newImageStillPoint)
void	setImageResolution (qreal xRes, qreal yRes)
void	setZoom (KoZoomMode::Mode mode, qreal zoom, qreal resolutionX, qreal resolutionY, const std::optional< KoViewTransformStillPoint > &stillPoint)
	changes the zoom mode of the canvas
void	setZoom (qreal zoom) override
QPointF	snapToDevicePixel (const QPointF &point) const
	Adjust a given pair of coordinates to the nearest device pixel according to the value of devicePixelRatio.
QSizeF	snapWidgetSizeToDevicePixel (const QSizeF &size) const
QVector< qreal >	standardZoomLevels () const
QSize	viewportDevicePixelSize () const
template<class T >
_Private::Traits< T >::Result	viewportToImage (const T &obj) const
template<class T >
_Private::Traits< T >::Result	viewportToWidget (const T &obj) const
QTransform	viewportToWidgetTransform () const
QTransform	viewToWidget () const override
QPointF	widgetCenterPoint () const
QRectF	widgetRectInFlakePixels () const
QRectF	widgetRectInImagePixels () const
template<class T >
_Private::Traits< T >::Result	widgetToDocument (const T &obj) const
template<class T >
_Private::Traits< T >::Result	widgetToFlake (const T &obj) const
template<class T >
_Private::Traits< T >::Result	widgetToImage (const T &obj) const
QTransform	widgetToView () const override
template<class T >
_Private::Traits< T >::Result	widgetToViewport (const T &obj) const
bool	xAxisMirrored () const
bool	yAxisMirrored () const
void	zoomTo (const QRectF &widgetRect)
	~KisCoordinatesConverter () override
Public Member Functions inherited from KoZoomHandler
QPointF	documentToView (const QPointF &documentPoint) const override
QRectF	documentToView (const QRectF &documentRect) const override
QSizeF	documentToView (const QSizeF &documentSize) const override
qreal	documentToViewX (qreal documentX) const override
qreal	documentToViewY (qreal documentY) const override
	KoZoomHandler ()
qreal	resolutionX () const
qreal	resolutionY () const
void	setDpi (int dpiX, int dpiY)
void	setResolution (qreal resolutionX, qreal resolutionY)
void	setZoom (qreal zoom) override
virtual void	setZoomedResolution (qreal zoomedResolutionX, qreal zoomedResolutionY)
void	setZoomMarginSize (int size)
void	setZoomMode (KoZoomMode::Mode zoomMode)
qreal	unzoomItX (qreal x) const
qreal	unzoomItY (qreal y) const
QPointF	viewToDocument (const QPointF &viewPoint) const override
QRectF	viewToDocument (const QRectF &viewRect) const override
QSizeF	viewToDocument (const QSizeF &viewSize) const override
qreal	viewToDocumentX (qreal viewX) const override
qreal	viewToDocumentY (qreal viewY) const override
qreal	zoom () const
virtual void	zoom (qreal *zoomX, qreal *zoomY) const
void	zoom (qreal *zoomX, qreal *zoomY) const override
qreal	zoomedResolutionX () const
qreal	zoomedResolutionY () const
qreal	zoomFactorX () const
qreal	zoomFactorY () const
int	zoomInPercent () const
qreal	zoomItX (qreal z) const
qreal	zoomItY (qreal z) const
int	zoomMarginSize () const
KoZoomMode::Mode	zoomMode () const
	~KoZoomHandler () override
Public Member Functions inherited from KoViewConverter
QTransform	documentToView () const
	KoViewConverter ()
QTransform	viewToDocument () const
qreal	zoom () const
virtual	~KoViewConverter ()

Static Public Member Functions
static qreal	findNextZoom (qreal currentZoom, const QVector< qreal > &zoomLevels)
static qreal	findPrevZoom (qreal currentZoom, const QVector< qreal > &zoomLevels)

Private Member Functions
QPointF	centeringCorrection () const
void	correctOffsetToTransformationAndSnap ()
void	correctTransformationToOffset ()
void	recalculateOffsetBoundsAndCrop ()
void	recalculateTransformations ()
void	recalculateZoomLevelLimits ()
void	resetPreferredTransformationCenter ()

Private Attributes
Private *const	m_d

Friends
class	KisCoordinatesConverterTest
class	KisZoomAndPanTest

Additional Inherited Members
Protected Attributes inherited from KoZoomHandler
qreal	m_resolutionX
qreal	m_resolutionY
qreal	m_zoomedResolutionX
qreal	m_zoomedResolutionY
int	m_zoomMarginSize
KoZoomMode::Mode	m_zoomMode

Detailed Description

Definition at line 48 of file kis_coordinates_converter.h.

Constructor & Destructor Documentation

KisCoordinatesConverter()

KisCoordinatesConverter::KisCoordinatesConverter

(

)

Definition at line 216 of file kis_coordinates_converter.cpp.

    : m_d(new Private) { }

~KisCoordinatesConverter()

KisCoordinatesConverter::~KisCoordinatesConverter ( )

override

Definition at line 219 of file kis_coordinates_converter.cpp.

{
    delete m_d;
}

References m_d.

Member Function Documentation

beginRotation()

void KisCoordinatesConverter::beginRotation

(

)

Definition at line 568 of file kis_coordinates_converter.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->isRotating);
 
    // Save the current transformation and angle to use as the base of the ongoing rotation.
    m_d->rotationBaseTransform = m_d->flakeToWidget;
    m_d->rotationBaseAngle = m_d->rotationAngle;
    m_d->isRotating = true;
}

References KisCoordinatesConverter::Private::flakeToWidget, KisCoordinatesConverter::Private::isRotating, KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, KisCoordinatesConverter::Private::rotationAngle, KisCoordinatesConverter::Private::rotationBaseAngle, and KisCoordinatesConverter::Private::rotationBaseTransform.

centeringCorrection()

QPointF KisCoordinatesConverter::centeringCorrection ( ) const

private

When vastScrolling value is less than 0.5 it is possible that the whole scrolling area (viewport) will be smaller than the size of the widget. In such cases the image should be centered in the widget. Previously we used a special parameter documentOrigin for this purpose, now the value for this centering is calculated dynamically, helping the offset to center the image inside the widget

Note that the correction is null when the size of the document plus vast scrolling reserve is larger than the widget. This is always true for vastScrolling parameter > 0.5.

Definition at line 96 of file kis_coordinates_converter.cpp.

{
    KisConfig cfg(true);
 
    QSize documentSize = imageRectInWidgetPixels().toAlignedRect().size();
    QPointF dPoint(documentSize.width(), documentSize.height());
    QPointF wPoint(m_d->canvasWidgetSize.width(), m_d->canvasWidgetSize.height());
 
    QPointF minOffset = -cfg.vastScrolling() * wPoint;
    QPointF maxOffset = dPoint - wPoint + cfg.vastScrolling() * wPoint;
 
    QPointF range = maxOffset - minOffset;
 
    range.rx() = qMin(range.x(), (qreal)0.0);
    range.ry() = qMin(range.y(), (qreal)0.0);
 
    range /= 2;
 
    return -range;
}

References KisCoordinatesConverter::Private::canvasWidgetSize, imageRectInWidgetPixels(), m_d, and KisConfig::vastScrolling().

clampZoom()

qreal KisCoordinatesConverter::clampZoom

(

qreal

zoom

)

const

Definition at line 927 of file kis_coordinates_converter.cpp.

{
    return std::clamp(zoom, minZoom(), maxZoom());
}

References maxZoom(), minZoom(), and KoZoomHandler::zoom().

correctOffsetToTransformationAndSnap()

void KisCoordinatesConverter::correctOffsetToTransformationAndSnap ( )

private

The document offset and the position of the top left corner of the image must always coincide, that is why we need to correct them to and fro.

When we change zoom level, the calculation of the new offset is done by KoCanvasControllerWidget, that is why we just passively fix the flakeToWidget transform to conform the offset and wait until the canvas controller will recenter us.

But when we do our own transformations of the canvas, like rotation and mirroring, we cannot rely on the centering of the canvas controller and we do it ourselves. Then we just set new offset and return its value to be set in the canvas controller explicitly.

Definition at line 173 of file kis_coordinates_converter.cpp.

{
    m_d->documentOffset = snapToDevicePixel(-(imageRectInWidgetPixels().topLeft() -
          centeringCorrection()));
}

References centeringCorrection(), KisCoordinatesConverter::Private::documentOffset, imageRectInWidgetPixels(), m_d, and snapToDevicePixel().

correctTransformationToOffset()

void KisCoordinatesConverter::correctTransformationToOffset ( )

private

Definition at line 179 of file kis_coordinates_converter.cpp.

{
    QPointF topLeft = imageRectInWidgetPixels().topLeft();
    QPointF diff = (-topLeft) - m_d->documentOffset;
    diff += centeringCorrection();
    m_d->flakeToWidget *= QTransform::fromTranslate(diff.x(), diff.y());
}

References centeringCorrection(), KisCoordinatesConverter::Private::documentOffset, KisCoordinatesConverter::Private::flakeToWidget, imageRectInWidgetPixels(), and m_d.

devicePixelRatio()

qreal KisCoordinatesConverter::devicePixelRatio

(

)

const

Definition at line 352 of file kis_coordinates_converter.cpp.

{
    return m_d->devicePixelRatio;
}

References KisCoordinatesConverter::Private::devicePixelRatio, and m_d.

documentOffset()

QPoint KisCoordinatesConverter::documentOffset

(

)

const

Definition at line 357 of file kis_coordinates_converter.cpp.

{
    return QPoint(int(m_d->documentOffset.x()), int(m_d->documentOffset.y()));
}

References KisCoordinatesConverter::Private::documentOffset, and m_d.

documentOffsetF()

QPointF KisCoordinatesConverter::documentOffsetF

(

)

const

Definition at line 362 of file kis_coordinates_converter.cpp.

{
    return m_d->documentOffset;
}

References KisCoordinatesConverter::Private::documentOffset, and m_d.

documentToFlake()

template<class T >

_Private::Traits< T >::Result KisCoordinatesConverter::documentToFlake ( const T & obj ) const

inline

Definition at line 182 of file kis_coordinates_converter.h.

{ return _Private::Traits<T>::map(documentToFlakeTransform(), obj); }

References _Private::Traits< T >::map().

documentToFlakeTransform()

QTransform KisCoordinatesConverter::documentToFlakeTransform

(

)

const

Definition at line 738 of file kis_coordinates_converter.cpp.

                                                                   {
    return m_d->documentToFlake;
}

References KisCoordinatesConverter::Private::documentToFlake, and m_d.

documentToImage()

template<class T >

_Private::Traits< T >::Result KisCoordinatesConverter::documentToImage ( const T & obj ) const

inline

Definition at line 179 of file kis_coordinates_converter.h.

{ return _Private::Traits<T>::map(imageToDocumentTransform().inverted(), obj); }

References _Private::Traits< T >::map().

documentToWidget()

template<class T >

_Private::Traits< T >::Result KisCoordinatesConverter::documentToWidget ( const T & obj ) const

inline

Definition at line 172 of file kis_coordinates_converter.h.

{ return _Private::Traits<T>::map(documentToWidgetTransform(), obj); }

References _Private::Traits< T >::map().

documentToWidgetTransform()

QTransform KisCoordinatesConverter::documentToWidgetTransform

(

)

const

Definition at line 746 of file kis_coordinates_converter.cpp.

                                                                    {
    return m_d->documentToFlake * m_d->flakeToWidget;
}

References KisCoordinatesConverter::Private::documentToFlake, KisCoordinatesConverter::Private::flakeToWidget, and m_d.

effectivePhysicalZoom()

qreal KisCoordinatesConverter::effectivePhysicalZoom

(

)

const

Definition at line 550 of file kis_coordinates_converter.cpp.

{
    qreal scaleX, scaleY;
    this->imagePhysicalScale(&scaleX, &scaleY);
 
    if (scaleX != scaleY) {
        qWarning() << "WARNING: Zoom is not isotropic!"  << ppVar(scaleX) << ppVar(scaleY) << ppVar(qFuzzyCompare(scaleX, scaleY));
    }
 
    // zoom by average of x and y
    return 0.5 * (scaleX + scaleY);
}

References imagePhysicalScale(), ppVar, and qFuzzyCompare().

effectiveZoom()

qreal KisCoordinatesConverter::effectiveZoom

(

)

const

A composition of to scale methods: zoom level + image resolution

Definition at line 537 of file kis_coordinates_converter.cpp.

{
    qreal scaleX, scaleY;
    this->imageScale(&scaleX, &scaleY);
 
    if (scaleX != scaleY) {
        qWarning() << "WARNING: Zoom is not isotropic!"  << ppVar(scaleX) << ppVar(scaleY) << ppVar(qFuzzyCompare(scaleX, scaleY));
    }
 
    // zoom by average of x and y
    return 0.5 * (scaleX + scaleY);
}

References imageScale(), ppVar, and qFuzzyCompare().

enableNatureGestureFlag()

void KisCoordinatesConverter::enableNatureGestureFlag

(

)

Definition at line 563 of file kis_coordinates_converter.cpp.

{
    m_d->isNativeGesture = true;
}

References KisCoordinatesConverter::Private::isNativeGesture, and m_d.

endRotation()

void KisCoordinatesConverter::endRotation

(

)

Definition at line 578 of file kis_coordinates_converter.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->isRotating);
 
    m_d->isNativeGesture = false;
    m_d->isRotating = false;
}

References KisCoordinatesConverter::Private::isNativeGesture, KisCoordinatesConverter::Private::isRotating, KIS_SAFE_ASSERT_RECOVER_NOOP, and m_d.

findNextZoom()

qreal KisCoordinatesConverter::findNextZoom ( qreal currentZoom, const QVector< qreal > & zoomLevels )

static

Definition at line 957 of file kis_coordinates_converter.cpp.

{
    return KoZoomMode::findNextZoom(currentZoom, zoomLevels);
}

References KoZoomMode::findNextZoom().

findPrevZoom()

qreal KisCoordinatesConverter::findPrevZoom ( qreal currentZoom, const QVector< qreal > & zoomLevels )

static

Definition at line 962 of file kis_coordinates_converter.cpp.

{
    return KoZoomMode::findPrevZoom(currentZoom, zoomLevels);
}

References KoZoomMode::findPrevZoom().

flakeCenterPoint()

QPointF KisCoordinatesConverter::flakeCenterPoint

(

)

const

Definition at line 855 of file kis_coordinates_converter.cpp.

{
    QRectF widgetRect = widgetRectInFlakePixels();
    return QPointF(widgetRect.left() + widgetRect.width() / 2,
                   widgetRect.top() + widgetRect.height() / 2);
}

References widgetRectInFlakePixels().

flakeToDocument()

template<class T >

_Private::Traits< T >::Result KisCoordinatesConverter::flakeToDocument ( const T & obj ) const

inline

Definition at line 184 of file kis_coordinates_converter.h.

{ return _Private::Traits<T>::map(documentToFlakeTransform().inverted(), obj); }

References _Private::Traits< T >::map().

flakeToWidget()

template<class T >

_Private::Traits< T >::Result KisCoordinatesConverter::flakeToWidget ( const T & obj ) const

inline

Definition at line 162 of file kis_coordinates_converter.h.

{ return _Private::Traits<T>::map(flakeToWidgetTransform(), obj); }

References _Private::Traits< T >::map().

flakeToWidgetTransform()

QTransform KisCoordinatesConverter::flakeToWidgetTransform

(

)

const

Definition at line 742 of file kis_coordinates_converter.cpp.

                                                                 {
    return m_d->flakeToWidget;
}

References KisCoordinatesConverter::Private::flakeToWidget, and m_d.

getCanvasWidgetSize()

QSizeF KisCoordinatesConverter::getCanvasWidgetSize

(

)

const

Definition at line 224 of file kis_coordinates_converter.cpp.

{
    return m_d->canvasWidgetSize;
}

References KisCoordinatesConverter::Private::canvasWidgetSize, and m_d.

getOpenGLCheckersInfo()

void KisCoordinatesConverter::getOpenGLCheckersInfo	(	const QRectF &	viewportRect,
		QTransform *	textureTransform,
		QTransform *	modelTransform,
		QRectF *	textureRect,
		QRectF *	modelRect,
		const bool	scrollCheckers ) const

Definition at line 787 of file kis_coordinates_converter.cpp.

{
    if(scrollCheckers) {
        *textureTransform = QTransform();
        *textureRect = QRectF(0, 0, viewportRect.width(),viewportRect.height());
    }
    else {
        *textureTransform = viewportToWidgetTransform();
        *textureRect = viewportRect;
    }
 
    *modelTransform = viewportToWidgetTransform();
    *modelRect = viewportRect;
}

References viewportToWidgetTransform().

getQPainterCheckersInfo()

void KisCoordinatesConverter::getQPainterCheckersInfo	(	QTransform *	transform,
		QPointF *	brushOrigin,
		QPolygonF *	polygon,
		const bool	scrollCheckers ) const

Qt has different rounding for QPainter::drawRect/drawImage. The image is rounded mathematically, while rect in aligned to the next integer. That causes transparent line appear on the canvas.

See: https://bugreports.qt.nokia.com/browse/QTBUG-22827

Definition at line 758 of file kis_coordinates_converter.cpp.

{
    QRectF imageRect = imageRectInViewportPixels();
    imageRect.adjust(0,0,-0.5,-0.5);
 
    if (scrollCheckers) {
        *transform = viewportToWidgetTransform();
        *polygon = imageRect;
        *brushOrigin = imageToViewport(QPointF(0,0));
    }
    else {
        *transform = QTransform();
        *polygon = viewportToWidgetTransform().map(imageRect);
        *brushOrigin = QPoint(0,0);
    }
}

References imageRectInViewportPixels(), imageToViewport(), and viewportToWidgetTransform().

imageCenterInWidgetPixel()

QPointF KisCoordinatesConverter::imageCenterInWidgetPixel

(

)

const

Definition at line 807 of file kis_coordinates_converter.cpp.

{
    QPolygonF poly = imageToWidget(QPolygon(m_d->imageBounds));
    return (poly[0] + poly[1] + poly[2] + poly[3]) / 4.0;
}

References KisCoordinatesConverter::Private::imageBounds, imageToWidget(), and m_d.

imagePhysicalScale()

void KisCoordinatesConverter::imagePhysicalScale	(	qreal *	scaleX,
		qreal *	scaleY ) const

Definition at line 882 of file kis_coordinates_converter.cpp.

{
    imageScale(scaleX, scaleY);
    *scaleX *= m_d->devicePixelRatio;
    *scaleY *= m_d->devicePixelRatio;
}

References KisCoordinatesConverter::Private::devicePixelRatio, imageScale(), and m_d.

imageRectInDocumentPixels()

QRectF KisCoordinatesConverter::imageRectInDocumentPixels

(

)

const

Definition at line 831 of file kis_coordinates_converter.cpp.

{
    return imageToDocument(m_d->imageBounds);
}

References KisCoordinatesConverter::Private::imageBounds, imageToDocument(), and m_d.

imageRectInImagePixels()

QRect KisCoordinatesConverter::imageRectInImagePixels

(

)

const

Definition at line 826 of file kis_coordinates_converter.cpp.

{
    return m_d->imageBounds;
}

References KisCoordinatesConverter::Private::imageBounds, and m_d.

imageRectInViewportPixels()

QRectF KisCoordinatesConverter::imageRectInViewportPixels

(

)

const

Definition at line 821 of file kis_coordinates_converter.cpp.

{
    return imageToViewport(m_d->imageBounds);
}

References KisCoordinatesConverter::Private::imageBounds, imageToViewport(), and m_d.

imageRectInWidgetPixels()

QRectF KisCoordinatesConverter::imageRectInWidgetPixels

(

)

const

Definition at line 816 of file kis_coordinates_converter.cpp.

{
    return imageToWidget(m_d->imageBounds);
}

References KisCoordinatesConverter::Private::imageBounds, imageToWidget(), and m_d.

imageScale()

void KisCoordinatesConverter::imageScale	(	qreal *	scaleX,
		qreal *	scaleY ) const

Definition at line 867 of file kis_coordinates_converter.cpp.

{
    // get the x and y zoom level of the canvas
    qreal zoomX, zoomY;
    KoZoomHandler::zoom(&zoomX, &zoomY);
 
    // Get the KisImage resolution
    qreal resX = m_d->imageXRes;
    qreal resY = m_d->imageYRes;
 
    // Compute the scale factors
    *scaleX = zoomX / resX;
    *scaleY = zoomY / resY;
}

References KisCoordinatesConverter::Private::imageXRes, KisCoordinatesConverter::Private::imageYRes, m_d, and KoZoomHandler::zoom().

imageSizeInFlakePixels()

QSizeF KisCoordinatesConverter::imageSizeInFlakePixels

(

)

const

Definition at line 836 of file kis_coordinates_converter.cpp.

{
    qreal scaleX, scaleY;
    imageScale(&scaleX, &scaleY);
    QSize imageSize = m_d->imageBounds.size();
 
    return QSizeF(imageSize.width() * scaleX, imageSize.height() * scaleY);
}

References KisCoordinatesConverter::Private::imageBounds, imageScale(), and m_d.

imageToDocument()

template<class T >

_Private::Traits< T >::Result KisCoordinatesConverter::imageToDocument ( const T & obj ) const

inline

Definition at line 177 of file kis_coordinates_converter.h.

{ return _Private::Traits<T>::map(imageToDocumentTransform(), obj); }

References _Private::Traits< T >::map().

imageToDocumentTransform()

QTransform KisCoordinatesConverter::imageToDocumentTransform

(

)

const

Definition at line 734 of file kis_coordinates_converter.cpp.

                                                                   {
    return m_d->imageToDocument;
}

References KisCoordinatesConverter::Private::imageToDocument, and m_d.

imageToViewport()

template<class T >

_Private::Traits< T >::Result KisCoordinatesConverter::imageToViewport ( const T & obj ) const

inline

Definition at line 157 of file kis_coordinates_converter.h.

{ return _Private::Traits<T>::map(imageToViewportTransform(), obj); }

References _Private::Traits< T >::map().

imageToViewportTransform()

QTransform KisCoordinatesConverter::imageToViewportTransform

(

)

const

Definition at line 754 of file kis_coordinates_converter.cpp.

                                                                   {
    return m_d->imageToDocument * m_d->documentToFlake * m_d->flakeToWidget * m_d->widgetToViewport;
}

References KisCoordinatesConverter::Private::documentToFlake, KisCoordinatesConverter::Private::flakeToWidget, KisCoordinatesConverter::Private::imageToDocument, m_d, and KisCoordinatesConverter::Private::widgetToViewport.

imageToWidget()

template<class T >

_Private::Traits< T >::Result KisCoordinatesConverter::imageToWidget ( const T & obj ) const

inline

Definition at line 187 of file kis_coordinates_converter.h.

{ return _Private::Traits<T>::map(imageToWidgetTransform(), obj); }

References _Private::Traits< T >::map().

imageToWidgetTransform()

QTransform KisCoordinatesConverter::imageToWidgetTransform

(

)

const

Definition at line 730 of file kis_coordinates_converter.cpp.

                                                                 {
    return m_d->imageToDocument * m_d->documentToFlake * m_d->flakeToWidget;
}

References KisCoordinatesConverter::Private::documentToFlake, KisCoordinatesConverter::Private::flakeToWidget, KisCoordinatesConverter::Private::imageToDocument, and m_d.

makeDocStillPoint()

KoViewTransformStillPoint KisCoordinatesConverter::makeDocStillPoint ( const QPointF & docPoint ) const

overridevirtual

Creates a still point that links the docPoint of the image (in document pixels!) to the corresponding point on the screen (in the canvas widget).

The link is "baked" in KoViewTransformStillPoint object, hence intermediate transformations will not affect it.

Reimplemented in KisCoordinatesConverter.

Reimplemented from KoViewConverter.

Definition at line 972 of file kis_coordinates_converter.cpp.

{
    return {docPoint, documentToWidget(docPoint)};
}

References documentToWidget().

makeWidgetStillPoint()

KoViewTransformStillPoint KisCoordinatesConverter::makeWidgetStillPoint ( const QPointF & viewPoint ) const

overridevirtual

Creates a still point that links the viewPoint of the widget to the corresponding point of the image.

The link is "baked" in KoViewTransformStillPoint object, hence intermediate transformations will not affect it.

Reimplemented in KisCoordinatesConverter.

Reimplemented from KoViewConverter.

Definition at line 967 of file kis_coordinates_converter.cpp.

{
    return {widgetToDocument(viewPoint), viewPoint};
}

References widgetToDocument().

maximumOffset()

QPoint KisCoordinatesConverter::maximumOffset

(

)

const

Definition at line 152 of file kis_coordinates_converter.cpp.

{
    return m_d->maximumOffset;
}

References m_d, and KisCoordinatesConverter::Private::maximumOffset.

maxZoom()

qreal KisCoordinatesConverter::maxZoom

(

)

const

Definition at line 923 of file kis_coordinates_converter.cpp.

{
    return m_d->maxZoom;
}

References m_d, and KisCoordinatesConverter::Private::maxZoom.

minimumOffset()

QPoint KisCoordinatesConverter::minimumOffset

(

)

const

Definition at line 147 of file kis_coordinates_converter.cpp.

{
    return m_d->minimumOffset;
}

References m_d, and KisCoordinatesConverter::Private::minimumOffset.

minZoom()

qreal KisCoordinatesConverter::minZoom

(

)

const

Definition at line 919 of file kis_coordinates_converter.cpp.

{
    return m_d->minZoom;
}

References m_d, and KisCoordinatesConverter::Private::minZoom.

mirror()

void KisCoordinatesConverter::mirror	(	const std::optional< KoViewTransformStillPoint > &	stillPoint,
		bool	mirrorXAxis,
		bool	mirrorYAxis )

mirrors the canvas

For the meaning of stillPoint

See also

setZoom()

Definition at line 628 of file kis_coordinates_converter.cpp.

{
    bool keepOrientation = false; // XXX: Keep here for now, maybe some day we can restore the parameter again.
 
    KoViewTransformStillPoint effectiveStillPoint =
        stillPoint ? *stillPoint :
        KoViewTransformStillPoint(m_d->preferredTransformationCenterInDocumentPixels(), widgetCenterPoint());
 
 
    if (kisSquareDistance(effectiveStillPoint.viewPoint(), widgetCenterPoint()) > 2.0) {
        // when mirroring not against the center, reset the zoom mode
        setZoomMode(KoZoomMode::ZOOM_CONSTANT);
    }
 
    const QPointF oldDocumentOffset = m_d->documentOffset;
 
    bool       doXMirroring = m_d->isXAxisMirrored ^ mirrorXAxis;
    bool       doYMirroring = m_d->isYAxisMirrored ^ mirrorYAxis;
    qreal      scaleX       = doXMirroring ? -1.0 : 1.0;
    qreal      scaleY       = doYMirroring ? -1.0 : 1.0;
    QTransform mirror       = QTransform::fromScale(scaleX, scaleY);
 
    QTransform rot;
    rot.rotate(m_d->rotationAngle);
 
    m_d->flakeToWidget *= QTransform::fromTranslate(-effectiveStillPoint.viewPoint().x(),-effectiveStillPoint.viewPoint().y());
 
    if (keepOrientation) {
        m_d->flakeToWidget *= rot.inverted();
    }
 
    m_d->flakeToWidget *= mirror;
 
    if (keepOrientation) {
        m_d->flakeToWidget *= rot;
    }
 
    m_d->flakeToWidget *= QTransform::fromTranslate(effectiveStillPoint.viewPoint().x(),effectiveStillPoint.viewPoint().y());
 
 
    if (!keepOrientation && (doXMirroring ^ doYMirroring)) {
        m_d->rotationAngle = -m_d->rotationAngle;
    }
 
    m_d->isXAxisMirrored = mirrorXAxis;
    m_d->isYAxisMirrored = mirrorYAxis;
 
    correctOffsetToTransformationAndSnap();
 
    if (zoomMode() != KoZoomMode::ZOOM_CONSTANT) {
        // we were "centered", so let's try to keep the offset as before
        m_d->documentOffset = oldDocumentOffset;
    } else {
        recalculateTransformations();
        const QPointF newStillPoint = documentToWidget(effectiveStillPoint.docPoint());
        const QPointF offset = newStillPoint - effectiveStillPoint.viewPoint();
        m_d->documentOffset = snapToDevicePixel(m_d->documentOffset + offset);
    }
 
    recalculateTransformations();
 
    if (stillPoint) {
        resetPreferredTransformationCenter();
    }
}

References correctOffsetToTransformationAndSnap(), KoViewTransformStillPoint::docPoint(), KisCoordinatesConverter::Private::documentOffset, documentToWidget(), KisCoordinatesConverter::Private::flakeToWidget, KisCoordinatesConverter::Private::isXAxisMirrored, KisCoordinatesConverter::Private::isYAxisMirrored, kisSquareDistance(), m_d, mirror(), KisCoordinatesConverter::Private::preferredTransformationCenterInDocumentPixels(), recalculateTransformations(), resetPreferredTransformationCenter(), KisCoordinatesConverter::Private::rotationAngle, KoZoomHandler::setZoomMode(), snapToDevicePixel(), KoViewTransformStillPoint::viewPoint(), widgetCenterPoint(), KoZoomMode::ZOOM_CONSTANT, and KoZoomHandler::zoomMode().

preferredTransformationCenter()

QPointF KisCoordinatesConverter::preferredTransformationCenter

(

)

const

returns the point in image coordinates which is supposed to be the default still point for the transformations of the canvas. It returns the point of the image that is "roughly" mapped to to the center of the canvas widget.

Some of the methods of the converter accept std::optional<KoViewTransformStillPoint> for a still point, over which the transformation should happen. When this argument is std::nullotp, then preferredTransformationCenter() is used.

One important property of preferredTransformationCenter() is that it is not changed when the canvas is transformed over it, even when pixel alignment happens. It means that preferredTransformationCenter() may not exactly map to the center of the widget, due to hardware-pixel-alignment.

Keeping this value unchanged allows us to avoid drifts of the offset when zooming and rotating the canvas.

Definition at line 367 of file kis_coordinates_converter.cpp.

{
    return m_d->preferredTransformationCenterImage;
}

References m_d, and KisCoordinatesConverter::Private::preferredTransformationCenterImage.

recalculateOffsetBoundsAndCrop()

void KisCoordinatesConverter::recalculateOffsetBoundsAndCrop ( )

private

Definition at line 117 of file kis_coordinates_converter.cpp.

{
    if (!m_d->canvasWidgetSize.isValid()) return;
 
    KisConfig cfg(true);
 
    const QRect refRect = imageToWidget(m_d->extraReferencesBounds).toAlignedRect();
 
    QRect documentRect = imageRectInWidgetPixels().toAlignedRect();
    QPointF dPointMax(qMax(documentRect.width(), refRect.right() + 1 - documentRect.x()),
                      qMax(documentRect.height(),  refRect.bottom() + 1 - documentRect.y()));
    QPointF dPointMin(qMin(0, refRect.left() - documentRect.x()),
                      qMin(0,  refRect.top() - documentRect.y()));
    QPointF wPoint(m_d->canvasWidgetSize.width(), m_d->canvasWidgetSize.height());
 
    QPointF minOffset = dPointMin - cfg.vastScrolling() * wPoint;
    QPointF maxOffset = dPointMax - wPoint + cfg.vastScrolling() * wPoint;
 
    m_d->minimumOffset = minOffset.toPoint();
    m_d->maximumOffset = maxOffset.toPoint();
 
    const QRectF limitRect(m_d->minimumOffset, m_d->maximumOffset);
 
    if (!limitRect.contains(m_d->documentOffset)) {
        m_d->documentOffset = snapToDevicePixel(KisAlgebra2D::clampPoint(m_d->documentOffset, limitRect));
        qDebug() << "    corrected offset:" << m_d->documentOffset;
        correctTransformationToOffset();
    }
}

References KisCoordinatesConverter::Private::canvasWidgetSize, KisAlgebra2D::clampPoint(), correctTransformationToOffset(), KisCoordinatesConverter::Private::documentOffset, KisCoordinatesConverter::Private::extraReferencesBounds, imageRectInWidgetPixels(), imageToWidget(), m_d, KisCoordinatesConverter::Private::maximumOffset, KisCoordinatesConverter::Private::minimumOffset, snapToDevicePixel(), and KisConfig::vastScrolling().

recalculateTransformations()

void KisCoordinatesConverter::recalculateTransformations ( )

private

Definition at line 192 of file kis_coordinates_converter.cpp.

{
    m_d->imageToDocument = QTransform::fromScale(1 / m_d->imageXRes,
                                                 1 / m_d->imageYRes);
 
    qreal zoomX, zoomY;
    KoZoomHandler::zoom(&zoomX, &zoomY);
    m_d->documentToFlake = QTransform::fromScale(zoomX, zoomY);
 
    correctTransformationToOffset();
    recalculateOffsetBoundsAndCrop();
 
    QRectF irect = imageRectInWidgetPixels();
    QRectF wrect = QRectF(QPoint(0,0), m_d->canvasWidgetSize);
    QRectF rrect = irect & wrect;
 
    QTransform reversedTransform = flakeToWidgetTransform().inverted();
    QRectF     canvasBounds      = reversedTransform.mapRect(rrect);
    QPointF    offset            = canvasBounds.topLeft();
 
    m_d->widgetToViewport = reversedTransform * QTransform::fromTranslate(-offset.x(), -offset.y());
}

References KisCoordinatesConverter::Private::canvasWidgetSize, correctTransformationToOffset(), KisCoordinatesConverter::Private::documentToFlake, flakeToWidgetTransform(), imageRectInWidgetPixels(), KisCoordinatesConverter::Private::imageToDocument, KisCoordinatesConverter::Private::imageXRes, KisCoordinatesConverter::Private::imageYRes, m_d, recalculateOffsetBoundsAndCrop(), KisCoordinatesConverter::Private::widgetToViewport, and KoZoomHandler::zoom().

recalculateZoomLevelLimits()

void KisCoordinatesConverter::recalculateZoomLevelLimits ( )

private

Definition at line 942 of file kis_coordinates_converter.cpp.

{
    qreal minDimension = 0.0;
 
    if (m_d->imageBounds.width() < m_d->imageBounds.height()) {
        minDimension = m_d->imageBounds.width() * resolutionX() / m_d->imageXRes;
    } else {
        minDimension = m_d->imageBounds.height() * resolutionY() / m_d->imageYRes;
    }
 
    m_d->minZoom = qMin(100.0 / minDimension, 0.1);
    m_d->maxZoom = 90.0;
    m_d->standardZoomLevels.clear(); // TODO: reset only on real change!
}

References KisCoordinatesConverter::Private::imageBounds, KisCoordinatesConverter::Private::imageXRes, KisCoordinatesConverter::Private::imageYRes, m_d, KisCoordinatesConverter::Private::maxZoom, KisCoordinatesConverter::Private::minZoom, KoZoomHandler::resolutionX(), KoZoomHandler::resolutionY(), and KisCoordinatesConverter::Private::standardZoomLevels.

resetPreferredTransformationCenter()

void KisCoordinatesConverter::resetPreferredTransformationCenter ( )

private

Definition at line 187 of file kis_coordinates_converter.cpp.

{
    m_d->preferredTransformationCenterImage = widgetToImage(this->widgetCenterPoint());
}

References m_d, KisCoordinatesConverter::Private::preferredTransformationCenterImage, widgetCenterPoint(), and widgetToImage().

resetRotation()

void KisCoordinatesConverter::resetRotation

(

const std::optional< KoViewTransformStillPoint > &

stillPoint

)

resets canvas rotation

For the meaning of stillPoint

See also

setZoom()

Definition at line 704 of file kis_coordinates_converter.cpp.

{
    KoViewTransformStillPoint effectiveStillPoint =
        stillPoint ? *stillPoint :
        KoViewTransformStillPoint(m_d->preferredTransformationCenterInDocumentPixels(), widgetCenterPoint());
 
    QTransform rot;
    rot.rotate(-m_d->rotationAngle);
 
    m_d->flakeToWidget *= rot;
    m_d->rotationAngle = 0.0;
    m_d->rotationIsOrthogonal = true;
 
    correctOffsetToTransformationAndSnap();
    recalculateTransformations();
 
    const QPointF newStillPoint = documentToWidget(effectiveStillPoint.docPoint());
    const QPointF offset = newStillPoint - effectiveStillPoint.viewPoint();
    m_d->documentOffset = snapToDevicePixel(m_d->documentOffset + offset);
    recalculateTransformations();
 
    if (stillPoint) {
        resetPreferredTransformationCenter();
    }
}

References correctOffsetToTransformationAndSnap(), KoViewTransformStillPoint::docPoint(), KisCoordinatesConverter::Private::documentOffset, documentToWidget(), KisCoordinatesConverter::Private::flakeToWidget, m_d, KisCoordinatesConverter::Private::preferredTransformationCenterInDocumentPixels(), recalculateTransformations(), resetPreferredTransformationCenter(), KisCoordinatesConverter::Private::rotationAngle, KisCoordinatesConverter::Private::rotationIsOrthogonal, snapToDevicePixel(), KoViewTransformStillPoint::viewPoint(), and widgetCenterPoint().

rotate()

void KisCoordinatesConverter::rotate	(	const std::optional< KoViewTransformStillPoint > &	stillPoint,
		qreal	angle )

rotates the canvas

For the meaning of stillPoint

See also

setZoom()

Definition at line 586 of file kis_coordinates_converter.cpp.

{
    setZoomMode(KoZoomMode::ZOOM_CONSTANT);
 
    KoViewTransformStillPoint effectiveStillPoint =
        stillPoint ? *stillPoint :
        KoViewTransformStillPoint(m_d->preferredTransformationCenterInDocumentPixels(), widgetCenterPoint());
 
    QTransform rot;
    rot.rotate(angle);
 
    if (!m_d->isNativeGesture && m_d->isRotating)
    {
        // Modal (begin/end) rotation. Transform from the stable base.
        m_d->flakeToWidget = m_d->rotationBaseTransform;
        m_d->rotationAngle = std::fmod(m_d->rotationBaseAngle + angle, 360.0);
    }
    else
    {
        // Immediate rotation, directly applied to the canvas transformation.
        m_d->rotationAngle = std::fmod(m_d->rotationAngle + angle, 360.0);
    }
 
    {
        const qreal numQuadrants = m_d->rotationAngle / 90.0;
        m_d->rotationIsOrthogonal = std::floor(numQuadrants) == numQuadrants;
    }
 
    m_d->flakeToWidget *= rot;
    correctOffsetToTransformationAndSnap();
    recalculateTransformations();
 
    const QPointF newStillPoint = documentToWidget(effectiveStillPoint.docPoint());
    const QPointF offset = newStillPoint - effectiveStillPoint.viewPoint();
    m_d->documentOffset = snapToDevicePixel(m_d->documentOffset + offset);
    recalculateTransformations();
 
    if (stillPoint) {
        resetPreferredTransformationCenter();
    }
}

References correctOffsetToTransformationAndSnap(), KoViewTransformStillPoint::docPoint(), KisCoordinatesConverter::Private::documentOffset, documentToWidget(), KisCoordinatesConverter::Private::flakeToWidget, KisCoordinatesConverter::Private::isNativeGesture, KisCoordinatesConverter::Private::isRotating, m_d, KisCoordinatesConverter::Private::preferredTransformationCenterInDocumentPixels(), recalculateTransformations(), resetPreferredTransformationCenter(), KisCoordinatesConverter::Private::rotationAngle, KisCoordinatesConverter::Private::rotationBaseAngle, KisCoordinatesConverter::Private::rotationBaseTransform, KisCoordinatesConverter::Private::rotationIsOrthogonal, KoZoomHandler::setZoomMode(), snapToDevicePixel(), KoViewTransformStillPoint::viewPoint(), widgetCenterPoint(), and KoZoomMode::ZOOM_CONSTANT.

rotationAngle()

qreal KisCoordinatesConverter::rotationAngle

(

)

const

Definition at line 372 of file kis_coordinates_converter.cpp.

{
    return m_d->rotationAngle;
}

References m_d, and KisCoordinatesConverter::Private::rotationAngle.

setCanvasWidgetSize()

void KisCoordinatesConverter::setCanvasWidgetSize

(

QSizeF

size

)

Definition at line 229 of file kis_coordinates_converter.cpp.

{
    m_d->canvasWidgetSize = snapWidgetSizeToDevicePixel(size);
    recalculateTransformations();
 
    // the widget center has changed, hence the preferred
    // center changes as well
    resetPreferredTransformationCenter();
}

References KisCoordinatesConverter::Private::canvasWidgetSize, m_d, recalculateTransformations(), resetPreferredTransformationCenter(), and snapWidgetSizeToDevicePixel().

setCanvasWidgetSizeKeepZoom()

void KisCoordinatesConverter::setCanvasWidgetSizeKeepZoom

(

const QSizeF &

size

)

WARNING: we can safely call setZoom() after changing widget size only for non-constant modes, because they have no still points, they always align to the center of the widget. Constant mode, reads the state of the canvas before transformation to calculate the position of the still point, hence we cannot change the state separately.

Definition at line 388 of file kis_coordinates_converter.cpp.

{
    setCanvasWidgetSize(size);
 
    if (zoomMode() == KoZoomMode::ZOOM_CONSTANT) {
        // in constant mode we just preserve the document offset
        // (as much as we can in relation to the vast scroll factor)
    } else {
        setZoom(zoomMode(), 777.0, resolutionX(), resolutionY(), std::nullopt);
    }
}

References KoZoomHandler::resolutionX(), KoZoomHandler::resolutionY(), setCanvasWidgetSize(), setZoom(), KoZoomMode::ZOOM_CONSTANT, and KoZoomHandler::zoomMode().

setDevicePixelRatio()

void KisCoordinatesConverter::setDevicePixelRatio

(

qreal

value

)

Definition at line 239 of file kis_coordinates_converter.cpp.

{
    m_d->devicePixelRatio = value;
}

References KisCoordinatesConverter::Private::devicePixelRatio, m_d, and value().

setDocumentOffset()

void KisCoordinatesConverter::setDocumentOffset

(

const QPointF &

offset

)

Definition at line 329 of file kis_coordinates_converter.cpp.

{
    // when changing the offset manually, the mode is explicitly
    // reset to constant
    setZoomMode(KoZoomMode::ZOOM_CONSTANT);
 
    // The given offset is in widget logical pixels. In order to prevent fuzzy
    // canvas rendering at 100% pixel-perfect zoom level when devicePixelRatio
    // is not integral, we adjusts the offset to map to whole device pixels.
 
    // Steps to reproduce the issue (when no snapping):
    // 1) Download an image with 1px vertical black and white stripes
    // 2) Enable fractional HiDPI support in Krita
    // 3) Set display scaling to 1.5 or 2.5
    // 4) Try to change offset of the image. If offset is unaligned, then
    //    the image will disappear on the canvas.
 
    m_d->documentOffset = snapToDevicePixel(offset);
    recalculateTransformations();
 
    resetPreferredTransformationCenter();
}

References KisCoordinatesConverter::Private::documentOffset, m_d, recalculateTransformations(), resetPreferredTransformationCenter(), KoZoomHandler::setZoomMode(), snapToDevicePixel(), and KoZoomMode::ZOOM_CONSTANT.

setExtraReferencesBounds()

void KisCoordinatesConverter::setExtraReferencesBounds

(

const QRect &

imageRect

)

Definition at line 269 of file kis_coordinates_converter.cpp.

{
    if (imageRect == m_d->extraReferencesBounds) return;
 
    // this value affects scroll range only, so no need to do extra
    // still point tracking
    m_d->extraReferencesBounds = imageRect;
    recalculateTransformations();
}

References KisCoordinatesConverter::Private::extraReferencesBounds, m_d, and recalculateTransformations().

setImage()

void KisCoordinatesConverter::setImage

(

KisImageWSP

image

)

Definition at line 244 of file kis_coordinates_converter.cpp.

{
    m_d->imageXRes = image->xRes();
    m_d->imageYRes = image->yRes();
 
    // we should **not** call setResolution() here, since
    // it is a different kind of resolution that is used
    // to convert the image to the physical size of the display
 
    m_d->imageBounds = image->bounds();
    recalculateZoomLevelLimits();
    recalculateTransformations();
 
    if (m_d->canvasWidgetSize.isEmpty()) {
        // if setImage() comes before setCanvasWidgetSize(), then just remember the
        // proposed mode and postpone the actual recentering of the image
        // (this case is supposed to happen in unittests only)
        KoZoomHandler::setZoomMode(KoZoomMode::ZOOM_PAGE);
        m_d->preferredTransformationCenterImage = m_d->imageBounds.center();
    } else {
        // the default mode after initialization is "Zoom Page"
        setZoom(KoZoomMode::ZOOM_PAGE, 777.7, resolutionX(), resolutionY(), std::nullopt);
    }
}

References KisImage::bounds(), KisCoordinatesConverter::Private::canvasWidgetSize, KisCoordinatesConverter::Private::imageBounds, KisCoordinatesConverter::Private::imageXRes, KisCoordinatesConverter::Private::imageYRes, m_d, KisCoordinatesConverter::Private::preferredTransformationCenterImage, recalculateTransformations(), recalculateZoomLevelLimits(), KoZoomHandler::resolutionX(), KoZoomHandler::resolutionY(), setZoom(), KoZoomHandler::setZoomMode(), KisImage::xRes(), KisImage::yRes(), and KoZoomMode::ZOOM_PAGE.

setImageBounds()

void KisCoordinatesConverter::setImageBounds	(	const QRect &	rect,
		const QPointF	oldImageStillPoint,
		const QPointF	newImageStillPoint )

Definition at line 279 of file kis_coordinates_converter.cpp.

{
    if (rect == m_d->imageBounds) return;
 
    const QPointF oldWidgetStillPoint = imageToWidget(oldImageStillPoint);
 
    // we reset zoom mode to constant to make sure that
    // the image changes visually for the user
    setZoomMode(KoZoomMode::ZOOM_CONSTANT);
 
    m_d->imageBounds = rect;
    recalculateZoomLevelLimits();
    recalculateTransformations();
 
    const QPointF newWidgetStillPoint = imageToWidget(newImageStillPoint);
    m_d->documentOffset = snapToDevicePixel(m_d->documentOffset + newWidgetStillPoint - oldWidgetStillPoint);
    recalculateTransformations();
 
    resetPreferredTransformationCenter();
}

References KisCoordinatesConverter::Private::documentOffset, KisCoordinatesConverter::Private::imageBounds, imageToWidget(), m_d, recalculateTransformations(), recalculateZoomLevelLimits(), resetPreferredTransformationCenter(), KoZoomHandler::setZoomMode(), snapToDevicePixel(), and KoZoomMode::ZOOM_CONSTANT.

setImageResolution()

void KisCoordinatesConverter::setImageResolution	(	qreal	xRes,
		qreal	yRes )

Definition at line 300 of file kis_coordinates_converter.cpp.

{
    // we consiter the center of the image to be the still point
    // on the canvas
 
    if (qFuzzyCompare(xRes, m_d->imageXRes) && qFuzzyCompare(yRes, m_d->imageYRes)) return;
 
    const QPointF oldImageCenter = imageCenterInWidgetPixel();
 
    // we should **not** call setResolution() here, since
    // it is a different kind of resolution that is used
    // to convert the image to the physical size of the display
 
    // we reset zoom mode to constant to make sure that
    // the image changes visually for the user
    setZoomMode(KoZoomMode::ZOOM_CONSTANT);
 
    m_d->imageXRes = xRes;
    m_d->imageYRes = yRes;
    recalculateZoomLevelLimits();
    recalculateTransformations();
 
    const QPointF newImageCenter = imageCenterInWidgetPixel();
    m_d->documentOffset = snapToDevicePixel(m_d->documentOffset + newImageCenter - oldImageCenter);
    recalculateTransformations();
 
    resetPreferredTransformationCenter();
}

References KisCoordinatesConverter::Private::documentOffset, imageCenterInWidgetPixel(), KisCoordinatesConverter::Private::imageXRes, KisCoordinatesConverter::Private::imageYRes, m_d, qFuzzyCompare(), recalculateTransformations(), recalculateZoomLevelLimits(), resetPreferredTransformationCenter(), KoZoomHandler::setZoomMode(), snapToDevicePixel(), and KoZoomMode::ZOOM_CONSTANT.

setZoom() [1/2]

void KisCoordinatesConverter::setZoom	(	KoZoomMode::Mode	mode,
		qreal	zoom,
		qreal	resolutionX,
		qreal	resolutionY,
		const std::optional< KoViewTransformStillPoint > &	stillPoint )

changes the zoom mode of the canvas

When mode is KoZoomMode::ZOOM_CONSTANT, stillPoint instructs the converter to keep the passed point "still", i.e. to make sure that stillPoint.docPoint() maps to stillPoint.widgetPoint() on screen.

Please make sure that there is no guarantee that the still point will map to the passed points exactly! The still point may be offset by at most (0.5 * sqrt(2) / devicePixelRatio()) due to hardware pixel alignment.

This alignment is the reason why we pass both document and view points as a still point, because both values should be kept constant during iterative zoom operations. Otherwise the canvas will drift to the side because of the pixel alignmentl.

If stillPoint is std::nullopt, then the zooming happens over preferredTransformationCenter(), which is basically the center of canvas widget, but with some guards against the drifting.

only constant mode is a subject for clamping, fit-modes are allowed to zoom as much as needed

Definition at line 433 of file kis_coordinates_converter.cpp.

{
    const int cfgMargin = zoomMarginSize();
 
    auto updateDisplayResolution = [&]() {
        if (!qFuzzyCompare(resolutionX, this->resolutionX()) || !qFuzzyCompare(resolutionY, this->resolutionY())) {
            setResolution(resolutionX, resolutionY);
            recalculateZoomLevelLimits();
        }
    };
 
    if(mode == KoZoomMode::ZOOM_CONSTANT) {
        if(qFuzzyIsNull(zoom)) return;
 
        zoom = clampZoom(zoom);
 
        KoViewTransformStillPoint effectiveStillPoint =
            stillPoint ? *stillPoint :
            KoViewTransformStillPoint(m_d->preferredTransformationCenterInDocumentPixels(), widgetCenterPoint());
 
        updateDisplayResolution();
        KoZoomHandler::setZoom(zoom);
        KoZoomHandler::setZoomMode(mode);
        recalculateTransformations();
 
        const QPointF newStillPoint = documentToWidget(effectiveStillPoint.docPoint());
        const QPointF offset = newStillPoint - effectiveStillPoint.viewPoint();
        m_d->documentOffset = snapToDevicePixel(m_d->documentOffset + offset);
        recalculateTransformations();
 
        if (stillPoint) {
            resetPreferredTransformationCenter();
        }
 
    } else if (mode == KoZoomMode::ZOOM_PAGE || mode == KoZoomMode::ZOOM_WIDTH || mode == KoZoomMode::ZOOM_HEIGHT) {
        updateDisplayResolution();
        recalculateTransformations();
 
        KIS_SAFE_ASSERT_RECOVER_RETURN(!m_d->canvasWidgetSize.isEmpty());
 
        const QSizeF documentSize = imageRectInWidgetPixels().size();
        const qreal zoomCoeffX = (m_d->canvasWidgetSize.width() - 2 * cfgMargin) / documentSize.width();
        const qreal zoomCoeffY = (m_d->canvasWidgetSize.height() - 2 * cfgMargin) / documentSize.height();
 
        const bool fitToWidth = [&]() {
            if (mode == KoZoomMode::ZOOM_PAGE) {
                return zoomCoeffX < zoomCoeffY;
            } else if (mode == KoZoomMode::ZOOM_HEIGHT) {
                return false;
            } else if (mode == KoZoomMode::ZOOM_WIDTH) {
                return true;
            }
            Q_UNREACHABLE_RETURN(true);
        }();
 
        KoZoomHandler::setZoom(this->zoom() * (fitToWidth ? zoomCoeffX : zoomCoeffY));
        KoZoomHandler::setZoomMode(mode);
        recalculateTransformations();
 
        const QPointF offset = imageCenterInWidgetPixel() - widgetCenterPoint();
 
        QPointF newDocumentOffset = m_d->documentOffset + offset;
 
        // just explicitly set minimal axis offset to zero to
        // avoid imperfections of floating point numbers
        if (fitToWidth) {
            newDocumentOffset.setX(-cfgMargin);
        } else {
            newDocumentOffset.setY(-cfgMargin);
        }
 
        m_d->documentOffset = snapToDevicePixel(newDocumentOffset);
        recalculateTransformations();
 
        resetPreferredTransformationCenter();
    }
}

References KisCoordinatesConverter::Private::canvasWidgetSize, clampZoom(), KoViewTransformStillPoint::docPoint(), KisCoordinatesConverter::Private::documentOffset, documentToWidget(), imageCenterInWidgetPixel(), imageRectInWidgetPixels(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisCoordinatesConverter::Private::preferredTransformationCenterInDocumentPixels(), qFuzzyCompare(), qFuzzyIsNull(), recalculateTransformations(), recalculateZoomLevelLimits(), resetPreferredTransformationCenter(), KoZoomHandler::resolutionX(), KoZoomHandler::resolutionY(), KoZoomHandler::setResolution(), KoZoomHandler::setZoom(), KoZoomHandler::setZoomMode(), snapToDevicePixel(), KoViewTransformStillPoint::viewPoint(), widgetCenterPoint(), KoZoomHandler::zoom(), KoZoomMode::ZOOM_CONSTANT, KoZoomMode::ZOOM_HEIGHT, KoZoomMode::ZOOM_PAGE, KoZoomMode::ZOOM_WIDTH, and KoZoomHandler::zoomMarginSize().

setZoom() [2/2]

void KisCoordinatesConverter::setZoom ( qreal zoom )

overridevirtual

Set the zoom level. 1.0 is 100%.

Reimplemented from KoViewConverter.

Definition at line 377 of file kis_coordinates_converter.cpp.

{
    // when changing the offset manually, the mode is explicitly
    // reset to constant, this method is used in unittests mostly
    setZoomMode(KoZoomMode::ZOOM_CONSTANT);
 
    KoZoomHandler::setZoom(zoom);
    recalculateTransformations();
    resetPreferredTransformationCenter();
}

References recalculateTransformations(), resetPreferredTransformationCenter(), KoZoomHandler::setZoom(), KoZoomHandler::setZoomMode(), KoZoomHandler::zoom(), and KoZoomMode::ZOOM_CONSTANT.

snapToDevicePixel()

QPointF KisCoordinatesConverter::snapToDevicePixel

(

const QPointF &

point

)

const

Adjust a given pair of coordinates to the nearest device pixel according to the value of devicePixelRatio.

Parameters

point

a point in logical pixel space

Returns

The point in logical pixel space but adjusted to the nearest device pixel

Definition at line 897 of file kis_coordinates_converter.cpp.

{
    if (!m_d->rotationIsOrthogonal) {
        return point;
    }
 
    QPoint devicePixel = (point * m_d->devicePixelRatio).toPoint();
    // These adjusted coords will be in logical pixel but is aligned in device
    // pixel space for pixel-perfect rendering.
    return QPointF(devicePixel) / m_d->devicePixelRatio;
}

References KisCoordinatesConverter::Private::devicePixelRatio, m_d, and KisCoordinatesConverter::Private::rotationIsOrthogonal.

snapWidgetSizeToDevicePixel()

QSizeF KisCoordinatesConverter::snapWidgetSizeToDevicePixel

(

const QSizeF &

size

)

const

Definition at line 407 of file kis_coordinates_converter.cpp.

{
    if (qFuzzyCompare(m_d->devicePixelRatio, 1.0)) return size;
 
    // This is how QOpenGLCanvas sets the FBO and the viewport size. If
    // devicePixelRatioF() is non-integral, the result is truncated.
    // *Correction*: The FBO size is actually rounded, but the glViewport call
    // uses integer truncation and that's what really matters.
    const int viewportWidth = static_cast<int>(size.width() * m_d->devicePixelRatio);
    const int viewportHeight = static_cast<int>(size.height() * m_d->devicePixelRatio);
 
    // The widget size may be an integer but here we actually want to give
    // KisCoordinatesConverter the logical viewport size aligned to device
    // pixels.
    return QSizeF(viewportWidth, viewportHeight) / m_d->devicePixelRatio;
}

References KisCoordinatesConverter::Private::devicePixelRatio, m_d, and qFuzzyCompare().

standardZoomLevels()

QVector< qreal > KisCoordinatesConverter::standardZoomLevels

(

)

const

Definition at line 932 of file kis_coordinates_converter.cpp.

{
    return m_d->standardZoomLevels.value();
}

References m_d, and KisCoordinatesConverter::Private::standardZoomLevels.

viewportDevicePixelSize()

QSize KisCoordinatesConverter::viewportDevicePixelSize

(

)

const

Definition at line 424 of file kis_coordinates_converter.cpp.

{
    // TODO: add an assert and a unittest to verify that there is no
    //       actual rounding happens, only intolerances!
    return qFuzzyCompare(m_d->devicePixelRatio, 1.0) ?
        m_d->canvasWidgetSize.toSize() :
        (m_d->canvasWidgetSize * m_d->devicePixelRatio).toSize();
}

References KisCoordinatesConverter::Private::canvasWidgetSize, KisCoordinatesConverter::Private::devicePixelRatio, m_d, and qFuzzyCompare().

viewportToImage()

template<class T >

_Private::Traits< T >::Result KisCoordinatesConverter::viewportToImage ( const T & obj ) const

inline

Definition at line 159 of file kis_coordinates_converter.h.

{ return _Private::Traits<T>::map(imageToViewportTransform().inverted(), obj); }

References _Private::Traits< T >::map().

viewportToWidget()

template<class T >

_Private::Traits< T >::Result KisCoordinatesConverter::viewportToWidget ( const T & obj ) const

inline

Definition at line 169 of file kis_coordinates_converter.h.

{ return _Private::Traits<T>::map(viewportToWidgetTransform(), obj); }

References _Private::Traits< T >::map().

viewportToWidgetTransform()

QTransform KisCoordinatesConverter::viewportToWidgetTransform

(

)

const

Definition at line 750 of file kis_coordinates_converter.cpp.

                                                                    {
    return m_d->widgetToViewport.inverted();
}

References m_d, and KisCoordinatesConverter::Private::widgetToViewport.

viewToWidget()

QTransform KisCoordinatesConverter::viewToWidget ( ) const

overridevirtual

Reimplemented from KoViewConverter.

Definition at line 909 of file kis_coordinates_converter.cpp.

{
    return flakeToWidgetTransform();
}

References flakeToWidgetTransform().

widgetCenterPoint()

QPointF KisCoordinatesConverter::widgetCenterPoint

(

)

const

Definition at line 862 of file kis_coordinates_converter.cpp.

{
    return QPointF(m_d->canvasWidgetSize.width() / 2.0, m_d->canvasWidgetSize.height() / 2.0);
}

References KisCoordinatesConverter::Private::canvasWidgetSize, and m_d.

widgetRectInFlakePixels()

QRectF KisCoordinatesConverter::widgetRectInFlakePixels

(

)

const

Definition at line 845 of file kis_coordinates_converter.cpp.

{
    return widgetToFlake(QRectF(QPoint(0,0), m_d->canvasWidgetSize));
}

References KisCoordinatesConverter::Private::canvasWidgetSize, m_d, and widgetToFlake().

widgetRectInImagePixels()

QRectF KisCoordinatesConverter::widgetRectInImagePixels

(

)

const

Definition at line 850 of file kis_coordinates_converter.cpp.

{
    return widgetToImage(QRectF(QPoint(0,0), m_d->canvasWidgetSize));
}

References KisCoordinatesConverter::Private::canvasWidgetSize, m_d, and widgetToImage().

widgetToDocument()

template<class T >

_Private::Traits< T >::Result KisCoordinatesConverter::widgetToDocument ( const T & obj ) const

inline

Definition at line 174 of file kis_coordinates_converter.h.

{ return _Private::Traits<T>::map(documentToWidgetTransform().inverted(), obj); }

References _Private::Traits< T >::map().

widgetToFlake()

template<class T >

_Private::Traits< T >::Result KisCoordinatesConverter::widgetToFlake ( const T & obj ) const

inline

Definition at line 164 of file kis_coordinates_converter.h.

{ return _Private::Traits<T>::map(flakeToWidgetTransform().inverted(), obj); }

References _Private::Traits< T >::map().

widgetToImage()

template<class T >

_Private::Traits< T >::Result KisCoordinatesConverter::widgetToImage ( const T & obj ) const

inline

Definition at line 189 of file kis_coordinates_converter.h.

{ return _Private::Traits<T>::map(imageToWidgetTransform().inverted(), obj); }

References _Private::Traits< T >::map().

widgetToView()

QTransform KisCoordinatesConverter::widgetToView ( ) const

overridevirtual

Reimplemented from KoViewConverter.

Definition at line 914 of file kis_coordinates_converter.cpp.

{
    return flakeToWidgetTransform().inverted();
}

References flakeToWidgetTransform().

widgetToViewport()

template<class T >

_Private::Traits< T >::Result KisCoordinatesConverter::widgetToViewport ( const T & obj ) const

inline

Definition at line 167 of file kis_coordinates_converter.h.

{ return _Private::Traits<T>::map(viewportToWidgetTransform().inverted(), obj); }

References _Private::Traits< T >::map().

xAxisMirrored()

bool KisCoordinatesConverter::xAxisMirrored

(

)

const

Definition at line 694 of file kis_coordinates_converter.cpp.

{
    return m_d->isXAxisMirrored;
}

References KisCoordinatesConverter::Private::isXAxisMirrored, and m_d.

yAxisMirrored()

bool KisCoordinatesConverter::yAxisMirrored

(

)

const

Definition at line 699 of file kis_coordinates_converter.cpp.

{
    return m_d->isYAxisMirrored;
}

References KisCoordinatesConverter::Private::isYAxisMirrored, and m_d.

zoomTo()

void KisCoordinatesConverter::zoomTo

(

const QRectF &

widgetRect

)

Definition at line 513 of file kis_coordinates_converter.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(!zoomRectWidget.isEmpty());
 
    const QPointF zoomPortionCenterInImagePixels = widgetToImage(zoomRectWidget.center());
 
    const qreal zoomCoeffX = m_d->canvasWidgetSize.width() / zoomRectWidget.width();
    const qreal zoomCoeffY = m_d->canvasWidgetSize.height() / zoomRectWidget.height();
 
    const bool fitToWidth = zoomCoeffX < zoomCoeffY;
 
    KoZoomHandler::setZoom(this->zoom() * (fitToWidth ? zoomCoeffX : zoomCoeffY));
    KoZoomHandler::setZoomMode(KoZoomMode::ZOOM_CONSTANT);
    recalculateTransformations();
 
    const QPointF offset = imageToWidget(zoomPortionCenterInImagePixels) - widgetCenterPoint();
    QPointF newDocumentOffset = m_d->documentOffset + offset;
 
    m_d->documentOffset = snapToDevicePixel(newDocumentOffset);
    recalculateTransformations();
 
    resetPreferredTransformationCenter();
}

References KisCoordinatesConverter::Private::canvasWidgetSize, KisCoordinatesConverter::Private::documentOffset, imageToWidget(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, recalculateTransformations(), resetPreferredTransformationCenter(), KoZoomHandler::setZoom(), KoZoomHandler::setZoomMode(), snapToDevicePixel(), widgetCenterPoint(), widgetToImage(), KoZoomHandler::zoom(), and KoZoomMode::ZOOM_CONSTANT.

Friends And Related Symbol Documentation

KisCoordinatesConverterTest

friend class KisCoordinatesConverterTest

friend

Definition at line 250 of file kis_coordinates_converter.h.

KisZoomAndPanTest

friend class KisZoomAndPanTest

friend

Definition at line 249 of file kis_coordinates_converter.h.

Member Data Documentation

m_d

Private* const KisCoordinatesConverter::m_d

private

Definition at line 262 of file kis_coordinates_converter.h.

---

The documentation for this class was generated from the following files:

• libs/ui/canvas/kis_coordinates_converter.h
• libs/ui/canvas/kis_coordinates_converter.cpp