/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "private/qpathclipper_p.h"

#include "paths.h"

#include <QtTest/QtTest>

#include <qpainterpath.h>

#include <qpolygon.h>

#include <qdebug.h>

#include <qpainter.h>

#include <math.h>

class tst_QPathClipper : public QObject

{

    Q_OBJECT

public:

    tst_QPathClipper();

    virtual ~tst_QPathClipper();

private:

    void clipTest(int subjectIndex, int clipIndex, QPathClipper::Operation op);

    QList<QPainterPath> paths;

public slots:

    void initTestCase();

private slots:

    void testWingedEdge();

    void testComparePaths();

    void clip_data();

    void clip();

    void clip2();

    void clip3();

    void testIntersections();

    void testIntersections2();

    void testIntersections3();

    void testIntersections4();

    void testIntersections5();

    void testIntersections6();

    void testIntersections7();

    void testIntersections8();

    void testIntersections9();

    void zeroDerivativeCurves();

    void task204301_data();

    void task204301();

    void task209056();

    void task251909();

};

Q_DECLARE_METATYPE(QPainterPath)

Q_DECLARE_METATYPE(QPathClipper::Operation)

tst_QPathClipper::tst_QPathClipper()

{

}

tst_QPathClipper::~tst_QPathClipper()

{

}

void tst_QPathClipper::initTestCase()

{

    paths << Paths::rect();

    paths << Paths::heart();

    paths << Paths::body();

    paths << Paths::mailbox();

    paths << Paths::deer();

    paths << Paths::fire();

    paths << Paths::random1();

    paths << Paths::random2();

    paths << Paths::heart2();

    paths << Paths::rect2();

    paths << Paths::rect3();

    paths << Paths::rect4();

    paths << Paths::rect5();

    paths << Paths::rect6();

    paths << Paths::frame1();

    paths << Paths::frame2();

    paths << Paths::frame3();

    paths << Paths::frame4();

    paths << Paths::triangle1();

    paths << Paths::triangle2();

    paths << Paths::node();

    paths << Paths::interRect();

    paths << Paths::simpleCurve();

    paths << Paths::simpleCurve2();

    paths << Paths::simpleCurve3();

    paths << Paths::bezier1();

    paths << Paths::bezier2();

    paths << Paths::bezier3();

    paths << Paths::bezier4();

    paths << Paths::bezierFlower();

    paths << Paths::lips();

    paths << Paths::clover();

    paths << Paths::ellipses();

    paths << Paths::windingFill();

    paths << Paths::oddEvenFill();

    paths << Paths::squareWithHole();

    paths << Paths::circleWithHole();

    paths << Paths::bezierQuadrant();

    // make sure all the bounding rects are centered at the origin

    for (int i = 0; i < paths.size(); ++i) {

        QRectF bounds = paths[i].boundingRect();

        QMatrix m(1, 0,

                  0, 1,

                  -bounds.center().x(), -bounds.center().y());

        paths[i] = m.map(paths[i]);

    }

}

static QPainterPath samplePath1()

{

    QPainterPath path;

    path.moveTo(QPointF(200, 246.64789));

    path.lineTo(QPointF(200, 206.64789));

    path.lineTo(QPointF(231.42858, 206.64789));

    path.lineTo(QPointF(231.42858, 246.64789));

    path.lineTo(QPointF(200, 246.64789));

    return path;

}

static QPainterPath samplePath2()

{

    QPainterPath path;

    path.moveTo(QPointF(200, 146.64789));

    path.lineTo(QPointF(200, 106.64789));

    path.lineTo(QPointF(231.42858, 106.64789));

    path.lineTo(QPointF(231.42858, 146.64789));

    path.lineTo(QPointF(200, 146.64789));

    return path;

}

static QPainterPath samplePath3()

{

    QPainterPath path;

    path.moveTo(QPointF(231.42858, 80.933609));

    path.lineTo(QPointF(200, 80.933609));

    path.lineTo(QPointF(200, 96.64788999999999));

    path.lineTo(QPointF(231.42858, 96.64788999999999));

    path.lineTo(QPointF(231.42858, 80.933609));

    return path;

}

static QPainterPath samplePath4()

{

    QPainterPath path;

    path.moveTo(QPointF(288.571434, 80.933609));

    path.lineTo(QPointF(431.42858, 80.933609));

    path.lineTo(QPointF(431.42858, 96.64788999999999));

    path.lineTo(QPointF(288.571434, 96.64788999999999));

    path.lineTo(QPointF(288.571434, 80.933609));

    return path;

}

static QPainterPath samplePath5()

{

    QPainterPath path;

    path.moveTo(QPointF(588.571434, 80.933609));

    path.lineTo(QPointF(682.85715, 80.933609));

    path.lineTo(QPointF(682.85715, 96.64788999999999));

    path.lineTo(QPointF(588.571434, 96.64788999999999));

    path.lineTo(QPointF(588.571434, 80.933609));

    return path;

}

static QPainterPath samplePath6()

{

    QPainterPath path;

    path.moveTo(QPointF(588.571434, 80.933609));

    path.lineTo(QPointF(200, 80.933609));

    path.lineTo(QPointF(200, 446.6479));

    path.lineTo(QPointF(682.85715, 446.6479));

    path.lineTo(QPointF(682.85715, 96.64788999999999));

    path.lineTo(QPointF(731.42858, 96.64788999999999));

    path.lineTo(QPointF(731.42858, 56.64788999999999));

    path.lineTo(QPointF(588.571434, 56.64788999999999));

    path.lineTo(QPointF(588.571434, 80.933609));

    return path;

}

static QPainterPath samplePath7()

{

    QPainterPath path;

    path.moveTo(QPointF(682.85715, 206.64789));

    path.lineTo(QPointF(682.85715, 246.64789));

    path.lineTo(QPointF(588.571434, 246.64789));

    path.lineTo(QPointF(588.571434, 206.64789));

    path.lineTo(QPointF(682.85715, 206.64789));

    return path;

}

static QPainterPath samplePath8()

{

    QPainterPath path;

    path.moveTo(QPointF(682.85715, 406.64789));

    path.lineTo(QPointF(682.85715, 446.64789));

    path.lineTo(QPointF(588.571434, 446.64789));

    path.lineTo(QPointF(588.571434, 406.64789));

    path.lineTo(QPointF(682.85715, 406.64789));

    return path;

}

static QPainterPath samplePath9()

{

    QPainterPath path;

    path.moveTo(QPointF(682.85715, 426.64789));

    path.lineTo(QPointF(682.85715, 446.6479));

    path.lineTo(QPointF(568.571434, 446.6479));

    path.lineTo(QPointF(568.571434, 426.64789));

    path.lineTo(QPointF(682.85715, 426.64789));

    return path;

}

static QPainterPath samplePath10()

{

    QPainterPath path;

    path.moveTo(QPointF(511.42858, 446.6479));

    path.lineTo(QPointF(368.571434, 446.6479));

    path.lineTo(QPointF(368.571434, 426.64789));

    path.lineTo(QPointF(511.42858, 426.64789));

    path.lineTo(QPointF(511.42858, 446.6479));

    return path;

}

static QPainterPath samplePath13()

{

    QPainterPath path;

    path.moveTo(QPointF(160, 200));

    path.lineTo(QPointF(100, 200));

    path.lineTo(QPointF(100, 130));

    path.lineTo(QPointF(160, 130));

    path.lineTo(QPointF(160, 200));

    return path;

}

static QPainterPath samplePath14()

{

    QPainterPath path;

    return path;

}

void tst_QPathClipper::clip_data()

{

    //create the testtable instance and define the elements

    QTest::addColumn<QPainterPath>("subject");

    QTest::addColumn<QPainterPath>("clip");

    QTest::addColumn<QPathClipper::Operation>("op");

    QTest::addColumn<QPainterPath>("result");

    //next we fill it with data

    QTest::newRow( "simple1" )  << Paths::frame3()

                                << Paths::frame4()

                                << QPathClipper::BoolAnd

                                << samplePath1();

    QTest::newRow( "simple2" )  << Paths::frame3()

                                << Paths::frame4() * QTransform().translate(0, -100)

                                << QPathClipper::BoolAnd

                                << samplePath2();

    QTest::newRow( "simple3" )  << Paths::frame3()

                                << Paths::frame4() * QTransform().translate(0, -150)

                                << QPathClipper::BoolAnd

                                << samplePath3();

    QTest::newRow( "simple4" )  << Paths::frame3()

                                << Paths::frame4() * QTransform().translate(200, -150)

                                << QPathClipper::BoolAnd

                                << samplePath4();

    QTest::newRow( "simple5" )  << Paths::frame3()

                                << Paths::frame4() * QTransform().translate(500, -150)

                                << QPathClipper::BoolAnd

                                << samplePath5();

    QTest::newRow( "simple6" )  << Paths::frame3()

                                << Paths::frame4() * QTransform().translate(500, -150)

                                << QPathClipper::BoolOr

                                << samplePath6();

    QTest::newRow( "simple7" )  << Paths::frame3()

                                << Paths::frame4() * QTransform().translate(500, 0)

                                << QPathClipper::BoolAnd

                                << samplePath7();

    QTest::newRow( "simple8" )  << Paths::frame3()

                                << Paths::frame4() * QTransform().translate(500, 200)

                                << QPathClipper::BoolAnd

                                << samplePath8();

    QTest::newRow( "simple9" )  << Paths::frame3()

                                << Paths::frame4() * QTransform().translate(480, 220)

                                << QPathClipper::BoolAnd

                                << samplePath9();

    QTest::newRow( "simple10" )  << Paths::frame3()

                                 << Paths::frame4() * QTransform().translate(280, 220)

                                 << QPathClipper::BoolAnd

                                 << samplePath10();

    QTest::newRow( "simple_move_to1" )  << Paths::rect4()

                                       << Paths::rect2() * QTransform().translate(-20, 50)

                                       << QPathClipper::BoolAnd

                                       << samplePath13();

    QTest::newRow( "simple_move_to2" )  << Paths::rect4()

                                        << Paths::rect2() * QTransform().translate(-20, 0)

                                        << QPathClipper::BoolAnd

                                        << samplePath14();

}

// sanity check to make sure comparePaths declared above works

void tst_QPathClipper::testComparePaths()

{

    QPainterPath a;

    QPainterPath b;

    a.addRect(0, 0, 10, 10);

    b.addRect(0, 0, 10.00001, 10.00001);

    b = QPainterPath();

    b.addRect(0, 0, 10.00000000001, 10.00000000001);

    b = QPainterPath();

    b.moveTo(10, 0);

    b.lineTo(0, 0);

    b.lineTo(0, 10);

    b.lineTo(10, 10);

    b.lineTo(10, 0);

    b = QPainterPath();

    b.moveTo(10, 0);

    b.lineTo(0, 10);

    b.lineTo(0, 0);

    b.lineTo(10, 10);

}

void tst_QPathClipper::clip()

{

    if (sizeof(double) != sizeof(qreal)) {

        QSKIP("This test only works for qreal=double, otherwise ends in rounding errors", SkipAll);

    }

    QFETCH( QPainterPath, subject );

    QFETCH( QPainterPath, clip );

    QFETCH( QPathClipper::Operation, op );

    QFETCH( QPainterPath,  result);

    QPathClipper clipper(subject, clip);

    QPainterPath x = clipper.clip(op);

}

static inline QPointF randomPointInRect(const QRectF &rect)

{

    qreal rx = qrand() / (RAND_MAX + 1.);

    qreal ry = qrand() / (RAND_MAX + 1.);

    return QPointF(rect.left() + rx * rect.width(),

                   rect.top() + ry * rect.height());

}

void tst_QPathClipper::clipTest(int subjectIndex, int clipIndex, QPathClipper::Operation op)

{

    const QPainterPath &subject = paths[subjectIndex];

    const QPainterPath &clip = paths[clipIndex];

    const int count = 40;

    QRectF bounds = subject.boundingRect().united(clip.boundingRect());

    const qreal adjustX = bounds.width() * 0.01;

    const qreal adjustY = bounds.height() * 0.01;

    // make sure we test some points that are outside both paths as well

    bounds = bounds.adjusted(-adjustX, -adjustY, adjustX, adjustY);

    const int dim = 256;

    const qreal scale = qMin(dim / bounds.width(), dim / bounds.height());

    QPathClipper clipper(subject, clip);

    QPainterPath result = clipper.clip(op);

    // using the image here is a bit of a hacky way to make sure we don't test points that

    // are too close to the path edges to avoid test fails that are due to numerical errors

    QImage img(dim, dim, QImage::Format_ARGB32_Premultiplied);

    img.fill(0x0);

    QPainter p(&img);

    p.setRenderHint(QPainter::Antialiasing);

    p.scale(scale, scale);

    p.translate(-bounds.topLeft());

    p.setPen(Qt::black);

    p.drawPath(subject);

    p.setPen(Qt::red);

    p.drawPath(clip);

    p.end();

    for (int i = 0; i < count; ++i) {

        QPointF point;

        QRgb pixel;

        do {

            point = randomPointInRect(bounds);

            const QPointF imagePoint = (point - bounds.topLeft()) * scale;

            pixel = img.pixel(int(imagePoint.x()), int(imagePoint.y()));

        } while (qAlpha(pixel) > 0);

        const bool inSubject = subject.contains(point);

        const bool inClip = clip.contains(point);

        const bool inResult = result.contains(point);

        bool expected = false;

        switch (op) {

        case QPathClipper::BoolAnd:

            expected = inSubject && inClip;

            break;

        case QPathClipper::BoolOr:

            expected = inSubject || inClip;

            break;

        case QPathClipper::BoolSub:

            expected = inSubject && !inClip;

            break;

        default:

            break;

        }

        if (expected != inResult) {

            char str[256];

            const char *opStr =

                 op == QPathClipper::BoolAnd ? "and" :

                 op == QPathClipper::BoolOr ? "or" : "sub";

            sprintf(str, "Expected: %d, actual: %d, subject: %d, clip: %d, op: %s\n",

                     int(expected), int(inResult), subjectIndex, clipIndex, opStr);

            // debugging

#if 0

            QRect rect = bounds.toAlignedRect();

            QPainter p(&img);

            p.scale(scale, scale);

            p.translate(-bounds.topLeft());

            p.setPen(Qt::NoPen);

            p.setBrush(QColor(0x700ff00));