cumulative pathops patch

tests/PathOpsAngleIdeas.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 "PathOpsTestCommon.h"
 #include "SkIntersections.h"
+#include "SkOpContour.h"
 #include "SkOpSegment.h"
-#include "SkPathOpsTriangle.h"
 #include "SkRandom.h"
 #include "SkTArray.h"
 #include "SkTSort.h"
 #include "Test.h"
 
 static bool gPathOpsAngleIdeasVerbose = false;
 static bool gPathOpsAngleIdeasEnableBruteCheck = false;
 
 class PathOpsAngleTester {
 public:
-    static int ConvexHullOverlaps(const SkOpAngle& lh, const SkOpAngle& rh) {
-        return lh.convexHullOverlaps(rh);
+    static int ConvexHullOverlaps(SkOpAngle& lh, SkOpAngle& rh) {
+        return lh.convexHullOverlaps(&rh);
     }
 
-    static int EndsIntersect(const SkOpAngle& lh, const SkOpAngle& rh) {
-        return lh.endsIntersect(rh);
+    static int EndsIntersect(SkOpAngle& lh, SkOpAngle& rh) {
+        return lh.endsIntersect(&rh);
     }
 };
 
 struct TRange {
     double tMin1;
     double tMin2;
     double t1;
     double t2;
     double tMin;
     double a1;
@@ skipping 362 matching lines @@
 }
 
 static bool bruteForceCheck(skiatest::Reporter* reporter, const SkDQuad& quad1,
         const SkDQuad& quad2, bool ccw) {
     TRange lowerRange, upperRange;
     bool result = bruteMinT(reporter, quad1, quad2, &lowerRange, &upperRange);
     REPORTER_ASSERT(reporter, result);
     return ccw == upperRange.ccw;
 }
 
-class PathOpsSegmentTester {
-public:
-    static void ConstructQuad(SkOpSegment* segment, SkPoint shortQuad[3]) {
-        segment->debugConstructQuad(shortQuad);
-    }
-};
-
-static void makeSegment(const SkDQuad& quad, SkPoint shortQuad[3], SkOpSegment* result) {
+static void makeSegment(SkOpContour* contour, const SkDQuad& quad, SkPoint shortQuad[3],
+        SkChunkAlloc* allocator) {
     shortQuad[0] = quad[0].asSkPoint();
     shortQuad[1] = quad[1].asSkPoint();
     shortQuad[2] = quad[2].asSkPoint();
-    PathOpsSegmentTester::ConstructQuad(result, shortQuad);
+    contour->addQuad(shortQuad, allocator);
 }
 
 static void testQuadAngles(skiatest::Reporter* reporter, const SkDQuad& quad1, const SkDQuad& quad2,
-        int testNo) {
+        int testNo, SkChunkAlloc* allocator) {
     SkPoint shortQuads[2][3];
-    SkOpSegment seg[2];
-    makeSegment(quad1, shortQuads[0], &seg[0]);
-    makeSegment(quad2, shortQuads[1], &seg[1]);
-    int realOverlap = PathOpsAngleTester::ConvexHullOverlaps(*seg[0].debugLastAngle(),
-            *seg[1].debugLastAngle());
+
+    SkOpContour contour;
+    SkOpGlobalState state(NULL  PATH_OPS_DEBUG_PARAMS(&contour));
+    contour.init(&state, false, false);
+    makeSegment(&contour, quad1, shortQuads[0], allocator);
+    makeSegment(&contour, quad1, shortQuads[1], allocator);
+    SkOpSegment* seg1 = contour.first();
+    seg1->debugAddAngle(0, 1, allocator);
+    SkOpSegment* seg2 = seg1->next();
+    seg2->debugAddAngle(0, 1, allocator);
+    int realOverlap = PathOpsAngleTester::ConvexHullOverlaps(*seg1->debugLastAngle(),
+            *seg2->debugLastAngle());
     const SkDPoint& origin = quad1[0];
     REPORTER_ASSERT(reporter, origin == quad2[0]);
     double a1s = atan2(origin.fY - quad1[1].fY, quad1[1].fX - origin.fX);
     double a1e = atan2(origin.fY - quad1[2].fY, quad1[2].fX - origin.fX);
     double a2s = atan2(origin.fY - quad2[1].fY, quad2[1].fX - origin.fX);
     double a2e = atan2(origin.fY - quad2[2].fY, quad2[2].fX - origin.fX);
     bool oldSchoolOverlap = radianBetween(a1s, a2s, a1e)
         || radianBetween(a1s, a2e, a1e) || radianBetween(a2s, a1s, a2e)
         || radianBetween(a2s, a1e, a2e);
     int overlap = quadHullsOverlap(reporter, quad1, quad2);
@@ skipping 97 matching lines @@
         SkASSERT(SkScalarSignAsInt(SkDoubleToScalar(midXray))
             == SkScalarSignAsInt(SkDoubleToScalar(vDir[sIndex])));
         firstInside = (rayDist > endDist) ^ (sIndex == 0) ^ (vDir[sIndex] < 0);
     } else if (overlap >= 0) {
         return;  // answer has already been determined
     } else {
         firstInside = checkParallel(reporter, quad1, quad2);
     }
     if (overlap < 0) {
         SkDEBUGCODE(int realEnds =)
-                PathOpsAngleTester::EndsIntersect(*seg[0].debugLastAngle(),
-                *seg[1].debugLastAngle());
+                PathOpsAngleTester::EndsIntersect(*seg1->debugLastAngle(),
+                *seg2->debugLastAngle());
         SkASSERT(realEnds == (firstInside ? 1 : 0));
     }
     bruteForce(reporter, quad1, quad2, firstInside);
 }
 
 DEF_TEST(PathOpsAngleOverlapHullsOne, reporter) {
+    SkChunkAlloc allocator(4096);
 //    gPathOpsAngleIdeasVerbose = true;
     const SkDQuad quads[] = {
 {{{939.4808349609375, 914.355224609375}, {-357.7921142578125, 590.842529296875}, {736.8936767578125, -350.717529296875}}},
 {{{939.4808349609375, 914.355224609375}, {-182.85418701171875, 634.4552001953125}, {-509.62615966796875, 576.1182861328125}}}
     };
     for (int index = 0; index < (int) SK_ARRAY_COUNT(quads); index += 2) {
-        testQuadAngles(reporter, quads[index], quads[index + 1], 0);
+        testQuadAngles(reporter, quads[index], quads[index + 1], 0, &allocator);
     }
 }
 
 DEF_TEST(PathOpsAngleOverlapHulls, reporter) {
+    SkChunkAlloc allocator(4096);
     if (!gPathOpsAngleIdeasVerbose) {  // takes a while to run -- so exclude it by default
         return;
     }
     SkRandom ran;
     for (int index = 0; index < 100000; ++index) {
         if (index % 1000 == 999) SkDebugf(".");
         SkDPoint origin = {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)};
         SkDQuad quad1 = {{origin, {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)},
             {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)}}};
         if (quad1[0] == quad1[2]) {
             continue;
         }
         SkDQuad quad2 = {{origin, {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)},
             {ran.nextRangeF(-1000, 1000), ran.nextRangeF(-1000, 1000)}}};
         if (quad2[0] == quad2[2]) {
             continue;
         }
         SkIntersections i;
         i.intersect(quad1, quad2);
         REPORTER_ASSERT(reporter, i.used() >= 1);
         if (i.used() > 1) {
             continue;
         }
-        testQuadAngles(reporter, quad1, quad2, index);
+        testQuadAngles(reporter, quad1, quad2, index, &allocator);
     }
 }
 
 DEF_TEST(PathOpsAngleBruteT, reporter) {
     if (!gPathOpsAngleIdeasVerbose) {  // takes a while to run -- so exclude it by default
         return;
     }
     SkRandom ran;
     double smaller = SK_Scalar1;
     SkDQuad small[2];
@@ skipping 250 matching lines @@
             step /= 2;
         }
 #ifdef SK_DEBUG
 //        DumpQ(q1, q2, 999);
 #endif
     }
     if (gPathOpsAngleIdeasVerbose) {
         SkDebugf("maxR=%1.9g\n", maxR);
     }
 }