path ops work in progress

src/pathops/SkDQuadLineIntersection.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 "SkPathOpsLine.h"
 #include "SkPathOpsQuad.h"
 
@@ skipping 119 matching lines @@
         double A = r[2];
         double B = r[1];
         double C = r[0];
         A += C - 2 * B;  // A = a - 2*b + c
         B -= C;  // B = -(b - c)
         return SkDQuad::RootsValidT(A, 2 * B, C, roots);
     }
 
     int intersect() {
         addExactEndPoints();
+        if (fAllowNear) {
+            addNearEndPoints();
+        }
         double rootVals[2];
         int roots = intersectRay(rootVals);
         for (int index = 0; index < roots; ++index) {
             double quadT = rootVals[index];
             double lineT = findLineT(quadT);
             SkDPoint pt;
             if (pinTs(&quadT, &lineT, &pt, kPointUninitialized)) {
                 fIntersections->insert(quadT, lineT, pt);
             }
         }
-        if (fAllowNear) {
-            addNearEndPoints();
-        }
         return fIntersections->used();
     }
 
     int horizontalIntersect(double axisIntercept, double roots[2]) {
         double D = fQuad[2].fY;  // f
         double E = fQuad[1].fY;  // e
         double F = fQuad[0].fY;  // d
         D += F - 2 * E;         // D = d - 2*e + f
         E -= F;                 // E = -(d - e)
         F -= axisIntercept;
         return SkDQuad::RootsValidT(D, 2 * E, F, roots);
     }
 
     int horizontalIntersect(double axisIntercept, double left, double right, bool flipped) {
         addExactHorizontalEndPoints(left, right, axisIntercept);
+        if (fAllowNear) {
+            addNearHorizontalEndPoints(left, right, axisIntercept);
+        }
         double rootVals[2];
         int roots = horizontalIntersect(axisIntercept, rootVals);
         for (int index = 0; index < roots; ++index) {
             double quadT = rootVals[index];
             SkDPoint pt = fQuad.ptAtT(quadT);
             double lineT = (pt.fX - left) / (right - left);
             if (pinTs(&quadT, &lineT, &pt, kPointInitialized)) {
                 fIntersections->insert(quadT, lineT, pt);
             }
         }
-        if (fAllowNear) {
-            addNearHorizontalEndPoints(left, right, axisIntercept);
-        }
         if (flipped) {
             fIntersections->flip();
         }
         return fIntersections->used();
     }
 
     int verticalIntersect(double axisIntercept, double roots[2]) {
         double D = fQuad[2].fX;  // f
         double E = fQuad[1].fX;  // e
         double F = fQuad[0].fX;  // d
         D += F - 2 * E;         // D = d - 2*e + f
         E -= F;                 // E = -(d - e)
         F -= axisIntercept;
         return SkDQuad::RootsValidT(D, 2 * E, F, roots);
     }
 
     int verticalIntersect(double axisIntercept, double top, double bottom, bool flipped) {
         addExactVerticalEndPoints(top, bottom, axisIntercept);
+        if (fAllowNear) {
+            addNearVerticalEndPoints(top, bottom, axisIntercept);
+        }
         double rootVals[2];
         int roots = verticalIntersect(axisIntercept, rootVals);
         for (int index = 0; index < roots; ++index) {
             double quadT = rootVals[index];
             SkDPoint pt = fQuad.ptAtT(quadT);
             double lineT = (pt.fY - top) / (bottom - top);
             if (pinTs(&quadT, &lineT, &pt, kPointInitialized)) {
                 fIntersections->insert(quadT, lineT, pt);
             }
         }
-        if (fAllowNear) {
-            addNearVerticalEndPoints(top, bottom, axisIntercept);
-        }
         if (flipped) {
             fIntersections->flip();
         }
         return fIntersections->used();
     }
 
 protected:
     // add endpoints first to get zero and one t values exactly
     void addExactEndPoints() {
         for (int qIndex = 0; qIndex < 3; qIndex += 2) {
@@ skipping 95 matching lines @@
         if (!approximately_zero_or_more(*lineT)) {
             return false;
         }
         double qT = *quadT = SkPinT(*quadT);
         double lT = *lineT = SkPinT(*lineT);
         if (lT == 0 || lT == 1 || (ptSet == kPointUninitialized && qT != 0 && qT != 1)) {
             *pt = fLine.ptAtT(lT);
         } else if (ptSet == kPointUninitialized) {
             *pt = fQuad.ptAtT(qT);
         }
+        SkPoint gridPt = pt->asSkPoint();
+        if (gridPt == fLine[0].asSkPoint()) {
+            *lineT = 0;
+        } else if (gridPt == fLine[1].asSkPoint()) {
+            *lineT = 1;
+        }
+        if (gridPt == fQuad[0].asSkPoint()) {
+            *quadT = 0;
+        } else if (gridPt == fQuad[2].asSkPoint()) {
+            *quadT = 1;
+        }
         return true;
     }
 
 private:
     const SkDQuad& fQuad;
     const SkDLine& fLine;
     SkIntersections* fIntersections;
     bool fAllowNear;
 };
 
@@ skipping 56 matching lines @@
 }
 
 int SkIntersections::intersectRay(const SkDQuad& quad, const SkDLine& line) {
     LineQuadraticIntersections q(quad, line, this);
     fUsed = q.intersectRay(fT[0]);
     for (int index = 0; index < fUsed; ++index) {
         fPt[index] = quad.ptAtT(fT[0][index]);
     }
     return fUsed;
 }