compute convexity for very small paths

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"
@@ skipping 1594 matching lines @@
         // Set the first return pt to the move pt
         fSegmentState = kAfterPrimitive_SegmentState;
         return fMoveTo;
     } else {
         SkASSERT(fSegmentState == kAfterPrimitive_SegmentState);
          // Set the first return pt to the last pt of the previous primitive.
         return fPts[-1];
     }
 }
 
-void SkPath::Iter::consumeDegenerateSegments() {
+void SkPath::Iter::consumeDegenerateSegments(bool exact) {
     // We need to step over anything that will not move the current draw point
     // forward before the next move is seen
     const uint8_t* lastMoveVerb = 0;
     const SkPoint* lastMovePt = 0;
     const SkScalar* lastMoveWeight = NULL;
     SkPoint lastPt = fLastPt;
     while (fVerbs != fVerbStop) {
         unsigned verb = *(fVerbs - 1); // fVerbs is one beyond the current verb
         switch (verb) {
             case kMove_Verb:
@@ skipping 10 matching lines @@
                 // A close when we are in a segment is always valid except when it
                 // follows a move which follows a segment.
                 if (fSegmentState == kAfterPrimitive_SegmentState && !lastMoveVerb) {
                     return;
                 }
                 // A close at any other time must be ignored
                 fVerbs--;
                 break;
 
             case kLine_Verb:
-                if (!IsLineDegenerate(lastPt, fPts[0])) {
+                if (!IsLineDegenerate(lastPt, fPts[0], exact)) {
                     if (lastMoveVerb) {
                         fVerbs = lastMoveVerb;
                         fPts = lastMovePt;
                         fConicWeights = lastMoveWeight;
                         return;
                     }
                     return;
                 }
                 // Ignore this line and continue
                 fVerbs--;
                 fPts++;
                 break;
 
             case kConic_Verb:
             case kQuad_Verb:
-                if (!IsQuadDegenerate(lastPt, fPts[0], fPts[1])) {
+                if (!IsQuadDegenerate(lastPt, fPts[0], fPts[1], exact)) {
                     if (lastMoveVerb) {
                         fVerbs = lastMoveVerb;
                         fPts = lastMovePt;
                         fConicWeights = lastMoveWeight;
                         return;
                     }
                     return;
                 }
                 // Ignore this line and continue
                 fVerbs--;
                 fPts += 2;
                 fConicWeights += (kConic_Verb == verb);
                 break;
 
             case kCubic_Verb:
-                if (!IsCubicDegenerate(lastPt, fPts[0], fPts[1], fPts[2])) {
+                if (!IsCubicDegenerate(lastPt, fPts[0], fPts[1], fPts[2], exact)) {
                     if (lastMoveVerb) {
                         fVerbs = lastMoveVerb;
                         fPts = lastMovePt;
                         fConicWeights = lastMoveWeight;
                         return;
                     }
                     return;
                 }
                 // Ignore this line and continue
                 fVerbs--;
@@ skipping 420 matching lines @@
         }
 
         if (0 == fPtCount) {
             fCurrPt = pt;
             ++fPtCount;
         } else {
             SkVector vec = pt - fCurrPt;
             SkScalar lengthSqd = vec.lengthSqd();
             if (!SkScalarIsFinite(lengthSqd)) {
                 fIsFinite = false;
-            } else if (!SkScalarNearlyZero(lengthSqd, SK_ScalarNearlyZero*SK_ScalarNearlyZero)) {
+            } else if (lengthSqd) {
                 fPriorPt = fLastPt;
                 fLastPt = fCurrPt;
                 fCurrPt = pt;
                 if (++fPtCount == 2) {
                     fFirstVec = fLastVec = vec;
                 } else {
                     SkASSERT(fPtCount > 2);
                     this->addVec(vec);
                 }
 
@@ skipping 116 matching lines @@
     SkPath::Verb    verb;
     SkPath::Iter    iter(*this, true);
 
     int             contourCount = 0;
     int             count;
     Convexicator    state;
 
     if (!isFinite()) {
         return kUnknown_Convexity;
     }
-    while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
+    while ((verb = iter.next(pts, true, true)) != SkPath::kDone_Verb) {
         switch (verb) {
             case kMove_Verb:
                 if (++contourCount > 1) {
                     fConvexity = kConcave_Convexity;
                     return kConcave_Convexity;
                 }
                 pts[1] = pts[0];
                 // fall through
             case kLine_Verb:
                 count = 1;
@@ skipping 541 matching lines @@
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }