update pathops to circle sort

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 68 matching lines @@
          (2 (a - 2 b + c - d g' + 2 e g' - f g'))
          }
         }
 
 Thus, if the slope of the line tends towards vertical, we use:
        A =   ( (a - 2*b + c) - g'*(d  - 2*e + f)      )
        B = 2*(-(a -   b    ) + g'*(d  -   e    )      )
        C =   ( (a          ) - g'*(d           ) - h' )
  */
 
-
 class LineQuadraticIntersections {
 public:
     enum PinTPoint {
         kPointUninitialized,
         kPointInitialized
     };
 
     LineQuadraticIntersections(const SkDQuad& q, const SkDLine& l, SkIntersections* i)
         : fQuad(q)
         , fLine(l)
@@ skipping 204 matching lines @@
         SkDPoint xy = fQuad.ptAtT(t);
         double dx = fLine[1].fX - fLine[0].fX;
         double dy = fLine[1].fY - fLine[0].fY;
         if (fabs(dx) > fabs(dy)) {
             return (xy.fX - fLine[0].fX) / dx;
         }
         return (xy.fY - fLine[0].fY) / dy;
     }
 
     bool pinTs(double* quadT, double* lineT, SkDPoint* pt, PinTPoint ptSet) {
-        if (!approximately_one_or_less(*lineT)) {
+        if (!approximately_one_or_less_double(*lineT)) {
             return false;
         }
-        if (!approximately_zero_or_more(*lineT)) {
+        if (!approximately_zero_or_more_double(*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()) {
+            *pt = fLine[0];
             *lineT = 0;
         } else if (gridPt == fLine[1].asSkPoint()) {
+            *pt = fLine[1];
             *lineT = 1;
         }
         if (gridPt == fQuad[0].asSkPoint()) {
+            *pt = fQuad[0];
             *quadT = 0;
         } else if (gridPt == fQuad[2].asSkPoint()) {
+            *pt = fQuad[2];
             *quadT = 1;
         }
         return true;
     }
 
 private:
     const SkDQuad& fQuad;
     const SkDLine& fLine;
     SkIntersections* fIntersections;
     bool fAllowNear;
 };
 
-// utility for pairs of coincident quads
-static double horizontalIntersect(const SkDQuad& quad, const SkDPoint& pt) {
-    LineQuadraticIntersections q(quad, *(static_cast<SkDLine*>(0)),
-            static_cast<SkIntersections*>(0));
-    double rootVals[2];
-    int roots = q.horizontalIntersect(pt.fY, rootVals);
-    for (int index = 0; index < roots; ++index) {
-        double t = rootVals[index];
-        SkDPoint qPt = quad.ptAtT(t);
-        if (AlmostEqualUlps(qPt.fX, pt.fX)) {
-            return t;
-        }
-    }
-    return -1;
-}
-
-static double verticalIntersect(const SkDQuad& quad, const SkDPoint& pt) {
-    LineQuadraticIntersections q(quad, *(static_cast<SkDLine*>(0)),
-            static_cast<SkIntersections*>(0));
-    double rootVals[2];
-    int roots = q.verticalIntersect(pt.fX, rootVals);
-    for (int index = 0; index < roots; ++index) {
-        double t = rootVals[index];
-        SkDPoint qPt = quad.ptAtT(t);
-        if (AlmostEqualUlps(qPt.fY, pt.fY)) {
-            return t;
-        }
-    }
-    return -1;
-}
-
-double SkIntersections::Axial(const SkDQuad& q1, const SkDPoint& p, bool vertical) {
-    if (vertical) {
-        return verticalIntersect(q1, p);
-    }
-    return horizontalIntersect(q1, p);
-}
-
 int SkIntersections::horizontal(const SkDQuad& quad, double left, double right, double y,
                                 bool flipped) {
     SkDLine line = {{{ left, y }, { right, y }}};
     LineQuadraticIntersections q(quad, line, this);
     return q.horizontalIntersect(y, left, right, flipped);
 }
 
 int SkIntersections::vertical(const SkDQuad& quad, double top, double bottom, double x,
                               bool flipped) {
     SkDLine line = {{{ x, top }, { x, bottom }}};
     LineQuadraticIntersections q(quad, line, this);
     return q.verticalIntersect(x, top, bottom, flipped);
 }
 
 int SkIntersections::intersect(const SkDQuad& quad, const SkDLine& line) {
     LineQuadraticIntersections q(quad, line, this);
     q.allowNear(fAllowNear);
     return q.intersect();
 }
 
 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;
 }