Fastpath lines in SkCurveMeasure

src/utils/SkCurveMeasure.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCurveMeasure.h"
 #include "SkGeometry.h"
 
@@ skipping 59 matching lines @@
                                             const Sk8f (&xCoeff)[3],
                                             const Sk8f (&yCoeff)[3],
                                             const SkSegType segType) {
     Sk8f x;
     Sk8f y;
     switch (segType) {
         case kQuad_SegType:
             x = xCoeff[0]*ts + xCoeff[1];
             y = yCoeff[0]*ts + yCoeff[1];
             break;
-        case kLine_SegType:
-            // length of line derivative is constant
-            // and we precompute it in the constructor
-            return xCoeff[0];
         case kCubic_SegType:
             x = (xCoeff[0]*ts + xCoeff[1])*ts + xCoeff[2];
             y = (yCoeff[0]*ts + yCoeff[1])*ts + yCoeff[2];
             break;
         case kConic_SegType:
             UNIMPLEMENTED;
             break;
         default:
             UNIMPLEMENTED;
     }
@@ skipping 16 matching lines @@
             float Cy = pts[2].y();
 
             // precompute coefficients for derivative
             xCoeff[0] = Sk8f(2.0f*(Ax - 2*Bx + Cx));
             xCoeff[1] = Sk8f(2.0f*(Bx - Ax));
 
             yCoeff[0] = Sk8f(2.0f*(Ay - 2*By + Cy));
             yCoeff[1] = Sk8f(2.0f*(By - Ay));
         }
             break;
-        case kLine_SegType: {
-            // the length of the derivative of a line is constant
-            // we put in in both coeff arrays for consistency's sake
-            SkScalar length = (pts[1] - pts[0]).length();
-            xCoeff[0] = Sk8f(length);
-            yCoeff[0] = Sk8f(length);
-        }
-            break;
         case kCubic_SegType:
         {
             float Ax = pts[0].x();
             float Bx = pts[1].x();
             float Cx = pts[2].x();
             float Dx = pts[3].x();
             float Ay = pts[0].y();
             float By = pts[1].y();
             float Cy = pts[2].y();
             float Dy = pts[3].y();
@@ skipping 38 matching lines @@
     : fSegType(segType) {
     switch (fSegType) {
         case SkSegType::kQuad_SegType:
             for (size_t i = 0; i < 3; i++) {
                 fPts[i] = pts[i];
             }
             break;
         case SkSegType::kLine_SegType:
             fPts[0] = pts[0];
             fPts[1] = pts[1];
+            fLength = (fPts[1] - fPts[0]).length();
             break;
         case SkSegType::kCubic_SegType:
             for (size_t i = 0; i < 4; i++) {
                 fPts[i] = pts[i];
             }
             break;
         case SkSegType::kConic_SegType:
             for (size_t i = 0; i < 4; i++) {
                 fPts[i] = pts[i];
             }
             break;
         default:
             UNIMPLEMENTED;
             break;
     }
-    fIntegrator = ArcLengthIntegrator(fPts, fSegType);
+    if (kLine_SegType != segType) {
+        fIntegrator = ArcLengthIntegrator(fPts, fSegType);
+    }
 }
 
 SkScalar SkCurveMeasure::getLength() {
     if (-1.0f == fLength) {
         fLength = fIntegrator.computeLength(1.0f);
     }
     return fLength;
 }
 
 // Given an arc length targetLength, we want to determine what t
 // gives us the corresponding arc length along the curve.
 // We do this by letting the arc length integral := f(t) and
 // solving for the root of the equation f(t) - targetLength = 0
 // using Newton's method and lerp-bisection.
 // The computationally expensive parts are the integral approximation
 // at each step, and computing the derivative of the arc length integral,
 // which is equal to the length of the tangent (so we have to do a sqrt).
 
 SkScalar SkCurveMeasure::getTime(SkScalar targetLength) {
     if (targetLength == 0.0f) {
         return 0.0f;
     }
 
     SkScalar currentLength = getLength();
 
     if (SkScalarNearlyEqual(targetLength, currentLength)) {
         return 1.0f;
     }
+    if (kLine_SegType == fSegType) {
+        return targetLength / currentLength;
+    }
 
     // initial estimate of t is percentage of total length
     SkScalar currentT = targetLength / currentLength;
     SkScalar prevT = -1.0f;
     SkScalar newT;
 
     SkScalar minT = 0.0f;
     SkScalar maxT = 1.0f;
 
     int iterations = 0;
@@ skipping 67 matching lines @@
     if (time) {
         *time = t;
     }
     if (pos) {
         *pos = evaluate(fPts, fSegType, t);
     }
     if (tan) {
         *tan = evaluateDerivative(fPts, fSegType, t);
     }
 }