path ops work in progress

src/pathops/SkDCubicLineIntersection.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 87 matching lines @@
 
 int intersect() {
     addEndPoints();
     double rootVals[3];
     int roots = intersectRay(rootVals);
     for (int index = 0; index < roots; ++index) {
         double cubicT = rootVals[index];
         double lineT = findLineT(cubicT);
         if (pinTs(&cubicT, &lineT)) {
             SkDPoint pt = line.xyAtT(lineT);
+#if ONE_OFF_DEBUG
+            SkDPoint cPt = cubic.xyAtT(cubicT);
+            SkDebugf("%s pt=(%1.9g,%1.9g) cPt=(%1.9g,%1.9g)\n", __FUNCTION__, pt.fX, pt.fY,
+                    cPt.fX, cPt.fY);
+#endif
             intersections.insert(cubicT, lineT, pt);
         }
     }
     return intersections.used();
 }
 
 int horizontalIntersect(double axisIntercept, double roots[3]) {
     double A, B, C, D;
     SkDCubic::Coefficients(&cubic[0].fY, &A, &B, &C, &D);
     D -= axisIntercept;
@@ skipping 40 matching lines @@
     if (flipped) {
         intersections.flip();
     }
     return intersections.used();
 }
 
 protected:
 
 void addEndPoints() {
     for (int cIndex = 0; cIndex < 4; cIndex += 3) {
+        bool foundEnd = false;
         for (int lIndex = 0; lIndex < 2; lIndex++) {
             if (cubic[cIndex] == line[lIndex]) {
                 intersections.insert(cIndex >> 1, lIndex, line[lIndex]);
+                foundEnd = true;
             }
         }
+        // for the test case this was written for, the dist / error ratio was 170.6667
+        // it looks like the cubic stops short of touching the line, but this fixed it.
+        if (foundEnd) {
+            continue;
+        }
+        // See if the cubic end touches the line. 
+        double dist = line.isLeft(cubic[cIndex]); // this distance isn't cartesian
+        SkDVector lineLen = line[1] - line[0]; // the x/y magnitudes of the line
+        // compute the ULPS of the larger of the x/y deltas
+        double larger = SkTMax(SkTAbs(lineLen.fX), SkTAbs(lineLen.fY));
+        if (!RoughlyEqualUlps(larger, larger + dist)) { // is the dist within ULPS tolerance?
+            continue;
+        }
+        double lineT = findLineT(cIndex >> 1);
+        if (!between(0, lineT, 1)) {
+            continue;
+        }
+        SkDPoint linePt = line.xyAtT(lineT);
+        if (linePt.approximatelyEqual(cubic[cIndex])) {
+            intersections.insert(cIndex >> 1, lineT, cubic[cIndex]);
+        }
     }
 }
 
 void addHorizontalEndPoints(double left, double right, double y) {
     for (int cIndex = 0; cIndex < 4; cIndex += 3) {
         if (cubic[cIndex].fY != y) {
             continue;
         }
         if (cubic[cIndex].fX == left) {
             intersections.insert(cIndex >> 1, 0, cubic[cIndex]);
@@ skipping 73 matching lines @@
 }
 
 int SkIntersections::intersectRay(const SkDCubic& cubic, const SkDLine& line) {
     LineCubicIntersections c(cubic, line, *this);
     fUsed = c.intersectRay(fT[0]);
     for (int index = 0; index < fUsed; ++index) {
         fPt[index] = cubic.xyAtT(fT[0][index]);
     }
     return fUsed;
 }