Home | History | Annotate | Download | only in tests 
      1 /*
      2  * Copyright 2012 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 #include "PathOpsCubicIntersectionTestData.h"
      8 #include "PathOpsQuadIntersectionTestData.h"
      9 #include "PathOpsTestCommon.h"
     10 #include "SkGeometry.h"
     11 #include "SkIntersections.h"
     12 #include "SkPathOpsRect.h"
     13 #include "SkReduceOrder.h"
     14 #include "Test.h"
     15 
     16 static void test(skiatest::Reporter* reporter, const SkDCubic* cubics, const char* name,
     17                  int firstTest, size_t testCount) {
     18     for (size_t index = firstTest; index < testCount; ++index) {
     19         const SkDCubic& cubic = cubics[index];
     20         SkASSERT(ValidCubic(cubic));
     21         double precision = cubic.calcPrecision();
     22         SkTArray<SkDQuad, true> quads;
     23         CubicToQuads(cubic, precision, quads);
     24         if (quads.count() != 1 && quads.count() != 2) {
     25             SkDebugf("%s [%d] cubic to quadratics failed count=%d\n", name, static_cast<int>(index),
     26                     quads.count());
     27         }
     28         REPORTER_ASSERT(reporter, quads.count() == 1);
     29     }
     30 }
     31 
     32 static void test(skiatest::Reporter* reporter, const SkDQuad* quadTests, const char* name,
     33                  int firstTest, size_t testCount) {
     34     for (size_t index = firstTest; index < testCount; ++index) {
     35         const SkDQuad& quad = quadTests[index];
     36         SkASSERT(ValidQuad(quad));
     37         SkDCubic cubic = quad.toCubic();
     38         double precision = cubic.calcPrecision();
     39         SkTArray<SkDQuad, true> quads;
     40         CubicToQuads(cubic, precision, quads);
     41         if (quads.count() != 1 && quads.count() != 2) {
     42             SkDebugf("%s [%d] cubic to quadratics failed count=%d\n", name, static_cast<int>(index),
     43                     quads.count());
     44         }
     45         REPORTER_ASSERT(reporter, quads.count() <= 2);
     46     }
     47 }
     48 
     49 static void testC(skiatest::Reporter* reporter, const SkDCubic* cubics, const char* name,
     50                   int firstTest, size_t testCount) {
     51     // test if computed line end points are valid
     52     for (size_t index = firstTest; index < testCount; ++index) {
     53         const SkDCubic& cubic = cubics[index];
     54         SkASSERT(ValidCubic(cubic));
     55         double precision = cubic.calcPrecision();
     56         SkTArray<SkDQuad, true> quads;
     57         CubicToQuads(cubic, precision, quads);
     58         if (!AlmostEqualUlps(cubic[0].fX, quads[0][0].fX)
     59                 || !AlmostEqualUlps(cubic[0].fY, quads[0][0].fY)) {
     60             SkDebugf("[%d] unmatched start\n", static_cast<int>(index));
     61             REPORTER_ASSERT(reporter, 0);
     62         }
     63         int last = quads.count() - 1;
     64         if (!AlmostEqualUlps(cubic[3].fX, quads[last][2].fX)
     65                 || !AlmostEqualUlps(cubic[3].fY, quads[last][2].fY)) {
     66             SkDebugf("[%d] unmatched end\n", static_cast<int>(index));
     67             REPORTER_ASSERT(reporter, 0);
     68         }
     69     }
     70 }
     71 
     72 static void testC(skiatest::Reporter* reporter, const SkDCubic(* cubics)[2], const char* name,
     73                   int firstTest, size_t testCount) {
     74     for (size_t index = firstTest; index < testCount; ++index) {
     75         for (int idx2 = 0; idx2 < 2; ++idx2) {
     76             const SkDCubic& cubic = cubics[index][idx2];
     77             SkASSERT(ValidCubic(cubic));
     78             double precision = cubic.calcPrecision();
     79             SkTArray<SkDQuad, true> quads;
     80             CubicToQuads(cubic, precision, quads);
     81             if (!AlmostEqualUlps(cubic[0].fX, quads[0][0].fX)
     82                     || !AlmostEqualUlps(cubic[0].fY, quads[0][0].fY)) {
     83                 SkDebugf("[%d][%d] unmatched start\n", static_cast<int>(index), idx2);
     84                 REPORTER_ASSERT(reporter, 0);
     85             }
     86             int last = quads.count() - 1;
     87             if (!AlmostEqualUlps(cubic[3].fX, quads[last][2].fX)
     88                     || !AlmostEqualUlps(cubic[3].fY, quads[last][2].fY)) {
     89                 SkDebugf("[%d][%d] unmatched end\n", static_cast<int>(index), idx2);
     90                 REPORTER_ASSERT(reporter, 0);
     91             }
     92         }
     93     }
     94 }
     95 
     96 static void CubicToQuads_Test(skiatest::Reporter* reporter) {
     97     enum {
     98         RunAll,
     99         RunPointDegenerates,
    100         RunNotPointDegenerates,
    101         RunLines,
    102         RunNotLines,
    103         RunModEpsilonLines,
    104         RunLessEpsilonLines,
    105         RunNegEpsilonLines,
    106         RunQuadraticLines,
    107         RunQuadraticModLines,
    108         RunComputedLines,
    109         RunComputedTests,
    110         RunNone
    111     } run = RunAll;
    112     int firstTestIndex = 0;
    113 #if 0
    114     run = RunComputedLines;
    115     firstTestIndex = 18;
    116 #endif
    117     int firstPointDegeneratesTest = run == RunAll ? 0 : run == RunPointDegenerates
    118             ? firstTestIndex : SK_MaxS32;
    119     int firstNotPointDegeneratesTest = run == RunAll ? 0 : run == RunNotPointDegenerates
    120             ? firstTestIndex : SK_MaxS32;
    121     int firstLinesTest = run == RunAll ? 0 : run == RunLines ? firstTestIndex : SK_MaxS32;
    122     int firstNotLinesTest = run == RunAll ? 0 : run == RunNotLines ? firstTestIndex : SK_MaxS32;
    123     int firstModEpsilonTest = run == RunAll ? 0 : run == RunModEpsilonLines
    124             ? firstTestIndex : SK_MaxS32;
    125     int firstLessEpsilonTest = run == RunAll ? 0 : run == RunLessEpsilonLines
    126             ? firstTestIndex : SK_MaxS32;
    127     int firstNegEpsilonTest = run == RunAll ? 0 : run == RunNegEpsilonLines
    128             ? firstTestIndex : SK_MaxS32;
    129     int firstQuadraticLineTest = run == RunAll ? 0 : run == RunQuadraticLines
    130             ? firstTestIndex : SK_MaxS32;
    131     int firstQuadraticModLineTest = run == RunAll ? 0 : run == RunQuadraticModLines
    132             ? firstTestIndex : SK_MaxS32;
    133     int firstComputedLinesTest = run == RunAll ? 0 : run == RunComputedLines
    134             ? firstTestIndex : SK_MaxS32;
    135     int firstComputedCubicsTest = run == RunAll ? 0 : run == RunComputedTests
    136             ? firstTestIndex : SK_MaxS32;
    137 
    138     test(reporter, pointDegenerates, "pointDegenerates", firstPointDegeneratesTest,
    139             pointDegenerates_count);
    140     testC(reporter, notPointDegenerates, "notPointDegenerates", firstNotPointDegeneratesTest,
    141             notPointDegenerates_count);
    142     test(reporter, lines, "lines", firstLinesTest, lines_count);
    143     testC(reporter, notLines, "notLines", firstNotLinesTest, notLines_count);
    144     testC(reporter, modEpsilonLines, "modEpsilonLines", firstModEpsilonTest, modEpsilonLines_count);
    145     test(reporter, lessEpsilonLines, "lessEpsilonLines", firstLessEpsilonTest,
    146             lessEpsilonLines_count);
    147     test(reporter, negEpsilonLines, "negEpsilonLines", firstNegEpsilonTest, negEpsilonLines_count);
    148     test(reporter, quadraticLines, "quadraticLines", firstQuadraticLineTest, quadraticLines_count);
    149     test(reporter, quadraticModEpsilonLines, "quadraticModEpsilonLines", firstQuadraticModLineTest,
    150             quadraticModEpsilonLines_count);
    151     testC(reporter, lines, "computed lines", firstComputedLinesTest, lines_count);
    152     testC(reporter, tests, "computed tests", firstComputedCubicsTest, tests_count);
    153 }
    154 
    155 static SkDCubic locals[] = {
    156     {{{0, 1}, {1.9274705288631189e-19, 1.0000000000000002},
    157             {0.0017190297609673323, 0.99828097023903239},
    158             {0.0053709083094631276, 0.99505672974365911}}},
    159     {{{14.5975863, 41.632436}, {16.3518929, 26.2639684}, {18.5165519, 7.68775139},
    160             {8.03767257, 89.1628526}}},
    161     {{{69.7292014, 38.6877352}, {24.7648688, 23.1501713}, {84.9283191, 90.2588441},
    162             {80.392774, 61.3533852}}},
    163     {{{60.776536520932126, 71.249307306133829}, {87.107894191103014, 22.377669868235323},
    164             {1.4974754310666936, 68.069569937917208}, {45.261946574441133, 17.536076632112298}}},
    165 };
    166 
    167 static size_t localsCount = SK_ARRAY_COUNT(locals);
    168 
    169 #define DEBUG_CRASH 0
    170 #define TEST_AVERAGE_END_POINTS 0  // must take const off to test
    171 extern const bool AVERAGE_END_POINTS;
    172 
    173 static void oneOff(skiatest::Reporter* reporter, size_t x) {
    174     const SkDCubic& cubic = locals[x];
    175     SkASSERT(ValidCubic(cubic));
    176     const SkPoint skcubic[4] = {
    177             {static_cast<float>(cubic[0].fX), static_cast<float>(cubic[0].fY)},
    178             {static_cast<float>(cubic[1].fX), static_cast<float>(cubic[1].fY)},
    179             {static_cast<float>(cubic[2].fX), static_cast<float>(cubic[2].fY)},
    180             {static_cast<float>(cubic[3].fX), static_cast<float>(cubic[3].fY)}};
    181     SkScalar skinflect[2];
    182     int skin = SkFindCubicInflections(skcubic, skinflect);
    183     if (false) SkDebugf("%s %d %1.9g\n", __FUNCTION__, skin, skinflect[0]);
    184     SkTArray<SkDQuad, true> quads;
    185     double precision = cubic.calcPrecision();
    186     CubicToQuads(cubic, precision, quads);
    187     if (false) SkDebugf("%s quads=%d\n", __FUNCTION__, quads.count());
    188 }
    189 
    190 static void CubicsToQuadratics_OneOffTests(skiatest::Reporter* reporter) {
    191     for (size_t x = 0; x < localsCount; ++x) {
    192         oneOff(reporter, x);
    193     }
    194 }
    195 
    196 static void CubicsToQuadratics_OneOffTest(skiatest::Reporter* reporter) {
    197     oneOff(reporter, 0);
    198 }
    199 
    200 static void PathOpsCubicToQuadsTest(skiatest::Reporter* reporter) {
    201     CubicToQuads_Test(reporter);
    202     CubicsToQuadratics_OneOffTest(reporter);
    203     CubicsToQuadratics_OneOffTests(reporter);
    204 }
    205 
    206 #include "TestClassDef.h"
    207 DEFINE_TESTCLASS_SHORT(PathOpsCubicToQuadsTest)
    208