Yet another attempt to fix quadratic circle approximation

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 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 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.
+    the new off-curve point and endpoint into 'dest'. 
     Should only return false if the computed pos is the start of the curve
     (i.e. root == 0)
 */
 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);
         dest[0] = tmp[1];
-        dest[1] = tmp[2];
+        dest[1].set(x, y);
         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
         {
             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
-// approximation is required to make the quad circle points convex. The
-// root of the problem is that with the root2over2 value in SkScalar.h
-// the arcs really are ever so slightly concave. Some alternative fixes
-// to this problem (besides just arbitrarily pushing out the mid-point as
-// is done here) are:
-//    Adjust all the points (not just the middle) to both better approximate
-//             the curve and remain convex
-//    Switch over to using cubics rather then quads
-//    Use a different method to create the mid-point (e.g., compute
-//             the two side points, average them, then move it out as needed
-#define SK_ScalarRoot2Over2_QuadCircle    0.7072f
-
+// SK_ScalarRoot2Over2 - SK_ScalarTanPIOver8), the "correct" off curve
+// control points cause the quadratic circle approximation to be concave.
+// SK_OffEps is used to pull in the off-curve control points a bit
+// to make the quadratic approximation convex.
+// Pulling the off-curve controls points in is preferable to pushing some
+// of the on-curve points off.
+#define SK_OffEps 0.0001f
 #else
-    #define SK_ScalarRoot2Over2_QuadCircle    SK_FixedRoot2Over2
+#define SK_OffEps 0
 #endif
 
 
 static const SkPoint gQuadCirclePts[kSkBuildQuadArcStorage] = {
     { SK_Scalar1,                      0                                  },
-    { SK_Scalar1,                      SK_ScalarTanPIOver8                },
-    { SK_ScalarRoot2Over2_QuadCircle,  SK_ScalarRoot2Over2_QuadCircle     },
-    { SK_ScalarTanPIOver8,             SK_Scalar1                         },
+    { SK_Scalar1 - SK_OffEps,          SK_ScalarTanPIOver8 - SK_OffEps    },
+    { SK_ScalarRoot2Over2,             SK_ScalarRoot2Over2                },
+    { SK_ScalarTanPIOver8 - SK_OffEps, SK_Scalar1 - SK_OffEps             },
 
     { 0,                               SK_Scalar1                         },
-    { -SK_ScalarTanPIOver8,            SK_Scalar1                         },
-    { -SK_ScalarRoot2Over2_QuadCircle, SK_ScalarRoot2Over2_QuadCircle     },
-    { -SK_Scalar1,                     SK_ScalarTanPIOver8                },
+    { -SK_ScalarTanPIOver8 + SK_OffEps,SK_Scalar1 - SK_OffEps             },
+    { -SK_ScalarRoot2Over2,            SK_ScalarRoot2Over2                },
+    { -SK_Scalar1 + SK_OffEps,         SK_ScalarTanPIOver8 - SK_OffEps    },
 
     { -SK_Scalar1,                     0                                  },
-    { -SK_Scalar1,                     -SK_ScalarTanPIOver8               },
-    { -SK_ScalarRoot2Over2_QuadCircle, -SK_ScalarRoot2Over2_QuadCircle    },
-    { -SK_ScalarTanPIOver8,            -SK_Scalar1                        },
+    { -SK_Scalar1 + SK_OffEps,         -SK_ScalarTanPIOver8 + SK_OffEps   },
+    { -SK_ScalarRoot2Over2,            -SK_ScalarRoot2Over2               },
+    { -SK_ScalarTanPIOver8 + SK_OffEps,-SK_Scalar1 + SK_OffEps            },
 
     { 0,                               -SK_Scalar1                        },
-    { SK_ScalarTanPIOver8,             -SK_Scalar1                        },
-    { SK_ScalarRoot2Over2_QuadCircle,  -SK_ScalarRoot2Over2_QuadCircle    },
-    { SK_Scalar1,                      -SK_ScalarTanPIOver8               },
+    { SK_ScalarTanPIOver8 - SK_OffEps, -SK_Scalar1 + SK_OffEps            },
+    { SK_ScalarRoot2Over2,             -SK_ScalarRoot2Over2               },
+    { SK_Scalar1 - SK_OffEps,          -SK_ScalarTanPIOver8 + SK_OffEps   },
 
     { SK_Scalar1,                      0                                  }
 };
 
 int SkBuildQuadArc(const SkVector& uStart, const SkVector& uStop,
                    SkRotationDirection dir, const SkMatrix* userMatrix,
                    SkPoint quadPoints[])
 {
     // rotate by x,y so that uStart is (1.0)
     SkScalar x = SkPoint::DotProduct(uStart, uStop);
@@ skipping 346 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);
 }