void KisZoomAndPanTest::initializeViewport(ZoomAndPanTester &t, bool fullscreenMode, bool rotate, bool mirror)
{
QCOMPARE(t.image()->size(), QSize(640,441));
QCOMPARE(t.image()->xRes(), 1.0);
QCOMPARE(t.image()->yRes(), 1.0);
t.canvasController()->resize(QSize(500,500));
t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, 1.0);
t.canvasController()->setPreferredCenter(QPoint(320,220));
QCOMPARE(t.canvasWidget()->size(), QSize(483,483));
QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize());
QVERIFY(verifyOffset(t, QPoint(79,-21)));
if (fullscreenMode) {
QCOMPARE(t.canvasController()->preferredCenter(), QPointF(320,220));
QAction *action = t.view()->actionCollection()->action("view_show_just_the_canvas");
action->setChecked(true);
QVERIFY(verifyOffset(t, QPoint(79,-21)));
QCOMPARE(t.canvasController()->preferredCenter(), QPointF(329,220));
t.canvasController()->resize(QSize(483,483));
QCOMPARE(t.canvasWidget()->size(), QSize(483,483));
QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize());
QVERIFY(verifyOffset(t, QPoint(79,-21)));
/**
* FIXME: here is a small flaw in KoCanvasControllerWidget
* We cannot set the center point explicitly, because it'll be rounded
* up by recenterPreferred function, so real center point will be
* different. Make the preferredCenter() return real center of the
* image instead of the set value
*/
QCOMPARE(t.canvasController()->preferredCenter(), QPointF(320.5,220));
}
if (rotate) {
t.canvasController()->rotateCanvas(90);
QVERIFY(verifyOffset(t, QPoint(-21,79)));
QVERIFY(compareWithRounding(QPointF(220,320), t.canvasController()->preferredCenter(), 2));
QCOMPARE(t.coordinatesConverter()->imageRectInWidgetPixels().topLeft().toPoint(), -t.coordinatesConverter()->documentOffset());
}
if (mirror) {
t.canvasController()->mirrorCanvas(true);
QVERIFY(verifyOffset(t, QPoint(78, -21)));
QVERIFY(compareWithRounding(QPointF(320,220), t.canvasController()->preferredCenter(), 2));
QCOMPARE(t.coordinatesConverter()->imageRectInWidgetPixels().topLeft().toPoint(), -t.coordinatesConverter()->documentOffset());
}
}
bool KisZoomAndPanTest::checkPan(ZoomAndPanTester &t, QPoint shift)
{
QPoint oldOffset = t.coordinatesConverter()->documentOffset();
QPointF oldPrefCenter = t.canvasController()->preferredCenter();
t.canvasController()->pan(shift);
QPoint newOffset = t.coordinatesConverter()->documentOffset();
QPointF newPrefCenter = t.canvasController()->preferredCenter();
QPointF newTopLeft = t.coordinatesConverter()->imageRectInWidgetPixels().topLeft();
QPoint expectedOffset = oldOffset + shift;
QPointF expectedPrefCenter = oldPrefCenter + shift;
// no tolerance accepted for pan
bool offsetAsExpected = newOffset == expectedOffset;
// rounding can happen due to the scroll bars being the main
// source of the offset
bool preferredCenterAsExpected =
compareWithRounding(expectedPrefCenter, newPrefCenter, 1.0);
bool topLeftAsExpected = newTopLeft.toPoint() == -newOffset;
if (!offsetAsExpected ||
!preferredCenterAsExpected ||
!topLeftAsExpected) {
qDebug() << "***** PAN *****************";
if(!offsetAsExpected) {
qDebug() << " ### Offset invariant broken";
}
if(!preferredCenterAsExpected) {
qDebug() << " ### Preferred center invariant broken";
}
if(!topLeftAsExpected) {
qDebug() << " ### TopLeft invariant broken";
}
qDebug() << ppVar(expectedOffset);
qDebug() << ppVar(expectedPrefCenter);
qDebug() << ppVar(oldOffset) << ppVar(newOffset);
qDebug() << ppVar(oldPrefCenter) << ppVar(newPrefCenter);
qDebug() << ppVar(newTopLeft);
qDebug() << "***************************";
}
return offsetAsExpected && preferredCenterAsExpected && topLeftAsExpected;
}
void KisZoomAndPanTest::testImageCropped()
{
ZoomAndPanTester t;
QApplication::processEvents();
initializeViewport(t, false, false, false);
QApplication::processEvents();
QVERIFY(checkPan(t, QPoint(-150,-150)));
QApplication::processEvents();
QPointF oldStillPoint =
t.coordinatesConverter()->imageToWidget(QPointF(150,150));
t.image()->cropImage(QRect(100,100,100,100));
t.image()->waitForDone();
QApplication::processEvents();
QPointF newStillPoint =
t.coordinatesConverter()->imageToWidget(QPointF(50,50));
QVERIFY(compareWithRounding(oldStillPoint, newStillPoint, 1.0));
}
void KisZoomAndPanTest::testImageRescaled_0_5()
{
ZoomAndPanTester t;
QApplication::processEvents();
initializeViewport(t, false, false, false);
QApplication::processEvents();
QVERIFY(checkPan(t, QPoint(200,200)));
QApplication::processEvents();
QPointF oldStillPoint =
t.coordinatesConverter()->imageRectInWidgetPixels().center();
KisFilterStrategy *strategy = new KisBilinearFilterStrategy();
t.image()->scaleImage(QSize(320, 220), t.image()->xRes(), t.image()->yRes(), strategy);
t.image()->waitForDone();
QApplication::processEvents();
delete strategy;
QPointF newStillPoint =
t.coordinatesConverter()->imageRectInWidgetPixels().center();
QVERIFY(compareWithRounding(oldStillPoint, newStillPoint, 1.0));
}
void KisZoomAndPanTest::testRotation(qreal vastScrolling, qreal zoom)
{
KisConfig cfg;
cfg.setVastScrolling(vastScrolling);
ZoomAndPanTester t;
QCOMPARE(t.image()->size(), QSize(640,441));
QCOMPARE(t.image()->xRes(), 1.0);
QCOMPARE(t.image()->yRes(), 1.0);
QPointF preferredCenter = zoom * t.image()->bounds().center();
t.canvasController()->resize(QSize(500,500));
t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, zoom);
t.canvasController()->setPreferredCenter(preferredCenter.toPoint());
QCOMPARE(t.canvasWidget()->size(), QSize(483,483));
QCOMPARE(t.canvasWidget()->size(), t.canvasController()->viewportSize());
QPointF realCenterPoint = t.coordinatesConverter()->widgetToImage(t.coordinatesConverter()->widgetCenterPoint());
QPointF expectedCenterPoint = QPointF(t.image()->bounds().center());
if(!compareWithRounding(realCenterPoint, expectedCenterPoint, 2/zoom)) {
qDebug() << "Failed to set initial center point";
qDebug() << ppVar(expectedCenterPoint) << ppVar(realCenterPoint);
QFAIL("FAIL: Failed to set initial center point");
}
QVERIFY(checkRotation(t, 30));
QVERIFY(checkRotation(t, 20));
QVERIFY(checkRotation(t, 10));
QVERIFY(checkRotation(t, 5));
QVERIFY(checkRotation(t, 5));
QVERIFY(checkRotation(t, 5));
if(vastScrolling < 0.5 && zoom < 1) {
qWarning() << "Disabling a few tests for vast scrolling ="
<< vastScrolling << ". See comment for more";
/**
* We have to disable a couple of tests here for the case when
* vastScrolling value is 0.2. The problem is that the centering
* correction applied to the offset in
* KisCanvasController::rotateCanvas pollutes the preferredCenter
* value, because KoCnvasControllerWidget has no access to this
* correction and cannot calculate the real value of the center of
* the image. To fix this bug the calculation of correction
* (aka "origin") should be moved to the KoCanvasControllerWidget
* itself which would cause quite huge changes (including the change
* of the external interface of it). Namely, we would have to
* *calculate* offset from the value of the scroll bars, but not
* use their values directly:
*
* offset = scrollBarValue - origin
*
* So now we just disable these unittests and allow a couple
* of "jumping" bugs appear in vastScrolling < 0.5 modes, which
* is, actually, not the default case.
*/
} else {
QVERIFY(checkRotation(t, 5));
QVERIFY(checkRotation(t, 5));
QVERIFY(checkRotation(t, 5));
}
}
bool KisZoomAndPanTest::checkRotation(ZoomAndPanTester &t, qreal angle)
{
// save old values
QPoint oldOffset = t.coordinatesConverter()->documentOffset();
QPointF oldCenteringCorrection = t.coordinatesConverter()->centeringCorrection();
QPointF oldPreferredCenter = t.canvasController()->preferredCenter();
QPointF oldRealCenterPoint = t.coordinatesConverter()->widgetToImage(t.coordinatesConverter()->widgetCenterPoint());
QSize oldDocumentSize = t.canvasController()->documentSize();
qreal baseAngle = t.coordinatesConverter()->rotationAngle();
t.canvasController()->rotateCanvas(angle);
// save result values
QPoint newOffset = t.coordinatesConverter()->documentOffset();
QPointF newCenteringCorrection = t.coordinatesConverter()->centeringCorrection();
QPointF newPreferredCenter = t.canvasController()->preferredCenter();
QPointF newRealCenterPoint = t.coordinatesConverter()->widgetToImage(t.coordinatesConverter()->widgetCenterPoint());
QSize newDocumentSize = t.canvasController()->documentSize();
// calculate theoretical preferred center
QTransform rot;
rot.rotate(angle);
QSizeF dSize = t.coordinatesConverter()->imageSizeInFlakePixels();
QPointF dPoint(dSize.width(), dSize.height());
QPointF expectedPreferredCenter =
(oldPreferredCenter - dPoint * correctionMatrix(baseAngle)) * rot +
dPoint * correctionMatrix(baseAngle + angle);
// calculate theoretical offset based on the real preferred center
QPointF wPoint(t.canvasWidget()->size().width(), t.canvasWidget()->size().height());
QPointF expectedOldOffset = oldPreferredCenter - 0.5 * wPoint;
QPointF expectedNewOffset = newPreferredCenter - 0.5 * wPoint;
bool preferredCenterAsExpected =
compareWithRounding(expectedPreferredCenter, newPreferredCenter, 2);
bool oldOffsetAsExpected =
compareWithRounding(expectedOldOffset + oldCenteringCorrection, QPointF(oldOffset), 2);
bool newOffsetAsExpected =
compareWithRounding(expectedNewOffset + newCenteringCorrection, QPointF(newOffset), 3);
qreal zoom = t.zoomController()->zoomAction()->effectiveZoom();
bool realCenterPointAsExpected =
compareWithRounding(oldRealCenterPoint, newRealCenterPoint, 2/zoom);
if (!oldOffsetAsExpected ||
!newOffsetAsExpected ||
!preferredCenterAsExpected ||
!realCenterPointAsExpected) {
qDebug() << "***** ROTATE **************";
if(!oldOffsetAsExpected) {
qDebug() << " ### Old offset invariant broken";
}
if(!newOffsetAsExpected) {
qDebug() << " ### New offset invariant broken";
}
if(!preferredCenterAsExpected) {
qDebug() << " ### Preferred center invariant broken";
}
if(!realCenterPointAsExpected) {
qDebug() << " ### *Real* center invariant broken";
}
qDebug() << ppVar(expectedOldOffset);
qDebug() << ppVar(expectedNewOffset);
qDebug() << ppVar(expectedPreferredCenter);
qDebug() << ppVar(oldOffset) << ppVar(newOffset);
qDebug() << ppVar(oldCenteringCorrection) << ppVar(newCenteringCorrection);
qDebug() << ppVar(oldPreferredCenter) << ppVar(newPreferredCenter);
qDebug() << ppVar(oldRealCenterPoint) << ppVar(newRealCenterPoint);
qDebug() << ppVar(oldDocumentSize) << ppVar(newDocumentSize);
qDebug() << ppVar(baseAngle) << "deg";
qDebug() << ppVar(angle) << "deg";
qDebug() << "***************************";
}
return preferredCenterAsExpected && oldOffsetAsExpected && newOffsetAsExpected && realCenterPointAsExpected;
}
bool KisZoomAndPanTest::checkInvariants(const QPointF &baseFlakePoint,
const QPoint &oldOffset,
const QPointF &oldPreferredCenter,
qreal oldZoom,
const QPoint &newOffset,
const QPointF &newPreferredCenter,
qreal newZoom,
const QPointF &newTopLeft,
const QSize &oldDocumentSize)
{
qreal k = newZoom / oldZoom;
QPointF expectedOffset = oldOffset + (k - 1) * baseFlakePoint;
QPointF expectedPreferredCenter = oldPreferredCenter + (k - 1) * baseFlakePoint;
qreal oldPreferredCenterFractionX = 1.0 * oldPreferredCenter.x() / oldDocumentSize.width();
qreal oldPreferredCenterFractionY = 1.0 * oldPreferredCenter.y() / oldDocumentSize.height();
qreal roundingTolerance =
qMax(1.0, qMax(oldPreferredCenterFractionX, oldPreferredCenterFractionY) / k);
/**
* In the computation of the offset two roundings happen:
* first for the computation of oldOffset and the second
* for the computation of newOffset. So the maximum tolerance
* should equal 2.
*/
bool offsetAsExpected =
compareWithRounding(expectedOffset, QPointF(newOffset), 2 * roundingTolerance);
/**
* Rounding for the preferred center happens due to the rounding
* of the document size while zooming. The wider the step of the
* zooming, the bigger tolerance should be
*/
bool preferredCenterAsExpected =
compareWithRounding(expectedPreferredCenter, newPreferredCenter,
roundingTolerance);
bool topLeftAsExpected = newTopLeft.toPoint() == -newOffset;
if (!offsetAsExpected ||
!preferredCenterAsExpected ||
!topLeftAsExpected) {
qDebug() << "***** ZOOM ****************";
if(!offsetAsExpected) {
qDebug() << " ### Offset invariant broken";
}
if(!preferredCenterAsExpected) {
qDebug() << " ### Preferred center invariant broken";
}
if(!topLeftAsExpected) {
qDebug() << " ### TopLeft invariant broken";
}
qDebug() << ppVar(expectedOffset);
qDebug() << ppVar(expectedPreferredCenter);
qDebug() << ppVar(oldOffset) << ppVar(newOffset);
qDebug() << ppVar(oldPreferredCenter) << ppVar(newPreferredCenter);
qDebug() << ppVar(oldPreferredCenterFractionX);
qDebug() << ppVar(oldPreferredCenterFractionY);
qDebug() << ppVar(oldZoom) << ppVar(newZoom);
qDebug() << ppVar(baseFlakePoint);
qDebug() << ppVar(newTopLeft);
qDebug() << ppVar(roundingTolerance);
qDebug() << "***************************";
}
return offsetAsExpected && preferredCenterAsExpected && topLeftAsExpected;
}