Stub for conic section max curvature

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"
 
-bool SkXRayCrossesLine(const SkXRay& pt, const SkPoint pts[2], bool* ambiguous) {
+bool SkXRayCrossesLine(const SkXRay& pt,
+                       const SkPoint pts[2],
+                       bool* ambiguous) {
     if (ambiguous) {
         *ambiguous = false;
     }
     // Determine quick discards.
     // Consider query line going exactly through point 0 to not
     // intersect, for symmetry with SkXRayCrossesMonotonicCubic.
     if (pt.fY == pts[0].fY) {
         if (ambiguous) {
             *ambiguous = true;
         }
@@ skipping 545 matching lines @@
     dst[4].set(x123, y123);
     dst[5].set(x23, y23);
     dst[6] = src[3];
 }
 
 static void flatten_double_cubic_extrema(SkScalar coords[14]) {
     coords[4] = coords[8] = coords[6];
 }
 
 /** Given 4 points on a cubic bezier, chop it into 1, 2, 3 beziers such that
-    the resulting beziers are monotonic in Y. This is called by the scan converter.
-    Depending on what is returned, dst[] is treated as follows
+    the resulting beziers are monotonic in Y. This is called by the scan
+    converter.  Depending on what is returned, dst[] is treated as follows:
     0   dst[0..3] is the original cubic
     1   dst[0..3] and dst[3..6] are the two new cubics
     2   dst[0..3], dst[3..6], dst[6..9] are the three new cubics
     If dst == null, it is ignored and only the count is returned.
 */
 int SkChopCubicAtYExtrema(const SkPoint src[4], SkPoint dst[10]) {
     SkScalar    tValues[2];
     int         roots = SkFindCubicExtrema(src[0].fY, src[1].fY, src[2].fY,
                                            src[3].fY, tValues);
 
@@ skipping 36 matching lines @@
     (BxCy - ByCx)t^2 + (AxCy - AyCx)t + AxBy - AyBx == 0
 */
 int SkFindCubicInflections(const SkPoint src[4], SkScalar tValues[]) {
     SkScalar    Ax = src[1].fX - src[0].fX;
     SkScalar    Ay = src[1].fY - src[0].fY;
     SkScalar    Bx = src[2].fX - 2 * src[1].fX + src[0].fX;
     SkScalar    By = src[2].fY - 2 * src[1].fY + src[0].fY;
     SkScalar    Cx = src[3].fX + 3 * (src[1].fX - src[2].fX) - src[0].fX;
     SkScalar    Cy = src[3].fY + 3 * (src[1].fY - src[2].fY) - src[0].fY;
 
-    return SkFindUnitQuadRoots(Bx*Cy - By*Cx, Ax*Cy - Ay*Cx, Ax*By - Ay*Bx, tValues);
+    return SkFindUnitQuadRoots(Bx*Cy - By*Cx,
+                               Ax*Cy - Ay*Cx,
+                               Ax*By - Ay*Bx,
+                               tValues);
 }
 
 int SkChopCubicAtInflections(const SkPoint src[], SkPoint dst[10]) {
     SkScalar    tValues[2];
     int         count = SkFindCubicInflections(src, tValues);
 
     if (dst) {
         if (count == 0) {
             memcpy(dst, src, 4 * sizeof(SkPoint));
         } else {
@@ skipping 310 matching lines @@
              && !SkScalarNearlyZero(eval.fY - pt.fY));
     if (pt.fX <= eval.fX) {
         if (ambiguous) {
             *ambiguous = pt_at_extremum;
         }
         return true;
     }
     return false;
 }
 
-int SkNumXRayCrossingsForCubic(const SkXRay& pt, const SkPoint cubic[4], bool* ambiguous) {
+int SkNumXRayCrossingsForCubic(const SkXRay& pt,
+                               const SkPoint cubic[4],
+                               bool* ambiguous) {
     int num_crossings = 0;
     SkPoint monotonic_cubics[10];
     int num_monotonic_cubics = SkChopCubicAtYExtrema(cubic, monotonic_cubics);
     if (ambiguous) {
         *ambiguous = false;
     }
     bool locally_ambiguous;
-    if (SkXRayCrossesMonotonicCubic(pt, &monotonic_cubics[0], &locally_ambiguous))
+    if (SkXRayCrossesMonotonicCubic(pt,
+                                    &monotonic_cubics[0],
+                                    &locally_ambiguous))
         ++num_crossings;
     if (ambiguous) {
         *ambiguous |= locally_ambiguous;
     }
     if (num_monotonic_cubics > 0)
-        if (SkXRayCrossesMonotonicCubic(pt, &monotonic_cubics[3], &locally_ambiguous))
+        if (SkXRayCrossesMonotonicCubic(pt,
+                                        &monotonic_cubics[3],
+                                        &locally_ambiguous))
             ++num_crossings;
     if (ambiguous) {
         *ambiguous |= locally_ambiguous;
     }
     if (num_monotonic_cubics > 1)
-        if (SkXRayCrossesMonotonicCubic(pt, &monotonic_cubics[6], &locally_ambiguous))
+        if (SkXRayCrossesMonotonicCubic(pt,
+                                        &monotonic_cubics[6],
+                                        &locally_ambiguous))
             ++num_crossings;
     if (ambiguous) {
         *ambiguous |= locally_ambiguous;
     }
     return num_crossings;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /*  Find t value for quadratic [a, b, c] = d.
@@ skipping 59 matching lines @@
             dest[1].set(x, y);
             return true;
         }
     }
     return false;
 }
 
 static const SkPoint gQuadCirclePts[kSkBuildQuadArcStorage] = {
 // The mid point of the quadratic arc approximation is half way between the two
 // control points. The float epsilon adjustment moves the on curve point out by
-// two bits, distributing the convex test error between the round rect approximation
-// and the convex cross product sign equality test.
-#define SK_MID_RRECT_OFFSET (SK_Scalar1 + SK_ScalarTanPIOver8 + FLT_EPSILON * 4) / 2
+// two bits, distributing the convex test error between the round rect
+// approximation and the convex cross product sign equality test.
+#define SK_MID_RRECT_OFFSET \
+    (SK_Scalar1 + SK_ScalarTanPIOver8 + FLT_EPSILON * 4) / 2
     { SK_Scalar1,            0                      },
     { SK_Scalar1,            SK_ScalarTanPIOver8    },
     { SK_MID_RRECT_OFFSET,   SK_MID_RRECT_OFFSET    },
     { SK_ScalarTanPIOver8,   SK_Scalar1             },
 
     { 0,                     SK_Scalar1             },
     { -SK_ScalarTanPIOver8,  SK_Scalar1             },
     { -SK_MID_RRECT_OFFSET,  SK_MID_RRECT_OFFSET    },
     { -SK_Scalar1,           SK_ScalarTanPIOver8    },
 
@@ skipping 76 matching lines @@
     if (dir == kCCW_SkRotationDirection) {
         matrix.preScale(SK_Scalar1, -SK_Scalar1);
     }
     if (userMatrix) {
         matrix.postConcat(*userMatrix);
     }
     matrix.mapPoints(quadPoints, pointCount);
     return pointCount;
 }
 
+
 ///////////////////////////////////////////////////////////////////////////////
-
+//
+// NURB representation for conics.  Helpful explanations at:
+//
+// http://citeseerx.ist.psu.edu/viewdoc/
+//   download?doi=10.1.1.44.5740&rep=rep1&type=ps
+// and
+// http://www.cs.mtu.edu/~shene/COURSES/cs3621/NOTES/spline/NURBS/RB-conics.html
+//
 // F = (A (1 - t)^2 + C t^2 + 2 B (1 - t) t w)
 //     ------------------------------------------
 //         ((1 - t)^2 + t^2 + 2 (1 - t) t w)
 //
 //   = {t^2 (P0 + P2 - 2 P1 w), t (-2 P0 + 2 P1 w), P0}
 //     ------------------------------------------------
 //             {t^2 (2 - 2 w), t (-2 + 2 w), 1}
 //
 
-// Take the parametric specification for the conic (either X or Y) and return
-// in coeff[] the coefficients for the simple quadratic polynomial
-//    coeff[0] for t^2
-//    coeff[1] for t
-//    coeff[2] for constant term
-//
 static SkScalar conic_eval_pos(const SkScalar src[], SkScalar w, SkScalar t) {
     SkASSERT(src);
     SkASSERT(t >= 0 && t <= SK_Scalar1);
 
     SkScalar    src2w = SkScalarMul(src[2], w);
     SkScalar    C = src[0];
     SkScalar    A = src[4] - 2 * src2w + C;
     SkScalar    B = 2 * (src2w - C);
     SkScalar numer = SkScalarMulAdd(SkScalarMulAdd(A, t, B), t, C);
 
@@ skipping 11 matching lines @@
 //  t^1 : (-2 P0 + 2 P2 + 4 P0 w - 4 P1 w)
 //  t^0 : -2 P0 w + 2 P1 w
 //
 //  We disregard magnitude, so we can freely ignore the denominator of F', and
 //  divide the numerator by 2
 //
 //    coeff[0] for t^2
 //    coeff[1] for t^1
 //    coeff[2] for t^0
 //
-static void conic_deriv_coeff(const SkScalar src[], SkScalar w, SkScalar coeff[3]) {
+static void conic_deriv_coeff(const SkScalar src[],
+                              SkScalar w,
+                              SkScalar coeff[3]) {
     const SkScalar P20 = src[4] - src[0];
     const SkScalar P10 = src[2] - src[0];
     const SkScalar wP10 = w * P10;
     coeff[0] = w * P20 - P20;
     coeff[1] = P20 - 2 * wP10;
     coeff[2] = wP10;
 }
 
 static SkScalar conic_eval_tan(const SkScalar coord[], SkScalar w, SkScalar t) {
     SkScalar coeff[3];
@@ skipping 69 matching lines @@
     tmp2[0].projectDown(&dst[0].fPts[1]);
     tmp2[1].projectDown(&dst[0].fPts[2]); dst[1].fPts[0] = dst[0].fPts[2];
     tmp2[2].projectDown(&dst[1].fPts[1]);
     dst[1].fPts[2] = fPts[2];
 
     // to put in "standard form", where w0 and w2 are both 1, we compute the
     // new w1 as sqrt(w1*w1/w0*w2)
     // or
     // w1 /= sqrt(w0*w2)
     //
-    // However, in our case, we know that for dst[0], w0 == 1, and for dst[1], w2 == 1
+    // However, in our case, we know that for dst[0]:
+    //     w0 == 1, and for dst[1], w2 == 1
     //
     SkScalar root = SkScalarSqrt(tmp2[1].fZ);
     dst[0].fW = tmp2[0].fZ / root;
     dst[1].fW = tmp2[2].fZ / root;
 }
 
 static SkScalar subdivide_w_value(SkScalar w) {
     return SkScalarSqrt(SK_ScalarHalf + w * SK_ScalarHalf);
 }
 
@@ skipping 121 matching lines @@
     }
     if (this->findYExtrema(&t)) {
         this->evalAt(t, &pts[count++]);
     }
     bounds->set(pts, count);
 }
 
 void SkConic::computeFastBounds(SkRect* bounds) const {
     bounds->set(fPts, 3);
 }
+
+bool SkConic::findMaxCurvature(SkScalar* t) const {
+    // TODO: Implement me
+    return false;
+}