use pathops utils to improve precision of cubic chopping in scan converter

src/core/SkGeometry.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 "SkGeometry.h"
 #include "SkMatrix.h"
 #include "SkNx.h"
@@ skipping 898 matching lines @@
     if (dst) {
         if (count == 0) {
             memcpy(dst, src, 4 * sizeof(SkPoint));
         } else {
             SkChopCubicAt(src, dst, tValues, count);
         }
     }
     return count + 1;
 }
 
+#include "../pathops/SkPathOpsCubic.h"
+
+//static int RootsValidT(const double A, const double B, const double C, double D, double s[3]);
+
+static void cubic_to_dcoeff(double p0, double p1, double p2, double p3, double coeff[4]) {
+    const Sk2s three(3);

[caryclark, 2015/04/30 12:59:41]

unused variable?

[reed1, 2015/04/30 13:34:22]

Done.

+    double p1minusp2 = p1 - p2;
+
+    double D = p0;
+    double A = p3 + 3 * p1minusp2 - D;
+    double B = 3 * (D - p1minusp2 - p1);
+    double C = 3 * (p1 - D);
+
+    coeff[0] = A;
+    coeff[1] = B;
+    coeff[2] = C;
+    coeff[3] = D;
+}
+
+static SkPoint dpoint_to_point(const SkDPoint& src) {

[caryclark, 2015/04/30 12:59:40]

this is the same as

src.asSkPoint()

[reed1, 2015/04/30 13:34:22]

Done.

+    return SkPoint::Make(SkDoubleToScalar(src.fX), SkDoubleToScalar(src.fY));
+}
+
+static bool cubic_dchop_at_root(const SkPoint src[4], const double coeff[4], SkPoint dst[7]) {
+    double t[3];
+    int roots = SkDCubic::RootsValidT(coeff[0], coeff[1], coeff[2], coeff[3], t);

[caryclark, 2015/04/30 12:59:41]

This doesn't take into account the case where the roots miss the end because of
numerical imprecision. Consider instead:

SkDCubic cubic;
cubic.set(src);
int roots = LineCubicIntersections::HorizontalIntersect(src, y, t)

and 

int roots = LineCubicIntersections::VerticalIntersect(src, y, t)

[caryclark, 2015/04/30 13:03:00]

On 2015/04/30 12:59:41, caryclark wrote:
 int roots = LineCubicIntersections::HorizontalIntersect(cubic, y, t)
 int roots = LineCubicIntersections::VerticalIntersect(cubic, y, t)

(fixed typos)

[reed1, 2015/04/30 13:34:22]

Done.

+    SkASSERT(roots <= 1);
+    if (roots > 0) {
+        SkDCubic cubic;
+        SkDCubicPair pair = cubic.set(src).chopAt(t[0]);
+        for (int i = 0; i < 7; ++i) {
+            dst[i] = dpoint_to_point(pair.pts[i]);
+        }
+        return true;
+    }
+    return false;
+}
+
+bool SkChopMonoCubicAtY(SkPoint src[4], SkScalar y, SkPoint dst[7]) {
+    double coeff[4];
+    cubic_to_dcoeff(src[0].fY, src[1].fY, src[2].fY, src[3].fY, coeff);
+    coeff[3] -= y;
+    return cubic_dchop_at_root(src, coeff, dst);
+}
+
+bool SkChopMonoCubicAtX(SkPoint src[4], SkScalar x, SkPoint dst[7]) {
+    double coeff[4];
+    cubic_to_dcoeff(src[0].fX, src[1].fX, src[2].fX, src[3].fX, coeff);
+    coeff[3] -= x;
+    return cubic_dchop_at_root(src, coeff, dst);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 /*  Find t value for quadratic [a, b, c] = d.
     Return 0 if there is no solution within [0, 1)
 */
 static SkScalar quad_solve(SkScalar a, SkScalar b, SkScalar c, SkScalar d) {
     // At^2 + Bt + C = d
     SkScalar A = a - 2 * b + c;
     SkScalar B = 2 * (b - a);
     SkScalar C = a - d;
@@ skipping 621 matching lines @@
         matrix.preScale(SK_Scalar1, -SK_Scalar1);
     }
     if (userMatrix) {
         matrix.postConcat(*userMatrix);
     }
     for (int i = 0; i < conicCount; ++i) {
         matrix.mapPoints(dst[i].fPts, 3);
     }
     return conicCount;
 }