src/third_party/skia/tests/PathOpsAngleTest.cpp

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