path ops work in progress

tests/PathOpsCubicIntersectionTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "PathOpsCubicIntersectionTestData.h"
 #include "PathOpsTestCommon.h"
 #include "SkIntersections.h"
 #include "SkPathOpsRect.h"
@@ skipping 43 matching lines @@
             double tt1 = tIntersections[0][pt];
             SkDPoint xy1 = cubic1.ptAtT(tt1);
             double tt2 = tIntersections[1][pt];
             SkDPoint xy2 = cubic2.ptAtT(tt2);
             if (!xy1.approximatelyEqual(xy2)) {
                 SkDebugf("%s [%d,%d] x!= t1=%g (%g,%g) t2=%g (%g,%g)\n",
                     __FUNCTION__, (int)index, pt, tt1, xy1.fX, xy1.fY, tt2, xy2.fX, xy2.fY);
             }
             REPORTER_ASSERT(reporter, xy1.approximatelyEqual(xy2));
         }
+        reporter->bumpTestCount();
     }
 }
 
 static const SkDCubic testSet[] = {
 // FIXME: uncommenting these two will cause this to fail
 // this results in two curves very nearly but not exactly coincident
 #if 0
 {{{67.426548091427676, 37.993772624988935}, {23.483695892376684, 90.476863174921306},
       {35.597065061143162, 79.872482633158796}, {75.38634169631932, 18.244890038969412}}},
 {{{67.4265481, 37.9937726}, {23.4836959, 90.4768632}, {35.5970651, 79.8724826},
@@ skipping 82 matching lines @@
 
 {{{18.1312339, 31.6473732}, {95.5711034, 63.5350219}, {92.3283165, 62.0158945},
         {18.5656052, 32.1268808}}},
 {{{97.402018, 35.7169972}, {33.1127443, 25.8935163}, {1.13970027, 54.9424981},
         {56.4860195, 60.529264}}},
 };
 
 const size_t testSetCount = SK_ARRAY_COUNT(testSet);
 
 static const SkDCubic newTestSet[] = {
-{{{134, 11414}, {131.990234375, 11414}, {130.32666015625, 11415.482421875}, {130.04275512695312, 11417.4130859375}}},
+#if 0  // FIXME: asserts coincidence, not working yet
+{{{195, 785}, {124.30755615234375, 785}, {67, 841.85986328125}, {67, 912}}},
+{{{67, 913}, {67, 842.30755615234375}, {123.85984039306641, 785}, {194, 785}}},
+#endif
+
+{{{399,657}, {399,661.970581}, {403.029449,666}, {408,666}}},
+{{{406,666}, {402.686279,666}, {400,663.313721}, {400,660}}},
+
+{{{0,5}, {3,5}, {3,0}, {3,2}}},
+{{{0,3}, {2,3}, {5,0}, {5,3}}},
+
 {{{132, 11419}, {130.89543151855469, 11419}, {130, 11418.1044921875}, {130, 11417}}},
 
 {{{3, 4}, {1, 5}, {4, 3}, {6, 4}}},
 {{{3, 4}, {4, 6}, {4, 3}, {5, 1}}},
 
 {{{130.04275512695312, 11417.413085937500 },
     {130.23312377929687, 11418.319335937500 },
     {131.03707885742187, 11419.000000000000 },
     {132.00000000000000, 11419.000000000000 }}},
 
@@ skipping 99 matching lines @@
 
 {{{0, 6}, {1, 2}, {1, 0}, {1, 0}}},
 {{{0, 1}, {0, 1}, {6, 0}, {2, 1}}},
 
 {{{0, 2}, {0, 1}, {3, 0}, {1, 0}}},
 {{{0, 3}, {0, 1}, {2, 0}, {1, 0}}},
 };
 
 const size_t newTestSetCount = SK_ARRAY_COUNT(newTestSet);
 
-static void oneOff(skiatest::Reporter* reporter, const SkDCubic& cubic1, const SkDCubic& cubic2) {
+static void oneOff(skiatest::Reporter* reporter, const SkDCubic& cubic1, const SkDCubic& cubic2,
+        bool coin) {
     SkASSERT(ValidCubic(cubic1));
     SkASSERT(ValidCubic(cubic2));
 #if ONE_OFF_DEBUG
     SkDebugf("computed quadratics given\n");
     SkDebugf("  {{%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}},\n",
         cubic1[0].fX, cubic1[0].fY, cubic1[1].fX, cubic1[1].fY,
         cubic1[2].fX, cubic1[2].fY, cubic1[3].fX, cubic1[3].fY);
     SkDebugf("  {{%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}},\n",
         cubic2[0].fX, cubic2[0].fY, cubic2[1].fX, cubic2[1].fY,
         cubic2[2].fX, cubic2[2].fY, cubic2[3].fX, cubic2[3].fY);
@@ skipping 13 matching lines @@
 #if ONE_OFF_DEBUG
     SkDebugf("computed quadratics set 2\n");
     for (int index = 0; index < quads2.count(); ++index) {
         const SkDQuad& q = quads2[index];
         SkDebugf("  {{%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}},\n", q[0].fX, q[0].fY,
                  q[1].fX, q[1].fY,  q[2].fX, q[2].fY);
     }
 #endif
     SkIntersections intersections;
     intersections.intersect(cubic1, cubic2);
+    REPORTER_ASSERT(reporter, !coin || intersections.used() == 2);
     double tt1, tt2;
     SkDPoint xy1, xy2;
     for (int pt3 = 0; pt3 < intersections.used(); ++pt3) {
         tt1 = intersections[0][pt3];
         xy1 = cubic1.ptAtT(tt1);
         tt2 = intersections[1][pt3];
         xy2 = cubic2.ptAtT(tt2);
         const SkDPoint& iPt = intersections.pt(pt3);
 #if ONE_OFF_DEBUG
         SkDebugf("%s t1=%1.9g (%1.9g, %1.9g) (%1.9g, %1.9g) (%1.9g, %1.9g) t2=%1.9g\n",
                 __FUNCTION__, tt1, xy1.fX, xy1.fY, iPt.fX,
                 iPt.fY, xy2.fX, xy2.fY, tt2);
 #endif
        REPORTER_ASSERT(reporter, xy1.approximatelyEqual(iPt));
        REPORTER_ASSERT(reporter, xy2.approximatelyEqual(iPt));
        REPORTER_ASSERT(reporter, xy1.approximatelyEqual(xy2));
     }
+    reporter->bumpTestCount();
 }
 
 static void oneOff(skiatest::Reporter* reporter, int outer, int inner) {
     const SkDCubic& cubic1 = testSet[outer];
     const SkDCubic& cubic2 = testSet[inner];
-    oneOff(reporter, cubic1, cubic2);
+    oneOff(reporter, cubic1, cubic2, false);
 }
 
 static void newOneOff(skiatest::Reporter* reporter, int outer, int inner) {
     const SkDCubic& cubic1 = newTestSet[outer];
     const SkDCubic& cubic2 = newTestSet[inner];
-    oneOff(reporter, cubic1, cubic2);
+    oneOff(reporter, cubic1, cubic2, false);
 }
 
 static void oneOffTests(skiatest::Reporter* reporter) {
     for (size_t outer = 0; outer < testSetCount - 1; ++outer) {
         for (size_t inner = outer + 1; inner < testSetCount; ++inner) {
             oneOff(reporter, outer, inner);
         }
     }
     for (size_t outer = 0; outer < newTestSetCount - 1; ++outer) {
         for (size_t inner = outer + 1; inner < newTestSetCount; ++inner) {
@@ skipping 46 matching lines @@
     #endif
             REPORTER_ASSERT(reporter, 0);
         }
         for (int pt = 0; pt < intersections2.used(); ++pt) {
             double tt1 = intersections2[0][pt];
             SkDPoint xy1 = cubic1.ptAtT(tt1);
             double tt2 = intersections2[1][pt];
             SkDPoint xy2 = cubic2.ptAtT(tt2);
             REPORTER_ASSERT(reporter, xy1.approximatelyEqual(xy2));
         }
+        reporter->bumpTestCount();
     }
 }
 
 static void intersectionFinder(int index0, int index1, double t1Seed, double t2Seed,
         double t1Step, double t2Step) {
     const SkDCubic& cubic1 = newTestSet[index0];
     const SkDCubic& cubic2 = newTestSet[index1];
     SkDPoint t1[3], t2[3];
     bool toggle = true;
     do {
@@ skipping 127 matching lines @@
     SkDebugf("\n");
 #endif
     SkIntersections i;
     int result = i.intersect(cubic);
     REPORTER_ASSERT(reporter, result == 1);
     REPORTER_ASSERT(reporter, i.used() == 1);
     REPORTER_ASSERT(reporter, !approximately_equal(i[0][0], i[1][0]));
     SkDPoint pt1 = cubic.ptAtT(i[0][0]);
     SkDPoint pt2 = cubic.ptAtT(i[1][0]);
     REPORTER_ASSERT(reporter, pt1.approximatelyEqual(pt2));
+    reporter->bumpTestCount();
 }
 
 static void cubicIntersectionSelfTest(skiatest::Reporter* reporter) {
     size_t firstFail = 0;
     for (size_t index = firstFail; index < selfSetCount; ++index) {
         selfOneOff(reporter, index);
     }
 }
 
+static const SkDCubic coinSet[] = {
+    {{{317, 711}, {322.52285766601562, 711}, {327, 715.4771728515625}, {327, 721}}},
+    {{{324.07107543945312, 713.928955078125}, {324.4051513671875, 714.26300048828125},
+            {324.71566772460937, 714.62060546875}, {325, 714.9990234375}}},
+
+    {{{2, 3}, {0, 4}, {3, 2}, {5, 3}}},
+    {{{2, 3}, {0, 4}, {3, 2}, {5, 3}}},
+};
+
+size_t coinSetCount = SK_ARRAY_COUNT(coinSet);
+
+static void coinOneOff(skiatest::Reporter* reporter, int index) {
+    const SkDCubic& cubic1 = coinSet[index];
+    const SkDCubic& cubic2 = coinSet[index + 1];
+    oneOff(reporter, cubic1, cubic2, true);
+}
+
+static void cubicIntersectionCoinTest(skiatest::Reporter* reporter) {
+    size_t firstFail = 0;
+    for (size_t index = firstFail; index < coinSetCount; index += 2) {
+        coinOneOff(reporter, index);
+    }
+}
+
+static void PathOpsCubicCoinOneOffTest(skiatest::Reporter* reporter) {
+    coinOneOff(reporter, 0);
+}
+
 static void PathOpsCubicIntersectionOneOffTest(skiatest::Reporter* reporter) {
     newOneOff(reporter, 0, 1);
 }
 
 static void PathOpsCubicSelfOneOffTest(skiatest::Reporter* reporter) {
     selfOneOff(reporter, 0);
 }
 
 static void PathOpsCubicIntersectionTest(skiatest::Reporter* reporter) {
     oneOffTests(reporter);
     cubicIntersectionSelfTest(reporter);
+    cubicIntersectionCoinTest(reporter);
     standardTestCases(reporter);
     if (false) CubicIntersection_IntersectionFinder();
     if (false) CubicIntersection_RandTest(reporter);
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS_SHORT(PathOpsCubicIntersectionTest)
 
 DEFINE_TESTCLASS_SHORT(PathOpsCubicIntersectionOneOffTest)
 
 DEFINE_TESTCLASS_SHORT(PathOpsCubicSelfOneOffTest)
+
+DEFINE_TESTCLASS_SHORT(PathOpsCubicCoinOneOffTest)