compute convexity for very small paths

include/core/SkPath.h

 /*
  * 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.
  */
 
 #ifndef SkPath_DEFINED
 #define SkPath_DEFINED
 
@@ skipping 188 matching lines @@
      consumption on the device.
      */
     void setIsVolatile(bool isVolatile) {
         fIsVolatile = isVolatile;
     }
 
     /** Test a line for zero length
 
         @return true if the line is of zero length; otherwise false.
     */
-    static bool IsLineDegenerate(const SkPoint& p1, const SkPoint& p2) {
-        return p1.equalsWithinTolerance(p2);
+    static bool IsLineDegenerate(const SkPoint& p1, const SkPoint& p2, bool exact) {
+        return exact ? p1 == p2 : p1.equalsWithinTolerance(p2);
     }
 
     /** Test a quad for zero length
 
         @return true if the quad is of zero length; otherwise false.
     */
     static bool IsQuadDegenerate(const SkPoint& p1, const SkPoint& p2,
-                                 const SkPoint& p3) {
-        return p1.equalsWithinTolerance(p2) &&
+                                 const SkPoint& p3, bool exact) {
+        return exact ? p1 == p2 && p2 == p3 : p1.equalsWithinTolerance(p2) &&
                p2.equalsWithinTolerance(p3);
     }
 
     /** Test a cubic curve for zero length
 
         @return true if the cubic is of zero length; otherwise false.
     */
     static bool IsCubicDegenerate(const SkPoint& p1, const SkPoint& p2,
-                                  const SkPoint& p3, const SkPoint& p4) {
-        return p1.equalsWithinTolerance(p2) &&
+                                  const SkPoint& p3, const SkPoint& p4, bool exact) {
+        return exact ? p1 == p2 && p2 == p3 && p3 == p4 : p1.equalsWithinTolerance(p2) &&
                p2.equalsWithinTolerance(p3) &&
                p3.equalsWithinTolerance(p4);
     }
 
     /**
      *  Returns true if the path specifies a single line (i.e. it contains just
      *  a moveTo and a lineTo). If so, and line[] is not null, it sets the 2
      *  points in line[] to the end-points of the line. If the path is not a
      *  line, returns false and ignores line[].
      */
@@ skipping 552 matching lines @@
         Iter();
         Iter(const SkPath&, bool forceClose);
 
         void setPath(const SkPath&, bool forceClose);
 
         /** Return the next verb in this iteration of the path. When all
             segments have been visited, return kDone_Verb.
 
             @param  pts The points representing the current verb and/or segment
             @param doConsumeDegerates If true, first scan for segments that are
                    deemed degenerate (too short) and skip those.

[robertphillips, 2015/07/13 17:49:11]

@param exact if true perform exact comparison ...
?

[caryclark, 2015/07/13 18:23:41]

Done. Good catch -- I forgot about updating the documentation.

             @return The verb for the current segment
         */
-        Verb next(SkPoint pts[4], bool doConsumeDegerates = true) {
+        Verb next(SkPoint pts[4], bool doConsumeDegerates = true, bool exact = false) {
             if (doConsumeDegerates) {
-                this->consumeDegenerateSegments();
+                this->consumeDegenerateSegments(exact);
             }
             return this->doNext(pts);
         }
 
         /**
          *  Return the weight for the current conic. Only valid if the current
          *  segment return by next() was a conic.
          */
         SkScalar conicWeight() const { return *fConicWeights; }
 
@@ skipping 19 matching lines @@
         const SkScalar* fConicWeights;
         SkPoint         fMoveTo;
         SkPoint         fLastPt;
         SkBool8         fForceClose;
         SkBool8         fNeedClose;
         SkBool8         fCloseLine;
         SkBool8         fSegmentState;
 
         inline const SkPoint& cons_moveTo();
         Verb autoClose(SkPoint pts[2]);
-        void consumeDegenerateSegments();
+        void consumeDegenerateSegments(bool exact);
         Verb doNext(SkPoint pts[4]);
     };
 
     /** Iterate through the verbs in the path, providing the associated points.
     */
     class SK_API RawIter {
     public:
         RawIter();
         RawIter(const SkPath&);
 
@@ skipping 139 matching lines @@
     void setPt(int index, SkScalar x, SkScalar y);
 
     friend class SkAutoPathBoundsUpdate;
     friend class SkAutoDisableOvalCheck;
     friend class SkAutoDisableDirectionCheck;
     friend class SkBench_AddPathTest; // perf test reversePathTo
     friend class PathTest_Private; // unit test reversePathTo
 };
 
 #endif