fix bugs in path contains

src/core/SkPath.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBuffer.h"
 #include "SkCubicClipper.h"
 #include "SkErrorInternals.h"
@@ skipping 2603 matching lines @@
     SkScalar min, max;
     min = max = pts[0].fX;
     for (size_t i = 1; i < N; ++i) {
         min = SkMinScalar(min, pts[i].fX);
         max = SkMaxScalar(max, pts[i].fX);
     }
     *minPtr = min;
     *maxPtr = max;
 }
 
+static bool checkOnCurve(SkScalar x, SkScalar y, const SkPoint& start, const SkPoint& end) {
+    if (start.fY == end.fY) {
+        return between(start.fX, x, end.fX) && x != end.fX;
+    } else {
+        return x == start.fX && y == start.fY;
+    }
+}
+
 static int winding_mono_cubic(const SkPoint pts[], SkScalar x, SkScalar y, int* onCurveCount) {
-    if (!between(pts[0].fY, y, pts[3].fY)) {
+    SkScalar y0 = pts[0].fY;
+    SkScalar y3 = pts[3].fY;
+
+    int dir = 1;
+    if (y0 > y3) {
+        SkTSwap(y0, y3);
+        dir = -1;
+    }
+    if (y < y0 || y > y3) {
         return 0;
     }
-    if (y == pts[3].fY) {
-        // if the cubic is a horizontal line, check if the point is on it
-        // but don't check the last point, because that point is shared with the next curve
-        if (pts[0].fY == pts[3].fY && between(pts[0].fX, x, pts[3].fX) && x != pts[3].fX) {
-            *onCurveCount += 1;
-        }
+    if (checkOnCurve(x, y, pts[0], pts[3])) {
+        *onCurveCount += 1;
         return 0;
     }
-    int dir = pts[0].fY > pts[3].fY ? -1 : 1;
+    if (y == y3) {
+        return 0;
+    }
+
     // quickreject or quickaccept
     SkScalar min, max;
     find_minmax<4>(pts, &min, &max);
     if (x < min) {
         return 0;
     }
     if (x > max) {
         return dir;
     }
 
     // compute the actual x(t) value
     SkScalar t;
     SkAssertResult(SkCubicClipper::ChopMonoAtY(pts, y, &t));
     SkScalar xt = eval_cubic_pts(pts[0].fX, pts[1].fX, pts[2].fX, pts[3].fX, t);
     if (SkScalarNearlyEqual(xt, x)) {
         if (x != pts[3].fX || y != pts[3].fY) {  // don't test end points; they're start points
             *onCurveCount += 1;
+            return 0;
         }
     }
     return xt < x ? dir : 0;
 }
 
 static int winding_cubic(const SkPoint pts[], SkScalar x, SkScalar y, int* onCurveCount) {
     SkPoint dst[10];
     int n = SkChopCubicAtYExtrema(pts, dst);
     int w = 0;
     for (int i = 0; i <= n; ++i) {
@@ skipping 26 matching lines @@
     SkScalar y2 = pts[2].fY;
 
     int dir = 1;
     if (y0 > y2) {
         SkTSwap(y0, y2);
         dir = -1;
     }
     if (y < y0 || y > y2) {
         return 0;
     }
+    if (checkOnCurve(x, y, pts[0], pts[2])) {
+        *onCurveCount += 1;
+        return 0;
+    }
     if (y == y2) {
-        if (y0 == y2 && between(pts[0].fX, x, pts[2].fX) && x != pts[2].fX) {  // check horizontal
-            *onCurveCount += 1;
-        }
         return 0;
     }
 
     SkScalar roots[2];
     SkScalar A = pts[2].fY;
     SkScalar B = pts[1].fY * conic.fW - y * conic.fW + y;
     SkScalar C = pts[0].fY;
     A += C - 2 * B;  // A = a + c - 2*(b*w - yCept*w + yCept)
     B -= C;  // B = b*w - w * yCept + yCept - a
     C -= y;
     int n = SkFindUnitQuadRoots(A, 2 * B, C, roots);
     SkASSERT(n <= 1);
     SkScalar xt;
     if (0 == n) {
-        SkScalar mid = SkScalarAve(y0, y2);
-        // Need [0] and [2] if dir == 1
-        // and  [2] and [0] if dir == -1
-        xt = y < mid ? pts[1 - dir].fX : pts[dir - 1].fX;
+        // zero roots are returned only when y0 == y
+        // Need [0] if dir == 1
+        // and  [2] if dir == -1
+        xt = pts[1 - dir].fX;
     } else {
         SkScalar t = roots[0];
         xt = conic_eval_numerator(&pts[0].fX, conic.fW, t) / conic_eval_denominator(conic.fW, t);
     }
     if (SkScalarNearlyEqual(xt, x)) {
         if (x != pts[2].fX || y != pts[2].fY) {  // don't test end points; they're start points
             *onCurveCount += 1;
+            return 0;
         }
     }
     return xt < x ? dir : 0;
 }
 
 static bool is_mono_quad(SkScalar y0, SkScalar y1, SkScalar y2) {
     //    return SkScalarSignAsInt(y0 - y1) + SkScalarSignAsInt(y1 - y2) != 0;
     if (y0 == y1) {
         return true;
     }
@@ skipping 27 matching lines @@
     SkScalar y2 = pts[2].fY;
 
     int dir = 1;
     if (y0 > y2) {
         SkTSwap(y0, y2);
         dir = -1;
     }
     if (y < y0 || y > y2) {
         return 0;
     }
+    if (checkOnCurve(x, y, pts[0], pts[2])) {
+        *onCurveCount += 1;
+        return 0;
+    }
     if (y == y2) {
-        if (y0 == y2 && between(pts[0].fX, x, pts[2].fX) && x != pts[2].fX) {  // check horizontal
-            *onCurveCount += 1;
-        }
         return 0;
     }
     // bounds check on X (not required. is it faster?)
 #if 0
     if (pts[0].fX > x && pts[1].fX > x && pts[2].fX > x) {
         return 0;
     }
 #endif
 
     SkScalar roots[2];
     int n = SkFindUnitQuadRoots(pts[0].fY - 2 * pts[1].fY + pts[2].fY,
                                 2 * (pts[1].fY - pts[0].fY),
                                 pts[0].fY - y,
                                 roots);
     SkASSERT(n <= 1);
     SkScalar xt;
     if (0 == n) {
-        SkScalar mid = SkScalarAve(y0, y2);
-        // Need [0] and [2] if dir == 1
-        // and  [2] and [0] if dir == -1
-        xt = y < mid ? pts[1 - dir].fX : pts[dir - 1].fX;
+        // zero roots are returned only when y0 == y
+        // Need [0] if dir == 1
+        // and  [2] if dir == -1
+        xt = pts[1 - dir].fX;
     } else {
         SkScalar t = roots[0];
         SkScalar C = pts[0].fX;
         SkScalar A = pts[2].fX - 2 * pts[1].fX + C;
         SkScalar B = 2 * (pts[1].fX - C);
         xt = SkScalarMulAdd(SkScalarMulAdd(A, t, B), t, C);
     }
     if (SkScalarNearlyEqual(xt, x)) {
         if (x != pts[2].fX || y != pts[2].fY) {  // don't test end points; they're start points
             *onCurveCount += 1;
+            return 0;
         }
     }
     return xt < x ? dir : 0;
 }
 
 static int winding_quad(const SkPoint pts[], SkScalar x, SkScalar y, int* onCurveCount) {
     SkPoint dst[5];
     int     n = 0;
 
     if (!is_mono_quad(pts[0].fY, pts[1].fY, pts[2].fY)) {
@@ skipping 16 matching lines @@
     SkScalar dy = y1 - y0;
 
     int dir = 1;
     if (y0 > y1) {
         SkTSwap(y0, y1);
         dir = -1;
     }
     if (y < y0 || y > y1) {
         return 0;
     }
-    if (y == pts[1].fY) {
-        if (y0 == y1 && between(x0, x, x1) && x != x1) {  // check if on horizontal line
-            *onCurveCount += 1;
-        }
+    if (checkOnCurve(x, y, pts[0], pts[1])) {
+        *onCurveCount += 1;
+        return 0;
+    }
+    if (y == y1) {
         return 0;
     }
     SkScalar cross = SkScalarMul(x1 - x0, y - pts[0].fY) - SkScalarMul(dy, x - x0);
 
     if (!cross) {
         // zero cross means the point is on the line, and since the case where
         // y of the query point is at the end point is handled above, we can be
         // sure that we're on the line (excluding the end point) here
-        *onCurveCount += 1;
+        if (x != x1 || y != pts[1].fY) {

[fs, 2015/12/18 10:18:34]

Nit: Maybe you should use pts[1].fX rather than x1 to be consistent with the
other similar cases?

+            *onCurveCount += 1;
+        }
         dir = 0;
     } else if (SkScalarSignAsInt(cross) == dir) {
         dir = 0;
     }
     return dir;
 }
 
 static void tangent_cubic(const SkPoint pts[], SkScalar x, SkScalar y,
         SkTDArray<SkVector>* tangents) {
     if (!between(pts[0].fY, y, pts[1].fY) && !between(pts[1].fY, y, pts[2].fY)
@@ skipping 146 matching lines @@
     }
     if (onCurveCount <= 1) {
         return SkToBool(onCurveCount) ^ isInverse;
     }
     if ((onCurveCount & 1) || evenOddFill) {
         return SkToBool(onCurveCount & 1) ^ isInverse;
     }
     // If the point touches an even number of curves, and the fill is winding, check for  
     // coincidence. Count coincidence as places where the on curve points have identical tangents.
     iter.setPath(*this, true);
+    done = false;
     SkTDArray<SkVector> tangents;
     do {
         SkPoint pts[4];
         int oldCount = tangents.count();
         switch (iter.next(pts, false)) {
             case SkPath::kMove_Verb:
             case SkPath::kClose_Verb:
                 break;
             case SkPath::kLine_Verb:
                 tangent_line(pts, x, y, &tangents);
@@ skipping 13 matching lines @@
        }
        if (tangents.count() > oldCount) {
             int last = tangents.count() - 1;
             const SkVector& tangent = tangents[last];
             if (SkScalarNearlyZero(tangent.lengthSqd())) {
                 tangents.remove(last);
             } else {
                 for (int index = 0; index < last; ++index) {
                     const SkVector& test = tangents[index];
                     if (SkScalarNearlyZero(test.cross(tangent))
-                            && SkScalarSignAsInt(tangent.fX - test.fX) <= 0
-                            && SkScalarSignAsInt(tangent.fY - test.fY) <= 0) {
+                            && SkScalarSignAsInt(tangent.fX * test.fX) <= 0
+                            && SkScalarSignAsInt(tangent.fY * test.fY) <= 0) {
                         tangents.remove(last);
                         tangents.removeShuffle(index);
                         break;
                     }
                 }
             }
         }
     } while (!done);
     return SkToBool(tangents.count()) ^ isInverse;
 }
 
 int SkPath::ConvertConicToQuads(const SkPoint& p0, const SkPoint& p1, const SkPoint& p2,
                                 SkScalar w, SkPoint pts[], int pow2) {
     const SkConic conic(p0, p1, p2, w);
     return conic.chopIntoQuadsPOW2(pts, pow2);
 }