SkStroke.cpp File Reference

#include "src/core/SkStroke.h"
#include "include/core/SkPath.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkScalar.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkMacros.h"
#include "include/private/base/SkTo.h"
#include "src/core/SkGeometry.h"
#include "src/core/SkPathEnums.h"
#include "src/core/SkPathPriv.h"
#include "src/core/SkPointPriv.h"
#include "src/core/SkStrokerPriv.h"
#include <algorithm>
#include <array>
#include "src/core/SkPaintDefaults.h"

Go to the source code of this file.

Classes
struct	SkQuadConstruct
class	SkPathStroker
class	AutoTmpPath

Macros
#define	DEBUG_QUAD_STROKER   0
#define	STROKER_RESULT(resultType, depth, quadPts, format, ...)    resultType
#define	STROKER_DEBUG_PARAMS(...)
#define	DEBUG_CUBIC_RECURSION_DEPTHS   0
#define	DEBUG_CUBIC_RECURSION_TRACK_DEPTH(depth)   (void)(depth)

Enumerations
enum	{ kTangent_RecursiveLimit , kCubic_RecursiveLimit , kConic_RecursiveLimit , kQuad_RecursiveLimit }

Functions
static bool	degenerate_vector (const SkVector &v)
static bool	set_normal_unitnormal (const SkPoint &before, const SkPoint &after, SkScalar scale, SkScalar radius, SkVector *normal, SkVector *unitNormal)
static bool	set_normal_unitnormal (const SkVector &vec, SkScalar radius, SkVector *normal, SkVector *unitNormal)
static bool	has_valid_tangent (const SkPath::Iter *iter)
static SkScalar	pt_to_line (const SkPoint &pt, const SkPoint &lineStart, const SkPoint &lineEnd)
static bool	cubic_in_line (const SkPoint cubic[4])
static bool	quad_in_line (const SkPoint quad[3])
static bool	conic_in_line (const SkConic &conic)
static int	intersect_quad_ray (const SkPoint line[2], const SkPoint quad[3], SkScalar roots[2])
static bool	points_within_dist (const SkPoint &nearPt, const SkPoint &farPt, SkScalar limit)
static bool	sharp_angle (const SkPoint quad[3])
static SkPathDirection	reverse_direction (SkPathDirection dir)
static void	addBevel (SkPath *path, const SkRect &r, const SkRect &outer, SkPathDirection dir)

Variables
static const int	kRecursiveLimits [] = { 5*3, 24, 11*3, 11*3 }

Macro Definition Documentation

DEBUG_CUBIC_RECURSION_DEPTHS

#define DEBUG_CUBIC_RECURSION_DEPTHS   0

Definition at line 69 of file SkStroke.cpp.

DEBUG_CUBIC_RECURSION_TRACK_DEPTH

#define DEBUG_CUBIC_RECURSION_TRACK_DEPTH

(

depth

)

(void)(depth)

Definition at line 94 of file SkStroke.cpp.

DEBUG_QUAD_STROKER

#define DEBUG_QUAD_STROKER   0

Definition at line 51 of file SkStroke.cpp.

STROKER_DEBUG_PARAMS

#define STROKER_DEBUG_PARAMS

(

...

)

Definition at line 65 of file SkStroke.cpp.

STROKER_RESULT

#define STROKER_RESULT	(		resultType,
			depth,
			quadPts,
			format,
			...
	)		resultType

Definition at line 63 of file SkStroke.cpp.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
kTangent_RecursiveLimit
kCubic_RecursiveLimit
kConic_RecursiveLimit
kQuad_RecursiveLimit

Definition at line 26 of file SkStroke.cpp.

     {
    kTangent_RecursiveLimit,
    kCubic_RecursiveLimit,
    kConic_RecursiveLimit,
    kQuad_RecursiveLimit
};

Function Documentation

addBevel()

static void addBevel ( SkPath *  path, const SkRect &  r, const SkRect &  outer, SkPathDirection  dir  )

static

Definition at line 1559 of file SkStroke.cpp.

                                                                                              {
    SkPoint pts[8];
 
    if (SkPathDirection::kCW == dir) {
        pts[0].set(r.fLeft, outer.fTop);
        pts[1].set(r.fRight, outer.fTop);
        pts[2].set(outer.fRight, r.fTop);
        pts[3].set(outer.fRight, r.fBottom);
        pts[4].set(r.fRight, outer.fBottom);
        pts[5].set(r.fLeft, outer.fBottom);
        pts[6].set(outer.fLeft, r.fBottom);
        pts[7].set(outer.fLeft, r.fTop);
    } else {
        pts[7].set(r.fLeft, outer.fTop);
        pts[6].set(r.fRight, outer.fTop);
        pts[5].set(outer.fRight, r.fTop);
        pts[4].set(outer.fRight, r.fBottom);
        pts[3].set(r.fRight, outer.fBottom);
        pts[2].set(r.fLeft, outer.fBottom);
        pts[1].set(outer.fLeft, r.fBottom);
        pts[0].set(outer.fLeft, r.fTop);
    }
    path->addPoly(pts, 8, true);
}

conic_in_line()

static bool conic_in_line ( const SkConic &  conic )

static

Definition at line 641 of file SkStroke.cpp.

                                                {
    return quad_in_line(conic.fPts);
}

cubic_in_line()

static bool cubic_in_line ( const SkPoint  cubic[4] )

static

Definition at line 580 of file SkStroke.cpp.

                                                  {
    SkScalar ptMax = -1;
    int outer1 SK_INIT_TO_AVOID_WARNING;
    int outer2 SK_INIT_TO_AVOID_WARNING;
    for (int index = 0; index < 3; ++index) {
        for (int inner = index + 1; inner < 4; ++inner) {
            SkVector testDiff = cubic[inner] - cubic[index];
            SkScalar testMax = std::max(SkScalarAbs(testDiff.fX), SkScalarAbs(testDiff.fY));
            if (ptMax < testMax) {
                outer1 = index;
                outer2 = inner;
                ptMax = testMax;
            }
        }
    }
    SkASSERT(outer1 >= 0 && outer1 <= 2);
    SkASSERT(outer2 >= 1 && outer2 <= 3);
    SkASSERT(outer1 < outer2);
    int mid1 = (1 + (2 >> outer2)) >> outer1;
    SkASSERT(mid1 >= 0 && mid1 <= 2);
    SkASSERT(outer1 != mid1 && outer2 != mid1);
    int mid2 = outer1 ^ outer2 ^ mid1;
    SkASSERT(mid2 >= 1 && mid2 <= 3);
    SkASSERT(mid2 != outer1 && mid2 != outer2 && mid2 != mid1);
    SkASSERT(((1 << outer1) | (1 << outer2) | (1 << mid1) | (1 << mid2)) == 0x0f);
    SkScalar lineSlop = ptMax * ptMax * 0.00001f;  // this multiplier is pulled out of the air
    return pt_to_line(cubic[mid1], cubic[outer1], cubic[outer2]) <= lineSlop
            && pt_to_line(cubic[mid2], cubic[outer1], cubic[outer2]) <= lineSlop;
}

degenerate_vector()

static bool degenerate_vector ( const SkVector &  v )

inlinestatic

Definition at line 97 of file SkStroke.cpp.

                                                        {
    return !SkPointPriv::CanNormalize(v.fX, v.fY);
}

has_valid_tangent()

static bool has_valid_tangent ( const SkPath::Iter *  iter )

static

Definition at line 442 of file SkStroke.cpp.

                                                      {
    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;
}

intersect_quad_ray()

static int intersect_quad_ray ( const SkPoint  line[2], const SkPoint  quad[3], SkScalar  roots[2]  )

static

Definition at line 977 of file SkStroke.cpp.

                                                                                               {
    SkVector vec = line[1] - line[0];
    SkScalar r[3];
    for (int n = 0; n < 3; ++n) {
        r[n] = (quad[n].fY - line[0].fY) * vec.fX - (quad[n].fX - line[0].fX) * vec.fY;
    }
    SkScalar A = r[2];
    SkScalar B = r[1];
    SkScalar C = r[0];
    A += C - 2 * B;  // A = a - 2*b + c
    B -= C;  // B = -(b - c)
    return SkFindUnitQuadRoots(A, 2 * B, C, roots);
}

points_within_dist()

static bool points_within_dist ( const SkPoint &  nearPt, const SkPoint &  farPt, SkScalar  limit  )

static

Definition at line 1012 of file SkStroke.cpp.

                                                                                            {
    return SkPointPriv::DistanceToSqd(nearPt, farPt) <= limit * limit;
}

pt_to_line()

static SkScalar pt_to_line ( const SkPoint &  pt, const SkPoint &  lineStart, const SkPoint &  lineEnd  )

static

Definition at line 541 of file SkStroke.cpp.

                                                                                                {
    SkVector dxy = lineEnd - lineStart;
    SkVector ab0 = pt - lineStart;
    SkScalar numer = dxy.dot(ab0);
    SkScalar denom = dxy.dot(dxy);
    SkScalar t = sk_ieee_float_divide(numer, denom);
    if (t >= 0 && t <= 1) {
        SkPoint hit;
        hit.fX = lineStart.fX * (1 - t) + lineEnd.fX * t;
        hit.fY = lineStart.fY * (1 - t) + lineEnd.fY * t;
        return SkPointPriv::DistanceToSqd(hit, pt);
    } else {
        return SkPointPriv::DistanceToSqd(pt, lineStart);
    }
}

quad_in_line()

static bool quad_in_line ( const SkPoint  quad[3] )

static

Definition at line 617 of file SkStroke.cpp.

                                                {
    SkScalar ptMax = -1;
    int outer1 SK_INIT_TO_AVOID_WARNING;
    int outer2 SK_INIT_TO_AVOID_WARNING;
    for (int index = 0; index < 2; ++index) {
        for (int inner = index + 1; inner < 3; ++inner) {
            SkVector testDiff = quad[inner] - quad[index];
            SkScalar testMax = std::max(SkScalarAbs(testDiff.fX), SkScalarAbs(testDiff.fY));
            if (ptMax < testMax) {
                outer1 = index;
                outer2 = inner;
                ptMax = testMax;
            }
        }
    }
    SkASSERT(outer1 >= 0 && outer1 <= 1);
    SkASSERT(outer2 >= 1 && outer2 <= 2);
    SkASSERT(outer1 < outer2);
    int mid = outer1 ^ outer2 ^ 3;
    const float kCurvatureSlop = 0.000005f;  // this multiplier is pulled out of the air
    SkScalar lineSlop =  ptMax * ptMax * kCurvatureSlop;
    return pt_to_line(quad[mid], quad[outer1], quad[outer2]) <= lineSlop;
}

reverse_direction()

static SkPathDirection reverse_direction ( SkPathDirection  dir )

static

Definition at line 1554 of file SkStroke.cpp.

                                                              {
    static const SkPathDirection gOpposite[] = { SkPathDirection::kCCW, SkPathDirection::kCW };
    return gOpposite[(int)dir];
}

set_normal_unitnormal() [1/2]

static bool set_normal_unitnormal ( const SkPoint &  before, const SkPoint &  after, SkScalar  scale, SkScalar  radius, SkVector *  normal, SkVector *  unitNormal  )

static

Definition at line 101 of file SkStroke.cpp.

                                                                          {
    if (!unitNormal->setNormalize((after.fX - before.fX) * scale,
                                  (after.fY - before.fY) * scale)) {
        return false;
    }
    SkPointPriv::RotateCCW(unitNormal);
    unitNormal->scale(radius, normal);
    return true;
}

set_normal_unitnormal() [2/2]

static bool set_normal_unitnormal ( const SkVector &  vec, SkScalar  radius, SkVector *  normal, SkVector *  unitNormal  )

static

Definition at line 113 of file SkStroke.cpp.

                                                                          {
    if (!unitNormal->setNormalize(vec.fX, vec.fY)) {
        return false;
    }
    SkPointPriv::RotateCCW(unitNormal);
    unitNormal->scale(radius, normal);
    return true;
}

sharp_angle()

static bool sharp_angle ( const SkPoint  quad[3] )

static

Definition at line 1016 of file SkStroke.cpp.

                                               {
    SkVector smaller = quad[1] - quad[0];
    SkVector larger = quad[1] - quad[2];
    SkScalar smallerLen = SkPointPriv::LengthSqd(smaller);
    SkScalar largerLen = SkPointPriv::LengthSqd(larger);
    if (smallerLen > largerLen) {
        using std::swap;
        swap(smaller, larger);
        largerLen = smallerLen;
    }
    if (!smaller.setLength(largerLen)) {
        return false;
    }
    SkScalar dot = smaller.dot(larger);
    return dot > 0;
}

Variable Documentation

kRecursiveLimits

const int kRecursiveLimits[] = { 5*3, 24, 11*3, 11*3 }

static

Definition at line 40 of file SkStroke.cpp.