tests/PathOpsAngleTest.cpp

/*
 * Copyright 2013 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
#include "SkOpSegment.h"
#include "Test.h"

static const SkPoint cubics[][4] = {
/* 0 */    {{0, 1}, {2, 6}, {4, 2}, {5, 3}},
/* 1 */    {{10, 234}, {10, 229.581726f}, {13.5817204f, 226}, {18, 226}},
/* 2 */    {{132, 11419}, {130.89543151855469f, 11419}, {130, 11418.1044921875f}, {130, 11417}},
/* 3 */    {{130.04275512695312f, 11417.4130859375f}, {130.23307800292969f, 11418.3193359375f},
                    {131.03709411621094f, 11419}, {132, 11419}},
/* 4 */    {{0,1}, {0,5}, {4,1}, {6,4}},
/* 5 */    {{1,5}, {4,6}, {1,0}, {4,0}},
/* 6 */    {{0,1}, {0,4}, {5,1}, {6,4}},
/* 7 */    {{0,1}, {1,2}, {1,0}, {6,1}},
/* 8 */    {{0,3}, {0,1}, {2,0}, {1,0}},
/* 9 */    {{189,7}, {189,5.3431458473205566f}, {190.3431396484375f,4}, {192,4}},
/* 10 */   {{0,1}, {1,3}, {1,0}, {6,4}},
/* 11 */   {{0,1}, {2,3}, {2,1}, {4,3}},
/* 12 */   {{1,2}, {3,4}, {1,0}, {3,2}},
};

static const SkPoint quads[][3] = {
/* 0 */    {{12.3423996f, 228.342407f}, {10, 230.686295f}, {10, 234}},
/* 1 */    {{304.24319458007812f,591.75677490234375f}, {306,593.51470947265625f}, {306,596}},
};

static const SkPoint lines[][2] = {
/* 0 */    {{6, 2}, {2, 4}},
/* 1 */    {{306,617}, {306,590}},
/* 2 */    {{306,596}, {306,617}},
/* 3 */    {{6,4}, {0,1}},
/* 4 */    {{6,1}, {0,1}},
/* 5 */    {{1,0}, {0,3}},
/* 6 */    {{246,4}, {189,4}},
/* 7 */    {{192,4}, {243,4}},
/* 8 */    {{4,3}, {0,1}},
/* 9 */    {{3,2}, {1,2}},
};

struct SortSet {
    const SkPoint* ptData;
    int ptCount;
    double tStart;
    double tEnd;
};

static const SortSet set1[] = {
    {cubics[0], 4, 0.66666987081928919, 0.875},
    {lines[0], 2, 0.574070336, 0.388888889},
    {cubics[0], 4, 0.66666987081928919, 0.4050371120499307 },
    {lines[0], 2, 0.574070336, 0.9140625},
};

static const SortSet set2[] = {
    {cubics[0], 4, 0.666666667, 0.875},
    {lines[0], 2, 0.574074074, 0.388888889},
    {cubics[0], 4, 0.666666667, 0.405037112},
    {lines[0], 2, 0.574074074, 0.9140625},
};

static const SortSet set3[] = {
    {cubics[1], 4, 0, 1},
    {quads[0], 3, 1, 0},
};

static const SortSet set4[] = {
    {cubics[2], 4, 0.812114222, 1},
    {cubics[3], 4, 0.0684734759, 0},
};

static const SortSet set5[] = {
    {lines[1], 2, 0.777777778, 1},
    {quads[1], 3, 1, 4.34137342e-06},
    {lines[2], 2, 0, 1},
};

static const SortSet set6[] = {
    {lines[3], 2, 0.407407407, 0.554627832},
    {cubics[4], 4, 0.666666667, 0.548022446},
    {lines[3], 2, 0.407407407, 0},
    {cubics[4], 4, 0.666666667, 1},
};

static const SortSet set7[] = {
    {cubics[5], 4, 0.545233342, 0.545454545},
    {cubics[6], 4, 0.484938134, 0.484805744},
    {cubics[5], 4, 0.545233342, 0},
    {cubics[6], 4, 0.484938134, 0.545454545},
};

static const SortSet set8[] = {
    {cubics[7], 4, 0.5, 0.522986744 },
    {lines[4], 2, 0.75, 1},
    {cubics[7], 4, 0.5, 0},
    {lines[4], 2, 0.75, 0.737654321},
};

static const SortSet set9[] = {
    {cubics[8], 4, 0.4, 1},
    {lines[5], 2, 0.36, 0},
    {cubics[8], 4, 0.4, 0.394675838},
    {lines[5], 2, 0.36, 0.363999782},
};

static const SortSet set10[] = {
    {lines[6], 2, 0.947368421, 1},
    {cubics[9], 4, 1, 0.500000357},
    {lines[7], 2, 0, 1},
};

static const SortSet set11[] = {
    {lines[3], 2, 0.75, 1},
    {cubics[10], 4, 0.5, 0.228744269},
    {lines[3], 2, 0.75, 0.627112191},
    {cubics[10], 4, 0.5, 0.6339746},
};

static const SortSet set12[] = {
    {cubics[12], 4, 0.5, 1},
    {lines[8], 2, 0.5, 1},
    {cubics[11], 4, 0.5, 0},
    {lines[9], 2, 0.5, 1},
    {cubics[12], 4, 0.5, 0},
    {lines[8], 2, 0.5, 0},
    {cubics[11], 4, 0.5, 1},
    {lines[9], 2, 0.5, 0},
};

struct SortSetTests {
    const SortSet* set;
    size_t count;
};

static const SortSetTests tests[] = {
    { set12, SK_ARRAY_COUNT(set12) },
    { set11, SK_ARRAY_COUNT(set11) },
    { set10, SK_ARRAY_COUNT(set10) },
    { set9, SK_ARRAY_COUNT(set9) },
    { set8, SK_ARRAY_COUNT(set8) },
    { set7, SK_ARRAY_COUNT(set7) },
    { set6, SK_ARRAY_COUNT(set6) },
    { set2, SK_ARRAY_COUNT(set2) },
    { set5, SK_ARRAY_COUNT(set5) },
    { set4, SK_ARRAY_COUNT(set4) },
    { set3, SK_ARRAY_COUNT(set3) },
    { set1, SK_ARRAY_COUNT(set1) },
};

static void setup(const SortSet* set, const size_t idx, SkPoint const ** data,
        SkOpSegment* seg, int* ts) {
    SkPoint start, end;
    *data = set[idx].ptData;
    switch(set[idx].ptCount) {
        case 2: {
            seg->addLine(*data, false, false);
            SkDLine dLine;
            dLine.set(set[idx].ptData);
            start = dLine.xyAtT(set[idx].tStart).asSkPoint();
            end = dLine.xyAtT(set[idx].tEnd).asSkPoint();
            } break;
        case 3: {
            seg->addQuad(*data, false, false);
            SkDQuad dQuad;
            dQuad.set(set[idx].ptData);
            start = dQuad.xyAtT(set[idx].tStart).asSkPoint();
            end = dQuad.xyAtT(set[idx].tEnd).asSkPoint();
            } break;
        case 4: {
            seg->addCubic(*data, false, false);
            SkDCubic dCubic;
            dCubic.set(set[idx].ptData);
            start = dCubic.xyAtT(set[idx].tStart).asSkPoint();
            end = dCubic.xyAtT(set[idx].tEnd).asSkPoint();
            } break;
    }
    double tStart = set[idx].tStart;
    double tEnd = set[idx].tEnd;
    seg->addT(NULL, start, tStart);
    seg->addT(NULL, end, tEnd);
    double tLeft = tStart < tEnd ? 0 : 1;
    if (tStart != tLeft && tEnd != tLeft) {
        seg->addT(NULL, set[idx].ptData[0], tLeft);
    }
    double tRight = tStart < tEnd ? 1 : 0;
    if (tStart != tRight && tEnd != tRight) {
        seg->addT(NULL, set[idx].ptData[set[idx].ptCount - 1], tRight);
    }
    int tIndex = 0;
    do {
        if (seg->t(tIndex) == set[idx].tStart) {
            ts[0] = tIndex;
        }
        if (seg->t(tIndex) == set[idx].tEnd) {
            ts[1] = tIndex;
        }
        if (seg->t(tIndex) >= 1) {
            break;
        }
    } while (++tIndex);
}

static void PathOpsAngleTest(skiatest::Reporter* reporter) {
    for (size_t index = 0; index < SK_ARRAY_COUNT(tests); ++index) {
        const SortSetTests& test = tests[index];
        for (size_t idxL = 0; idxL < test.count - 1; ++idxL) {
            SkOpSegment lesser, greater;
            int lesserTs[2], greaterTs[2];
            const SkPoint* lesserData, * greaterData;
            const SortSet* set = test.set;
            setup(set, idxL, &lesserData, &lesser, lesserTs);
            size_t idxG = idxL + 1;
            setup(set, idxG, &greaterData, &greater, greaterTs);
            SkOpAngle first, second;
            first.set(lesserData, SkPathOpsPointsToVerb(set[idxL].ptCount - 1), &lesser,
                    lesserTs[0], lesserTs[1], lesser.spans());
            second.set(greaterData, SkPathOpsPointsToVerb(set[idxG].ptCount - 1), &greater,
                    greaterTs[0], greaterTs[1], greater.spans());
            bool compare = first < second;
            if (!compare) {
                SkDebugf("%s test[%d]:  lesser[%d] > greater[%d]\n", __FUNCTION__,
                        index, idxL,  idxG);
                compare = first < second;
            }
            REPORTER_ASSERT(reporter, compare);
            reporter->bumpTestCount();
        }
    }
}

#include "TestClassDef.h"
DEFINE_TESTCLASS_SHORT(PathOpsAngleTest)