Ignore fill when stroke & filling convex line-only paths

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 37 matching lines @@
 #endif
 
 static inline bool degenerate_vector(const SkVector& v) {
     return !SkPoint::CanNormalize(v.fX, v.fY);
 }
 
 static bool set_normal_unitnormal(const SkPoint& before, const SkPoint& after, SkScalar scale,
                                   SkScalar radius,
                                   SkVector* normal, SkVector* unitNormal) {
     if (!unitNormal->setNormalize((after.fX - before.fX) * scale,
-            (after.fY - before.fY) * scale)) {
+                                  (after.fY - before.fY) * scale)) {
         return false;
     }
     unitNormal->rotateCCW();
     unitNormal->scale(radius, normal);
     return true;
 }
 
 static bool set_normal_unitnormal(const SkVector& vec,
                                   SkScalar radius,
                                   SkVector* normal, SkVector* unitNormal) {
@@ skipping 45 matching lines @@
         fTangentEnd = parent->fTangentEnd;
         fEndSet = true;
         return true;
    }
 };
 
 class SkPathStroker {
 public:
     SkPathStroker(const SkPath& src,
                   SkScalar radius, SkScalar miterLimit, SkPaint::Cap,
-                  SkPaint::Join, SkScalar resScale);
+                  SkPaint::Join, SkScalar resScale,
+                  bool canIgnoreCenter);
 
     bool hasOnlyMoveTo() const { return 0 == fSegmentCount; }
     SkPoint moveToPt() const { return fFirstPt; }
 
     void moveTo(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); }
@@ skipping 15 matching lines @@
     SkScalar    fInvMiterLimit;
     SkScalar    fResScale;
     SkScalar    fInvResScale;
     SkScalar    fInvResScaleSquared;
 
     SkVector    fFirstNormal, fPrevNormal, fFirstUnitNormal, fPrevUnitNormal;
     SkPoint     fFirstPt, fPrevPt;  // on original path
     SkPoint     fFirstOuterPt;
     int         fSegmentCount;
     bool        fPrevIsLine;
+    bool        fCanIgnoreCenter;
 
     SkStrokerPriv::CapProc  fCapper;
     SkStrokerPriv::JoinProc fJoiner;
 
     SkPath  fInner, fOuter; // outer is our working answer, inner is temp
     SkPath  fExtra;         // added as extra complete contours
 
     enum StrokeType {
         kOuter_StrokeType = 1,      // use sign-opposite values later to flip perpendicular axis
         kInner_StrokeType = -1
@@ skipping 117 matching lines @@
 
 void SkPathStroker::finishContour(bool close, bool currIsLine) {
     if (fSegmentCount > 0) {
         SkPoint pt;
 
         if (close) {
             fJoiner(&fOuter, &fInner, fPrevUnitNormal, fPrevPt,
                     fFirstUnitNormal, fRadius, fInvMiterLimit,
                     fPrevIsLine, currIsLine);
             fOuter.close();
-            // now add fInner as its own contour
-            fInner.getLastPt(&pt);
-            fOuter.moveTo(pt.fX, pt.fY);
-            fOuter.reversePathTo(fInner);
-            fOuter.close();
+
+            if (fCanIgnoreCenter) {
+                if (!fOuter.getBounds().contains(fInner.getBounds())) {
+                    SkASSERT(fInner.getBounds().contains(fOuter.getBounds()));
+                    fInner.swap(fOuter);
+                }
+            } else {
+                // now add fInner as its own contour
+                fInner.getLastPt(&pt);
+                fOuter.moveTo(pt.fX, pt.fY);
+                fOuter.reversePathTo(fInner);
+                fOuter.close();
+            }
         } else {    // add caps to start and end
             // cap the end
             fInner.getLastPt(&pt);
             fCapper(&fOuter, fPrevPt, fPrevNormal, pt,
                     currIsLine ? &fInner : nullptr);
             fOuter.reversePathTo(fInner);
             // cap the start
             fCapper(&fOuter, fFirstPt, -fFirstNormal, fFirstOuterPt,
                     fPrevIsLine ? &fInner : nullptr);
             fOuter.close();
         }
     }
     // since we may re-use fInner, we rewind instead of reset, to save on
     // reallocating its internal storage.
     fInner.rewind();
     fSegmentCount = -1;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPathStroker::SkPathStroker(const SkPath& src,
                              SkScalar radius, SkScalar miterLimit,
-                             SkPaint::Cap cap, SkPaint::Join join, SkScalar resScale)
+                             SkPaint::Cap cap, SkPaint::Join join, SkScalar resScale,
+                             bool canIgnoreCenter)
         : fRadius(radius)
-        , fResScale(resScale) {
+        , fResScale(resScale)
+        , fCanIgnoreCenter(canIgnoreCenter) {
 
     /*  This is only used when join is miter_join, but we initialize it here
         so that it is always defined, to fis valgrind warnings.
     */
     fInvMiterLimit = 0;
 
     if (join == SkPaint::kMiter_Join) {
         if (miterLimit <= SK_Scalar1) {
             join = SkPaint::kBevel_Join;
         } else {
@@ skipping 1022 matching lines @@
             this->strokeRect(rect, dst, dir);
             // our answer should preserve the inverseness of the src
             if (src.isInverseFillType()) {
                 SkASSERT(!dst->isInverseFillType());
                 dst->toggleInverseFillType();
             }
             return;
         }
     }
 
-    SkPathStroker   stroker(src, radius, fMiterLimit, this->getCap(), this->getJoin(), fResScale);
+    // We can always ignore centers for stroke and fill convex line-only paths
+    // TODO: remove the line-only restriction
+    bool ignoreCenter = fDoFill && (src.getSegmentMasks() == SkPath::kLine_SegmentMask) && 
+                        src.isLastContourClosed() && src.isConvex();
+
+    SkPathStroker   stroker(src, radius, fMiterLimit, this->getCap(), this->getJoin(),
+                            fResScale, ignoreCenter);
     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:
@@ skipping 33 matching lines @@
                 }
                 stroker.close(lastSegment == SkPath::kLine_Verb);
                 break;
             case SkPath::kDone_Verb:
                 goto DONE;
         }
     }
 DONE:
     stroker.done(dst, lastSegment == SkPath::kLine_Verb);
 
-    if (fDoFill) {
+    if (fDoFill && !ignoreCenter) {
         if (SkPathPriv::CheapIsFirstDirection(src, SkPathPriv::kCCW_FirstDirection)) {
             dst->reverseAddPath(src);
         } else {
             dst->addPath(src);
         }
     } else {
         //  Seems like we can assume that a 2-point src would always result in
         //  a convex stroke, but testing has proved otherwise.
         //  TODO: fix the stroker to make this assumption true (without making
         //  it slower that the work that will be done in computeConvexity())
@@ skipping 93 matching lines @@
         default:
             break;
     }
 
     if (fWidth < SkMinScalar(rw, rh) && !fDoFill) {
         r = rect;
         r.inset(radius, radius);
         dst->addRect(r, reverse_direction(dir));
     }
 }