use conics

src/core/SkPath.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 "SkBuffer.h"
 #include "SkErrorInternals.h"
+#include "SkGeometry.h"
 #include "SkMath.h"
 #include "SkPath.h"
 #include "SkPathRef.h"
 #include "SkRRect.h"
 #include "SkThread.h"
 
+#define SK_SUPPORT_LEGACY_ADDOVAL
+
 ////////////////////////////////////////////////////////////////////////////
 
 /**
  *  Path.bounds is defined to be the bounds of all the control points.
  *  If we called bounds.join(r) we would skip r if r was empty, which breaks
  *  our promise. Hence we have a custom joiner that doesn't look at emptiness
  */
 static void joinNoEmptyChecks(SkRect* dst, const SkRect& src) {
     dst->fLeft = SkMinScalar(dst->fLeft, src.fLeft);
     dst->fTop = SkMinScalar(dst->fTop, src.fTop);
@@ skipping 196 matching lines @@
         SkScalar xT = SkScalarMul(v.fX, rect.fTop - edgeBegin->fY);
         SkScalar yR = SkScalarMul(v.fY, rect.fRight - edgeBegin->fX);
         SkScalar xB = SkScalarMul(v.fX, rect.fBottom - edgeBegin->fY);
         if ((xT < yL) || (xT < yR) || (xB < yL) || (xB < yR)) {
             return false;
         }
     }
     return true;
 }
 
