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 89 matching lines @@
         for (int n = 0; n < 4; ++n) {
             r[n].fX = (fCubic[n].fY - fLine[0].fY) * adj - (fCubic[n].fX - fLine[0].fX) * opp;
         }
         double A, B, C, D;
         SkDCubic::Coefficients(&r[0].fX, &A, &B, &C, &D);
         return SkDCubic::RootsValidT(A, B, C, D, roots);
     }
 
     int intersect() {
         addExactEndPoints();
+        if (fAllowNear) {
+            addNearEndPoints();
+        }
         double rootVals[3];
         int roots = intersectRay(rootVals);
         for (int index = 0; index < roots; ++index) {
             double cubicT = rootVals[index];
             double lineT = findLineT(cubicT);
             SkDPoint pt;
             if (pinTs(&cubicT, &lineT, &pt, kPointUninitialized)) {
     #if ONE_OFF_DEBUG
                 SkDPoint cPt = fCubic.ptAtT(cubicT);
                 SkDebugf("%s pt=(%1.9g,%1.9g) cPt=(%1.9g,%1.9g)\n", __FUNCTION__, pt.fX, pt.fY,
                         cPt.fX, cPt.fY);
     #endif
                 fIntersections->insert(cubicT, lineT, pt);
             }
         }
-        if (fAllowNear) {
-            addNearEndPoints();
-        }
         return fIntersections->used();
     }
 
     int horizontalIntersect(double axisIntercept, double roots[3]) {
         double A, B, C, D;
         SkDCubic::Coefficients(&fCubic[0].fY, &A, &B, &C, &D);
         D -= axisIntercept;
         return SkDCubic::RootsValidT(A, B, C, D, roots);
     }
 
     int horizontalIntersect(double axisIntercept, double left, double right, bool flipped) {
         addExactHorizontalEndPoints(left, right, axisIntercept);
+        if (fAllowNear) {
+            addNearHorizontalEndPoints(left, right, axisIntercept);
+        }
         double rootVals[3];
         int roots = horizontalIntersect(axisIntercept, rootVals);
         for (int index = 0; index < roots; ++index) {
             double cubicT = rootVals[index];
             SkDPoint pt = fCubic.ptAtT(cubicT);
             double lineT = (pt.fX - left) / (right - left);
             if (pinTs(&cubicT, &lineT, &pt, kPointInitialized)) {
                 fIntersections->insert(cubicT, lineT, pt);
             }
         }
-        if (fAllowNear) {
-            addNearHorizontalEndPoints(left, right, axisIntercept);
-        }
         if (flipped) {
             fIntersections->flip();
         }
         return fIntersections->used();
     }
 
     int verticalIntersect(double axisIntercept, double roots[3]) {
         double A, B, C, D;
         SkDCubic::Coefficients(&fCubic[0].fX, &A, &B, &C, &D);
         D -= axisIntercept;
         return SkDCubic::RootsValidT(A, B, C, D, roots);
     }
 
     int verticalIntersect(double axisIntercept, double top, double bottom, bool flipped) {
         addExactVerticalEndPoints(top, bottom, axisIntercept);
+        if (fAllowNear) {
+            addNearVerticalEndPoints(top, bottom, axisIntercept);
+        }
         double rootVals[3];
         int roots = verticalIntersect(axisIntercept, rootVals);
         for (int index = 0; index < roots; ++index) {
             double cubicT = rootVals[index];
             SkDPoint pt = fCubic.ptAtT(cubicT);
             double lineT = (pt.fY - top) / (bottom - top);
             if (pinTs(&cubicT, &lineT, &pt, kPointInitialized)) {
                 fIntersections->insert(cubicT, lineT, pt);
             }
         }
-        if (fAllowNear) {
-            addNearVerticalEndPoints(top, bottom, axisIntercept);
-        }
         if (flipped) {
             fIntersections->flip();
         }
         return fIntersections->used();
     }
 
     protected:
 
     void addExactEndPoints() {
         for (int cIndex = 0; cIndex < 4; cIndex += 3) {
@@ skipping 89 matching lines @@
         if (!approximately_zero_or_more(*lineT)) {
             return false;
         }
         double cT = *cubicT = SkPinT(*cubicT);
         double lT = *lineT = SkPinT(*lineT);
         if (lT == 0 || lT == 1 || (ptSet == kPointUninitialized && cT != 0 && cT != 1)) {
             *pt = fLine.ptAtT(lT);
         } else if (ptSet == kPointUninitialized) {
             *pt = fCubic.ptAtT(cT);
         }
+        SkPoint gridPt = pt->asSkPoint();
+        if (gridPt == fLine[0].asSkPoint()) {
+            *lineT = 0;
+        } else if (gridPt == fLine[1].asSkPoint()) {
+            *lineT = 1;
+        }
+        if (gridPt == fCubic[0].asSkPoint() && approximately_equal(*cubicT, 0)) {
+            *cubicT = 0;
+        } else if (gridPt == fCubic[3].asSkPoint() && approximately_equal(*cubicT, 1)) {
+            *cubicT = 1;
+        }
         return true;
     }
 
 private:
     const SkDCubic& fCubic;
     const SkDLine& fLine;
     SkIntersections* fIntersections;
     bool fAllowNear;
 };
 
@@ skipping 18 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.ptAtT(fT[0][index]);
     }
     return fUsed;
 }