harden pathops for pathological test

src/pathops/SkDCubicIntersection.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 "SkIntersections.h"
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsLine.h"
@@ skipping 91 matching lines @@
             SkReduceOrder s2;
             int o2 = quadPart(cubic2, t2Start, t2, &s2);
         #if ONE_OFF_DEBUG
             char tab[] = "                  ";
             if (tLimits1[0][0] >= t1Start && tLimits1[0][1] <= t1
                     && tLimits1[1][0] >= t2Start && tLimits1[1][1] <= t2) {
                 SkDebugf("%.*s %s t1=(%1.9g,%1.9g) t2=(%1.9g,%1.9g)", i.depth()*2, tab,
                         __FUNCTION__, t1Start, t1, t2Start, t2);
                 SkIntersections xlocals;
                 xlocals.allowNear(false);
+                xlocals.allowFlatMeasure(true);
                 intersectWithOrder(s1.fQuad, o1, s2.fQuad, o2, xlocals);
                 SkDebugf(" xlocals.fUsed=%d\n", xlocals.used());
             }
         #endif
             SkIntersections locals;
             locals.allowNear(false);
+            locals.allowFlatMeasure(true);
             intersectWithOrder(s1.fQuad, o1, s2.fQuad, o2, locals);
             int tCount = locals.used();
             for (int tIdx = 0; tIdx < tCount; ++tIdx) {
                 double to1 = t1Start + (t1 - t1Start) * locals[0][tIdx];
                 double to2 = t2Start + (t2 - t2Start) * locals[1][tIdx];
     // if the computed t is not sufficiently precise, iterate
                 SkDPoint p1 = cubic1.ptAtT(to1);
                 SkDPoint p2 = cubic2.ptAtT(to2);
                 if (p1.approximatelyEqual(p2)) {
     // FIXME: local edge may be coincident -- experiment with not propagating coincidence to caller
@@ skipping 161 matching lines @@
     double testT = (double) !start;
     bool swap = swapped();
     // quad/quad at this point checks to see if exact matches have already been found
     // cubic/cubic can't reject so easily since cubics can intersect same point more than once
     SkDLine tmpLine;
     tmpLine[0] = tmpLine[1] = cubic2[t1Index];
     tmpLine[1].fX += cubic2[2 - start].fY - cubic2[t1Index].fY;
     tmpLine[1].fY -= cubic2[2 - start].fX - cubic2[t1Index].fX;
     SkIntersections impTs;
     impTs.allowNear(false);
+    impTs.allowFlatMeasure(true);
     impTs.intersectRay(cubic1, tmpLine);
     for (int index = 0; index < impTs.used(); ++index) {
         SkDPoint realPt = impTs.pt(index);
         if (!tmpLine[0].approximatelyEqual(realPt)) {
             continue;
         }
         if (swap) {
             cubicInsert(testT, impTs[0][index], tmpLine[0], cubic2, cubic1);
         } else {
             cubicInsert(impTs[0][index], testT, tmpLine[0], cubic1, cubic2);
@@ skipping 240 matching lines @@
             cubicNearEnd(c2, true, c1, c1Bounds);
         }
         swap();
     }
     if (cubicCheckCoincidence(c1, c2)) {
         SkASSERT(!selfIntersect);
         return fUsed;
     }
     SkIntersections i;
     i.fAllowNear = false;
+    i.fFlatMeasure = true;
     i.fMax = 9;
     ::intersect(c1, 0, 1, c2, 0, 1, 1, i);
     int compCount = i.used();
     if (compCount) {
         int exactCount = used();
         if (exactCount == 0) {
             *this = i;
         } else {
             // at least one is exact or near, and at least one was computed. Eliminate duplicates
             for (int exIdx = 0; exIdx < exactCount; ++exIdx) {
@@ skipping 86 matching lines @@
             }
         }
     }
     return fUsed;
 }
 
 // Up promote the quad to a cubic.
 // OPTIMIZATION If this is a common use case, optimize by duplicating
 // the intersect 3 loop to avoid the promotion  / demotion code
 int SkIntersections::intersect(const SkDCubic& cubic, const SkDQuad& quad) {
-    fMax = 6;
+    fMax = 7;
     SkDCubic up = quad.toCubic();
     (void) intersect(cubic, up);
     return used();
 }
 
 /* http://www.ag.jku.at/compass/compasssample.pdf
 ( Self-Intersection Problems and Approximate Implicitization by Jan B. Thomassen
 Centre of Mathematics for Applications, University of Oslo http://www.cma.uio.no janbth@math.uio.no
 SINTEF Applied Mathematics http://www.sintef.no )
 describes a method to find the self intersection of a cubic by taking the gradient of the implicit
 form dotted with the normal, and solving for the roots. My math foo is too poor to implement this.*/
 
 int SkIntersections::intersect(const SkDCubic& c) {
     fMax = 1;
     // check to see if x or y end points are the extrema. Are other quick rejects possible?
     if (c.endsAreExtremaInXOrY()) {
         return false;
     }
     // OPTIMIZATION: could quick reject if neither end point tangent ray intersected the line
     // segment formed by the opposite end point to the control point
     (void) intersect(c, c);
-    if (used() > 0) {
+    if (used() > 1) {
+        fUsed = 0;
+    } else if (used() > 0) {
         if (approximately_equal_double(fT[0][0], fT[1][0])) {
             fUsed = 0;
         } else {
             SkASSERT(used() == 1);
             if (fT[0][0] > fT[1][0]) {
                 swapPts();
             }
         }
     }
     return used();
 }