path ops near exact

src/pathops/SkDQuadIntersection.cpp

 // Another approach is to start with the implicit form of one curve and solve
 // (seek implicit coefficients in QuadraticParameter.cpp
 // by substituting in the parametric form of the other.
 // The downside of this approach is that early rejects are difficult to come by.
 // http://planetmath.org/encyclopedia/GaloisTheoreticDerivationOfTheQuarticFormula.html#step
 
 
 #include "SkDQuadImplicit.h"
 #include "SkIntersections.h"
 #include "SkPathOpsLine.h"
@@ skipping 109 matching lines @@
 static bool add_intercept(const SkDQuad& q1, const SkDQuad& q2, double tMin, double tMax,
                           SkIntersections* i, bool* subDivide) {
     double tMid = (tMin + tMax) / 2;
     SkDPoint mid = q2.xyAtT(tMid);
     SkDLine line;
     line[0] = line[1] = mid;
     SkDVector dxdy = q2.dxdyAtT(tMid);
     line[0] -= dxdy;
     line[1] += dxdy;
     SkIntersections rootTs;
+    rootTs.allowNear(false);
     int roots = rootTs.intersect(q1, line);
     if (roots == 0) {
         if (subDivide) {
             *subDivide = true;
         }
         return true;
     }
     if (roots == 2) {
         return false;
     }
     SkDPoint pt2 = q1.xyAtT(rootTs[0][0]);
     if (!pt2.approximatelyEqualHalf(mid)) {
         return false;
     }
     i->insertSwap(rootTs[0][0], tMid, pt2);
     return true;
 }
 
 static bool is_linear_inner(const SkDQuad& q1, double t1s, double t1e, const SkDQuad& q2,
                             double t2s, double t2e, SkIntersections* i, bool* subDivide) {
     SkDQuad hull = q1.subDivide(t1s, t1e);
     SkDLine line = {{hull[2], hull[0]}};
     const SkDLine* testLines[] = { &line, (const SkDLine*) &hull[0], (const SkDLine*) &hull[1] };
     const size_t kTestCount = SK_ARRAY_COUNT(testLines);
     SkSTArray<kTestCount * 2, double, true> tsFound;
     for (size_t index = 0; index < kTestCount; ++index) {
         SkIntersections rootTs;
+        rootTs.allowNear(false);
         int roots = rootTs.intersect(q2, *testLines[index]);
         for (int idx2 = 0; idx2 < roots; ++idx2) {
             double t = rootTs[0][idx2];
 #ifdef SK_DEBUG
             SkDPoint qPt = q2.xyAtT(t);
             SkDPoint lPt = testLines[index]->xyAtT(rootTs[1][idx2]);
             SkASSERT(qPt.approximatelyEqual(lPt));
 #endif
             if (approximately_negative(t - t2s) || approximately_positive(t - t2e)) {
                 continue;
@@ skipping 332 matching lines @@
         }
         if (lowestIndex < 0) {
             break;
         }
         insert(roots1Copy[lowestIndex], roots2Copy[closest[lowestIndex]],
                 pts1[lowestIndex]);
         closest[lowestIndex] = -1;
     } while (++used < r1Count);
     return fUsed;
 }