Ignore zero-length joins

src/core/SkStroke.cpp

 /*
  * Copyright 2008 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 "SkStrokerPriv.h"
 #include "SkGeometry.h"
 #include "SkPathPriv.h"
@@ skipping 108 matching lines @@
 class SkPathStroker {
 public:
     SkPathStroker(const SkPath& src,
                   SkScalar radius, SkScalar miterLimit, SkPaint::Cap,
                   SkPaint::Join, SkScalar resScale);
 
     bool hasOnlyMoveTo() const { return 0 == fSegmentCount; }
     SkPoint moveToPt() const { return fFirstPt; }
 
     void moveTo(const SkPoint&);
-    void lineTo(const SkPoint&);
+    void lineTo(const SkPoint&, const SkPath::Iter* iter = nullptr);
     void quadTo(const SkPoint&, const SkPoint&);
     void conicTo(const SkPoint&, const SkPoint&, SkScalar weight);
     void cubicTo(const SkPoint&, const SkPoint&, const SkPoint&);
     void close(bool isLine) { this->finishContour(true, isLine); }
 
     void done(SkPath* dst, bool isLine) {
         this->finishContour(false, isLine);
         fOuter.addPath(fExtra);
         dst->swap(fOuter);
     }
@@ skipping 40 matching lines @@
         kDegenerate3_ReductionType, // three areas of max curvature found (for cubic)
     };
 
     enum IntersectRayType {
         kCtrlPt_RayType,
         kResultType_RayType,
     };
 
     int fRecursionDepth;            // track stack depth to abort if numerics run amok
     bool fFoundTangents;            // do less work until tangents meet (cubic)
+    bool fJoinCompleted;            // previous join was not degenerate
 
     void addDegenerateLine(const SkQuadConstruct* );
     static ReductionType CheckConicLinear(const SkConic& , SkPoint* reduction);
     static ReductionType CheckCubicLinear(const SkPoint cubic[4], SkPoint reduction[3],
                                    const SkPoint** tanPtPtr);
     static ReductionType CheckQuadLinear(const SkPoint quad[3], SkPoint* reduction);
     ResultType compareQuadConic(const SkConic& , SkQuadConstruct* ) const;
     ResultType compareQuadCubic(const SkPoint cubic[4], SkQuadConstruct* );
     ResultType compareQuadQuad(const SkPoint quad[3], SkQuadConstruct* );
     void conicPerpRay(const SkConic& , SkScalar t, SkPoint* tPt, SkPoint* onPt,
@@ skipping 66 matching lines @@
     } else {    // we have a previous segment
         fJoiner(&fOuter, &fInner, fPrevUnitNormal, fPrevPt, *unitNormal,
                 fRadius, fInvMiterLimit, fPrevIsLine, currIsLine);
     }
     fPrevIsLine = currIsLine;
     return true;
 }
 
 void SkPathStroker::postJoinTo(const SkPoint& currPt, const SkVector& normal,
                                const SkVector& unitNormal) {
+    fJoinCompleted = true;
     fPrevPt = currPt;
     fPrevUnitNormal = unitNormal;
     fPrevNormal = normal;
     fSegmentCount += 1;
 }
 
 void SkPathStroker::finishContour(bool close, bool currIsLine) {
     if (fSegmentCount > 0) {
         SkPoint pt;
 
@@ skipping 66 matching lines @@
     fInvResScaleSquared = fInvResScale * fInvResScale;
     fRecursionDepth = 0;
 }
 
 void SkPathStroker::moveTo(const SkPoint& pt) {
     if (fSegmentCount > 0) {
         this->finishContour(false, false);
     }
     fSegmentCount = 0;
     fFirstPt = fPrevPt = pt;
+    fJoinCompleted = false;
 }
 
 void SkPathStroker::line_to(const SkPoint& currPt, const SkVector& normal) {
     fOuter.lineTo(currPt.fX + normal.fX, currPt.fY + normal.fY);
     fInner.lineTo(currPt.fX - normal.fX, currPt.fY - normal.fY);
 }
 
-void SkPathStroker::lineTo(const SkPoint& currPt) {
+static bool has_valid_tangent(const SkPath::Iter* iter) {
+    SkPath::Iter copy = *iter;
+    SkPath::Verb verb;
+    SkPoint pts[4];
+    while ((verb = copy.next(pts))) {
+        switch (verb) {
+            case SkPath::kMove_Verb:
+                return false;
+            case SkPath::kLine_Verb:
+                if (pts[0] == pts[1]) {
+                    continue;
+                }
+                return true;
+            case SkPath::kQuad_Verb:
+            case SkPath::kConic_Verb:
+                if (pts[0] == pts[1] && pts[0] == pts[2]) {
+                    continue;
+                }
+                return true;
+            case SkPath::kCubic_Verb:
+                if (pts[0] == pts[1] && pts[0] == pts[2] && pts[0] == pts[3]) {
+                    continue;
+                }
+                return true;
+            case SkPath::kClose_Verb: 
+            case SkPath::kDone_Verb:
+                return false;
+        }
+    }
+    return false;
+}
+
+void SkPathStroker::lineTo(const SkPoint& currPt, const SkPath::Iter* iter) {
     if (SkStrokerPriv::CapFactory(SkPaint::kButt_Cap) == fCapper
             && fPrevPt.equalsWithinTolerance(currPt, SK_ScalarNearlyZero * fInvResScale)) {
         return;
     }
+    if (fPrevPt == currPt && (fJoinCompleted || (iter && has_valid_tangent(iter)))) {
+        return;
+    }
     SkVector    normal, unitNormal;
 
     if (!this->preJoinTo(currPt, &normal, &unitNormal, true)) {
         return;
     }
     this->line_to(currPt, normal);
     this->postJoinTo(currPt, normal, unitNormal);
 }
 
 void SkPathStroker::setQuadEndNormal(const SkPoint quad[3], const SkVector& normalAB,
@@ skipping 948 matching lines @@
     SkPath::Iter    iter(src, false);
     SkPath::Verb    lastSegment = SkPath::kMove_Verb;
 
     for (;;) {
         SkPoint  pts[4];
         switch (iter.next(pts, false)) {
             case SkPath::kMove_Verb:
                 stroker.moveTo(pts[0]);
                 break;
             case SkPath::kLine_Verb:
-                stroker.lineTo(pts[1]);
+                stroker.lineTo(pts[1], &iter);
                 lastSegment = SkPath::kLine_Verb;
                 break;
             case SkPath::kQuad_Verb:
                 stroker.quadTo(pts[1], pts[2]);
                 lastSegment = SkPath::kQuad_Verb;
                 break;
             case SkPath::kConic_Verb: {
                 stroker.conicTo(pts[1], pts[2], iter.conicWeight());
                 lastSegment = SkPath::kConic_Verb;
                 break;
@@ skipping 127 matching lines @@
         default:
             break;
     }
 
     if (fWidth < SkMinScalar(rw, rh) && !fDoFill) {
         r = rect;
         r.inset(radius, radius);
         dst->addRect(r, reverse_direction(dir));
     }
 }