Home | History | Annotate | Download | only in tests 
      1 /*
      2  * Copyright 2013 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 "PathOpsTestCommon.h"
      8 #include "SkIntersections.h"
      9 #include "SkOpContour.h"
     10 #include "SkOpSegment.h"
     11 #include "SkRandom.h"
     12 #include "SkTSort.h"
     13 #include "Test.h"
     14 
     15 static bool gDisableAngleTests = true;
     16 
     17 static float next(float f)
     18 {
     19     int fBits = SkFloatAs2sCompliment(f);
     20     ++fBits;
     21     float fNext = Sk2sComplimentAsFloat(fBits);
     22     return fNext;
     23 }
     24 
     25 static float prev(float f)
     26 {
     27     int fBits = SkFloatAs2sCompliment(f);
     28     --fBits;
     29     float fNext = Sk2sComplimentAsFloat(fBits);
     30     return fNext;
     31 }
     32 
     33 DEF_TEST(PathOpsAngleFindCrossEpsilon, reporter) {
     34     if (gDisableAngleTests) {
     35         return;
     36     }
     37     SkRandom ran;
     38     int maxEpsilon = 0;
     39     for (int index = 0; index < 10000000; ++index) {
     40         SkDLine line = {{{0, 0}, {ran.nextRangeF(0.0001f, 1000), ran.nextRangeF(0.0001f, 1000)}}};
     41         for (int inner = 0; inner < 10; ++inner) {
     42             float t = ran.nextRangeF(0.0001f, 1);
     43             SkDPoint dPt = line.ptAtT(t);
     44             SkPoint pt = dPt.asSkPoint();
     45             float xs[3] = { prev(pt.fX), pt.fX, next(pt.fX) };
     46             float ys[3] = { prev(pt.fY), pt.fY, next(pt.fY) };
     47             for (int xIdx = 0; xIdx < 3; ++xIdx) {
     48                 for (int yIdx = 0; yIdx < 3; ++yIdx) {
     49                     SkPoint test = { xs[xIdx], ys[yIdx] };
     50                     float p1 = SkDoubleToScalar(line[1].fX * test.fY);
     51                     float p2 = SkDoubleToScalar(line[1].fY * test.fX);
     52                     int p1Bits = SkFloatAs2sCompliment(p1);
     53                     int p2Bits = SkFloatAs2sCompliment(p2);
     54                     int epsilon = SkTAbs(p1Bits - p2Bits);
     55                     if (maxEpsilon < epsilon) {
     56                         SkDebugf("line={{0, 0}, {%1.7g, %1.7g}} t=%1.7g pt={%1.7g, %1.7g}"
     57                             " epsilon=%d\n",
     58                             line[1].fX, line[1].fY, t, test.fX, test.fY, epsilon);
     59                         maxEpsilon = epsilon;
     60                     }
     61                 }
     62             }
     63         }
     64     }
     65 }
     66 
     67 DEF_TEST(PathOpsAngleFindQuadEpsilon, reporter) {
     68     if (gDisableAngleTests) {
     69         return;
     70     }
     71     SkRandom ran;
     72     int maxEpsilon = 0;
     73     double maxAngle = 0;
     74     for (int index = 0; index < 100000; ++index) {
     75         SkDLine line = {{{0, 0}, {ran.nextRangeF(0.0001f, 1000), ran.nextRangeF(0.0001f, 1000)}}};
     76         float t = ran.nextRangeF(0.0001f, 1);
     77         SkDPoint dPt = line.ptAtT(t);
     78         float t2 = ran.nextRangeF(0.0001f, 1);
     79         SkDPoint qPt = line.ptAtT(t2);
     80         float t3 = ran.nextRangeF(0.0001f, 1);
     81         SkDPoint qPt2 = line.ptAtT(t3);
     82         qPt.fX += qPt2.fY;
     83         qPt.fY -= qPt2.fX;
     84         QuadPts q = {{line[0], dPt, qPt}};
     85         SkDQuad quad;
     86         quad.debugSet(q.fPts);
     87         // binary search for maximum movement of quad[1] towards test that still has 1 intersection
     88         double moveT = 0.5f;
     89         double deltaT = moveT / 2;
     90         SkDPoint last;
     91         do {
     92             last = quad[1];
     93             quad[1].fX = dPt.fX - line[1].fY * moveT;
     94             quad[1].fY = dPt.fY + line[1].fX * moveT;
     95             SkIntersections i;
     96             i.intersect(quad, line);
     97             REPORTER_ASSERT(reporter, i.used() > 0);
     98             if (i.used() == 1) {
     99                 moveT += deltaT;
    100             } else {
    101                 moveT -= deltaT;
    102             }
    103             deltaT /= 2;
    104         } while (last.asSkPoint() != quad[1].asSkPoint());
    105         float p1 = SkDoubleToScalar(line[1].fX * last.fY);
    106         float p2 = SkDoubleToScalar(line[1].fY * last.fX);
    107         int p1Bits = SkFloatAs2sCompliment(p1);
    108         int p2Bits = SkFloatAs2sCompliment(p2);
    109         int epsilon = SkTAbs(p1Bits - p2Bits);
    110         if (maxEpsilon < epsilon) {
    111             SkDebugf("line={{0, 0}, {%1.7g, %1.7g}} t=%1.7g/%1.7g/%1.7g moveT=%1.7g"
    112                     " pt={%1.7g, %1.7g} epsilon=%d\n",
    113                     line[1].fX, line[1].fY, t, t2, t3, moveT, last.fX, last.fY, epsilon);
    114             maxEpsilon = epsilon;
    115         }
    116         double a1 = atan2(line[1].fY, line[1].fX);
    117         double a2 = atan2(last.fY, last.fX);
    118         double angle = fabs(a1 - a2);
    119         if (maxAngle < angle) {
    120             SkDebugf("line={{0, 0}, {%1.7g, %1.7g}} t=%1.7g/%1.7g/%1.7g moveT=%1.7g"
    121                     " pt={%1.7g, %1.7g} angle=%1.7g\n",
    122                     line[1].fX, line[1].fY, t, t2, t3, moveT, last.fX, last.fY, angle);
    123             maxAngle = angle;
    124         }
    125     }
    126 }
    127 
    128 static int find_slop(double x, double y, double rx, double ry) {
    129     int slopBits = 0;
    130     bool less1, less2;
    131     double absX = fabs(x);
    132     double absY = fabs(y);
    133     double length = absX < absY ? absX / 2 + absY : absX + absY / 2;
    134     int exponent;
    135     (void) frexp(length, &exponent);
    136     double epsilon = ldexp(FLT_EPSILON, exponent);
    137     do {
    138         // get the length as the larger plus half the smaller (both same signs)
    139         // find the ulps of the length
    140         // compute the offsets from there
    141         double xSlop = epsilon * slopBits;
    142         double ySlop = x * y < 0 ? -xSlop : xSlop; // OPTIMIZATION: use copysign / _copysign ?
    143         double x1 = x - xSlop;
    144         double y1 = y + ySlop;
    145         double x_ry1 = x1 * ry;
    146         double rx_y1 = rx * y1;
    147         less1 = x_ry1 < rx_y1;
    148         double x2 = x + xSlop;
    149         double y2 = y - ySlop;
    150         double x_ry2 = x2 * ry;
    151         double rx_y2 = rx * y2;
    152         less2 = x_ry2 < rx_y2;
    153     } while (less1 == less2 && ++slopBits);
    154     return slopBits;
    155 }
    156 
    157 // from http://stackoverflow.com/questions/1427422/cheap-algorithm-to-find-measure-of-angle-between-vectors
    158 static double diamond_angle(double y, double x)
    159 {
    160     if (y >= 0)
    161         return (x >= 0 ? y/(x+y) : 1-x/(-x+y));
    162     else
    163         return (x < 0 ? 2-y/(-x-y) : 3+x/(x-y));
    164 }
    165 
    166 static const double slopTests[][4] = {
    167    // x                      y                       rx                      ry
    168     {-0.058554756452593892, -0.18804585843827226, -0.018568569646021160, -0.059615294434479438},
    169     {-0.0013717412948608398, 0.0041152238845825195, -0.00045837944195925573, 0.0013753175735478074},
    170     {-2.1033774145221198, -1.4046019261273715e-008, -0.70062688352066704, -1.2706324683777995e-008},
    171 };
    172 
    173 DEF_TEST(PathOpsAngleFindSlop, reporter) {
    174     if (gDisableAngleTests) {
    175         return;
    176     }
    177     for (int index = 0; index < (int) SK_ARRAY_COUNT(slopTests); ++index) {
    178         const double* slopTest = slopTests[index];
    179         double x = slopTest[0];
    180         double y = slopTest[1];
    181         double rx = slopTest[2];
    182         double ry = slopTest[3];
    183         SkDebugf("%s  xy %d=%d\n", __FUNCTION__, index, find_slop(x, y, rx, ry));
    184         SkDebugf("%s rxy %d=%d\n", __FUNCTION__, index, find_slop(rx, ry, x, y));
    185         double angle = diamond_angle(y, x);
    186         double rAngle = diamond_angle(ry, rx);
    187         double diff = fabs(angle - rAngle);
    188         SkDebugf("%s diamond xy=%1.9g rxy=%1.9g diff=%1.9g factor=%d\n", __FUNCTION__,
    189                 angle, rAngle, diff, (int) (diff / FLT_EPSILON));
    190     }
    191 }
    192 
    193 class PathOpsAngleTester {
    194 public:
    195     static int After(SkOpAngle& lh, SkOpAngle& rh) {
    196         return lh.after(&rh);
    197     }
    198 
    199     static int AllOnOneSide(SkOpAngle& lh, SkOpAngle& rh) {
    200         return lh.allOnOneSide(&rh);
    201     }
    202 
    203     static int ConvexHullOverlaps(SkOpAngle& lh, SkOpAngle& rh) {
    204         return lh.convexHullOverlaps(&rh);
    205     }
    206 
    207     static int Orderable(SkOpAngle& lh, SkOpAngle& rh) {
    208         return lh.orderable(&rh);
    209     }
    210 
    211     static int EndsIntersect(SkOpAngle& lh, SkOpAngle& rh) {
    212         return lh.endsIntersect(&rh);
    213     }
    214 
    215     static void SetNext(SkOpAngle& lh, SkOpAngle& rh) {
    216         lh.fNext = &rh;
    217     }
    218 };
    219 
    220 class PathOpsSegmentTester {
    221 public:
    222     static void DebugReset(SkOpSegment* segment) {
    223         segment->debugReset();
    224     }
    225 };
    226 
    227 struct CircleData {
    228     const CubicPts fPts;
    229     const int fPtCount;
    230     SkPoint fShortPts[4];
    231 };
    232 
    233 static CircleData circleDataSet[] = {
    234     { {{{313.0155029296875, 207.90290832519531}, {320.05078125, 227.58743286132812}}}, 2, {} },
    235     { {{{313.0155029296875, 207.90290832519531}, {313.98246891063195, 219.33615203830394},
    236             {320.05078125, 227.58743286132812}}}, 3, {} },
    237 };
    238 
    239 static const int circleDataSetSize = (int) SK_ARRAY_COUNT(circleDataSet);
    240 
    241 DEF_TEST(PathOpsAngleCircle, reporter) {
    242     char storage[4096];
    243     SkArenaAlloc allocator(storage);
    244     SkOpContourHead contour;
    245     SkOpGlobalState state(&contour, &allocator  SkDEBUGPARAMS(false) SkDEBUGPARAMS(nullptr));
    246     contour.init(&state, false, false);
    247     for (int index = 0; index < circleDataSetSize; ++index) {
    248         CircleData& data = circleDataSet[index];
    249         for (int idx2 = 0; idx2 < data.fPtCount; ++idx2) {
    250             data.fShortPts[idx2] = data.fPts.fPts[idx2].asSkPoint();
    251         }
    252         switch (data.fPtCount) {
    253             case 2:
    254                 contour.addLine(data.fShortPts);
    255                 break;
    256             case 3:
    257                 contour.addQuad(data.fShortPts);
    258                 break;
    259             case 4:
    260                 contour.addCubic(data.fShortPts);
    261                 break;
    262         }
    263     }
    264     SkOpSegment* first = contour.first();
    265     first->debugAddAngle(0, 1);
    266     SkOpSegment* next = first->next();
    267     next->debugAddAngle(0, 1);
    268     PathOpsAngleTester::Orderable(*first->debugLastAngle(), *next->debugLastAngle());
    269 }
    270 
    271 struct IntersectData {
    272     const CubicPts fPts;
    273     const int fPtCount;
    274     double fTStart;
    275     double fTEnd;
    276     SkPoint fShortPts[4];
    277 };
    278 
    279 static IntersectData intersectDataSet1[] = {
    280     { {{{322.935669,231.030273}, {312.832214,220.393295}, {312.832214,203.454178}}}, 3,
    281             0.865309956, 0.154740299, {} },
    282     { {{{322.12738,233.397751}, {295.718353,159.505829}}}, 2,
    283             0.345028807, 0.0786326511, {} },
    284     { {{{322.935669,231.030273}, {312.832214,220.393295}, {312.832214,203.454178}}}, 3,
    285             0.865309956, 1, {} },
    286     { {{{322.12738,233.397751}, {295.718353,159.505829}}}, 2,
    287             0.345028807, 1, {} },
    288 };
    289 
    290 static IntersectData intersectDataSet2[] = {
    291     { {{{364.390686,157.898193}, {375.281769,136.674606}, {396.039917,136.674606}}}, 3,
    292             0.578520747, 1, {} },
    293     { {{{364.390686,157.898193}, {375.281769,136.674606}, {396.039917,136.674606}}}, 3,
    294             0.578520747, 0.536512973, {} },
    295     { {{{366.608826,151.196014}, {378.803101,136.674606}, {398.164948,136.674606}}}, 3,
    296             0.490456543, 1, {} },
    297 };
    298 
    299 static IntersectData intersectDataSet3[] = {
    300     { {{{2.000000,0.000000}, {1.33333333,0.66666667}}}, 2, 1, 0, {} },
    301     { {{{1.33333333,0.66666667}, {0.000000,2.000000}}}, 2, 0, 0.25, {} },
    302     { {{{2.000000,2.000000}, {1.33333333,0.66666667}}}, 2, 1, 0, {} },
    303 };
    304 
    305 static IntersectData intersectDataSet4[] = {
    306     { {{{1.3333333,0.6666667}, {0.000,2.000}}}, 2, 0.250000006, 0, {} },
    307     { {{{1.000,0.000}, {1.000,1.000}}}, 2, 1, 0, {} },
    308     { {{{1.000,1.000}, {0.000,0.000}}}, 2, 0, 1, {} },
    309 };
    310 
    311 static IntersectData intersectDataSet5[] = {
    312     { {{{0.000,0.000}, {1.000,0.000}, {1.000,1.000}}}, 3, 1, 0.666666667, {} },
    313     { {{{0.000,0.000}, {2.000,1.000}, {0.000,2.000}}}, 3, 0.5, 1, {} },
    314     { {{{0.000,0.000}, {2.000,1.000}, {0.000,2.000}}}, 3, 0.5, 0, {} },
    315 };
    316 
    317 static IntersectData intersectDataSet6[] = { // pathops_visualizer.htm:3658
    318     { {{{0.000,1.000}, {3.000,4.000}, {1.000,0.000}, {3.000,0.000}}}, 4, 0.0925339054, 0, {} }, // pathops_visualizer.htm:3616
    319     { {{{0.000,1.000}, {0.000,3.000}, {1.000,0.000}, {4.000,3.000}}}, 4, 0.453872386, 0, {} }, // pathops_visualizer.htm:3616
    320     { {{{0.000,1.000}, {3.000,4.000}, {1.000,0.000}, {3.000,0.000}}}, 4, 0.0925339054, 0.417096368, {} }, // pathops_visualizer.htm:3616
    321 };
    322 
    323 static IntersectData intersectDataSet7[] = { // pathops_visualizer.htm:3748
    324     { {{{2.000,1.000}, {0.000,1.000}}}, 2, 0.5, 0, {} }, // pathops_visualizer.htm:3706
    325     { {{{2.000,0.000}, {0.000,2.000}}}, 2, 0.5, 1, {} }, // pathops_visualizer.htm:3706
    326     { {{{0.000,1.000}, {0.000,2.000}, {2.000,0.000}, {2.000,1.000}}}, 4, 0.5, 1, {} }, // pathops_visualizer.htm:3706
    327 }; //
    328 
    329 static IntersectData intersectDataSet8[] = { // pathops_visualizer.htm:4194
    330     { {{{0.000,1.000}, {2.000,3.000}, {5.000,1.000}, {4.000,3.000}}}, 4, 0.311007457, 0.285714286, {} }, // pathops_visualizer.htm:4152
    331     { {{{1.000,5.000}, {3.000,4.000}, {1.000,0.000}, {3.000,2.000}}}, 4, 0.589885081, 0.999982974, {} }, // pathops_visualizer.htm:4152
    332     { {{{1.000,5.000}, {3.000,4.000}, {1.000,0.000}, {3.000,2.000}}}, 4, 0.589885081, 0.576935809, {} }, // pathops_visualizer.htm:4152
    333 }; //
    334 
    335 static IntersectData intersectDataSet9[] = { // pathops_visualizer.htm:4142
    336     { {{{0.000,1.000}, {2.000,3.000}, {5.000,1.000}, {4.000,3.000}}}, 4, 0.476627072, 0.311007457, {} }, // pathops_visualizer.htm:4100
    337     { {{{1.000,5.000}, {3.000,4.000}, {1.000,0.000}, {3.000,2.000}}}, 4, 0.999982974, 1, {} }, // pathops_visualizer.htm:4100
    338     { {{{0.000,1.000}, {2.000,3.000}, {5.000,1.000}, {4.000,3.000}}}, 4, 0.476627072, 1, {} }, // pathops_visualizer.htm:4100
    339 }; //
    340 
    341 static IntersectData intersectDataSet10[] = { // pathops_visualizer.htm:4186
    342     { {{{0.000,1.000}, {1.000,6.000}, {1.000,0.000}, {1.000,0.000}}}, 4, 0.788195121, 0.726275769, {} }, // pathops_visualizer.htm:4144
    343     { {{{0.000,1.000}, {0.000,1.000}, {1.000,0.000}, {6.000,1.000}}}, 4, 0.473378977, 1, {} }, // pathops_visualizer.htm:4144
    344     { {{{0.000,1.000}, {1.000,6.000}, {1.000,0.000}, {1.000,0.000}}}, 4, 0.788195121, 1, {} }, // pathops_visualizer.htm:4144
    345 }; //
    346 
    347 static IntersectData intersectDataSet11[] = { // pathops_visualizer.htm:4704
    348     { {{{979.305,561.000}, {1036.695,291.000}}}, 2, 0.888888874, 0.11111108, {} }, // pathops_visualizer.htm:4662
    349     { {{{1006.695,291.000}, {1023.264,291.000}, {1033.840,304.431}, {1030.318,321.000}}}, 4, 1, 0, {} }, // pathops_visualizer.htm:4662
    350     { {{{979.305,561.000}, {1036.695,291.000}}}, 2, 0.888888874, 1, {} }, // pathops_visualizer.htm:4662
    351 }; //
    352 
    353 static IntersectData intersectDataSet12[] = { // pathops_visualizer.htm:5481
    354     { {{{67.000,912.000}, {67.000,913.000}}}, 2, 1, 0, {} }, // pathops_visualizer.htm:5439
    355     { {{{67.000,913.000}, {67.000,917.389}, {67.224,921.726}, {67.662,926.000}}}, 4, 0, 1, {} }, // pathops_visualizer.htm:5439
    356     { {{{194.000,1041.000}, {123.860,1041.000}, {67.000,983.692}, {67.000,913.000}}}, 4, 1, 0, {} }, // pathops_visualizer.htm:5439
    357 }; //
    358 
    359 static IntersectData intersectDataSet13[] = { // pathops_visualizer.htm:5735
    360     { {{{6.000,0.000}, {0.000,4.000}}}, 2, 0.625, 0.25, {} }, // pathops_visualizer.htm:5693
    361     { {{{0.000,1.000}, {0.000,6.000}, {4.000,0.000}, {6.000,1.000}}}, 4, 0.5, 0.833333333, {} }, // pathops_visualizer.htm:5693
    362     { {{{0.000,1.000}, {0.000,6.000}, {4.000,0.000}, {6.000,1.000}}}, 4, 0.5, 0.379043969, {} }, // pathops_visualizer.htm:5693
    363 }; //
    364 
    365 static IntersectData intersectDataSet14[] = { // pathops_visualizer.htm:5875
    366     { {{{0.000,1.000}, {4.000,6.000}, {2.000,1.000}, {2.000,0.000}}}, 4, 0.0756502183, 0.0594570973, {} }, // pathops_visualizer.htm:5833
    367     { {{{1.000,2.000}, {0.000,2.000}, {1.000,0.000}, {6.000,4.000}}}, 4, 0.0756502184, 0, {} }, // pathops_visualizer.htm:5833
    368     { {{{0.000,1.000}, {4.000,6.000}, {2.000,1.000}, {2.000,0.000}}}, 4, 0.0756502183, 0.531917258, {} }, // pathops_visualizer.htm:5833
    369 }; //
    370 
    371 static IntersectData intersectDataSet15[] = { // pathops_visualizer.htm:6580
    372     { {{{490.435,879.407}, {405.593,909.436}}}, 2, 0.500554405, 1, {} }, // pathops_visualizer.htm:6538
    373     { {{{447.967,894.438}, {448.007,894.424}, {448.014,894.422}}}, 3, 0, 1, {} }, // pathops_visualizer.htm:6538
    374     { {{{490.435,879.407}, {405.593,909.436}}}, 2, 0.500554405, 0.500000273, {} }, // pathops_visualizer.htm:6538
    375 }; //
    376 
    377 static IntersectData intersectDataSet16[] = { // pathops_visualizer.htm:7419
    378     { {{{1.000,4.000}, {4.000,5.000}, {3.000,2.000}, {6.000,3.000}}}, 4, 0.5, 0, {} }, // pathops_visualizer.htm:7377
    379     { {{{2.000,3.000}, {3.000,6.000}, {4.000,1.000}, {5.000,4.000}}}, 4, 0.5, 0.112701665, {} }, // pathops_visualizer.htm:7377
    380     { {{{5.000,4.000}, {2.000,3.000}}}, 2, 0.5, 0, {} }, // pathops_visualizer.htm:7377
    381 }; //
    382 
    383 // from skpi_gino_com_16
    384 static IntersectData intersectDataSet17[] = {
    385     { /*seg=7*/ {{{270.974121f, 770.025879f}, {234.948273f, 734}, {184, 734}}}
    386         , 3, 0.74590454, 0.547660352, {} },
    387     { /*seg=8*/ {{{185, 734}, {252.93103f, 734}, {308, 789.06897f}, {308, 857}}}
    388         , 4, 0.12052623, 0, {} },
    389     { /*seg=7*/ {{{270.974121f, 770.025879f}, {234.948273f, 734}, {184, 734}}}
    390         , 3, 0.74590454, 1, {} },
    391 };
    392 
    393 static IntersectData intersectDataSet18[] = {
    394     { /*seg=7*/ {{{270.974121f, 770.025879f}, {234.948273f, 734}, {184, 734}}}
    395         , 3, 0.74590454, 1, {} },
    396     { /*seg=8*/ {{{185, 734}, {252.93103f, 734}, {308, 789.06897f}, {308, 857}}}
    397         , 4, 0.12052623, 0.217351928, {} },
    398     { /*seg=7*/ {{{270.974121f, 770.025879f}, {234.948273f, 734}, {184, 734}}}
    399         , 3, 0.74590454, 0.547660352, {} },
    400 };
    401 
    402 static IntersectData intersectDataSet19[] = {
    403     { /*seg=1*/ {{{0, 1}, {3, 5}, {2, 1}, {3, 1}}}
    404         , 4, 0.135148995, 0.134791946, {} },
    405     { /*seg=3*/ {{{1, 2}, {1, 2.15061641f}, {1, 2.21049166f}, {1.01366711f, 2.21379328f}}}
    406         , 4, 0.956740456, 0.894913214, {} },
    407     { /*seg=1*/ {{{0, 1}, {3, 5}, {2, 1}, {3, 1}}}
    408         , 4, 0.135148995, 0.551812363, {} },
    409 };
    410 
    411 #define I(x) intersectDataSet##x
    412 
    413 static IntersectData* intersectDataSets[] = {
    414     I(1), I(2), I(3), I(4), I(5), I(6), I(7), I(8), I(9), I(10),
    415     I(11), I(12), I(13), I(14), I(15), I(16), I(17), I(18), I(19),
    416 };
    417 
    418 #undef I
    419 #define I(x) (int) SK_ARRAY_COUNT(intersectDataSet##x)
    420 
    421 static const int intersectDataSetSizes[] = {
    422     I(1), I(2), I(3), I(4), I(5), I(6), I(7), I(8), I(9), I(10),
    423     I(11), I(12), I(13), I(14), I(15), I(16), I(17), I(18), I(19),
    424 };
    425 
    426 #undef I
    427 
    428 static const int intersectDataSetsSize = (int) SK_ARRAY_COUNT(intersectDataSetSizes);
    429 
    430 struct FourPoints {
    431     SkPoint pts[4];
    432 };
    433 
    434 DEF_TEST(PathOpsAngleAfter, reporter) {
    435     char storage[4096];
    436     SkArenaAlloc allocator(storage);
    437     SkOpContourHead contour;
    438     SkOpGlobalState state(&contour, &allocator  SkDEBUGPARAMS(false) SkDEBUGPARAMS(nullptr));
    439     contour.init(&state, false, false);
    440     for (int index = intersectDataSetsSize - 1; index >= 0; --index) {
    441         IntersectData* dataArray = intersectDataSets[index];
    442         const int dataSize = intersectDataSetSizes[index];
    443         for (int index2 = 0; index2 < dataSize - 2; ++index2) {
    444             allocator.reset();
    445             contour.reset();
    446             for (int index3 = 0; index3 < 3; ++index3) {
    447                 IntersectData& data = dataArray[index2 + index3];
    448                 SkPoint* temp = (SkPoint*) SkOpTAllocator<FourPoints>::Allocate(&allocator);
    449                 for (int idx2 = 0; idx2 < data.fPtCount; ++idx2) {
    450                     temp[idx2] = data.fPts.fPts[idx2].asSkPoint();
    451                 }
    452                 switch (data.fPtCount) {
    453                     case 2: {
    454                         contour.addLine(temp);
    455                         } break;
    456                     case 3: {
    457                         contour.addQuad(temp);
    458                         } break;
    459                     case 4: {
    460                         contour.addCubic(temp);
    461                         } break;
    462                 }
    463             }
    464             SkOpSegment* seg1 = contour.first();
    465             seg1->debugAddAngle(dataArray[index2 + 0].fTStart, dataArray[index2 + 0].fTEnd);
    466             SkOpSegment* seg2 = seg1->next();
    467             seg2->debugAddAngle(dataArray[index2 + 1].fTStart, dataArray[index2 + 1].fTEnd);
    468             SkOpSegment* seg3 = seg2->next();
    469             seg3->debugAddAngle(dataArray[index2 + 2].fTStart, dataArray[index2 + 2].fTEnd);
    470             SkOpAngle& angle1 = *seg1->debugLastAngle();
    471             SkOpAngle& angle2 = *seg2->debugLastAngle();
    472             SkOpAngle& angle3 = *seg3->debugLastAngle();
    473             PathOpsAngleTester::SetNext(angle1, angle3);
    474        // These data sets are seeded when the set itself fails, so likely the dataset does not
    475        // match the expected result. The tests above return 1 when first added, but
    476        // return 0 after the bug is fixed.
    477             SkDEBUGCODE(int result =) PathOpsAngleTester::After(angle2, angle1);
    478             SkASSERT(result == 0 || result == 1);
    479         }
    480     }
    481 }
    482 
    483 void SkOpSegment::debugAddAngle(double startT, double endT) {
    484     SkOpPtT* startPtT = startT == 0 ? fHead.ptT() : startT == 1 ? fTail.ptT()
    485             : this->addT(startT);
    486     SkOpPtT* endPtT = endT == 0 ? fHead.ptT() : endT == 1 ? fTail.ptT()
    487             : this->addT(endT);
    488     SkOpAngle* angle = SkOpTAllocator<SkOpAngle>::Allocate(this->globalState()->allocator());
    489     SkOpSpanBase* startSpan = &fHead;
    490     while (startSpan->ptT() != startPtT) {
    491         startSpan = startSpan->upCast()->next();
    492     }
    493     SkOpSpanBase* endSpan = &fHead;
    494     while (endSpan->ptT() != endPtT) {
    495         endSpan = endSpan->upCast()->next();
    496     }
    497     angle->set(startSpan, endSpan);
    498     if (startT < endT) {
    499         startSpan->upCast()->setToAngle(angle);
    500         endSpan->setFromAngle(angle);
    501     } else {
    502         endSpan->upCast()->setToAngle(angle);
    503         startSpan->setFromAngle(angle);
    504     }
    505 }
    506 
    507 DEF_TEST(PathOpsAngleAllOnOneSide, reporter) {
    508     char storage[4096];
    509     SkArenaAlloc allocator(storage);
    510     SkOpContourHead contour;
    511     SkOpGlobalState state(&contour, &allocator  SkDEBUGPARAMS(false) SkDEBUGPARAMS(nullptr));
    512     contour.init(&state, false, false);
    513     SkPoint conicPts[3] = {{494.37100219726562f, 224.66200256347656f},
    514         {494.37360910682298f, 224.6729026561527f},
    515         {494.37600708007813f, 224.68400573730469f}};
    516     SkPoint linePts[2] = {{494.371002f, 224.662003f}, {494.375000f, 224.675995f}};
    517     for (int i = 10; i >= 0; --i) {
    518         SkPoint modLinePts[2] = { linePts[0], linePts[1] };
    519         modLinePts[1].fX += i * .1f;
    520         contour.addLine(modLinePts);
    521         contour.addQuad(conicPts);
    522    //     contour.addConic(conicPts, 0.999935746f, &allocator);
    523         SkOpSegment* first = contour.first();
    524         first->debugAddAngle(0, 1);
    525         SkOpSegment* next = first->next();
    526         next->debugAddAngle(0, 1);
    527         /* int result = */
    528             PathOpsAngleTester::AllOnOneSide(*first->debugLastAngle(), *next->debugLastAngle());
    529   //      SkDebugf("i=%d result=%d\n", i , result);
    530   //      SkDebugf("");
    531     }
    532 }
    533