increase coverage of SkPath.cpp, remove unused code

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"
@@ skipping 644 matching lines @@
     SkPathRef::Editor(&fPathRef, inc, inc);
     SkDEBUGCODE(this->validate();)
 }
 
 void SkPath::moveTo(SkScalar x, SkScalar y) {
     SkDEBUGCODE(this->validate();)
 
     SkPathRef::Editor ed(&fPathRef);
 
     // remember our index
-    fLastMoveToIndex = ed.pathRef()->countPoints();
+    fLastMoveToIndex = fPathRef->countPoints();
 
     ed.growForVerb(kMove_Verb)->set(x, y);
 }
 
 void SkPath::rMoveTo(SkScalar x, SkScalar y) {
     SkPoint pt;
     this->getLastPt(&pt);
     this->moveTo(pt.fX + x, pt.fY + y);
 }
 
@@ skipping 423 matching lines @@
         this->addOval(bounds, dir);
 #ifdef SK_IGNORE_QUAD_RR_CORNERS_OPT
     } else if (rrect.isSimple()) {
         const SkVector& rad = rrect.getSimpleRadii();
         this->addRoundRect(bounds, rad.x(), rad.y(), dir);
 #endif
     } else {
         fDirection = this->hasOnlyMoveTos() ? dir : kUnknown_Direction;
 
         SkAutoPathBoundsUpdate apbu(this, bounds);
-        SkAutoDisableDirectionCheck(this);
+        SkAutoDisableDirectionCheck addc(this);
 
         this->incReserve(21);
         if (kCW_Direction == dir) {
             this->moveTo(bounds.fLeft,
                          bounds.fBottom - rrect.fRadii[SkRRect::kLowerLeft_Corner].fY);
             add_corner_quads(this, rrect, SkRRect::kUpperLeft_Corner, dir);
             add_corner_quads(this, rrect, SkRRect::kUpperRight_Corner, dir);
             add_corner_quads(this, rrect, SkRRect::kLowerRight_Corner, dir);
             add_corner_quads(this, rrect, SkRRect::kLowerLeft_Corner, dir);
         } else {
             this->moveTo(bounds.fLeft,
                          bounds.fTop + rrect.fRadii[SkRRect::kUpperLeft_Corner].fY);
             add_corner_quads(this, rrect, SkRRect::kLowerLeft_Corner, dir);
             add_corner_quads(this, rrect, SkRRect::kLowerRight_Corner, dir);
             add_corner_quads(this, rrect, SkRRect::kUpperRight_Corner, dir);
             add_corner_quads(this, rrect, SkRRect::kUpperLeft_Corner, dir);
         }
         this->close();
     }
 }
 
 bool SkPath::hasOnlyMoveTos() const {
     int count = fPathRef->countVerbs();
     const uint8_t* verbs = const_cast<const SkPathRef*>(fPathRef.get())->verbsMemBegin();
     for (int i = 0; i < count; ++i) {
         if (*verbs == kLine_Verb ||
             *verbs == kQuad_Verb ||
+            *verbs == kConic_Verb ||
             *verbs == kCubic_Verb) {
             return false;
         }
         ++verbs;
     }
     return true;
 }
 
 #ifdef SK_IGNORE_QUAD_RR_CORNERS_OPT
 #define CUBIC_ARC_FACTOR    ((SK_ScalarSqrt2 - SK_Scalar1) * 4 / 3)
@@ skipping 25 matching lines @@
     bool skip_vert = ry >= halfH;
 
     if (skip_hori && skip_vert) {
         this->addOval(rect, dir);
         return;
     }
 
     fDirection = this->hasOnlyMoveTos() ? dir : kUnknown_Direction;
 
     SkAutoPathBoundsUpdate apbu(this, rect);
-    SkAutoDisableDirectionCheck(this);
+    SkAutoDisableDirectionCheck addc(this);
 
     if (skip_hori) {
         rx = halfW;
     } else if (skip_vert) {
         ry = halfH;
     }
     SkScalar    sx = SkScalarMul(rx, CUBIC_ARC_FACTOR);
     SkScalar    sy = SkScalarMul(ry, CUBIC_ARC_FACTOR);
 
     this->incReserve(17);
@@ skipping 311 matching lines @@
         2,  // kConic
         3,  // kCubic
         0,  // kClose
         0   // kDone
     };
 
     SkASSERT(verb < SK_ARRAY_COUNT(gPtsInVerb));
     return gPtsInVerb[verb];
 }
 
-// ignore the initial moveto, and stop when the 1st contour ends
-void SkPath::pathTo(const SkPath& path) {
-    int i, vcount = path.fPathRef->countVerbs();
-    // exit early if the path is empty, or just has a moveTo.
-    if (vcount < 2) {
-        return;
-    }
-
-    SkPathRef::Editor(&fPathRef, vcount, path.countPoints());
-
-    fIsOval = false;
-
-    const uint8_t* verbs = path.fPathRef->verbs();
-    // skip the initial moveTo
-    const SkPoint*  pts = path.fPathRef->points() + 1;
-    const SkScalar* conicWeight = path.fPathRef->conicWeights();
-
-    SkASSERT(verbs[~0] == kMove_Verb);
-    for (i = 1; i < vcount; i++) {
-        switch (verbs[~i]) {
-            case kLine_Verb:
-                this->lineTo(pts[0].fX, pts[0].fY);
-                break;
-            case kQuad_Verb:
-                this->quadTo(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY);
-                break;
-            case kConic_Verb:
-                this->conicTo(pts[0], pts[1], *conicWeight++);
-                break;
-            case kCubic_Verb:
-                this->cubicTo(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY);
-                break;
-            case kClose_Verb:
-                return;
-        }
-        pts += pts_in_verb(verbs[~i]);
-    }
-}
-
 // ignore the last point of the 1st contour
 void SkPath::reversePathTo(const SkPath& path) {
     int i, vcount = path.fPathRef->countVerbs();
     // exit early if the path is empty, or just has a moveTo.
     if (vcount < 2) {
         return;
     }
 
     SkPathRef::Editor(&fPathRef, vcount, path.countPoints());
 
@@ skipping 185 matching lines @@
             dst->fDirection = kUnknown_Direction;
         } else {
             SkScalar det2x2 =
                 SkScalarMul(matrix.get(SkMatrix::kMScaleX), matrix.get(SkMatrix::kMScaleY)) -
                 SkScalarMul(matrix.get(SkMatrix::kMSkewX), matrix.get(SkMatrix::kMSkewY));
             if (det2x2 < 0) {
                 dst->fDirection = SkPath::OppositeDirection(static_cast<Direction>(fDirection));
             } else if (det2x2 > 0) {
                 dst->fDirection = fDirection;
             } else {
+                dst->fConvexity = kUnknown_Convexity;
                 dst->fDirection = kUnknown_Direction;
             }
         }
 
         // It's an oval only if it stays a rect.
         dst->fIsOval = fIsOval && matrix.rectStaysRect();
 
         SkDEBUGCODE(dst->validate();)
     }
 }
