| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the test suite of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:GPL-EXCEPT$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| |
| #include <QtTest/QtTest> |
| #include "qtransform.h" |
| #include <qpolygon.h> |
| #include <qdebug.h> |
| |
| |
| class tst_QTransform : public QObject |
| { |
| Q_OBJECT |
| |
| private slots: |
| void mapRect_data(); |
| void mapToPolygon_data(); |
| void mapRect(); |
| void assignments(); |
| void mapToPolygon(); |
| void qhash(); |
| void translate(); |
| void scale(); |
| void matrix(); |
| void testOffset(); |
| void types(); |
| void types2_data(); |
| void types2(); |
| void scalarOps(); |
| void transform(); |
| void mapEmptyPath(); |
| void boundingRect(); |
| void controlPointRect(); |
| void inverted_data(); |
| void inverted(); |
| void projectivePathMapping(); |
| void mapInt(); |
| void mapPathWithPoint(); |
| |
| private: |
| void mapping_data(); |
| }; |
| |
| Q_DECLARE_METATYPE(QTransform) |
| Q_DECLARE_METATYPE(QTransform::TransformationType) |
| |
| void tst_QTransform::mapRect_data() |
| { |
| mapping_data(); |
| |
| // rotations that are not multiples of 90 degrees. mapRect returns the bounding rect here. |
| qreal deg = -45; |
| QTest::newRow( "rot 45 a" ) |
| << QTransform().rotate(deg) |
| << QRect( 0, 0, 10, 10 ) |
| << QPolygon( QRect( 0, -7, 14, 14 ) ); |
| QTest::newRow( "rot 45 b" ) |
| << QTransform().rotate(deg) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( 21, -14, 50, 49 ) ); |
| QTest::newRow( "rot 45 c" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 0, 0, 10, 10 ) |
| << QPolygon( QRect( 0, -71, 141, 142 ) ); |
| QTest::newRow( "rot 45 d" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( 212, -141, 495, 495 ) ); |
| |
| deg = 45; |
| QTest::newRow( "rot -45 a" ) |
| << QTransform().rotate(deg) |
| << QRect( 0, 0, 10, 10 ) |
| << QPolygon( QRect( -7, 0, 14, 14 ) ); |
| QTest::newRow( "rot -45 b" ) |
| << QTransform().rotate(deg) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( -35, 21, 49, 50 ) ); |
| QTest::newRow( "rot -45 c" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 0, 0, 10, 10 ) |
| << QPolygon( QRect( -71, 0, 142, 141 ) ); |
| QTest::newRow( "rot -45 d" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( -354, 212, 495, 495 ) ); |
| } |
| |
| void tst_QTransform::mapToPolygon_data() |
| { |
| mapping_data(); |
| } |
| |
| void tst_QTransform::mapping_data() |
| { |
| //create the testtable instance and define the elements |
| QTest::addColumn<QTransform>("matrix"); |
| QTest::addColumn<QRect>("src"); |
| QTest::addColumn<QPolygon>("res"); |
| |
| //next we fill it with data |
| |
| // identity |
| QTest::newRow( "identity" ) |
| << QTransform() |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( 10, 20, 30, 40 ) ); |
| // scaling |
| QTest::newRow( "scale 0" ) |
| << QTransform().scale(2, 2) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( 20, 40, 60, 80 ) ); |
| QTest::newRow( "scale 1" ) |
| << QTransform().scale(10, 10) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( 100, 200, 300, 400 ) ); |
| // mirroring |
| QTest::newRow( "mirror 0" ) |
| << QTransform().scale(-1, 1) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( -40, 20, 30, 40 ) ); |
| QTest::newRow( "mirror 1" ) |
| << QTransform().scale(1, -1) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( 10, -60, 30, 40 ) ); |
| QTest::newRow( "mirror 2" ) |
| << QTransform().scale(-1, -1) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( -40, -60, 30, 40 ) ); |
| QTest::newRow( "mirror 3" ) |
| << QTransform().scale(-2, -2) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( -80, -120, 60, 80 ) ); |
| QTest::newRow( "mirror 4" ) |
| << QTransform().scale(-10, -10) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( -400, -600, 300, 400 ) ); |
| QTest::newRow( "mirror 5" ) |
| << QTransform().scale(-1, 1) |
| << QRect( 0, 0, 30, 40 ) |
| << QPolygon( QRect( -30, 0, 30, 40 ) ); |
| QTest::newRow( "mirror 6" ) |
| << QTransform().scale(1, -1) |
| << QRect( 0, 0, 30, 40 ) |
| << QPolygon( QRect( 0, -40, 30, 40 ) ); |
| QTest::newRow( "mirror 7" ) |
| << QTransform().scale(-1, -1) |
| << QRect( 0, 0, 30, 40 ) |
| << QPolygon( QRect( -30, -40, 30, 40 ) ); |
| QTest::newRow( "mirror 8" ) |
| << QTransform().scale(-2, -2) |
| << QRect( 0, 0, 30, 40 ) |
| << QPolygon( QRect( -60, -80, 60, 80 ) ); |
| QTest::newRow( "mirror 9" ) |
| << QTransform().scale(-10, -10) << QRect( 0, 0, 30, 40 ) |
| << QPolygon( QRect( -300, -400, 300, 400 ) ); |
| |
| // rotations |
| float deg = 0.; |
| QTest::newRow( "rot 0 a" ) |
| << QTransform().rotate(deg) |
| << QRect( 0, 0, 30, 40 ) |
| << QPolygon ( QRect( 0, 0, 30, 40 ) ); |
| deg = 0.00001f; |
| QTest::newRow( "rot 0 b" ) |
| << QTransform().rotate(deg) |
| << QRect( 0, 0, 30, 40 ) |
| << QPolygon ( QRect( 0, 0, 30, 40 ) ); |
| deg = 0.; |
| QTest::newRow( "rot 0 c" ) |
| << QTransform().rotate(deg) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon ( QRect( 10, 20, 30, 40 ) ); |
| deg = 0.00001f; |
| QTest::newRow( "rot 0 d" ) |
| << QTransform().rotate(deg) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon ( QRect( 10, 20, 30, 40 ) ); |
| |
| // rotations |
| deg = -90.f; |
| QTest::newRow( "rotscale 90 a" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 0, 0, 30, 40 ) |
| << QPolygon( QRect( 0, -300, 400, 300 ) ); |
| deg = -90.00001f; |
| QTest::newRow( "rotscale 90 b" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 0, 0, 30, 40 ) |
| << QPolygon( QRect( 0, -300, 400, 300 ) ); |
| deg = -90.f; |
| QTest::newRow( "rotscale 90 c" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( 200, -400, 400, 300 ) ); |
| deg = -90.00001f; |
| QTest::newRow( "rotscale 90 d" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( 200, -400, 400, 300 ) ); |
| |
| deg = 180.f; |
| QTest::newRow( "rotscale 180 a" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 0, 0, 30, 40 ) |
| << QPolygon( QRect( -300, -400, 300, 400 ) ); |
| deg = 180.000001f; |
| QTest::newRow( "rotscale 180 b" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 0, 0, 30, 40 ) |
| << QPolygon( QRect( -300, -400, 300, 400 ) ); |
| deg = 180.f; |
| QTest::newRow( "rotscale 180 c" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( -400, -600, 300, 400 ) ); |
| deg = 180.000001f; |
| QTest::newRow( "rotscale 180 d" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( -400, -600, 300, 400 ) ); |
| |
| deg = -270.f; |
| QTest::newRow( "rotscale 270 a" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 0, 0, 30, 40 ) |
| << QPolygon( QRect( -400, 0, 400, 300 ) ); |
| deg = -270.0000001f; |
| QTest::newRow( "rotscale 270 b" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 0, 0, 30, 40 ) |
| << QPolygon( QRect( -400, 0, 400, 300 ) ); |
| deg = -270.f; |
| QTest::newRow( "rotscale 270 c" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( -600, 100, 400, 300 ) ); |
| deg = -270.000001f; |
| QTest::newRow( "rotscale 270 d" ) |
| << QTransform().rotate(deg).scale(10, 10) |
| << QRect( 10, 20, 30, 40 ) |
| << QPolygon( QRect( -600, 100, 400, 300 ) ); |
| } |
| |
| void tst_QTransform::mapRect() |
| { |
| QFETCH( QTransform, matrix ); |
| QFETCH( QRect, src ); |
| QFETCH( QPolygon, res ); |
| QRect mapped = matrix.mapRect(src); |
| QCOMPARE( mapped, res.boundingRect().adjusted(0, 0, -1, -1) ); |
| |
| QRectF r = matrix.mapRect(QRectF(src)); |
| QRect ir(r.topLeft().toPoint(), r.bottomRight().toPoint() - QPoint(1, 1)); |
| QCOMPARE( mapped, ir ); |
| } |
| |
| void tst_QTransform::assignments() |
| { |
| QTransform m; |
| m.scale(2, 3); |
| m.rotate(45); |
| m.shear(4, 5); |
| |
| QTransform c1(m); |
| |
| QCOMPARE(m.m11(), c1.m11()); |
| QCOMPARE(m.m12(), c1.m12()); |
| QCOMPARE(m.m21(), c1.m21()); |
| QCOMPARE(m.m22(), c1.m22()); |
| QCOMPARE(m.dx(), c1.dx()); |
| QCOMPARE(m.dy(), c1.dy()); |
| |
| QTransform c2 = m; |
| QCOMPARE(m.m11(), c2.m11()); |
| QCOMPARE(m.m12(), c2.m12()); |
| QCOMPARE(m.m21(), c2.m21()); |
| QCOMPARE(m.m22(), c2.m22()); |
| QCOMPARE(m.dx(), c2.dx()); |
| QCOMPARE(m.dy(), c2.dy()); |
| } |
| |
| |
| void tst_QTransform::mapToPolygon() |
| { |
| QFETCH( QTransform, matrix ); |
| QFETCH( QRect, src ); |
| QFETCH( QPolygon, res ); |
| |
| QPolygon poly = matrix.mapToPolygon(src); |
| |
| // don't care about starting point |
| bool equal = false; |
| for (int i = 0; i < poly.size(); ++i) { |
| QPolygon rot; |
| for (int j = i; j < poly.size(); ++j) |
| rot << poly[j]; |
| for (int j = 0; j < i; ++j) |
| rot << poly[j]; |
| if (rot == res) |
| equal = true; |
| } |
| |
| QVERIFY(equal); |
| } |
| |
| void tst_QTransform::qhash() |
| { |
| QMatrix m1; |
| m1.shear(3.0, 2.0); |
| m1.rotate(44); |
| |
| QMatrix m2 = m1; |
| |
| QTransform t1(m1); |
| QTransform t2(m2); |
| |
| // not really much to test here, so just the bare minimum: |
| QCOMPARE(qHash(m1), qHash(m2)); |
| QCOMPARE(qHash(t1), qHash(t2)); |
| } |
| |
| |
| void tst_QTransform::translate() |
| { |
| QTransform m( 1, 2, 3, 4, 5, 6 ); |
| QTransform res2( m ); |
| QTransform res( 1, 2, 3, 4, 75, 106 ); |
| m.translate( 10, 20 ); |
| QVERIFY( m == res ); |
| m.translate( -10, -20 ); |
| QVERIFY( m == res2 ); |
| QVERIFY( QTransform::fromTranslate( 0, 0 ).type() == QTransform::TxNone ); |
| QVERIFY( QTransform::fromTranslate( 10, 0 ).type() == QTransform::TxTranslate ); |
| QVERIFY( QTransform::fromTranslate( -1, 5 ) == QTransform().translate( -1, 5 )); |
| QVERIFY( QTransform::fromTranslate( 0, 0 ) == QTransform()); |
| } |
| |
| void tst_QTransform::scale() |
| { |
| QTransform m( 1, 2, 3, 4, 5, 6 ); |
| QTransform res2( m ); |
| QTransform res( 10, 20, 60, 80, 5, 6 ); |
| m.scale( 10, 20 ); |
| QVERIFY( m == res ); |
| m.scale( 1./10., 1./20. ); |
| QVERIFY( m == res2 ); |
| QVERIFY( QTransform::fromScale( 1, 1 ).type() == QTransform::TxNone ); |
| QVERIFY( QTransform::fromScale( 2, 4 ).type() == QTransform::TxScale ); |
| QVERIFY( QTransform::fromScale( 2, 4 ) == QTransform().scale( 2, 4 )); |
| QVERIFY( QTransform::fromScale( 1, 1 ) == QTransform()); |
| } |
| |
| void tst_QTransform::matrix() |
| { |
| QMatrix mat1; |
| mat1.scale(0.3, 0.7); |
| mat1.translate(53.3, 94.4); |
| mat1.rotate(45); |
| |
| QMatrix mat2; |
| mat2.rotate(33); |
| mat2.scale(0.6, 0.6); |
| mat2.translate(13.333, 7.777); |
| |
| QTransform tran1(mat1); |
| QTransform tran2(mat2); |
| QTransform dummy; |
| dummy.setMatrix(mat1.m11(), mat1.m12(), 0, |
| mat1.m21(), mat1.m22(), 0, |
| mat1.dx(), mat1.dy(), 1); |
| |
| QCOMPARE(tran1, dummy); |
| QCOMPARE(tran1.inverted(), dummy.inverted()); |
| QCOMPARE(tran1.inverted(), QTransform(mat1.inverted())); |
| QCOMPARE(tran2.inverted(), QTransform(mat2.inverted())); |
| |
| QMatrix mat3 = mat1 * mat2; |
| QTransform tran3 = tran1 * tran2; |
| QCOMPARE(QTransform(mat3), tran3); |
| |
| /* QMatrix::operator==() doesn't use qFuzzyCompare(), which |
| * on win32-g++ results in a failure. So we work around it by |
| * calling QTranform::operator==(), which performs a fuzzy compare. */ |
| QCOMPARE(QTransform(mat3), QTransform(tran3.toAffine())); |
| |
| QTransform tranInv = tran1.inverted(); |
| QMatrix matInv = mat1.inverted(); |
| |
| QRect rect(43, 70, 200, 200); |
| QPoint pt(43, 66); |
| QCOMPARE(tranInv.map(pt), matInv.map(pt)); |
| QCOMPARE(tranInv.map(pt), matInv.map(pt)); |
| |
| QPainterPath path; |
| path.moveTo(55, 60); |
| path.lineTo(110, 110); |
| path.quadTo(220, 50, 10, 20); |
| path.closeSubpath(); |
| QCOMPARE(tranInv.map(path), matInv.map(path)); |
| } |
| |
| void tst_QTransform::testOffset() |
| { |
| QTransform trans; |
| const QMatrix &aff = trans.toAffine(); |
| QCOMPARE((void*)(&aff), (void*)(&trans)); |
| } |
| |
| void tst_QTransform::types() |
| { |
| QTransform m1; |
| QCOMPARE(m1.type(), QTransform::TxNone); |
| |
| m1.translate(1.0f, 0.0f); |
| QCOMPARE(m1.type(), QTransform::TxTranslate); |
| QCOMPARE(m1.inverted().type(), QTransform::TxTranslate); |
| |
| m1.scale(1.0f, 2.0f); |
| QCOMPARE(m1.type(), QTransform::TxScale); |
| QCOMPARE(m1.inverted().type(), QTransform::TxScale); |
| |
| m1.rotate(45.0f); |
| QCOMPARE(m1.type(), QTransform::TxRotate); |
| QCOMPARE(m1.inverted().type(), QTransform::TxRotate); |
| |
| m1.shear(0.5f, 0.25f); |
| QCOMPARE(m1.type(), QTransform::TxShear); |
| QCOMPARE(m1.inverted().type(), QTransform::TxShear); |
| |
| m1.rotate(45.0f, Qt::XAxis); |
| QCOMPARE(m1.type(), QTransform::TxProject); |
| m1.shear(0.5f, 0.25f); |
| QCOMPARE(m1.type(), QTransform::TxProject); |
| m1.rotate(45.0f); |
| QCOMPARE(m1.type(), QTransform::TxProject); |
| m1.scale(1.0f, 2.0f); |
| QCOMPARE(m1.type(), QTransform::TxProject); |
| m1.translate(1.0f, 0.0f); |
| QCOMPARE(m1.type(), QTransform::TxProject); |
| |
| QTransform m2(1.0f, 0.0f, 0.0f, |
| 0.0f, 1.0f, 0.0f, |
| -1.0f, -1.0f, 1.0f); |
| |
| QCOMPARE(m2.type(), QTransform::TxTranslate); |
| QCOMPARE((m1 * m2).type(), QTransform::TxProject); |
| |
| m1 *= QTransform(); |
| QCOMPARE(m1.type(), QTransform::TxProject); |
| |
| m1 *= QTransform(1.0f, 0.0f, 0.0f, |
| 0.0f, 1.0f, 0.0f, |
| 1.0f, 0.0f, 1.0f); |
| QCOMPARE(m1.type(), QTransform::TxProject); |
| |
| m2.reset(); |
| QCOMPARE(m2.type(), QTransform::TxNone); |
| |
| m2.setMatrix(1.0f, 0.0f, 0.0f, |
| 0.0f, 1.0f, 0.0f, |
| 0.0f, 0.0f, 1.0f); |
| QCOMPARE(m2.type(), QTransform::TxNone); |
| |
| m2 *= QTransform(); |
| QCOMPARE(m2.type(), QTransform::TxNone); |
| |
| m2.setMatrix(2.0f, 0.0f, 0.0f, |
| 0.0f, 1.0f, 0.0f, |
| 0.0f, 0.0f, 1.0f); |
| QCOMPARE(m2.type(), QTransform::TxScale); |
| m2 *= QTransform(); |
| QCOMPARE(m2.type(), QTransform::TxScale); |
| |
| m2.setMatrix(0.0f, 1.0f, 0.0f, |
| 1.0f, 0.0f, 0.0f, |
| 0.0f, 1.0f, 1.0f); |
| QCOMPARE(m2.type(), QTransform::TxRotate); |
| m2 *= QTransform(); |
| QCOMPARE(m2.type(), QTransform::TxRotate); |
| |
| m2.setMatrix(1.0f, 0.0f, 0.5f, |
| 0.0f, 1.0f, 0.0f, |
| 0.0f, 0.0f, 1.0f); |
| QCOMPARE(m2.type(), QTransform::TxProject); |
| m2 *= QTransform(); |
| QCOMPARE(m2.type(), QTransform::TxProject); |
| |
| m2.setMatrix(1.0f, 1.0f, 0.0f, |
| 1.0f, 0.0f, 0.0f, |
| 0.0f, 1.0f, 1.0f); |
| QCOMPARE(m2.type(), QTransform::TxShear); |
| |
| m2 *= m2.inverted(); |
| QCOMPARE(m2.type(), QTransform::TxNone); |
| |
| m2.translate(5.0f, 5.0f); |
| m2.rotate(45.0f); |
| m2.rotate(-45.0f); |
| QCOMPARE(m2.type(), QTransform::TxTranslate); |
| |
| m2.scale(2.0f, 3.0f); |
| m2.shear(1.0f, 0.0f); |
| m2.shear(-1.0f, 0.0f); |
| QCOMPARE(m2.type(), QTransform::TxScale); |
| |
| m2 *= QTransform(1.0f, 1.0f, 0.0f, |
| 0.0f, 1.0f, 0.0f, |
| 0.0f, 0.0f, 1.0f); |
| QCOMPARE(m2.type(), QTransform::TxShear); |
| |
| m2 *= QTransform(1.0f, 0.0f, 0.0f, |
| 0.0f, 1.0f, 0.0f, |
| 1.0f, 0.0f, 1.0f); |
| QCOMPARE(m2.type(), QTransform::TxShear); |
| |
| QTransform m3(1.8f, 0.0f, 0.0f, |
| 0.0f, 1.8f, 0.0f, |
| 0.0f, 0.0f, 1.0f); |
| |
| QCOMPARE(m3.type(), QTransform::TxScale); |
| m3.translate(5.0f, 5.0f); |
| QCOMPARE(m3.type(), QTransform::TxScale); |
| QCOMPARE(m3.inverted().type(), QTransform::TxScale); |
| |
| m3.setMatrix(1.0f, 0.0f, 0.0f, |
| 0.0f, 1.0f, 0.0f, |
| 0.0f, 0.0f, 2.0f); |
| QCOMPARE(m3.type(), QTransform::TxProject); |
| |
| m3.setMatrix(0.0f, 2.0f, 0.0f, |
| 1.0f, 0.0f, 0.0f, |
| 0.0f, 0.0f, 2.0f); |
| QCOMPARE(m3.type(), QTransform::TxProject); |
| |
| QTransform m4; |
| m4.scale(5, 5); |
| m4.translate(4, 2); |
| m4.rotate(45); |
| |
| QCOMPARE(m4.type(), QTransform::TxRotate); |
| |
| QTransform m5; |
| m5.scale(5, 5); |
| m5 = m5.adjoint() / m5.determinant(); |
| QCOMPARE(m5.type(), QTransform::TxScale); |
| } |
| |
| void tst_QTransform::types2_data() |
| { |
| QTest::addColumn<QTransform>("t1"); |
| QTest::addColumn<QTransform::TransformationType>("type"); |
| |
| QTest::newRow( "identity" ) << QTransform() << QTransform::TxNone; |
| QTest::newRow( "translate" ) << QTransform().translate(10, -0.1) << QTransform::TxTranslate; |
| QTest::newRow( "scale" ) << QTransform().scale(10, -0.1) << QTransform::TxScale; |
| QTest::newRow( "rotate" ) << QTransform().rotate(10) << QTransform::TxRotate; |
| QTest::newRow( "shear" ) << QTransform().shear(10, -0.1) << QTransform::TxShear; |
| QTest::newRow( "project" ) << QTransform().rotate(10, Qt::XAxis) << QTransform::TxProject; |
| QTest::newRow( "combined" ) << QTransform().translate(10, -0.1).scale(10, -0.1).rotate(10, Qt::YAxis) << QTransform::TxProject; |
| } |
| |
| void tst_QTransform::types2() |
| { |
| #define CHECKTXTYPE(func) { QTransform t2(func); \ |
| QTransform t3(t2.m11(), t2.m12(), t2.m13(), t2.m21(), t2.m22(), t2.m23(), t2.m31(), t2.m32(), t2.m33()); \ |
| QVERIFY2(t3.type() == t2.type(), #func); \ |
| } |
| |
| QFETCH( QTransform, t1 ); |
| QFETCH( QTransform::TransformationType, type ); |
| |
| Q_ASSERT(t1.type() == type); |
| |
| CHECKTXTYPE(t1.adjoint()); |
| CHECKTXTYPE(t1.inverted()); |
| CHECKTXTYPE(t1.transposed()); |
| |
| #undef CHECKTXTYPE |
| } |
| |
| void tst_QTransform::scalarOps() |
| { |
| QTransform t; |
| QCOMPARE(t.m11(), 1.); |
| QCOMPARE(t.m33(), 1.); |
| QCOMPARE(t.m21(), 0.); |
| |
| t = QTransform() + 3; |
| QCOMPARE(t.m11(), 4.); |
| QCOMPARE(t.m33(), 4.); |
| QCOMPARE(t.m21(), 3.); |
| |
| t = t - 3; |
| QCOMPARE(t.m11(), 1.); |
| QCOMPARE(t.m33(), 1.); |
| QCOMPARE(t.m21(), 0.); |
| QCOMPARE(t.isIdentity(), true); |
| |
| t += 3; |
| t = t * 2; |
| QCOMPARE(t.m11(), 8.); |
| QCOMPARE(t.m33(), 8.); |
| QCOMPARE(t.m21(), 6.); |
| } |
| |
| void tst_QTransform::transform() |
| { |
| QTransform t; |
| t.rotate(30, Qt::YAxis); |
| t.translate(15, 10); |
| t.scale(2, 2); |
| t.rotate(30); |
| t.shear(0.5, 0.5); |
| |
| QTransform a, b, c, d, e; |
| a.rotate(30, Qt::YAxis); |
| b.translate(15, 10); |
| c.scale(2, 2); |
| d.rotate(30); |
| e.shear(0.5, 0.5); |
| |
| QVERIFY(qFuzzyCompare(t, e * d * c * b * a)); |
| } |
| |
| void tst_QTransform::mapEmptyPath() |
| { |
| QPainterPath path; |
| path.moveTo(10, 10); |
| path.lineTo(10, 10); |
| QCOMPARE(QTransform().map(path), path); |
| } |
| |
| void tst_QTransform::boundingRect() |
| { |
| QPainterPath path; |
| path.moveTo(10, 10); |
| path.lineTo(10, 10); |
| QCOMPARE(path.boundingRect(), QRectF(10, 10, 0, 0)); |
| } |
| |
| void tst_QTransform::controlPointRect() |
| { |
| QPainterPath path; |
| path.moveTo(10, 10); |
| path.lineTo(10, 10); |
| QCOMPARE(path.controlPointRect(), QRectF(10, 10, 0, 0)); |
| } |
| |
| void tst_QTransform::inverted_data() |
| { |
| QTest::addColumn<QTransform>("matrix"); |
| |
| QTest::newRow("identity") |
| << QTransform(); |
| |
| QTest::newRow("TxTranslate") |
| << QTransform().translate(200, 10); |
| |
| QTest::newRow("TxScale") |
| << QTransform().scale(5, 2); |
| |
| QTest::newRow("TxTranslate TxScale") |
| << QTransform().translate(100, -10).scale(40, 2); |
| |
| QTest::newRow("TxScale TxTranslate") |
| << QTransform().scale(40, 2).translate(100, -10); |
| |
| QTest::newRow("TxRotate") |
| << QTransform().rotate(40, Qt::ZAxis); |
| |
| QTest::newRow("TxRotate TxScale") |
| << QTransform().rotate(60, Qt::ZAxis).scale(2, 0.25); |
| |
| QTest::newRow("TxScale TxRotate") |
| << QTransform().scale(2, 0.25).rotate(30, Qt::ZAxis); |
| |
| QTest::newRow("TxRotate TxScale TxTranslate") |
| << QTransform().rotate(60, Qt::ZAxis).scale(2, 0.25).translate(200, -3000); |
| |
| QTest::newRow("TxRotate TxTranslate TxScale") |
| << QTransform().rotate(60, Qt::ZAxis).translate(200, -3000).scale(19, 77); |
| |
| QTest::newRow("TxShear") |
| << QTransform().shear(10, 10); |
| |
| QTest::newRow("TxShear TxRotate") |
| << QTransform().shear(10, 10).rotate(45, Qt::ZAxis); |
| |
| QTest::newRow("TxShear TxRotate TxScale") |
| << QTransform().shear(10, 10).rotate(45, Qt::ZAxis).scale(19, 81); |
| |
| QTest::newRow("TxTranslate TxShear TxRotate TxScale") |
| << QTransform().translate(150, -1).shear(10, 10).rotate(45, Qt::ZAxis).scale(19, 81); |
| |
| const qreal s = 500000; |
| |
| QTransform big; |
| big.scale(s, s); |
| |
| QTest::newRow("big") << big; |
| |
| QTransform smallTransform; |
| smallTransform.scale(1/s, 1/s); |
| |
| QTest::newRow("small") << smallTransform; |
| } |
| |
| void tst_QTransform::inverted() |
| { |
| if (sizeof(qreal) != sizeof(double)) |
| QSKIP("precision error if qreal is not double"); |
| |
| QFETCH(QTransform, matrix); |
| |
| const QTransform inverted = matrix.inverted(); |
| |
| QCOMPARE(matrix.isIdentity(), inverted.isIdentity()); |
| QCOMPARE(matrix.type(), inverted.type()); |
| |
| QVERIFY((matrix * inverted).isIdentity()); |
| QVERIFY((inverted * matrix).isIdentity()); |
| } |
| |
| void tst_QTransform::projectivePathMapping() |
| { |
| QPainterPath path; |
| path.addRect(-50, -50, 100, 100); |
| |
| const QRectF view(0, 0, 1024, 1024); |
| |
| QVERIFY(view.intersects(path.boundingRect())); |
| |
| for (int i = 0; i < 85; i += 5) { |
| QTransform transform; |
| transform.translate(512, 512); |
| transform.rotate(i, Qt::YAxis); |
| |
| const QPainterPath mapped = transform.map(path); |
| |
| QVERIFY(view.intersects(mapped.boundingRect())); |
| QVERIFY(transform.inverted().mapRect(view).intersects(path.boundingRect())); |
| } |
| } |
| |
| void tst_QTransform::mapInt() |
| { |
| int x = 0; |
| int y = 0; |
| |
| QTransform::fromTranslate(10, 10).map(x, y, &x, &y); |
| |
| QCOMPARE(x, 10); |
| QCOMPARE(y, 10); |
| } |
| |
| void tst_QTransform::mapPathWithPoint() |
| { |
| QPainterPath p(QPointF(10, 10)); |
| p = QTransform::fromTranslate(10, 10).map(p); |
| QCOMPARE(p.currentPosition(), QPointF(20, 20)); |
| } |
| |
| QTEST_APPLESS_MAIN(tst_QTransform) |
| |
| |
| #include "tst_qtransform.moc" |
