check in direct quad length measure

src/core/SkPathMeasure.cpp

 
 /*
  * Copyright 2008 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 "SkPathMeasure.h"
@@ skipping 72 matching lines @@
 static bool cubic_too_curvy(const SkPoint pts[4]) {
     return  cheap_dist_exceeds_limit(pts[1],
                          SkScalarInterp(pts[0].fX, pts[3].fX, SK_Scalar1/3),
                          SkScalarInterp(pts[0].fY, pts[3].fY, SK_Scalar1/3))
                          ||
             cheap_dist_exceeds_limit(pts[2],
                          SkScalarInterp(pts[0].fX, pts[3].fX, SK_Scalar1*2/3),
                          SkScalarInterp(pts[0].fY, pts[3].fY, SK_Scalar1*2/3));
 }
 
+/* from http://www.malczak.linuxpl.com/blog/quadratic-bezier-curve-length/ */
+static SkScalar compute_quad_len(const SkPoint pts[3]) {
+     SkPoint a,b;
+     a.fX = pts[0].fX - 2 * pts[1].fX + pts[2].fX;
+     a.fY = pts[0].fY - 2 * pts[1].fY + pts[2].fY;
+     b.fX = 2 * (pts[1].fX - pts[0].fX);
+     b.fY = 2 * (pts[1].fY - pts[0].fY);
+     SkScalar A = 4 * (a.fX * a.fX + a.fY * a.fY);
+     SkScalar B = 4 * (a.fX * b.fX + a.fY * b.fY);
+     SkScalar C =      b.fX * b.fX + b.fY * b.fY;
+
+     SkScalar Sabc = 2 * SkScalarSqrt(A + B + C);
+     SkScalar A_2  = SkScalarSqrt(A);
+     SkScalar A_32 = 2 * A * A_2;
+     SkScalar C_2  = 2 * SkScalarSqrt(C);
+     SkScalar BA   = B / A_2;
+
+     return (A_32 * Sabc + A_2 * B * (Sabc - C_2) +
+            (4 * C * A - B * B) * SkScalarLog((2 * A_2 + BA + Sabc) / (BA + C_2))) / (4 * A_32);
+}
+
+
 SkScalar SkPathMeasure::compute_quad_segs(const SkPoint pts[3],
                           SkScalar distance, int mint, int maxt, int ptIndex) {
     if (tspan_big_enough(maxt - mint) && quad_too_curvy(pts)) {
         SkPoint tmp[5];
         int     halft = (mint + maxt) >> 1;
 
         SkChopQuadAtHalf(pts, tmp);
         distance = this->compute_quad_segs(tmp, distance, mint, halft, ptIndex);
         distance = this->compute_quad_segs(&tmp[2], distance, halft, maxt, ptIndex);
     } else {
@@ skipping 99 matching lines @@
                     seg->fPtIndex = ptIndex;
                     seg->fType = kLine_SegType;
                     seg->fTValue = kMaxTValue;
                     fPts.append(1, pts + 1);
                     ptIndex++;
                 }
             } break;
 
             case SkPath::kQuad_Verb: {
                 SkScalar prevD = distance;
-                distance = this->compute_quad_segs(pts, distance, 0, kMaxTValue, ptIndex);
+                if (false) {
+                    SkScalar length = compute_quad_len(pts);
+                    if (length) {
+                        distance += length;
+                        Segment* seg = fSegments.append();
+                        seg->fDistance = distance;
+                        seg->fPtIndex = ptIndex;
+                        seg->fType = kQuad_SegType;
+                        seg->fTValue = kMaxTValue;
+                    }
+                } else {
+                    distance = this->compute_quad_segs(pts, distance, 0, kMaxTValue, ptIndex);
+                }
                 if (distance > prevD) {
                     fPts.append(2, pts + 1);
                     ptIndex += 2;
                 }
             } break;
 
             case SkPath::kConic_Verb: {
                 const SkConic conic(pts, fIter.conicWeight());
                 SkScalar prevD = distance;
                 distance = this->compute_conic_segs(conic, distance, 0, kMaxTValue, ptIndex);
@@ skipping 410 matching lines @@
 
     for (int i = 0; i < fSegments.count(); i++) {
         const Segment* seg = &fSegments[i];
         SkDebugf("pathmeas: seg[%d] distance=%g, point=%d, t=%g, type=%d\n",
                 i, seg->fDistance, seg->fPtIndex, seg->getScalarT(),
                  seg->fType);
     }
 }
 
 #endif