+// TODO: clean this up (e.g. add printing?) and add to SkTypes?
+static inline void SkCheck(bool predicate) {

[caryclark, 2014/12/17 15:52:43]

Is this different from SK_ALWAYSBREAK() ?

[bsalomon, 2014/12/17 16:00:26]

Seems weird to have this one-off here. Can this be separated out?

[reed1, 2014/12/17 16:12:38]

Will replace with ALWAYSBREAK, and propose the new name convention separately (I
NEVER remember that ALWAYSBREAK doesn't do it always, but is actually performing
a check).

+    if (!predicate) {
+        sk_throw();
+    }
+}
+
 bool SkPath::conservativelyContainsRect(const SkRect& rect) const {
     // This only handles non-degenerate convex paths currently.
     if (kConvex_Convexity != this->getConvexity()) {
         return false;
     }
 
     Direction direction;
     if (!this->cheapComputeDirection(&direction)) {
         return false;
     }
@@ skipping 31 matching lines @@
                 SkDEBUGCODE(++segmentCount);
                 nextPt = 3;
                 break;
             case kClose_Verb:
                 SkDEBUGCODE(++closeCount;)
                 break;
             default:
                 SkDEBUGFAIL("unknown verb");
         }
         if (-1 != nextPt) {
-            if (!check_edge_against_rect(prevPt, pts[nextPt], rect, direction)) {
-                return false;
+            if (SkPath::kConic_Verb == verb) {
+                SkConic orig;
+                orig.set(pts, iter.conicWeight());
+                SkPoint quadPts[5];
+                int count = orig.chopIntoQuadsPOW2(quadPts, 1);
+                SkCheck(2 == count);
+
+                if (!check_edge_against_rect(quadPts[0], quadPts[2], rect, direction)) {
+                    return false;
+                }
+                if (!check_edge_against_rect(quadPts[2], quadPts[4], rect, direction)) {
+                    return false;
+                }
+            } else {
+                if (!check_edge_against_rect(prevPt, pts[nextPt], rect, direction)) {
+                    return false;
+                }
             }
             prevPt = pts[nextPt];
         }
     }
 
     return check_edge_against_rect(prevPt, firstPt, rect, direction);
 }
 
 uint32_t SkPath::getGenerationID() const {
     uint32_t genID = fPathRef->genID();
@@ skipping 869 matching lines @@
     if (isOval) {
         fDirection = dir;
     } else {
         fDirection = kUnknown_Direction;
     }
 
     SkAutoDisableDirectionCheck addc(this);
 
     SkAutoPathBoundsUpdate apbu(this, oval);
 
+#ifdef SK_SUPPORT_LEGACY_ADDOVAL
     SkScalar    cx = oval.centerX();
     SkScalar    cy = oval.centerY();
     SkScalar    rx = SkScalarHalf(oval.width());
     SkScalar    ry = SkScalarHalf(oval.height());
 
     SkScalar    sx = SkScalarMul(rx, SK_ScalarTanPIOver8);
     SkScalar    sy = SkScalarMul(ry, SK_ScalarTanPIOver8);
     SkScalar    mx = SkScalarMul(rx, SK_ScalarRoot2Over2);
     SkScalar    my = SkScalarMul(ry, SK_ScalarRoot2Over2);
 
     /*
-        To handle imprecision in computing the center and radii, we revert to
-        the provided bounds when we can (i.e. use oval.fLeft instead of cx-rx)
-        to ensure that we don't exceed the oval's bounds *ever*, since we want
-        to use oval for our fast-bounds, rather than have to recompute it.
-    */
+     To handle imprecision in computing the center and radii, we revert to
+     the provided bounds when we can (i.e. use oval.fLeft instead of cx-rx)
+     to ensure that we don't exceed the oval's bounds *ever*, since we want
+     to use oval for our fast-bounds, rather than have to recompute it.
+     */
     const SkScalar L = oval.fLeft;      // cx - rx
     const SkScalar T = oval.fTop;       // cy - ry
     const SkScalar R = oval.fRight;     // cx + rx
     const SkScalar B = oval.fBottom;    // cy + ry
 
     this->incReserve(17);   // 8 quads + close
     this->moveTo(R, cy);
     if (dir == kCCW_Direction) {
         this->quadTo(      R, cy - sy, cx + mx, cy - my);
         this->quadTo(cx + sx,       T, cx     ,       T);
         this->quadTo(cx - sx,       T, cx - mx, cy - my);
         this->quadTo(      L, cy - sy,       L, cy     );
         this->quadTo(      L, cy + sy, cx - mx, cy + my);
         this->quadTo(cx - sx,       B, cx     ,       B);
         this->quadTo(cx + sx,       B, cx + mx, cy + my);
         this->quadTo(      R, cy + sy,       R, cy     );
     } else {
         this->quadTo(      R, cy + sy, cx + mx, cy + my);
         this->quadTo(cx + sx,       B, cx     ,       B);
         this->quadTo(cx - sx,       B, cx - mx, cy + my);
         this->quadTo(      L, cy + sy,       L, cy     );
         this->quadTo(      L, cy - sy, cx - mx, cy - my);
         this->quadTo(cx - sx,       T, cx     ,       T);
         this->quadTo(cx + sx,       T, cx + mx, cy - my);
         this->quadTo(      R, cy - sy,       R, cy     );
     }
+#else
+    const SkScalar L = oval.fLeft;
+    const SkScalar T = oval.fTop;
+    const SkScalar R = oval.fRight;
+    const SkScalar B = oval.fBottom;
+    const SkScalar cx = oval.centerX();
+    const SkScalar cy = oval.centerY();
+    const SkScalar weight = SK_ScalarRoot2Over2;
+
+    this->incReserve(9);   // move + 4 conics
+    this->moveTo(R, cy);
+    if (dir == kCCW_Direction) {
+        this->conicTo(R, T, cx, T, weight);
+        this->conicTo(L, T, L, cy, weight);
+        this->conicTo(L, B, cx, B, weight);
+        this->conicTo(R, B, R, cy, weight);
+    } else {
+        this->conicTo(R, B, cx, B, weight);
+        this->conicTo(L, B, L, cy, weight);
+        this->conicTo(L, T, cx, T, weight);
+        this->conicTo(R, T, R, cy, weight);
+    }
+#endif
     this->close();
 
     SkPathRef::Editor ed(&fPathRef);
 
     ed.setIsOval(isOval);
 }
 
 void SkPath::addCircle(SkScalar x, SkScalar y, SkScalar r, Direction dir) {
     if (r > 0) {
         SkRect  rect;
@@ skipping 295 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkPath::offset(SkScalar dx, SkScalar dy, SkPath* dst) const {
     SkMatrix    matrix;
 
     matrix.setTranslate(dx, dy);
     this->transform(matrix, dst);
 }
 
-#include "SkGeometry.h"
-
-static void subdivide_quad_to(SkPath* path, const SkPoint pts[3],
-                              int level = 2) {
-    if (--level >= 0) {
-        SkPoint tmp[5];
-
-        SkChopQuadAtHalf(pts, tmp);
-        subdivide_quad_to(path, &tmp[0], level);
-        subdivide_quad_to(path, &tmp[2], level);
-    } else {
-        path->quadTo(pts[1], pts[2]);
-    }
-}
-
 static void subdivide_cubic_to(SkPath* path, const SkPoint pts[4],
                                int level = 2) {
     if (--level >= 0) {
         SkPoint tmp[7];
 
         SkChopCubicAtHalf(pts, tmp);
         subdivide_cubic_to(path, &tmp[0], level);
         subdivide_cubic_to(path, &tmp[3], level);
     } else {
         path->cubicTo(pts[1], pts[2], pts[3]);
@@ skipping 16 matching lines @@
 
         while ((verb = iter.next(pts, false)) != kDone_Verb) {
             switch (verb) {
                 case kMove_Verb:
                     tmp.moveTo(pts[0]);
                     break;
                 case kLine_Verb:
                     tmp.lineTo(pts[1]);
                     break;
                 case kQuad_Verb:
-                    subdivide_quad_to(&tmp, pts);
+                    // promote the quad to a conic
+                    tmp.conicTo(pts[1], pts[2],
+                                SkConic::TransformW(pts, SK_Scalar1, matrix));
                     break;
                 case kConic_Verb:
-                    SkDEBUGFAIL("TODO: compute new weight");
-                    tmp.conicTo(pts[1], pts[2], iter.conicWeight());
+                    tmp.conicTo(pts[1], pts[2],
+                                SkConic::TransformW(pts, iter.conicWeight(), matrix));
                     break;
                 case kCubic_Verb:
                     subdivide_cubic_to(&tmp, pts);
                     break;
                 case kClose_Verb:
                     tmp.close();
                     break;
                 default:
                     SkDEBUGFAIL("unknown verb");
                     break;
@@ skipping 1268 matching lines @@
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }