1/*
2 * Copyright 2008 The Android Open Source Project
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "SkStrokerPriv.h"
9#include "SkGeometry.h"
10#include "SkPath.h"
11
12#define kMaxQuadSubdivide   5
13#define kMaxCubicSubdivide  7
14
15static inline bool degenerate_vector(const SkVector& v) {
16    return !SkPoint::CanNormalize(v.fX, v.fY);
17}
18
19static inline bool normals_too_curvy(const SkVector& norm0, SkVector& norm1) {
20    /*  root2/2 is a 45-degree angle
21        make this constant bigger for more subdivisions (but not >= 1)
22    */
23    static const SkScalar kFlatEnoughNormalDotProd =
24                                            SK_ScalarSqrt2/2 + SK_Scalar1/10;
25
26    SkASSERT(kFlatEnoughNormalDotProd > 0 &&
27             kFlatEnoughNormalDotProd < SK_Scalar1);
28
29    return SkPoint::DotProduct(norm0, norm1) <= kFlatEnoughNormalDotProd;
30}
31
32static inline bool normals_too_pinchy(const SkVector& norm0, SkVector& norm1) {
33    static const SkScalar kTooPinchyNormalDotProd = -SK_Scalar1 * 999 / 1000;
34
35    return SkPoint::DotProduct(norm0, norm1) <= kTooPinchyNormalDotProd;
36}
37
38static bool set_normal_unitnormal(const SkPoint& before, const SkPoint& after,
39                                  SkScalar radius,
40                                  SkVector* normal, SkVector* unitNormal) {
41    if (!unitNormal->setNormalize(after.fX - before.fX, after.fY - before.fY)) {
42        return false;
43    }
44    unitNormal->rotateCCW();
45    unitNormal->scale(radius, normal);
46    return true;
47}
48
49static bool set_normal_unitnormal(const SkVector& vec,
50                                  SkScalar radius,
51                                  SkVector* normal, SkVector* unitNormal) {
52    if (!unitNormal->setNormalize(vec.fX, vec.fY)) {
53        return false;
54    }
55    unitNormal->rotateCCW();
56    unitNormal->scale(radius, normal);
57    return true;
58}
59
60///////////////////////////////////////////////////////////////////////////////
61
62class SkPathStroker {
63public:
64    SkPathStroker(const SkPath& src,
65                  SkScalar radius, SkScalar miterLimit, SkPaint::Cap cap,
66                  SkPaint::Join join);
67
68    void moveTo(const SkPoint&);
69    void lineTo(const SkPoint&);
70    void quadTo(const SkPoint&, const SkPoint&);
71    void cubicTo(const SkPoint&, const SkPoint&, const SkPoint&);
72    void close(bool isLine) { this->finishContour(true, isLine); }
73
74    void done(SkPath* dst, bool isLine) {
75        this->finishContour(false, isLine);
76        fOuter.addPath(fExtra);
77        dst->swap(fOuter);
78    }
79
80private:
81    SkScalar    fRadius;
82    SkScalar    fInvMiterLimit;
83
84    SkVector    fFirstNormal, fPrevNormal, fFirstUnitNormal, fPrevUnitNormal;
85    SkPoint     fFirstPt, fPrevPt;  // on original path
86    SkPoint     fFirstOuterPt;
87    int         fSegmentCount;
88    bool        fPrevIsLine;
89
90    SkStrokerPriv::CapProc  fCapper;
91    SkStrokerPriv::JoinProc fJoiner;
92
93    SkPath  fInner, fOuter; // outer is our working answer, inner is temp
94    SkPath  fExtra;         // added as extra complete contours
95
96    void    finishContour(bool close, bool isLine);
97    void    preJoinTo(const SkPoint&, SkVector* normal, SkVector* unitNormal,
98                      bool isLine);
99    void    postJoinTo(const SkPoint&, const SkVector& normal,
100                       const SkVector& unitNormal);
101
102    void    line_to(const SkPoint& currPt, const SkVector& normal);
103    void    quad_to(const SkPoint pts[3],
104                    const SkVector& normalAB, const SkVector& unitNormalAB,
105                    SkVector* normalBC, SkVector* unitNormalBC,
106                    int subDivide);
107    void    cubic_to(const SkPoint pts[4],
108                    const SkVector& normalAB, const SkVector& unitNormalAB,
109                    SkVector* normalCD, SkVector* unitNormalCD,
110                    int subDivide);
111};
112
113///////////////////////////////////////////////////////////////////////////////
114
115void SkPathStroker::preJoinTo(const SkPoint& currPt, SkVector* normal,
116                              SkVector* unitNormal, bool currIsLine) {
117    SkASSERT(fSegmentCount >= 0);
118
119    SkScalar    prevX = fPrevPt.fX;
120    SkScalar    prevY = fPrevPt.fY;
121
122    SkAssertResult(set_normal_unitnormal(fPrevPt, currPt, fRadius, normal,
123                                         unitNormal));
124
125    if (fSegmentCount == 0) {
126        fFirstNormal = *normal;
127        fFirstUnitNormal = *unitNormal;
128        fFirstOuterPt.set(prevX + normal->fX, prevY + normal->fY);
129
130        fOuter.moveTo(fFirstOuterPt.fX, fFirstOuterPt.fY);
131        fInner.moveTo(prevX - normal->fX, prevY - normal->fY);
132    } else {    // we have a previous segment
133        fJoiner(&fOuter, &fInner, fPrevUnitNormal, fPrevPt, *unitNormal,
134                fRadius, fInvMiterLimit, fPrevIsLine, currIsLine);
135    }
136    fPrevIsLine = currIsLine;
137}
138
139void SkPathStroker::postJoinTo(const SkPoint& currPt, const SkVector& normal,
140                               const SkVector& unitNormal) {
141    fPrevPt = currPt;
142    fPrevUnitNormal = unitNormal;
143    fPrevNormal = normal;
144    fSegmentCount += 1;
145}
146
147void SkPathStroker::finishContour(bool close, bool currIsLine) {
148    if (fSegmentCount > 0) {
149        SkPoint pt;
150
151        if (close) {
152            fJoiner(&fOuter, &fInner, fPrevUnitNormal, fPrevPt,
153                    fFirstUnitNormal, fRadius, fInvMiterLimit,
154                    fPrevIsLine, currIsLine);
155            fOuter.close();
156            // now add fInner as its own contour
157            fInner.getLastPt(&pt);
158            fOuter.moveTo(pt.fX, pt.fY);
159            fOuter.reversePathTo(fInner);
160            fOuter.close();
161        } else {    // add caps to start and end
162            // cap the end
163            fInner.getLastPt(&pt);
164            fCapper(&fOuter, fPrevPt, fPrevNormal, pt,
165                    currIsLine ? &fInner : NULL);
166            fOuter.reversePathTo(fInner);
167            // cap the start
168            fCapper(&fOuter, fFirstPt, -fFirstNormal, fFirstOuterPt,
169                    fPrevIsLine ? &fInner : NULL);
170            fOuter.close();
171        }
172    }
173    // since we may re-use fInner, we rewind instead of reset, to save on
174    // reallocating its internal storage.
175    fInner.rewind();
176    fSegmentCount = -1;
177}
178
179///////////////////////////////////////////////////////////////////////////////
180
181SkPathStroker::SkPathStroker(const SkPath& src,
182                             SkScalar radius, SkScalar miterLimit,
183                             SkPaint::Cap cap, SkPaint::Join join)
184        : fRadius(radius) {
185
186    /*  This is only used when join is miter_join, but we initialize it here
187        so that it is always defined, to fis valgrind warnings.
188    */
189    fInvMiterLimit = 0;
190
191    if (join == SkPaint::kMiter_Join) {
192        if (miterLimit <= SK_Scalar1) {
193            join = SkPaint::kBevel_Join;
194        } else {
195            fInvMiterLimit = SkScalarInvert(miterLimit);
196        }
197    }
198    fCapper = SkStrokerPriv::CapFactory(cap);
199    fJoiner = SkStrokerPriv::JoinFactory(join);
200    fSegmentCount = -1;
201    fPrevIsLine = false;
202
203    // Need some estimate of how large our final result (fOuter)
204    // and our per-contour temp (fInner) will be, so we don't spend
205    // extra time repeatedly growing these arrays.
206    //
207    // 3x for result == inner + outer + join (swag)
208    // 1x for inner == 'wag' (worst contour length would be better guess)
209    fOuter.incReserve(src.countPoints() * 3);
210    fInner.incReserve(src.countPoints());
211}
212
213void SkPathStroker::moveTo(const SkPoint& pt) {
214    if (fSegmentCount > 0) {
215        this->finishContour(false, false);
216    }
217    fSegmentCount = 0;
218    fFirstPt = fPrevPt = pt;
219}
220
221void SkPathStroker::line_to(const SkPoint& currPt, const SkVector& normal) {
222    fOuter.lineTo(currPt.fX + normal.fX, currPt.fY + normal.fY);
223    fInner.lineTo(currPt.fX - normal.fX, currPt.fY - normal.fY);
224}
225
226void SkPathStroker::lineTo(const SkPoint& currPt) {
227    if (SkPath::IsLineDegenerate(fPrevPt, currPt)) {
228        return;
229    }
230    SkVector    normal, unitNormal;
231
232    this->preJoinTo(currPt, &normal, &unitNormal, true);
233    this->line_to(currPt, normal);
234    this->postJoinTo(currPt, normal, unitNormal);
235}
236
237void SkPathStroker::quad_to(const SkPoint pts[3],
238                      const SkVector& normalAB, const SkVector& unitNormalAB,
239                      SkVector* normalBC, SkVector* unitNormalBC,
240                      int subDivide) {
241    if (!set_normal_unitnormal(pts[1], pts[2], fRadius,
242                               normalBC, unitNormalBC)) {
243        // pts[1] nearly equals pts[2], so just draw a line to pts[2]
244        this->line_to(pts[2], normalAB);
245        *normalBC = normalAB;
246        *unitNormalBC = unitNormalAB;
247        return;
248    }
249
250    if (--subDivide >= 0 && normals_too_curvy(unitNormalAB, *unitNormalBC)) {
251        SkPoint     tmp[5];
252        SkVector    norm, unit;
253
254        SkChopQuadAtHalf(pts, tmp);
255        this->quad_to(&tmp[0], normalAB, unitNormalAB, &norm, &unit, subDivide);
256        this->quad_to(&tmp[2], norm, unit, normalBC, unitNormalBC, subDivide);
257    } else {
258        SkVector    normalB;
259
260        normalB = pts[2] - pts[0];
261        normalB.rotateCCW();
262        SkScalar dot = SkPoint::DotProduct(unitNormalAB, *unitNormalBC);
263        SkAssertResult(normalB.setLength(SkScalarDiv(fRadius,
264                                     SkScalarSqrt((SK_Scalar1 + dot)/2))));
265
266        fOuter.quadTo(  pts[1].fX + normalB.fX, pts[1].fY + normalB.fY,
267                        pts[2].fX + normalBC->fX, pts[2].fY + normalBC->fY);
268        fInner.quadTo(  pts[1].fX - normalB.fX, pts[1].fY - normalB.fY,
269                        pts[2].fX - normalBC->fX, pts[2].fY - normalBC->fY);
270    }
271}
272
273void SkPathStroker::cubic_to(const SkPoint pts[4],
274                      const SkVector& normalAB, const SkVector& unitNormalAB,
275                      SkVector* normalCD, SkVector* unitNormalCD,
276                      int subDivide) {
277    SkVector    ab = pts[1] - pts[0];
278    SkVector    cd = pts[3] - pts[2];
279    SkVector    normalBC, unitNormalBC;
280
281    bool    degenerateAB = degenerate_vector(ab);
282    bool    degenerateCD = degenerate_vector(cd);
283
284    if (degenerateAB && degenerateCD) {
285DRAW_LINE:
286        this->line_to(pts[3], normalAB);
287        *normalCD = normalAB;
288        *unitNormalCD = unitNormalAB;
289        return;
290    }
291
292    if (degenerateAB) {
293        ab = pts[2] - pts[0];
294        degenerateAB = degenerate_vector(ab);
295    }
296    if (degenerateCD) {
297        cd = pts[3] - pts[1];
298        degenerateCD = degenerate_vector(cd);
299    }
300    if (degenerateAB || degenerateCD) {
301        goto DRAW_LINE;
302    }
303    SkAssertResult(set_normal_unitnormal(cd, fRadius, normalCD, unitNormalCD));
304    bool degenerateBC = !set_normal_unitnormal(pts[1], pts[2], fRadius,
305                                               &normalBC, &unitNormalBC);
306#ifndef SK_IGNORE_CUBIC_STROKE_FIX
307    if (--subDivide < 0) {
308        goto DRAW_LINE;
309    }
310#endif
311    if (degenerateBC || normals_too_curvy(unitNormalAB, unitNormalBC) ||
312             normals_too_curvy(unitNormalBC, *unitNormalCD)) {
313#ifdef SK_IGNORE_CUBIC_STROKE_FIX
314        // subdivide if we can
315        if (--subDivide < 0) {
316            goto DRAW_LINE;
317        }
318#endif
319        SkPoint     tmp[7];
320        SkVector    norm, unit, dummy, unitDummy;
321
322        SkChopCubicAtHalf(pts, tmp);
323        this->cubic_to(&tmp[0], normalAB, unitNormalAB, &norm, &unit,
324                       subDivide);
325        // we use dummys since we already have a valid (and more accurate)
326        // normals for CD
327        this->cubic_to(&tmp[3], norm, unit, &dummy, &unitDummy, subDivide);
328    } else {
329        SkVector    normalB, normalC;
330
331        // need normals to inset/outset the off-curve pts B and C
332
333        SkVector    unitBC = pts[2] - pts[1];
334        unitBC.normalize();
335        unitBC.rotateCCW();
336
337        normalB = unitNormalAB + unitBC;
338        normalC = *unitNormalCD + unitBC;
339
340        SkScalar dot = SkPoint::DotProduct(unitNormalAB, unitBC);
341        SkAssertResult(normalB.setLength(SkScalarDiv(fRadius,
342                                    SkScalarSqrt((SK_Scalar1 + dot)/2))));
343        dot = SkPoint::DotProduct(*unitNormalCD, unitBC);
344        SkAssertResult(normalC.setLength(SkScalarDiv(fRadius,
345                                    SkScalarSqrt((SK_Scalar1 + dot)/2))));
346
347        fOuter.cubicTo( pts[1].fX + normalB.fX, pts[1].fY + normalB.fY,
348                        pts[2].fX + normalC.fX, pts[2].fY + normalC.fY,
349                        pts[3].fX + normalCD->fX, pts[3].fY + normalCD->fY);
350
351        fInner.cubicTo( pts[1].fX - normalB.fX, pts[1].fY - normalB.fY,
352                        pts[2].fX - normalC.fX, pts[2].fY - normalC.fY,
353                        pts[3].fX - normalCD->fX, pts[3].fY - normalCD->fY);
354    }
355}
356
357void SkPathStroker::quadTo(const SkPoint& pt1, const SkPoint& pt2) {
358    bool    degenerateAB = SkPath::IsLineDegenerate(fPrevPt, pt1);
359    bool    degenerateBC = SkPath::IsLineDegenerate(pt1, pt2);
360
361    if (degenerateAB | degenerateBC) {
362        if (degenerateAB ^ degenerateBC) {
363            this->lineTo(pt2);
364        }
365        return;
366    }
367
368    SkVector    normalAB, unitAB, normalBC, unitBC;
369
370    this->preJoinTo(pt1, &normalAB, &unitAB, false);
371
372    {
373        SkPoint pts[3], tmp[5];
374        pts[0] = fPrevPt;
375        pts[1] = pt1;
376        pts[2] = pt2;
377
378        if (SkChopQuadAtMaxCurvature(pts, tmp) == 2) {
379            unitBC.setNormalize(pts[2].fX - pts[1].fX, pts[2].fY - pts[1].fY);
380            unitBC.rotateCCW();
381            if (normals_too_pinchy(unitAB, unitBC)) {
382                normalBC = unitBC;
383                normalBC.scale(fRadius);
384
385                fOuter.lineTo(tmp[2].fX + normalAB.fX, tmp[2].fY + normalAB.fY);
386                fOuter.lineTo(tmp[2].fX + normalBC.fX, tmp[2].fY + normalBC.fY);
387                fOuter.lineTo(tmp[4].fX + normalBC.fX, tmp[4].fY + normalBC.fY);
388
389                fInner.lineTo(tmp[2].fX - normalAB.fX, tmp[2].fY - normalAB.fY);
390                fInner.lineTo(tmp[2].fX - normalBC.fX, tmp[2].fY - normalBC.fY);
391                fInner.lineTo(tmp[4].fX - normalBC.fX, tmp[4].fY - normalBC.fY);
392
393                fExtra.addCircle(tmp[2].fX, tmp[2].fY, fRadius,
394                                 SkPath::kCW_Direction);
395            } else {
396                this->quad_to(&tmp[0], normalAB, unitAB, &normalBC, &unitBC,
397                              kMaxQuadSubdivide);
398                SkVector n = normalBC;
399                SkVector u = unitBC;
400                this->quad_to(&tmp[2], n, u, &normalBC, &unitBC,
401                              kMaxQuadSubdivide);
402            }
403        } else {
404            this->quad_to(pts, normalAB, unitAB, &normalBC, &unitBC,
405                          kMaxQuadSubdivide);
406        }
407    }
408
409    this->postJoinTo(pt2, normalBC, unitBC);
410}
411
412void SkPathStroker::cubicTo(const SkPoint& pt1, const SkPoint& pt2,
413                            const SkPoint& pt3) {
414    bool    degenerateAB = SkPath::IsLineDegenerate(fPrevPt, pt1);
415    bool    degenerateBC = SkPath::IsLineDegenerate(pt1, pt2);
416    bool    degenerateCD = SkPath::IsLineDegenerate(pt2, pt3);
417
418    if (degenerateAB + degenerateBC + degenerateCD >= 2) {
419        this->lineTo(pt3);
420        return;
421    }
422
423    SkVector    normalAB, unitAB, normalCD, unitCD;
424
425    // find the first tangent (which might be pt1 or pt2
426    {
427        const SkPoint*  nextPt = &pt1;
428        if (degenerateAB)
429            nextPt = &pt2;
430        this->preJoinTo(*nextPt, &normalAB, &unitAB, false);
431    }
432
433    {
434        SkPoint pts[4], tmp[13];
435        int         i, count;
436        SkVector    n, u;
437        SkScalar    tValues[3];
438
439        pts[0] = fPrevPt;
440        pts[1] = pt1;
441        pts[2] = pt2;
442        pts[3] = pt3;
443
444        count = SkChopCubicAtMaxCurvature(pts, tmp, tValues);
445        n = normalAB;
446        u = unitAB;
447        for (i = 0; i < count; i++) {
448            this->cubic_to(&tmp[i * 3], n, u, &normalCD, &unitCD,
449                           kMaxCubicSubdivide);
450            if (i == count - 1) {
451                break;
452            }
453            n = normalCD;
454            u = unitCD;
455
456        }
457    }
458
459    this->postJoinTo(pt3, normalCD, unitCD);
460}
461
462///////////////////////////////////////////////////////////////////////////////
463///////////////////////////////////////////////////////////////////////////////
464
465#include "SkPaintDefaults.h"
466
467SkStroke::SkStroke() {
468    fWidth      = SK_Scalar1;
469    fMiterLimit = SkPaintDefaults_MiterLimit;
470    fCap        = SkPaint::kDefault_Cap;
471    fJoin       = SkPaint::kDefault_Join;
472    fDoFill     = false;
473}
474
475SkStroke::SkStroke(const SkPaint& p) {
476    fWidth      = p.getStrokeWidth();
477    fMiterLimit = p.getStrokeMiter();
478    fCap        = (uint8_t)p.getStrokeCap();
479    fJoin       = (uint8_t)p.getStrokeJoin();
480    fDoFill     = SkToU8(p.getStyle() == SkPaint::kStrokeAndFill_Style);
481}
482
483SkStroke::SkStroke(const SkPaint& p, SkScalar width) {
484    fWidth      = width;
485    fMiterLimit = p.getStrokeMiter();
486    fCap        = (uint8_t)p.getStrokeCap();
487    fJoin       = (uint8_t)p.getStrokeJoin();
488    fDoFill     = SkToU8(p.getStyle() == SkPaint::kStrokeAndFill_Style);
489}
490
491void SkStroke::setWidth(SkScalar width) {
492    SkASSERT(width >= 0);
493    fWidth = width;
494}
495
496void SkStroke::setMiterLimit(SkScalar miterLimit) {
497    SkASSERT(miterLimit >= 0);
498    fMiterLimit = miterLimit;
499}
500
501void SkStroke::setCap(SkPaint::Cap cap) {
502    SkASSERT((unsigned)cap < SkPaint::kCapCount);
503    fCap = SkToU8(cap);
504}
505
506void SkStroke::setJoin(SkPaint::Join join) {
507    SkASSERT((unsigned)join < SkPaint::kJoinCount);
508    fJoin = SkToU8(join);
509}
510
511///////////////////////////////////////////////////////////////////////////////
512
513// If src==dst, then we use a tmp path to record the stroke, and then swap
514// its contents with src when we're done.
515class AutoTmpPath {
516public:
517    AutoTmpPath(const SkPath& src, SkPath** dst) : fSrc(src) {
518        if (&src == *dst) {
519            *dst = &fTmpDst;
520            fSwapWithSrc = true;
521        } else {
522            (*dst)->reset();
523            fSwapWithSrc = false;
524        }
525    }
526
527    ~AutoTmpPath() {
528        if (fSwapWithSrc) {
529            fTmpDst.swap(*const_cast<SkPath*>(&fSrc));
530        }
531    }
532
533private:
534    SkPath          fTmpDst;
535    const SkPath&   fSrc;
536    bool            fSwapWithSrc;
537};
538
539void SkStroke::strokePath(const SkPath& src, SkPath* dst) const {
540    SkASSERT(&src != NULL && dst != NULL);
541
542    SkScalar radius = SkScalarHalf(fWidth);
543
544    AutoTmpPath tmp(src, &dst);
545
546    if (radius <= 0) {
547        return;
548    }
549
550    // If src is really a rect, call our specialty strokeRect() method
551    {
552        bool isClosed;
553        SkPath::Direction dir;
554        if (src.isRect(&isClosed, &dir) && isClosed) {
555            this->strokeRect(src.getBounds(), dst, dir);
556            // our answer should preserve the inverseness of the src
557            if (src.isInverseFillType()) {
558                SkASSERT(!dst->isInverseFillType());
559                dst->toggleInverseFillType();
560            }
561            return;
562        }
563    }
564
565    SkAutoConicToQuads converter;
566    const SkScalar conicTol = SK_Scalar1 / 4;
567
568    SkPathStroker   stroker(src, radius, fMiterLimit, this->getCap(),
569                            this->getJoin());
570    SkPath::Iter    iter(src, false);
571    SkPath::Verb    lastSegment = SkPath::kMove_Verb;
572
573    for (;;) {
574        SkPoint  pts[4];
575        switch (iter.next(pts, false)) {
576            case SkPath::kMove_Verb:
577                stroker.moveTo(pts[0]);
578                break;
579            case SkPath::kLine_Verb:
580                stroker.lineTo(pts[1]);
581                lastSegment = SkPath::kLine_Verb;
582                break;
583            case SkPath::kQuad_Verb:
584                stroker.quadTo(pts[1], pts[2]);
585                lastSegment = SkPath::kQuad_Verb;
586                break;
587            case SkPath::kConic_Verb: {
588                // todo: if we had maxcurvature for conics, perhaps we should
589                // natively extrude the conic instead of converting to quads.
590                const SkPoint* quadPts =
591                    converter.computeQuads(pts, iter.conicWeight(), conicTol);
592                for (int i = 0; i < converter.countQuads(); ++i) {
593                    stroker.quadTo(quadPts[1], quadPts[2]);
594                    quadPts += 2;
595                }
596                lastSegment = SkPath::kQuad_Verb;
597            } break;
598            case SkPath::kCubic_Verb:
599                stroker.cubicTo(pts[1], pts[2], pts[3]);
600                lastSegment = SkPath::kCubic_Verb;
601                break;
602            case SkPath::kClose_Verb:
603                stroker.close(lastSegment == SkPath::kLine_Verb);
604                break;
605            case SkPath::kDone_Verb:
606                goto DONE;
607        }
608    }
609DONE:
610    stroker.done(dst, lastSegment == SkPath::kLine_Verb);
611
612    if (fDoFill) {
613        if (src.cheapIsDirection(SkPath::kCCW_Direction)) {
614            dst->reverseAddPath(src);
615        } else {
616            dst->addPath(src);
617        }
618    } else {
619        //  Seems like we can assume that a 2-point src would always result in
620        //  a convex stroke, but testing has proved otherwise.
621        //  TODO: fix the stroker to make this assumption true (without making
622        //  it slower that the work that will be done in computeConvexity())
623#if 0
624        // this test results in a non-convex stroke :(
625        static void test(SkCanvas* canvas) {
626            SkPoint pts[] = { 146.333328,  192.333328, 300.333344, 293.333344 };
627            SkPaint paint;
628            paint.setStrokeWidth(7);
629            paint.setStrokeCap(SkPaint::kRound_Cap);
630            canvas->drawLine(pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, paint);
631        }
632#endif
633#if 0
634        if (2 == src.countPoints()) {
635            dst->setIsConvex(true);
636        }
637#endif
638    }
639
640    // our answer should preserve the inverseness of the src
641    if (src.isInverseFillType()) {
642        SkASSERT(!dst->isInverseFillType());
643        dst->toggleInverseFillType();
644    }
645}
646
647static SkPath::Direction reverse_direction(SkPath::Direction dir) {
648    SkASSERT(SkPath::kUnknown_Direction != dir);
649    return SkPath::kCW_Direction == dir ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
650}
651
652static void addBevel(SkPath* path, const SkRect& r, const SkRect& outer, SkPath::Direction dir) {
653    SkPoint pts[8];
654
655    if (SkPath::kCW_Direction == dir) {
656        pts[0].set(r.fLeft, outer.fTop);
657        pts[1].set(r.fRight, outer.fTop);
658        pts[2].set(outer.fRight, r.fTop);
659        pts[3].set(outer.fRight, r.fBottom);
660        pts[4].set(r.fRight, outer.fBottom);
661        pts[5].set(r.fLeft, outer.fBottom);
662        pts[6].set(outer.fLeft, r.fBottom);
663        pts[7].set(outer.fLeft, r.fTop);
664    } else {
665        pts[7].set(r.fLeft, outer.fTop);
666        pts[6].set(r.fRight, outer.fTop);
667        pts[5].set(outer.fRight, r.fTop);
668        pts[4].set(outer.fRight, r.fBottom);
669        pts[3].set(r.fRight, outer.fBottom);
670        pts[2].set(r.fLeft, outer.fBottom);
671        pts[1].set(outer.fLeft, r.fBottom);
672        pts[0].set(outer.fLeft, r.fTop);
673    }
674    path->addPoly(pts, 8, true);
675}
676
677void SkStroke::strokeRect(const SkRect& origRect, SkPath* dst,
678                          SkPath::Direction dir) const {
679    SkASSERT(dst != NULL);
680    dst->reset();
681
682    SkScalar radius = SkScalarHalf(fWidth);
683    if (radius <= 0) {
684        return;
685    }
686
687    SkScalar rw = origRect.width();
688    SkScalar rh = origRect.height();
689    if ((rw < 0) ^ (rh < 0)) {
690        dir = reverse_direction(dir);
691    }
692    SkRect rect(origRect);
693    rect.sort();
694    // reassign these, now that we know they'll be >= 0
695    rw = rect.width();
696    rh = rect.height();
697
698    SkRect r(rect);
699    r.outset(radius, radius);
700
701    SkPaint::Join join = (SkPaint::Join)fJoin;
702    if (SkPaint::kMiter_Join == join && fMiterLimit < SK_ScalarSqrt2) {
703        join = SkPaint::kBevel_Join;
704    }
705
706    switch (join) {
707        case SkPaint::kMiter_Join:
708            dst->addRect(r, dir);
709            break;
710        case SkPaint::kBevel_Join:
711            addBevel(dst, rect, r, dir);
712            break;
713        case SkPaint::kRound_Join:
714            dst->addRoundRect(r, radius, radius, dir);
715            break;
716        default:
717            break;
718    }
719
720    if (fWidth < SkMinScalar(rw, rh) && !fDoFill) {
721        r = rect;
722        r.inset(radius, radius);
723        dst->addRect(r, reverse_direction(dir));
724    }
725}
726