GM (and fix) for drawArc capping issue

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"
@@ skipping 1187 matching lines @@
     SkScalar B = 2 * (b - a);
     SkScalar C = a - d;
 
     SkScalar    roots[2];
     int         count = SkFindUnitQuadRoots(A, B, C, roots);
 
     SkASSERT(count <= 1);
     return count == 1 ? roots[0] : 0;
 }
 
-/*  given a quad-curve and a point (x,y), chop the quad at that point and return
-    the new quad's offCurve point. Should only return false if the computed pos
-    is the start of the curve (i.e. root == 0)
+/*  given a quad-curve and a point (x,y), chop the quad at that point and place
+    the new off-curve point and endpoint into 'dest'. The new end point is used
+    (rather than (x,y)) to compensate for numerical inaccuracies.
+    Should only return false if the computed pos is the start of the curve 
+    (i.e. root == 0)
 */
-static bool quad_pt2OffCurve(const SkPoint quad[3], SkScalar x, SkScalar y, SkPoint* offCurve)
+static bool truncate_last_curve(const SkPoint quad[3], SkScalar x, SkScalar y, SkPoint* dest)
 {
     const SkScalar* base;
     SkScalar        value;
 
     if (SkScalarAbs(x) < SkScalarAbs(y)) {
         base = &quad[0].fX;
         value = x;
     } else {
         base = &quad[0].fY;
         value = y;
     }
 
     // note: this returns 0 if it thinks value is out of range, meaning the
     // root might return something outside of [0, 1)
     SkScalar t = quad_solve(base[0], base[2], base[4], value);
 
     if (t > 0)
     {
         SkPoint tmp[5];
         SkChopQuadAt(quad, tmp, t);
-        *offCurve = tmp[1];
+        dest[0] = tmp[1];
+        dest[1] = tmp[2];
         return true;
     } else {
         /*  t == 0 means either the value triggered a root outside of [0, 1)
             For our purposes, we can ignore the <= 0 roots, but we want to
             catch the >= 1 roots (which given our caller, will basically mean
             a root of 1, give-or-take numerical instability). If we are in the
             >= 1 case, return the existing offCurve point.
 
             The test below checks to see if we are close to the "end" of the
             curve (near base[4]). Rather than specifying a tolerance, I just
             check to see if value is on to the right/left of the middle point
             (depending on the direction/sign of the end points).
         */
         if ((base[0] < base[4] && value > base[2]) ||
             (base[0] > base[4] && value < base[2]))   // should root have been 1
         {
-            *offCurve = quad[1];
+            dest[0] = quad[1];
+            dest[1].set(x, y);
             return true;
         }
     }
     return false;
 }
 
 #ifdef SK_SCALAR_IS_FLOAT
 
 // Due to floating point issues (i.e., 1.0f - SK_ScalarRoot2Over2 !=
 // SK_ScalarRoot2Over2 - SK_ScalarTanPIOver8) a cruder root2over2
@@ skipping 92 matching lines @@
                 sameSign = false;
             }
             if ((absX < absY) == sameSign)
                 oct += 1;
         }
 
         int wholeCount = oct << 1;
         memcpy(quadPoints, gQuadCirclePts, (wholeCount + 1) * sizeof(SkPoint));
 
         const SkPoint* arc = &gQuadCirclePts[wholeCount];
-        if (quad_pt2OffCurve(arc, x, y, &quadPoints[wholeCount + 1]))
+        if (truncate_last_curve(arc, x, y, &quadPoints[wholeCount + 1]))
         {
-            quadPoints[wholeCount + 2].set(x, y);
             wholeCount += 2;
         }
         pointCount = wholeCount + 1;
     }
 
     // now handle counter-clockwise and the initial unitStart rotation
     SkMatrix    matrix;
     matrix.setSinCos(uStart.fY, uStart.fX);
     if (dir == kCCW_SkRotationDirection) {
         matrix.preScale(SK_Scalar1, -SK_Scalar1);
@@ skipping 279 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);
 }