@@ skipping 544 matching lines @@
 #define kValueNeverReturnedBySign   2
 
 static bool AlmostEqual(SkScalar compA, SkScalar compB) {
     // The error epsilon was empirically derived; worse case round rects
     // with a mid point outset by 2x float epsilon in tests had an error
     // of 12.
     const int epsilon = 16;
     if (!SkScalarIsFinite(compA) || !SkScalarIsFinite(compB)) {
         return false;
     }
-    if (sk_float_abs(compA) <= FLT_EPSILON && sk_float_abs(compB) <= FLT_EPSILON) {
-        return true;
-    }
+    // no need to check for small numbers because SkPath::Iter has removed degenerate values
     int aBits = SkFloatAs2sCompliment(compA);
     int bBits = SkFloatAs2sCompliment(compB);
     return aBits < bBits + epsilon && bBits < aBits + epsilon;
 }
 
 // only valid for a single contour
 struct Convexicator {
     Convexicator()
     : fPtCount(0)
     , fConvexity(SkPath::kConvex_Convexity)
@@ skipping 290 matching lines @@
         } else if (x > max) {
             max = x;
             maxIndex = i;
         }
     }
     *maxIndexPtr = maxIndex;
     return minIndex;
 }
 
 static void crossToDir(SkScalar cross, SkPath::Direction* dir) {
-    if (dir) {
-        *dir = cross > 0 ? SkPath::kCW_Direction : SkPath::kCCW_Direction;
-    }
-}
-
-#if 0
-#include "SkString.h"
-#include "../utils/SkParsePath.h"
-static void dumpPath(const SkPath& path) {
-    SkString str;
-    SkParsePath::ToSVGString(path, &str);
-    SkDebugf("%s\n", str.c_str());
-}
-#endif
-
-namespace {
-// for use with convex_dir_test
-double mul(double a, double b) { return a * b; }
-SkScalar mul(SkScalar a, SkScalar b) { return SkScalarMul(a, b); }
-double toDouble(SkScalar a) { return SkScalarToDouble(a); }
-SkScalar toScalar(SkScalar a) { return a; }
-
-// determines the winding direction of a convex polygon with the precision
-// of T. CAST_SCALAR casts an SkScalar to T.
-template <typename T, T (CAST_SCALAR)(SkScalar)>
-bool convex_dir_test(int n, const SkPoint pts[], SkPath::Direction* dir) {
-    // we find the first three points that form a non-degenerate
-    // triangle. If there are no such points then the path is
-    // degenerate. The first is always point 0. Now we find the second
-    // point.
-    int i = 0;
-    enum { kX = 0, kY = 1 };
-    T v0[2];
-    while (1) {
-        v0[kX] = CAST_SCALAR(pts[i].fX) - CAST_SCALAR(pts[0].fX);
-        v0[kY] = CAST_SCALAR(pts[i].fY) - CAST_SCALAR(pts[0].fY);
-        if (v0[kX] || v0[kY]) {
-            break;
-        }
-        if (++i == n - 1) {
-            return false;
-        }
-    }
-    // now find a third point that is not colinear with the first two
-    // points and check the orientation of the triangle (which will be
-    // the same as the orientation of the path).
-    for (++i; i < n; ++i) {
-        T v1[2];
-        v1[kX] = CAST_SCALAR(pts[i].fX) - CAST_SCALAR(pts[0].fX);
-        v1[kY] = CAST_SCALAR(pts[i].fY) - CAST_SCALAR(pts[0].fY);
-        T cross = mul(v0[kX], v1[kY]) - mul(v0[kY], v1[kX]);
-        if (0 != cross) {
-            *dir = cross > 0 ? SkPath::kCW_Direction : SkPath::kCCW_Direction;
-            return true;
-        }
-    }
-    return false;
-}
+    *dir = cross > 0 ? SkPath::kCW_Direction : SkPath::kCCW_Direction;
 }
 
 /*
  *  We loop through all contours, and keep the computed cross-product of the
  *  contour that contained the global y-max. If we just look at the first
  *  contour, we may find one that is wound the opposite way (correctly) since
  *  it is the interior of a hole (e.g. 'o'). Thus we must find the contour
  *  that is outer most (or at least has the global y-max) before we can consider
  *  its cross product.
  */
 bool SkPath::cheapComputeDirection(Direction* dir) const {
-//    dumpPath(*this);
-    // don't want to pay the cost for computing this if it
-    // is unknown, so we don't call isConvex()
-
     if (kUnknown_Direction != fDirection) {
         *dir = static_cast<Direction>(fDirection);
         return true;
     }
-    const Convexity conv = this->getConvexityOrUnknown();
+
+    // don't want to pay the cost for computing this if it
+    // is unknown, so we don't call isConvex()
+    if (kConvex_Convexity == this->getConvexityOrUnknown()) {
+        SkASSERT(kUnknown_Direction == fDirection);
+        *dir = static_cast<Direction>(fDirection);
+        return false;
+    }
 
     ContourIter iter(*fPathRef.get());
 
     // initialize with our logical y-min
     SkScalar ymax = this->getBounds().fTop;
     SkScalar ymaxCross = 0;
 
     for (; !iter.done(); iter.next()) {
         int n = iter.count();
         if (n < 3) {
             continue;
         }
 
         const SkPoint* pts = iter.pts();
         SkScalar cross = 0;
-        if (kConvex_Convexity == conv) {
-            // We try first at scalar precision, and then again at double
-            // precision. This is because the vectors computed between distant
-            // points may lose too much precision.
-            if (convex_dir_test<SkScalar, toScalar>(n, pts, dir)) {
-                fDirection = *dir;
-                return true;
+        int index = find_max_y(pts, n);
+        if (pts[index].fY < ymax) {
+            continue;
+        }
+
+        // If there is more than 1 distinct point at the y-max, we take the
+        // x-min and x-max of them and just subtract to compute the dir.
+        if (pts[(index + 1) % n].fY == pts[index].fY) {
+            int maxIndex;
+            int minIndex = find_min_max_x_at_y(pts, index, n, &maxIndex);
+            if (minIndex == maxIndex) {
+                goto TRY_CROSSPROD;
             }
-            if (convex_dir_test<double, toDouble>(n, pts, dir)) {
-                fDirection = *dir;
-                return true;
-            } else {
-                return false;
-            }
+            SkASSERT(pts[minIndex].fY == pts[index].fY);
+            SkASSERT(pts[maxIndex].fY == pts[index].fY);
+            SkASSERT(pts[minIndex].fX <= pts[maxIndex].fX);
+            // we just subtract the indices, and let that auto-convert to
+            // SkScalar, since we just want - or + to signal the direction.
+            cross = minIndex - maxIndex;
         } else {
-            int index = find_max_y(pts, n);
-            if (pts[index].fY < ymax) {
+            TRY_CROSSPROD:
+            // Find a next and prev index to use for the cross-product test,
+            // but we try to find pts that form non-zero vectors from pts[index]
+            //
+            // Its possible that we can't find two non-degenerate vectors, so
+            // we have to guard our search (e.g. all the pts could be in the
+            // same place).
+
+            // we pass n - 1 instead of -1 so we don't foul up % operator by
+            // passing it a negative LH argument.
+            int prev = find_diff_pt(pts, index, n, n - 1);
+            if (prev == index) {
+                // completely degenerate, skip to next contour
                 continue;
             }
+            int next = find_diff_pt(pts, index, n, 1);
+            SkASSERT(next != index);
+            cross = cross_prod(pts[prev], pts[index], pts[next]);
+            // if we get a zero and the points are horizontal, then we look at the spread in
+            // x-direction. We really should continue to walk away from the degeneracy until
+            // there is a divergence.
+            if (0 == cross && pts[prev].fY == pts[index].fY && pts[next].fY == pts[index].fY) {
+                // construct the subtract so we get the correct Direction below
+                cross = pts[index].fX - pts[next].fX;
+            }
+        }
 
-            // If there is more than 1 distinct point at the y-max, we take the
-            // x-min and x-max of them and just subtract to compute the dir.
-            if (pts[(index + 1) % n].fY == pts[index].fY) {
-                int maxIndex;
-                int minIndex = find_min_max_x_at_y(pts, index, n, &maxIndex);
-                if (minIndex == maxIndex) {
-                    goto TRY_CROSSPROD;
-                }
-                SkASSERT(pts[minIndex].fY == pts[index].fY);
-                SkASSERT(pts[maxIndex].fY == pts[index].fY);
-                SkASSERT(pts[minIndex].fX <= pts[maxIndex].fX);
-                // we just subtract the indices, and let that auto-convert to
-                // SkScalar, since we just want - or + to signal the direction.
-                cross = minIndex - maxIndex;
-            } else {
-                TRY_CROSSPROD:
-                // Find a next and prev index to use for the cross-product test,
-                // but we try to find pts that form non-zero vectors from pts[index]
-                //
-                // Its possible that we can't find two non-degenerate vectors, so
-                // we have to guard our search (e.g. all the pts could be in the
-                // same place).
-
-                // we pass n - 1 instead of -1 so we don't foul up % operator by
-                // passing it a negative LH argument.
-                int prev = find_diff_pt(pts, index, n, n - 1);
-                if (prev == index) {
-                    // completely degenerate, skip to next contour
-                    continue;
-                }
-                int next = find_diff_pt(pts, index, n, 1);
-                SkASSERT(next != index);
-                cross = cross_prod(pts[prev], pts[index], pts[next]);
-                // if we get a zero and the points are horizontal, then we look at the spread in
-                // x-direction. We really should continue to walk away from the degeneracy until
-                // there is a divergence.
-                if (0 == cross && pts[prev].fY == pts[index].fY && pts[next].fY == pts[index].fY) {
-                    // construct the subtract so we get the correct Direction below
-                    cross = pts[index].fX - pts[next].fX;
-                }
-            }
-
-            if (cross) {
-                // record our best guess so far
-                ymax = pts[index].fY;
-                ymaxCross = cross;
-            }
+        if (cross) {
+            // record our best guess so far
+            ymax = pts[index].fY;
+            ymaxCross = cross;
         }
     }
     if (ymaxCross) {
         crossToDir(ymaxCross, dir);
         fDirection = *dir;
         return true;
     } else {
         return false;
     }
 }
@@ skipping 10 matching lines @@
     SkScalar A = c3 + 3*(c1 - c2) - c0;
     SkScalar B = 3*(c2 - c1 - c1 + c0);
     SkScalar C = 3*(c1 - c0);
     SkScalar D = c0;
     return eval_cubic_coeff(A, B, C, D, t);
 }
 
 /*  Given 4 cubic points (either Xs or Ys), and a target X or Y, compute the
  t value such that cubic(t) = target
  */
-static bool chopMonoCubicAt(SkScalar c0, SkScalar c1, SkScalar c2, SkScalar c3,
+static void chopMonoCubicAt(SkScalar c0, SkScalar c1, SkScalar c2, SkScalar c3,
                             SkScalar target, SkScalar* t) {
     //   SkASSERT(c0 <= c1 && c1 <= c2 && c2 <= c3);
     SkASSERT(c0 < target && target < c3);
 
     SkScalar D = c0 - target;
     SkScalar A = c3 + 3*(c1 - c2) - c0;
     SkScalar B = 3*(c2 - c1 - c1 + c0);
     SkScalar C = 3*(c1 - c0);
 
     const SkScalar TOLERANCE = SK_Scalar1 / 4096;
     SkScalar minT = 0;
     SkScalar maxT = SK_Scalar1;
     SkScalar mid;
     int i;
     for (i = 0; i < 16; i++) {
         mid = SkScalarAve(minT, maxT);
         SkScalar delta = eval_cubic_coeff(A, B, C, D, mid);
         if (delta < 0) {
             minT = mid;
             delta = -delta;
         } else {
             maxT = mid;
         }
         if (delta < TOLERANCE) {
             break;
         }
     }
     *t = mid;
-    return true;
 }
 
 template <size_t N> static void find_minmax(const SkPoint pts[],
                                             SkScalar* minPtr, SkScalar* maxPtr) {
     SkScalar min, max;
     min = max = pts[0].fX;
     for (size_t i = 1; i < N; ++i) {
         min = SkMinScalar(min, pts[i].fX);
         max = SkMaxScalar(max, pts[i].fX);
     }
@@ skipping 21 matching lines @@
     SkScalar min, max;
     find_minmax<4>(pts, &min, &max);
     if (x < min) {
         return 0;
     }
     if (x > max) {
         return dir;
     }
 
     // compute the actual x(t) value
-    SkScalar t, xt;
-    if (chopMonoCubicAt(pts[0].fY, pts[1].fY, pts[2].fY, pts[3].fY, y, &t)) {
-        xt = eval_cubic_pts(pts[0].fX, pts[1].fX, pts[2].fX, pts[3].fX, t);
-    } else {
-        SkScalar mid = SkScalarAve(pts[0].fY, pts[3].fY);
-        xt = y < mid ? pts[0].fX : pts[3].fX;
-    }
+    SkScalar t;
+    chopMonoCubicAt(pts[0].fY, pts[1].fY, pts[2].fY, pts[3].fY, y, &t);
+    SkScalar xt = eval_cubic_pts(pts[0].fX, pts[1].fX, pts[2].fX, pts[3].fX, t);
     return xt < x ? dir : 0;
 }
 
 static int winding_cubic(const SkPoint pts[], SkScalar x, SkScalar y) {
     SkPoint dst[10];
     int n = SkChopCubicAtYExtrema(pts, dst);
     int w = 0;
     for (int i = 0; i <= n; ++i) {
         w += winding_mono_cubic(&dst[i * 3], x, y);
     }
@@ skipping 139 matching lines @@
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }