tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the test suite of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** Commercial Usage
  11 ** Licensees holding valid Qt Commercial licenses may use this file in
  12 ** accordance with the Qt Commercial License Agreement provided with the
  13 ** Software or, alternatively, in accordance with the terms contained in
  14 ** a written agreement between you and Nokia.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** GNU General Public License Usage
  29 ** Alternatively, this file may be used under the terms of the GNU
  30 ** General Public License version 3.0 as published by the Free Software
  31 ** Foundation and appearing in the file LICENSE.GPL included in the
  32 ** packaging of this file.  Please review the following information to
  33 ** ensure the GNU General Public License version 3.0 requirements will be
  34 ** met: http://www.gnu.org/copyleft/gpl.html.
  35 **
  36 ** If you have questions regarding the use of this file, please contact
  37 ** Nokia at qt-info@nokia.com.
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42
  43 #include <QtTest/QtTest>
  44 #include <qgraphicsitem.h>
  45 #include <qgraphicstransform.h>
  46 #include "../../shared/util.h"
  47
  48 class tst_QGraphicsTransform : public QObject {
  49     Q_OBJECT
  50
  51 public slots:
  52     void initTestCase();
  53     void cleanupTestCase();
  54     void init();
  55     void cleanup();
  56
  57 private slots:
  58     void scale();
  59     void rotation();
  60     void rotation3d_data();
  61     void rotation3d();
  62     void rotation3dArbitraryAxis_data();
  63     void rotation3dArbitraryAxis();
  64 };
  65
  66
  67 // This will be called before the first test function is executed.
  68 // It is only called once.
  69 void tst_QGraphicsTransform::initTestCase()
  70 {
  71 }
  72
  73 // This will be called after the last test function is executed.
  74 // It is only called once.
  75 void tst_QGraphicsTransform::cleanupTestCase()
  76 {
  77 }
  78
  79 // This will be called before each test function is executed.
  80 void tst_QGraphicsTransform::init()
  81 {
  82 }
  83
  84 // This will be called after every test function.
  85 void tst_QGraphicsTransform::cleanup()
  86 {
  87 }
  88
  89 static QTransform transform2D(const QGraphicsTransform& t)
  90 {
  91     QMatrix4x4 m;
  92     t.applyTo(&m);
  93     return m.toTransform();
  94 }
  95
  96 void tst_QGraphicsTransform::scale()
  97 {
  98     QGraphicsScale scale;
  99
 100     // check initial conditions
 101     QCOMPARE(scale.xScale(), qreal(1));
 102     QCOMPARE(scale.yScale(), qreal(1));
 103     QCOMPARE(scale.zScale(), qreal(1));
 104     QCOMPARE(scale.origin(), QVector3D(0, 0, 0));
 105
 106     scale.setOrigin(QVector3D(10, 10, 0));
 107
 108     QCOMPARE(scale.xScale(), qreal(1));
 109     QCOMPARE(scale.yScale(), qreal(1));
 110     QCOMPARE(scale.zScale(), qreal(1));
 111     QCOMPARE(scale.origin(), QVector3D(10, 10, 0));
 112
 113     QMatrix4x4 t;
 114     scale.applyTo(&t);
 115
 116     QCOMPARE(t, QMatrix4x4());
 117     QCOMPARE(transform2D(scale), QTransform());
 118
 119     scale.setXScale(10);
 120     scale.setOrigin(QVector3D(0, 0, 0));
 121
 122     QCOMPARE(scale.xScale(), qreal(10));
 123     QCOMPARE(scale.yScale(), qreal(1));
 124     QCOMPARE(scale.zScale(), qreal(1));
 125     QCOMPARE(scale.origin(), QVector3D(0, 0, 0));
 126
 127     QTransform res;
 128     res.scale(10, 1);
 129
 130     QCOMPARE(transform2D(scale), res);
 131     QCOMPARE(transform2D(scale).map(QPointF(10, 10)), QPointF(100, 10));
 132
 133     scale.setOrigin(QVector3D(10, 10, 0));
 134     QCOMPARE(transform2D(scale).map(QPointF(10, 10)), QPointF(10, 10));
 135     QCOMPARE(transform2D(scale).map(QPointF(11, 10)), QPointF(20, 10));
 136
 137     scale.setYScale(2);
 138     scale.setZScale(4.5);
 139     scale.setOrigin(QVector3D(1, 2, 3));
 140
 141     QCOMPARE(scale.xScale(), qreal(10));
 142     QCOMPARE(scale.yScale(), qreal(2));
 143     QCOMPARE(scale.zScale(), qreal(4.5));
 144     QCOMPARE(scale.origin(), QVector3D(1, 2, 3));
 145
 146     QMatrix4x4 t2;
 147     scale.applyTo(&t2);
 148
 149     QCOMPARE(t2.map(QVector3D(4, 5, 6)), QVector3D(31, 8, 16.5));
 150
 151     // Because the origin has a non-zero z, mapping (4, 5) in 2D
 152     // will introduce a projective component into the result.
 153     QTransform t3 = t2.toTransform();
 154     QCOMPARE(t3.map(QPointF(4, 5)), QPointF(31 / t3.m33(), 8 / t3.m33()));
 155 }
 156
 157 // QMatrix4x4 uses float internally, whereas QTransform uses qreal.
 158 // This can lead to issues with qFuzzyCompare() where it uses double
 159 // precision to compare values that have no more than float precision
 160 // after conversion from QMatrix4x4 to QTransform.  The following
 161 // definitions correct for the difference.
 162 static inline bool fuzzyCompare(qreal p1, qreal p2)
 163 {
 164     // increase delta on small machines using float instead of double
 165     if (sizeof(qreal) == sizeof(float))
 166         return (qAbs(p1 - p2) <= 0.00003f * qMin(qAbs(p1), qAbs(p2)));
 167     else
 168         return (qAbs(p1 - p2) <= 0.00001f * qMin(qAbs(p1), qAbs(p2)));
 169 }
 170
 171 static bool fuzzyCompare(const QTransform& t1, const QTransform& t2)
 172 {
 173     return fuzzyCompare(t1.m11(), t2.m11()) &&
 174            fuzzyCompare(t1.m12(), t2.m12()) &&
 175            fuzzyCompare(t1.m13(), t2.m13()) &&
 176            fuzzyCompare(t1.m21(), t2.m21()) &&
 177            fuzzyCompare(t1.m22(), t2.m22()) &&
 178            fuzzyCompare(t1.m23(), t2.m23()) &&
 179            fuzzyCompare(t1.m31(), t2.m31()) &&
 180            fuzzyCompare(t1.m32(), t2.m32()) &&
 181            fuzzyCompare(t1.m33(), t2.m33());
 182 }
 183
 184 static inline bool fuzzyCompare(const QMatrix4x4& m1, const QMatrix4x4& m2)
 185 {
 186     bool ok = true;
 187     for (int y = 0; y < 4; ++y)
 188         for (int x = 0; x < 4; ++x)
 189             ok &= fuzzyCompare(m1(y, x), m2(y, x));
 190     return ok;
 191 }
 192
 193 void tst_QGraphicsTransform::rotation()
 194 {
 195     QGraphicsRotation rotation;
 196     QCOMPARE(rotation.axis(), QVector3D(0, 0, 1));
 197     QCOMPARE(rotation.origin(), QVector3D(0, 0, 0));
 198     QCOMPARE(rotation.angle(), (qreal)0);
 199
 200     rotation.setOrigin(QVector3D(10, 10, 0));
 201
 202     QCOMPARE(rotation.axis(), QVector3D(0, 0, 1));
 203     QCOMPARE(rotation.origin(), QVector3D(10, 10, 0));
 204     QCOMPARE(rotation.angle(), (qreal)0);
 205
 206     QMatrix4x4 t;
 207     rotation.applyTo(&t);
 208
 209     QCOMPARE(t, QMatrix4x4());
 210     QCOMPARE(transform2D(rotation), QTransform());
 211
 212     rotation.setAngle(40);
 213     rotation.setOrigin(QVector3D(0, 0, 0));
 214
 215     QCOMPARE(rotation.axis(), QVector3D(0, 0, 1));
 216     QCOMPARE(rotation.origin(), QVector3D(0, 0, 0));
 217     QCOMPARE(rotation.angle(), (qreal)40);
 218
 219     QTransform res;
 220     res.rotate(40);
 221
 222     QVERIFY(fuzzyCompare(transform2D(rotation), res));
 223
 224     rotation.setOrigin(QVector3D(10, 10, 0));
 225     rotation.setAngle(90);
 226     QCOMPARE(transform2D(rotation).map(QPointF(10, 10)), QPointF(10, 10));
 227     QCOMPARE(transform2D(rotation).map(QPointF(20, 10)), QPointF(10, 20));
 228 }
 229
 230 Q_DECLARE_METATYPE(Qt::Axis);
 231 void tst_QGraphicsTransform::rotation3d_data()
 232 {
 233     QTest::addColumn<Qt::Axis>("axis");
 234     QTest::addColumn<qreal>("angle");
 235
 236     for (int angle = 0; angle <= 360; angle++) {
 237         QTest::newRow("test rotation on X") << Qt::XAxis << qreal(angle);
 238         QTest::newRow("test rotation on Y") << Qt::YAxis << qreal(angle);
 239         QTest::newRow("test rotation on Z") << Qt::ZAxis << qreal(angle);
 240     }
 241 }
 242
 243 void tst_QGraphicsTransform::rotation3d()
 244 {
 245     QFETCH(Qt::Axis, axis);
 246     QFETCH(qreal, angle);
 247
 248     QGraphicsRotation rotation;
 249     rotation.setAxis(axis);
 250
 251     QMatrix4x4 t;
 252     rotation.applyTo(&t);
 253
 254     QVERIFY(t.isIdentity());
 255     QVERIFY(transform2D(rotation).isIdentity());
 256
 257     rotation.setAngle(angle);
 258
 259     // QGraphicsRotation uses a correct mathematical rotation in 3D.
 260     // QTransform's Qt::YAxis rotation is inverted from the mathematical
 261     // version of rotation.  We correct for that here.
 262     QTransform expected;
 263     if (axis == Qt::YAxis && angle != 180.)
 264         expected.rotate(-angle, axis);
 265     else
 266         expected.rotate(angle, axis);
 267
 268     QVERIFY(fuzzyCompare(transform2D(rotation), expected));
 269
 270     // Check that "rotation" produces the 4x4 form of the 3x3 matrix.
 271     // i.e. third row and column are 0 0 1 0.
 272     t.setToIdentity();
 273     rotation.applyTo(&t);
 274     QMatrix4x4 r(expected);
 275     if (sizeof(qreal) == sizeof(float) && angle == 268) {
 276         // This test fails, on only this angle, when qreal == float
 277         // because the deg2rad value in QTransform is not accurate
 278         // enough to match what QMatrix4x4 is doing.
 279     } else {
 280         QVERIFY(fuzzyCompare(t, r));
 281     }
 282
 283     //now let's check that a null vector will not change the transform
 284     rotation.setAxis(QVector3D(0, 0, 0));
 285     rotation.setOrigin(QVector3D(10, 10, 0));
 286
 287     t.setToIdentity();
 288     rotation.applyTo(&t);
 289
 290     QVERIFY(t.isIdentity());
 291     QVERIFY(transform2D(rotation).isIdentity());
 292
 293     rotation.setAngle(angle);
 294
 295     QVERIFY(t.isIdentity());
 296     QVERIFY(transform2D(rotation).isIdentity());
 297
 298     rotation.setOrigin(QVector3D(0, 0, 0));
 299
 300     QVERIFY(t.isIdentity());
 301     QVERIFY(transform2D(rotation).isIdentity());
 302 }
 303
 304 void tst_QGraphicsTransform::rotation3dArbitraryAxis_data()
 305 {
 306     QTest::addColumn<QVector3D>("axis");
 307     QTest::addColumn<qreal>("angle");
 308
 309     QVector3D axis1 = QVector3D(1.0f, 1.0f, 1.0f);
 310     QVector3D axis2 = QVector3D(2.0f, -3.0f, 0.5f);
 311     QVector3D axis3 = QVector3D(-2.0f, 0.0f, -0.5f);
 312     QVector3D axis4 = QVector3D(0.0001f, 0.0001f, 0.0001f);
 313     QVector3D axis5 = QVector3D(0.01f, 0.01f, 0.01f);
 314
 315     for (int angle = 0; angle <= 360; angle++) {
 316         QTest::newRow("test rotation on (1, 1, 1)") << axis1 << qreal(angle);
 317         QTest::newRow("test rotation on (2, -3, .5)") << axis2 << qreal(angle);
 318         QTest::newRow("test rotation on (-2, 0, -.5)") << axis3 << qreal(angle);
 319         QTest::newRow("test rotation on (.0001, .0001, .0001)") << axis4 << qreal(angle);
 320         QTest::newRow("test rotation on (.01, .01, .01)") << axis5 << qreal(angle);
 321     }
 322 }
 323
 324 void tst_QGraphicsTransform::rotation3dArbitraryAxis()
 325 {
 326     QFETCH(QVector3D, axis);
 327     QFETCH(qreal, angle);
 328
 329     QGraphicsRotation rotation;
 330     rotation.setAxis(axis);
 331
 332     QMatrix4x4 t;
 333     rotation.applyTo(&t);
 334
 335     QVERIFY(t.isIdentity());
 336     QVERIFY(transform2D(rotation).isIdentity());
 337
 338     rotation.setAngle(angle);
 339
 340     // Compute the expected answer using QMatrix4x4 and a projection.
 341     // These two steps are performed in one hit by QGraphicsRotation.
 342     QMatrix4x4 exp;
 343     exp.rotate(angle, axis);
 344     QTransform expected = exp.toTransform(1024.0f);
 345
 346     QVERIFY(fuzzyCompare(transform2D(rotation), expected));
 347
 348     // Check that "rotation" produces the 4x4 form of the 3x3 matrix.
 349     // i.e. third row and column are 0 0 1 0.
 350     t.setToIdentity();
 351     rotation.applyTo(&t);
 352     QMatrix4x4 r(expected);
 353     QVERIFY(qFuzzyCompare(t, r));
 354 }
 355
 356
 357 QTEST_MAIN(tst_QGraphicsTransform)
 358 #include "tst_qgraphicstransform.moc"
 359