fix zero-length tangent

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 112 matching lines @@
     SkScalar    A = src[4] - 2 * src[2] + C;
     SkScalar    B = 2 * (src[2] - C);
     return SkScalarMulAdd(SkScalarMulAdd(A, t, B), t, C);
 #else
     SkScalar    ab = SkScalarInterp(src[0], src[2], t);
     SkScalar    bc = SkScalarInterp(src[2], src[4], t);
     return SkScalarInterp(ab, bc, t);
 #endif
 }
 
-static SkScalar eval_quad_derivative(const SkScalar src[], SkScalar t) {
-    SkScalar A = src[4] - 2 * src[2] + src[0];
-    SkScalar B = src[2] - src[0];
-
-    return 2 * SkScalarMulAdd(A, t, B);
-}
-
 void SkQuadToCoeff(const SkPoint pts[3], SkPoint coeff[3]) {
     Sk2s p0 = from_point(pts[0]);
     Sk2s p1 = from_point(pts[1]);
     Sk2s p2 = from_point(pts[2]);
 
     Sk2s p1minus2 = p1 - p0;
 
     coeff[0] = to_point(p2 - p1 - p1 + p0);     // A * t^2
     coeff[1] = to_point(p1minus2 + p1minus2);   // B * t
     coeff[2] = pts[0];                          // C
 }
 
 void SkEvalQuadAt(const SkPoint src[3], SkScalar t, SkPoint* pt, SkVector* tangent) {
     SkASSERT(src);
     SkASSERT(t >= 0 && t <= SK_Scalar1);
 
     if (pt) {
         pt->set(eval_quad(&src[0].fX, t), eval_quad(&src[0].fY, t));
     }
     if (tangent) {
-        tangent->set(eval_quad_derivative(&src[0].fX, t),
-                     eval_quad_derivative(&src[0].fY, t));
+        *tangent = SkEvalQuadTangentAt(src, t);
     }
 }
 
 SkPoint SkEvalQuadAt(const SkPoint src[3], SkScalar t) {
     SkASSERT(src);
     SkASSERT(t >= 0 && t <= SK_Scalar1);
 
     const Sk2s t2(t);
 
     Sk2s P0 = from_point(src[0]);
     Sk2s P1 = from_point(src[1]);
     Sk2s P2 = from_point(src[2]);
 
     Sk2s B = P1 - P0;
     Sk2s A = P2 - P1 - B;
 
     return to_point((A * t2 + B+B) * t2 + P0);
 }
 
 SkVector SkEvalQuadTangentAt(const SkPoint src[3], SkScalar t) {
+    // The derivative equation is 2(b - a +(a - 2b +c)t). This returns a
+    // zero tangent vector when t is 0 or 1, and the control point is equal
+    // to the end point. In this case, use the quad end points to compute the tangent.
+    if ((t == 0 && src[0] == src[1]) || (t == 1 && src[1] == src[2])) {
+        return src[2] - src[0];
+    }
     SkASSERT(src);
     SkASSERT(t >= 0 && t <= SK_Scalar1);
 
     Sk2s P0 = from_point(src[0]);
     Sk2s P1 = from_point(src[1]);
     Sk2s P2 = from_point(src[2]);
 
     Sk2s B = P1 - P0;
     Sk2s A = P2 - P1 - B;
     Sk2s T = A * Sk2s(t) + B;
@@ skipping 199 matching lines @@
 
 void SkEvalCubicAt(const SkPoint src[4], SkScalar t, SkPoint* loc,
                    SkVector* tangent, SkVector* curvature) {
     SkASSERT(src);
     SkASSERT(t >= 0 && t <= SK_Scalar1);
 
     if (loc) {
         loc->set(eval_cubic(&src[0].fX, t), eval_cubic(&src[0].fY, t));
     }
     if (tangent) {
-        tangent->set(eval_cubic_derivative(&src[0].fX, t),
-                     eval_cubic_derivative(&src[0].fY, t));
+        // The derivative equation returns a zero tangent vector when t is 0 or 1, and the
+        // adjacent control point is equal to the end point. In this case, use the
+        // next control point or the end points to compute the tangent.
+        if ((t == 0 && src[0] == src[1]) || (t == 1 && src[2] == src[3])) {
+            if (t == 0) {
+                *tangent = src[2] - src[0];
+            } else {
+                *tangent = src[3] - src[1];
+            }
+            if (!tangent->fX && !tangent->fY) {
+                *tangent = src[3] - src[0];
+            }
+        } else {
+            tangent->set(eval_cubic_derivative(&src[0].fX, t),
+                         eval_cubic_derivative(&src[0].fY, t));
+        }
     }
     if (curvature) {
         curvature->set(eval_cubic_2ndDerivative(&src[0].fX, t),
                        eval_cubic_2ndDerivative(&src[0].fY, t));
     }
 }
 
 /** Cubic'(t) = At^2 + Bt + C, where
     A = 3(-a + 3(b - c) + d)
     B = 6(a - 2b + c)
@@ skipping 756 matching lines @@
                               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];
-    conic_deriv_coeff(coord, w, coeff);
-    return t * (t * coeff[0] + coeff[1]) + coeff[2];
-}
-
 static bool conic_find_extrema(const SkScalar src[], SkScalar w, SkScalar* t) {
     SkScalar coeff[3];
     conic_deriv_coeff(src, w, coeff);
 
     SkScalar tValues[2];
     int roots = SkFindUnitQuadRoots(coeff[0], coeff[1], coeff[2], tValues);
     SkASSERT(0 == roots || 1 == roots);
 
     if (1 == roots) {
         *t = tValues[0];
@@ skipping 30 matching lines @@
 }
 
 void SkConic::evalAt(SkScalar t, SkPoint* pt, SkVector* tangent) const {
     SkASSERT(t >= 0 && t <= SK_Scalar1);
 
     if (pt) {
         pt->set(conic_eval_pos(&fPts[0].fX, fW, t),
                 conic_eval_pos(&fPts[0].fY, fW, t));
     }
     if (tangent) {
-        tangent->set(conic_eval_tan(&fPts[0].fX, fW, t),
-                     conic_eval_tan(&fPts[0].fY, fW, t));
+        *tangent = evalTangentAt(t);
     }
 }
 
 void SkConic::chopAt(SkScalar t, SkConic dst[2]) const {
     SkP3D tmp[3], tmp2[3];
 
     ratquad_mapTo3D(fPts, fW, tmp);
 
     p3d_interp(&tmp[0].fX, &tmp2[0].fX, t);
     p3d_interp(&tmp[0].fY, &tmp2[0].fY, t);
@@ skipping 37 matching lines @@
     Sk2s numer = quad_poly_eval(A, B, C, tt);
 
     B = times_2(ww - one);
     A = Sk2s(0)-B;
     Sk2s denom = quad_poly_eval(A, B, one, tt);
 
     return to_point(numer / denom);
 }
 
 SkVector SkConic::evalTangentAt(SkScalar t) const {
+    // The derivative equation returns a zero tangent vector when t is 0 or 1,
+    // and the control point is equal to the end point.
+    // In this case, use the conic endpoints to compute the tangent.
+    if ((t == 0 && fPts[0] == fPts[1]) || (t == 1 && fPts[1] == fPts[2])) {
+        return fPts[2] - fPts[0];
+    }
     Sk2s p0 = from_point(fPts[0]);
     Sk2s p1 = from_point(fPts[1]);
     Sk2s p2 = from_point(fPts[2]);
     Sk2s ww(fW);
 
     Sk2s p20 = p2 - p0;
     Sk2s p10 = p1 - p0;
 
     Sk2s C = ww * p10;
     Sk2s A = ww * p20 - p20;
@@ skipping 275 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;
 }