SkContourMeasure.cpp File Reference

#include "include/core/SkContourMeasure.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathTypes.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkFloatingPoint.h"
#include "src/core/SkGeometry.h"
#include "src/core/SkPathMeasurePriv.h"
#include "src/core/SkPathPriv.h"
#include <algorithm>
#include <utility>

Go to the source code of this file.

Classes
class	SkContourMeasureIter::Impl

Macros
#define	kMaxTValue   0x3FFFFFFF
#define	CHEAP_DIST_LIMIT   (SK_Scalar1/2)

Functions
static constexpr SkScalar	tValue2Scalar (int t)
void	SkContourMeasure_segTo (const SkPoint pts[], unsigned segType, SkScalar startT, SkScalar stopT, SkPath *dst)
static int	tspan_big_enough (int tspan)
static bool	quad_too_curvy (const SkPoint pts[3], SkScalar tolerance)
static bool	conic_too_curvy (const SkPoint &firstPt, const SkPoint &midTPt, const SkPoint &lastPt, SkScalar tolerance)
static bool	cheap_dist_exceeds_limit (const SkPoint &pt, SkScalar x, SkScalar y, SkScalar tolerance)
static bool	cubic_too_curvy (const SkPoint pts[4], SkScalar tolerance)
static void	compute_pos_tan (const SkPoint pts[], unsigned segType, SkScalar t, SkPoint *pos, SkVector *tangent)
template<typename T , typename K >
int	SkTKSearch (const T base[], int count, const K &key)

Variables
constexpr int	kMaxRecursionDepth = 8

Macro Definition Documentation

CHEAP_DIST_LIMIT

#define CHEAP_DIST_LIMIT   (SK_Scalar1/2)

Definition at line 143 of file SkContourMeasure.cpp.

kMaxTValue

#define kMaxTValue   0x3FFFFFFF

Definition at line 23 of file SkContourMeasure.cpp.

Function Documentation

cheap_dist_exceeds_limit()

static bool cheap_dist_exceeds_limit ( const SkPoint &  pt, SkScalar  x, SkScalar  y, SkScalar  tolerance  )

static

Definition at line 166 of file SkContourMeasure.cpp.

                                                         {
    SkScalar dist = std::max(SkScalarAbs(x - pt.fX), SkScalarAbs(y - pt.fY));
    // just made up the 1/2
    return dist > tolerance;
}

compute_pos_tan()

static void compute_pos_tan ( const SkPoint  pts[], unsigned  segType, SkScalar  t, SkPoint *  pos, SkVector *  tangent  )

static

Definition at line 461 of file SkContourMeasure.cpp.

                                                                         {
    switch (segType) {
        case kLine_SegType:
            if (pos) {
                pos->set(SkScalarInterp(pts[0].fX, pts[1].fX, t),
                         SkScalarInterp(pts[0].fY, pts[1].fY, t));
            }
            if (tangent) {
                tangent->setNormalize(pts[1].fX - pts[0].fX, pts[1].fY - pts[0].fY);
            }
            break;
        case kQuad_SegType:
            SkEvalQuadAt(pts, t, pos, tangent);
            if (tangent) {
                tangent->normalize();
            }
            break;
        case kConic_SegType: {
            SkConic(pts[0], pts[2], pts[3], pts[1].fX).evalAt(t, pos, tangent);
            if (tangent) {
                tangent->normalize();
            }
        } break;
        case kCubic_SegType:
            SkEvalCubicAt(pts, t, pos, tangent, nullptr);
            if (tangent) {
                tangent->normalize();
            }
            break;
        default:
            SkDEBUGFAIL("unknown segType");
    }
}

conic_too_curvy()

static bool conic_too_curvy ( const SkPoint &  firstPt, const SkPoint &  midTPt, const SkPoint &  lastPt, SkScalar  tolerance  )

static

Definition at line 157 of file SkContourMeasure.cpp.

                                                                       {
    SkPoint midEnds = firstPt + lastPt;
    midEnds *= 0.5f;
    SkVector dxy = midTPt - midEnds;
    SkScalar dist = std::max(SkScalarAbs(dxy.fX), SkScalarAbs(dxy.fY));
    return dist > tolerance;
}

cubic_too_curvy()

static bool cubic_too_curvy ( const SkPoint  pts[4], SkScalar  tolerance  )

static

Definition at line 173 of file SkContourMeasure.cpp.

                                                                      {
    return  cheap_dist_exceeds_limit(pts[1],
                         SkScalarInterp(pts[0].fX, pts[3].fX, SK_Scalar1/3),
                         SkScalarInterp(pts[0].fY, pts[3].fY, SK_Scalar1/3), tolerance)
                         ||
            cheap_dist_exceeds_limit(pts[2],
                         SkScalarInterp(pts[0].fX, pts[3].fX, SK_Scalar1*2/3),
                         SkScalarInterp(pts[0].fY, pts[3].fY, SK_Scalar1*2/3), tolerance);
}

quad_too_curvy()

static bool quad_too_curvy ( const SkPoint  pts[3], SkScalar  tolerance  )

static

Definition at line 145 of file SkContourMeasure.cpp.

                                                                     {
    // diff = (a/4 + b/2 + c/4) - (a/2 + c/2)
    // diff = -a/4 + b/2 - c/4
    SkScalar dx = SkScalarHalf(pts[1].fX) -
                        SkScalarHalf(SkScalarHalf(pts[0].fX + pts[2].fX));
    SkScalar dy = SkScalarHalf(pts[1].fY) -
                        SkScalarHalf(SkScalarHalf(pts[0].fY + pts[2].fY));
 
    SkScalar dist = std::max(SkScalarAbs(dx), SkScalarAbs(dy));
    return dist > tolerance;
}

SkContourMeasure_segTo()

void SkContourMeasure_segTo	(	const SkPoint	pts[],
		unsigned	segType,
		SkScalar	startT,
		SkScalar	stopT,
		SkPath *	dst
	)

Definition at line 39 of file SkContourMeasure.cpp.

                                                                          {
    SkASSERT(startT >= 0 && startT <= SK_Scalar1);
    SkASSERT(stopT >= 0 && stopT <= SK_Scalar1);
    SkASSERT(startT <= stopT);
 
    if (startT == stopT) {
        if (!dst->isEmpty()) {
            /* if the dash as a zero-length on segment, add a corresponding zero-length line.
               The stroke code will add end caps to zero length lines as appropriate */
            SkPoint lastPt;
            SkAssertResult(dst->getLastPt(&lastPt));
            dst->lineTo(lastPt);
        }
        return;
    }
 
    SkPoint tmp0[7], tmp1[7];
 
    switch (segType) {
        case kLine_SegType:
            if (SK_Scalar1 == stopT) {
                dst->lineTo(pts[1]);
            } else {
                dst->lineTo(SkScalarInterp(pts[0].fX, pts[1].fX, stopT),
                            SkScalarInterp(pts[0].fY, pts[1].fY, stopT));
            }
            break;
        case kQuad_SegType:
            if (0 == startT) {
                if (SK_Scalar1 == stopT) {
                    dst->quadTo(pts[1], pts[2]);
                } else {
                    SkChopQuadAt(pts, tmp0, stopT);
                    dst->quadTo(tmp0[1], tmp0[2]);
                }
            } else {
                SkChopQuadAt(pts, tmp0, startT);
                if (SK_Scalar1 == stopT) {
                    dst->quadTo(tmp0[3], tmp0[4]);
                } else {
                    SkChopQuadAt(&tmp0[2], tmp1, (stopT - startT) / (1 - startT));
                    dst->quadTo(tmp1[1], tmp1[2]);
                }
            }
            break;
        case kConic_SegType: {
            SkConic conic(pts[0], pts[2], pts[3], pts[1].fX);
 
            if (0 == startT) {
                if (SK_Scalar1 == stopT) {
                    dst->conicTo(conic.fPts[1], conic.fPts[2], conic.fW);
                } else {
                    SkConic tmp[2];
                    if (conic.chopAt(stopT, tmp)) {
                        dst->conicTo(tmp[0].fPts[1], tmp[0].fPts[2], tmp[0].fW);
                    }
                }
            } else {
                if (SK_Scalar1 == stopT) {
                    SkConic tmp[2];
                    if (conic.chopAt(startT, tmp)) {
                        dst->conicTo(tmp[1].fPts[1], tmp[1].fPts[2], tmp[1].fW);
                    }
                } else {
                    SkConic tmp;
                    conic.chopAt(startT, stopT, &tmp);
                    dst->conicTo(tmp.fPts[1], tmp.fPts[2], tmp.fW);
                }
            }
        } break;
        case kCubic_SegType:
            if (0 == startT) {
                if (SK_Scalar1 == stopT) {
                    dst->cubicTo(pts[1], pts[2], pts[3]);
                } else {
                    SkChopCubicAt(pts, tmp0, stopT);
                    dst->cubicTo(tmp0[1], tmp0[2], tmp0[3]);
                }
            } else {
                SkChopCubicAt(pts, tmp0, startT);
                if (SK_Scalar1 == stopT) {
                    dst->cubicTo(tmp0[4], tmp0[5], tmp0[6]);
                } else {
                    SkChopCubicAt(&tmp0[3], tmp1, (stopT - startT) / (1 - startT));
                    dst->cubicTo(tmp1[1], tmp1[2], tmp1[3]);
                }
            }
            break;
        default:
            SK_ABORT("unknown segType");
    }
}

SkTKSearch()

template<typename T , typename K >

int SkTKSearch	(	const T	base[],
		int	count,
		const K &	key
	)

Definition at line 546 of file SkContourMeasure.cpp.

                                                        {
    SkASSERT(count >= 0);
    if (count <= 0) {
        return ~0;
    }
 
    SkASSERT(base != nullptr); // base may be nullptr if count is zero
 
    unsigned lo = 0;
    unsigned hi = count - 1;
 
    while (lo < hi) {
        unsigned mid = (hi + lo) >> 1;
        if (base[mid].fDistance < key) {
            lo = mid + 1;
        } else {
            hi = mid;
        }
    }
 
    if (base[hi].fDistance < key) {
        hi += 1;
        hi = ~hi;
    } else if (key < base[hi].fDistance) {
        hi = ~hi;
    }
    return hi;
}

tspan_big_enough()

static int tspan_big_enough ( int  tspan )

inlinestatic

Definition at line 135 of file SkContourMeasure.cpp.

                                              {
    SkASSERT((unsigned)tspan <= kMaxTValue);
    return tspan >> 10;
}

tValue2Scalar()

static constexpr SkScalar tValue2Scalar ( int  t )

inlinestaticconstexpr

Definition at line 25 of file SkContourMeasure.cpp.

                                                      {
    SkASSERT((unsigned)t <= kMaxTValue);
    // 1/kMaxTValue can't be represented as a float, but it's close and the limits work fine.
    const SkScalar kMaxTReciprocal = 1.0f / (SkScalar)kMaxTValue;
    return t * kMaxTReciprocal;
}

Variable Documentation

kMaxRecursionDepth

constexpr int kMaxRecursionDepth = 8

constexpr

Definition at line 185 of file SkContourMeasure.cpp.