In convexity checker don't advance last vector when x-product isn't significant.

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 2205 matching lines @@
     }
 #endif // SK_DEBUG_PATH
 }
 #endif // SK_DEBUG
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int sign(SkScalar x) { return x < 0; }
 #define kValueNeverReturnedBySign   2
 
-static bool AlmostEqual(SkScalar compA, SkScalar compB) {
+static bool almost_equal(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;
     }
     // 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)
     , fDirection(SkPath::kUnknown_Direction) {
         fSign = 0;
         // warnings
         fLastPt.set(0, 0);
         fCurrPt.set(0, 0);
-        fVec0.set(0, 0);
-        fVec1.set(0, 0);
+        fLastVec.set(0, 0);
         fFirstVec.set(0, 0);
 
         fDx = fDy = 0;
         fSx = fSy = kValueNeverReturnedBySign;
     }
 
     SkPath::Convexity getConvexity() const { return fConvexity; }
 
     /** The direction returned is only valid if the path is determined convex */
     SkPath::Direction getDirection() const { return fDirection; }
 
     void addPt(const SkPoint& pt) {
         if (SkPath::kConcave_Convexity == fConvexity) {
             return;
         }
 
         if (0 == fPtCount) {
             fCurrPt = pt;
             ++fPtCount;
         } else {
             SkVector vec = pt - fCurrPt;
             if (vec.fX || vec.fY) {
                 fLastPt = fCurrPt;
                 fCurrPt = pt;
                 if (++fPtCount == 2) {
-                    fFirstVec = fVec1 = vec;
+                    fFirstVec = fLastVec = vec;
                 } else {
                     SkASSERT(fPtCount > 2);
                     this->addVec(vec);
                 }
 
                 int sx = sign(vec.fX);
                 int sy = sign(vec.fY);
                 fDx += (sx != fSx);
                 fDy += (sy != fSy);
                 fSx = sx;
                 fSy = sy;
 
                 if (fDx > 3 || fDy > 3) {
                     fConvexity = SkPath::kConcave_Convexity;
                 }
             }
         }
     }
 
     void close() {
         if (fPtCount > 2) {
             this->addVec(fFirstVec);
         }
     }
 
 private:
     void addVec(const SkVector& vec) {
         SkASSERT(vec.fX || vec.fY);
-        fVec0 = fVec1;
-        fVec1 = vec;
-        SkScalar cross = SkPoint::CrossProduct(fVec0, fVec1);
+        SkScalar cross = SkPoint::CrossProduct(fLastVec, vec);
         SkScalar smallest = SkTMin(fCurrPt.fX, SkTMin(fCurrPt.fY, SkTMin(fLastPt.fX, fLastPt.fY)));
         SkScalar largest = SkTMax(fCurrPt.fX, SkTMax(fCurrPt.fY, SkTMax(fLastPt.fX, fLastPt.fY)));
         largest = SkTMax(largest, -smallest);
-        int sign = AlmostEqual(largest, largest + cross) ? 0 : SkScalarSignAsInt(cross);
-        if (0 == fSign) {
-            fSign = sign;
-            if (1 == sign) {
-                fDirection = SkPath::kCW_Direction;
-            } else if (-1 == sign) {
-                fDirection = SkPath::kCCW_Direction;
-            }
-        } else if (sign) {
-            if (fSign != sign) {
+        if (!almost_equal(largest, largest + cross)) {
+            int sign = SkScalarSignAsInt(cross);
+            if (0 == fSign) {
+                fSign = sign;
+                fDirection = (1 == sign) ? SkPath::kCW_Direction : SkPath::kCCW_Direction;
+            } else if (sign && fSign != sign) {
                 fConvexity = SkPath::kConcave_Convexity;
                 fDirection = SkPath::kUnknown_Direction;
             }
+            fLastVec = vec;
         }
     }
 
     SkPoint             fLastPt;
     SkPoint             fCurrPt;
-    SkVector            fVec0, fVec1, fFirstVec;
+    // fLastVec does not necessarily start at fLastPt. We only advance it when the cross product
+    // value with the current vec is deemed to be of a significant value.
+    SkVector            fLastVec, fFirstVec;
     int                 fPtCount;   // non-degenerate points
     int                 fSign;
     SkPath::Convexity   fConvexity;
     SkPath::Direction   fDirection;
     int                 fDx, fDy, fSx, fSy;
 };
 
 SkPath::Convexity SkPath::internalGetConvexity() const {
     SkASSERT(kUnknown_Convexity == fConvexity);
     SkPoint         pts[4];
@@ skipping 546 matching lines @@
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }