GrDistanceFieldGenFromVector.cpp File Reference

#include "src/gpu/ganesh/GrDistanceFieldGenFromVector.h"
#include "include/core/SkMatrix.h"
#include "include/private/base/SkTPin.h"
#include "src/base/SkAutoMalloc.h"
#include "src/core/SkDistanceFieldGen.h"
#include "src/core/SkGeometry.h"
#include "src/core/SkPathPriv.h"
#include "src/core/SkPointPriv.h"
#include "src/core/SkRectPriv.h"
#include "src/gpu/ganesh/geometry/GrPathUtils.h"

Go to the source code of this file.

Classes
struct	DFData
class	DAffineMatrix
class	PathSegment
struct	RowData

Typedefs
typedef TArray< PathSegment, true >	PathSegmentArray

Enumerations
enum	SegSide { kLeft_SegSide = -1 , kOn_SegSide = 0 , kRight_SegSide = 1 , kNA_SegSide = 2 }

Functions
static bool	between_closed_open (double a, double b, double c, double tolerance=0.0, bool xformToleranceToX=false)
static bool	between_closed (double a, double b, double c, double tolerance=0.0, bool xformToleranceToX=false)
static bool	nearly_zero (double x, double tolerance=kNearlyZero)
static bool	nearly_equal (double x, double y, double tolerance=kNearlyZero, bool xformToleranceToX=false)
static double	sign_of (const double &val)
static bool	is_colinear (const SkPoint pts[3])
static void	init_distances (DFData *data, int size)
static void	add_line (const SkPoint pts[2], PathSegmentArray *segments)
static void	add_quad (const SkPoint pts[3], PathSegmentArray *segments)
static void	add_cubic (const SkPoint pts[4], PathSegmentArray *segments)
static float	calculate_nearest_point_for_quad (const PathSegment &segment, const DPoint &xFormPt)
void	precomputation_for_row (RowData *rowData, const PathSegment &segment, const SkPoint &pointLeft, const SkPoint &pointRight)
SegSide	calculate_side_of_quad (const PathSegment &segment, const SkPoint &point, const DPoint &xFormPt, const RowData &rowData)
static float	distance_to_segment (const SkPoint &point, const PathSegment &segment, const RowData &rowData, SegSide *side)
static void	calculate_distance_field_data (PathSegmentArray *segments, DFData *dataPtr, int width, int height)
template<int distanceMagnitude>
static unsigned char	pack_distance_field_val (float dist)
bool	GrGenerateDistanceFieldFromPath (unsigned char *distanceField, const SkPath &path, const SkMatrix &drawMatrix, int width, int height, size_t rowBytes)

Variables
static const double	kClose = (SK_Scalar1 / 16.0)
static const double	kCloseSqd = kClose * kClose
static const double	kNearlyZero = (SK_Scalar1 / (1 << 18))
static const double	kTangentTolerance = (SK_Scalar1 / (1 << 11))
static const float	kConicTolerance = 0.25f

Typedef Documentation

PathSegmentArray

typedef TArray<PathSegment, true> PathSegmentArray

Definition at line 230 of file GrDistanceFieldGenFromVector.cpp.

Enumeration Type Documentation

SegSide

enum SegSide

If a scanline (a row of texel) cross from the kRight_SegSide of a segment to the kLeft_SegSide, the winding score should add 1. And winding score should subtract 1 if the scanline cross from kLeft_SegSide to kRight_SegSide. Always return kNA_SegSide if the scanline does not cross over the segment. Winding score should be zero in this case. You can get the winding number for each texel of the scanline by adding the winding score from left to right. Assuming we always start from outside, so the winding number should always start from zero.

---

| | | | ...R|L......L|R.....L|R......R|L..... <= Scanline & side of segment |+1 |-1 |-1 |+1 <= Winding score 0 | 1 ^ 0 ^ -1 |0 <= Winding number |________| |________|

.......NA................NA.......... 0 0

Enumerator
kLeft_SegSide
kOn_SegSide
kRight_SegSide
kNA_SegSide

Definition at line 61 of file GrDistanceFieldGenFromVector.cpp.

             {
    kLeft_SegSide  = -1,
    kOn_SegSide    =  0,
    kRight_SegSide =  1,
    kNA_SegSide    =  2,
};

Function Documentation

add_cubic()

static void add_cubic ( const SkPoint  pts[4], PathSegmentArray *  segments  )

inlinestatic

Definition at line 377 of file GrDistanceFieldGenFromVector.cpp.

                                                         {
    STArray<15, SkPoint, true> quads;
    GrPathUtils::convertCubicToQuads(pts, SK_Scalar1, &quads);
    int count = quads.size();
    for (int q = 0; q < count; q += 3) {
        add_quad(&quads[q], segments);
    }
}

add_line()

static void add_line ( const SkPoint  pts[2], PathSegmentArray *  segments  )

inlinestatic

Definition at line 347 of file GrDistanceFieldGenFromVector.cpp.

                                                                              {
    segments->push_back();
    segments->back().fType = PathSegment::kLine;
    segments->back().fPts[0] = pts[0];
    segments->back().fPts[1] = pts[1];
 
    segments->back().init();
}

add_quad()

static void add_quad ( const SkPoint  pts[3], PathSegmentArray *  segments  )

inlinestatic

Definition at line 356 of file GrDistanceFieldGenFromVector.cpp.

                                                                              {
    if (SkPointPriv::DistanceToSqd(pts[0], pts[1]) < kCloseSqd ||
        SkPointPriv::DistanceToSqd(pts[1], pts[2]) < kCloseSqd ||
        is_colinear(pts)) {
        if (pts[0] != pts[2]) {
            SkPoint line_pts[2];
            line_pts[0] = pts[0];
            line_pts[1] = pts[2];
            add_line(line_pts, segments);
        }
    } else {
        segments->push_back();
        segments->back().fType = PathSegment::kQuad;
        segments->back().fPts[0] = pts[0];
        segments->back().fPts[1] = pts[1];
        segments->back().fPts[2] = pts[2];
 
        segments->back().init();
    }
}

between_closed()

static bool between_closed ( double  a, double  b, double  c, double  tolerance = 0.0, bool  xformToleranceToX = false  )

inlinestatic

Definition at line 159 of file GrDistanceFieldGenFromVector.cpp.

                                                                  {
    SkASSERT(tolerance >= 0.0);
    double tolB = tolerance;
    double tolC = tolerance;
 
    if (xformToleranceToX) {
        tolB = tolerance / sqrt(4.0 * b * b + 1.0);
        tolC = tolerance / sqrt(4.0 * c * c + 1.0);
    }
    return b < c ? (a >= b - tolB && a <= c + tolC) :
                   (a >= c - tolC && a <= b + tolB);
}

between_closed_open()

static bool between_closed_open ( double  a, double  b, double  c, double  tolerance = 0.0, bool  xformToleranceToX = false  )

inlinestatic

Definition at line 136 of file GrDistanceFieldGenFromVector.cpp.

                                                                       {
    SkASSERT(tolerance >= 0.0);
    double tolB = tolerance;
    double tolC = tolerance;
 
    if (xformToleranceToX) {
        // Canonical space is y = x^2 and the derivative of x^2 is 2x.
        // So the slope of the tangent line at point (x, x^2) is 2x.
        //
        //                          /|
        //  sqrt(2x * 2x + 1 * 1)  / | 2x
        //                        /__|
        //                         1
        tolB = tolerance / sqrt(4.0 * b * b + 1.0);
        tolC = tolerance / sqrt(4.0 * c * c + 1.0);
    }
    return b < c ? (a >= b - tolB && a < c - tolC) :
                   (a >= c - tolC && a < b - tolB);
}

calculate_distance_field_data()

static void calculate_distance_field_data ( PathSegmentArray *  segments, DFData *  dataPtr, int  width, int  height  )

static

Definition at line 624 of file GrDistanceFieldGenFromVector.cpp.

                                                                 {
    int count = segments->size();
    // for each segment
    for (int a = 0; a < count; ++a) {
        PathSegment& segment = (*segments)[a];
        const SkRect& segBB = segment.fBoundingBox;
        // get the bounding box, outset by distance field pad, and clip to total bounds
        const SkRect& paddedBB = segBB.makeOutset(SK_DistanceFieldPad, SK_DistanceFieldPad);
        int startColumn = (int)paddedBB.fLeft;
        int endColumn = SkScalarCeilToInt(paddedBB.fRight);
 
        int startRow = (int)paddedBB.fTop;
        int endRow = SkScalarCeilToInt(paddedBB.fBottom);
 
        SkASSERT((startColumn >= 0) && "StartColumn < 0!");
        SkASSERT((endColumn <= width) && "endColumn > width!");
        SkASSERT((startRow >= 0) && "StartRow < 0!");
        SkASSERT((endRow <= height) && "EndRow > height!");
 
        // Clip inside the distance field to avoid overflow
        startColumn = std::max(startColumn, 0);
        endColumn   = std::min(endColumn,   width);
        startRow    = std::max(startRow,    0);
        endRow      = std::min(endRow,      height);
 
        // for each row in the padded bounding box
        for (int row = startRow; row < endRow; ++row) {
            SegSide prevSide = kNA_SegSide;   // track side for winding count
            const float pY = row + 0.5f;      // offset by 1/2? why?
            RowData rowData;
 
            const SkPoint pointLeft = SkPoint::Make((SkScalar)startColumn, pY);
            const SkPoint pointRight = SkPoint::Make((SkScalar)endColumn, pY);
 
            // if this is a row inside the original segment bounding box
            if (between_closed_open(pY, segBB.fTop, segBB.fBottom)) {
                // compute intersections with the row
                precomputation_for_row(&rowData, segment, pointLeft, pointRight);
            }
 
            // adjust distances and windings in each column based on the row calculation
            for (int col = startColumn; col < endColumn; ++col) {
                int idx = (row * width) + col;
 
                const float pX = col + 0.5f;
                const SkPoint point = SkPoint::Make(pX, pY);
 
                const float distSq = dataPtr[idx].fDistSq;
 
                 // Optimization for not calculating some points.
                int dilation = distSq < 1.5f * 1.5f ? 1 :
                               distSq < 2.5f * 2.5f ? 2 :
                               distSq < 3.5f * 3.5f ? 3 : SK_DistanceFieldPad;
                if (dilation < SK_DistanceFieldPad &&
                    !segBB.roundOut().makeOutset(dilation, dilation).contains(col, row)) {
                    continue;
                }
 
                SegSide side = kNA_SegSide;
                int     deltaWindingScore = 0;
                float   currDistSq = distance_to_segment(point, segment, rowData, &side);
                if (prevSide == kLeft_SegSide && side == kRight_SegSide) {
                    deltaWindingScore = -1;
                } else if (prevSide == kRight_SegSide && side == kLeft_SegSide) {
                    deltaWindingScore = 1;
                }
 
                prevSide = side;
 
                if (currDistSq < distSq) {
                    dataPtr[idx].fDistSq = currDistSq;
                }
 
                dataPtr[idx].fDeltaWindingScore += deltaWindingScore;
            }
        }
    }
}

calculate_nearest_point_for_quad()

static float calculate_nearest_point_for_quad ( const PathSegment &  segment, const DPoint &  xFormPt  )

static

Definition at line 387 of file GrDistanceFieldGenFromVector.cpp.

                                       {
    static const float kThird = 0.33333333333f;
    static const float kTwentySeventh = 0.037037037f;
 
    const float a = 0.5f - (float)xFormPt.fY;
    const float b = -0.5f * (float)xFormPt.fX;
 
    const float a3 = a * a * a;
    const float b2 = b * b;
 
    const float c = (b2 * 0.25f) + (a3 * kTwentySeventh);
 
    if (c >= 0.f) {
        const float sqrtC = sqrt(c);
        const float result = (float)cbrt((-b * 0.5f) + sqrtC) + (float)cbrt((-b * 0.5f) - sqrtC);
        return result;
    } else {
        const float cosPhi = (float)sqrt((b2 * 0.25f) * (-27.f / a3)) * ((b > 0) ? -1.f : 1.f);
        const float phi = (float)acos(cosPhi);
        float result;
        if (xFormPt.fX > 0.f) {
            result = 2.f * (float)sqrt(-a * kThird) * (float)cos(phi * kThird);
            if (!between_closed(result, segment.fP0T.fX, segment.fP2T.fX)) {
                result = 2.f * (float)sqrt(-a * kThird) * (float)cos((phi * kThird) + (SK_ScalarPI * 2.f * kThird));
            }
        } else {
            result = 2.f * (float)sqrt(-a * kThird) * (float)cos((phi * kThird) + (SK_ScalarPI * 2.f * kThird));
            if (!between_closed(result, segment.fP0T.fX, segment.fP2T.fX)) {
                result = 2.f * (float)sqrt(-a * kThird) * (float)cos(phi * kThird);
            }
        }
        return result;
    }
}

calculate_side_of_quad()

SegSide calculate_side_of_quad	(	const PathSegment &	segment,
		const SkPoint &	point,
		const DPoint &	xFormPt,
		const RowData &	rowData
	)

Definition at line 503 of file GrDistanceFieldGenFromVector.cpp.

                                    {
    SegSide side = kNA_SegSide;
 
    if (RowData::kVerticalLine == rowData.fIntersectionType) {
        side = (SegSide)(int)(sign_of(xFormPt.fY - rowData.fYAtIntersection) * rowData.fQuadXDirection);
    }
    else if (RowData::kTwoPointsIntersect == rowData.fIntersectionType) {
        const double p1 = rowData.fXAtIntersection1;
        const double p2 = rowData.fXAtIntersection2;
 
        int signP1 = (int)sign_of(p1 - xFormPt.fX);
        bool includeP1 = true;
        bool includeP2 = true;
 
        if (rowData.fScanlineXDirection == 1) {
            if ((rowData.fQuadXDirection == -1 && segment.fPts[0].fY <= point.fY &&
                 nearly_equal(segment.fP0T.fX, p1, segment.fNearlyZeroScaled, true)) ||
                 (rowData.fQuadXDirection == 1 && segment.fPts[2].fY <= point.fY &&
                 nearly_equal(segment.fP2T.fX, p1, segment.fNearlyZeroScaled, true))) {
                includeP1 = false;
            }
            if ((rowData.fQuadXDirection == -1 && segment.fPts[2].fY <= point.fY &&
                 nearly_equal(segment.fP2T.fX, p2, segment.fNearlyZeroScaled, true)) ||
                 (rowData.fQuadXDirection == 1 && segment.fPts[0].fY <= point.fY &&
                 nearly_equal(segment.fP0T.fX, p2, segment.fNearlyZeroScaled, true))) {
                includeP2 = false;
            }
        }
 
        if (includeP1 && between_closed(p1, segment.fP0T.fX, segment.fP2T.fX,
                                        segment.fNearlyZeroScaled, true)) {
            side = (SegSide)(signP1 * rowData.fQuadXDirection);
        }
        if (includeP2 && between_closed(p2, segment.fP0T.fX, segment.fP2T.fX,
                                        segment.fNearlyZeroScaled, true)) {
            int signP2 = (int)sign_of(p2 - xFormPt.fX);
            if (side == kNA_SegSide || signP2 == 1) {
                side = (SegSide)(-signP2 * rowData.fQuadXDirection);
            }
        }
    } else if (RowData::kTangentLine == rowData.fIntersectionType) {
        // The scanline is the tangent line of current quadratic segment.
 
        const double p = rowData.fXAtIntersection1;
        int signP = (int)sign_of(p - xFormPt.fX);
        if (rowData.fScanlineXDirection == 1) {
            // The path start or end at the tangent point.
            if (segment.fPts[0].fY == point.fY) {
                side = (SegSide)(signP);
            } else if (segment.fPts[2].fY == point.fY) {
                side = (SegSide)(-signP);
            }
        }
    }
 
    return side;
}

distance_to_segment()

static float distance_to_segment ( const SkPoint &  point, const PathSegment &  segment, const RowData &  rowData, SegSide *  side  )

static

Definition at line 565 of file GrDistanceFieldGenFromVector.cpp.

                                                {
    SkASSERT(side);
 
    const DPoint xformPt = segment.fXformMatrix.mapPoint(point);
 
    if (segment.fType == PathSegment::kLine) {
        float result = SK_DistanceFieldPad * SK_DistanceFieldPad;
 
        if (between_closed(xformPt.fX, segment.fP0T.fX, segment.fP2T.fX)) {
            result = (float)(xformPt.fY * xformPt.fY);
        } else if (xformPt.fX < segment.fP0T.fX) {
            result = (float)(xformPt.fX * xformPt.fX + xformPt.fY * xformPt.fY);
        } else {
            result = (float)((xformPt.fX - segment.fP2T.fX) * (xformPt.fX - segment.fP2T.fX)
                     + xformPt.fY * xformPt.fY);
        }
 
        if (between_closed_open(point.fY, segment.fBoundingBox.fTop,
                                segment.fBoundingBox.fBottom)) {
            *side = (SegSide)(int)sign_of(xformPt.fY);
        } else {
            *side = kNA_SegSide;
        }
        return result;
    } else {
        SkASSERT(segment.fType == PathSegment::kQuad);
 
        const float nearestPoint = calculate_nearest_point_for_quad(segment, xformPt);
 
        float dist;
 
        if (between_closed(nearestPoint, segment.fP0T.fX, segment.fP2T.fX)) {
            DPoint x = { nearestPoint, nearestPoint * nearestPoint };
            dist = (float)xformPt.distanceSquared(x);
        } else {
            const float distToB0T = (float)xformPt.distanceSquared(segment.fP0T);
            const float distToB2T = (float)xformPt.distanceSquared(segment.fP2T);
 
            if (distToB0T < distToB2T) {
                dist = distToB0T;
            } else {
                dist = distToB2T;
            }
        }
 
        if (between_closed_open(point.fY, segment.fBoundingBox.fTop,
                                segment.fBoundingBox.fBottom)) {
            *side = calculate_side_of_quad(segment, point, xformPt, rowData);
        } else {
            *side = kNA_SegSide;
        }
 
        return (float)(dist * segment.fScalingFactorSqd);
    }
}

GrGenerateDistanceFieldFromPath()

bool GrGenerateDistanceFieldFromPath	(	unsigned char *	distanceField,
		const SkPath &	path,
		const SkMatrix &	viewMatrix,
		int	width,
		int	height,
		size_t	rowBytes
	)

Given a vector path, generate the associated distance field.

Parameters

distanceField	The distance field to be generated. Should already be allocated by the client with the padding defined in "SkDistanceFieldGen.h".
path	The path we're using to generate the distance field.
matrix	Transformation matrix for path.
width	Width of the distance field.
height	Height of the distance field.
rowBytes	Size of each row in the distance field, in bytes.

Definition at line 721 of file GrDistanceFieldGenFromVector.cpp.

                                                                             {
    SkASSERT(distanceField);
 
    // transform to device space, then:
    // translate path to offset (SK_DistanceFieldPad, SK_DistanceFieldPad)
    SkMatrix dfMatrix(drawMatrix);
    dfMatrix.postTranslate(SK_DistanceFieldPad, SK_DistanceFieldPad);
 
#ifdef SK_DEBUG
    SkPath xformPath;
    path.transform(dfMatrix, &xformPath);
    SkIRect pathBounds = xformPath.getBounds().roundOut();
    SkIRect expectPathBounds = SkIRect::MakeWH(width, height);
#endif
 
    SkASSERT(expectPathBounds.isEmpty() ||
             expectPathBounds.contains(pathBounds.fLeft, pathBounds.fTop));
    SkASSERT(expectPathBounds.isEmpty() || pathBounds.isEmpty() ||
             expectPathBounds.contains(pathBounds));
 
// TODO: restore when Simplify() is working correctly
//       see https://bugs.chromium.org/p/skia/issues/detail?id=9732
//    SkPath simplifiedPath;
    SkPath workingPath;
//    if (Simplify(path, &simplifiedPath)) {
//        workingPath = simplifiedPath;
//    } else {
        workingPath = path;
//    }
    // only even-odd and inverse even-odd supported
    if (!IsDistanceFieldSupportedFillType(workingPath.getFillType())) {
        return false;
    }
 
    // transform to device space + SDF offset
    // TODO: remove degenerate segments while doing this?
    workingPath.transform(dfMatrix);
 
    SkDEBUGCODE(pathBounds = workingPath.getBounds().roundOut());
    SkASSERT(expectPathBounds.isEmpty() ||
             expectPathBounds.contains(pathBounds.fLeft, pathBounds.fTop));
    SkASSERT(expectPathBounds.isEmpty() || pathBounds.isEmpty() ||
             expectPathBounds.contains(pathBounds));
 
    // create temp data
    size_t dataSize = width * height * sizeof(DFData);
    SkAutoSMalloc<1024> dfStorage(dataSize);
    DFData* dataPtr = (DFData*) dfStorage.get();
 
    // create initial distance data (init to "far away")
    init_distances(dataPtr, width * height);
 
    // polygonize path into line and quad segments
    SkPathEdgeIter iter(workingPath);
    STArray<15, PathSegment, true> segments;
    while (auto e = iter.next()) {
        switch (e.fEdge) {
            case SkPathEdgeIter::Edge::kLine: {
                add_line(e.fPts, &segments);
                break;
            }
            case SkPathEdgeIter::Edge::kQuad:
                add_quad(e.fPts, &segments);
                break;
            case SkPathEdgeIter::Edge::kConic: {
                SkScalar weight = iter.conicWeight();
                SkAutoConicToQuads converter;
                const SkPoint* quadPts = converter.computeQuads(e.fPts, weight, kConicTolerance);
                for (int i = 0; i < converter.countQuads(); ++i) {
                    add_quad(quadPts + 2*i, &segments);
                }
                break;
            }
            case SkPathEdgeIter::Edge::kCubic: {
                add_cubic(e.fPts, &segments);
                break;
            }
        }
    }
 
    // do all the work
    calculate_distance_field_data(&segments, dataPtr, width, height);
 
    // adjust distance based on winding
    for (int row = 0; row < height; ++row) {
        using DFSign = int;
        constexpr DFSign kInside = -1;
        constexpr DFSign kOutside = 1;
 
        int windingNumber = 0;  // Winding number start from zero for each scanline
        for (int col = 0; col < width; ++col) {
            int idx = (row * width) + col;
            windingNumber += dataPtr[idx].fDeltaWindingScore;
 
            DFSign dfSign;
            switch (workingPath.getFillType()) {
                case SkPathFillType::kWinding:
                    dfSign = windingNumber ? kInside : kOutside;
                    break;
                case SkPathFillType::kInverseWinding:
                    dfSign = windingNumber ? kOutside : kInside;
                    break;
                case SkPathFillType::kEvenOdd:
                    dfSign = (windingNumber % 2) ? kInside : kOutside;
                    break;
                case SkPathFillType::kInverseEvenOdd:
                    dfSign = (windingNumber % 2) ? kOutside : kInside;
                    break;
            }
 
            const float miniDist = sqrt(dataPtr[idx].fDistSq);
            const float dist = dfSign * miniDist;
 
            unsigned char pixelVal = pack_distance_field_val<SK_DistanceFieldMagnitude>(dist);
 
            distanceField[(row * rowBytes) + col] = pixelVal;
        }
 
        // The winding number at the end of a scanline should be zero.
        if (windingNumber != 0) {
            SkDEBUGFAIL("Winding number should be zero at the end of a scan line.");
            // Fallback to use SkPath::contains to determine the sign of pixel in release build.
            for (int col = 0; col < width; ++col) {
                int idx = (row * width) + col;
                DFSign dfSign = workingPath.contains(col + 0.5, row + 0.5) ? kInside : kOutside;
                const float miniDist = sqrt(dataPtr[idx].fDistSq);
                const float dist = dfSign * miniDist;
 
                unsigned char pixelVal = pack_distance_field_val<SK_DistanceFieldMagnitude>(dist);
 
                distanceField[(row * rowBytes) + col] = pixelVal;
            }
            continue;
        }
    }
    return true;
}

init_distances()

static void init_distances ( DFData *  data, int  size  )

static

Definition at line 336 of file GrDistanceFieldGenFromVector.cpp.

                                                   {
    DFData* currData = data;
 
    for (int i = 0; i < size; ++i) {
        // init distance to "far away"
        currData->fDistSq = SK_DistanceFieldMagnitude * SK_DistanceFieldMagnitude;
        currData->fDeltaWindingScore = 0;
        ++currData;
    }
}

is_colinear()

static bool is_colinear ( const SkPoint  pts[3] )

static

Definition at line 193 of file GrDistanceFieldGenFromVector.cpp.

                                              {
    return nearly_zero((pts[1].fY - pts[0].fY) * (pts[1].fX - pts[2].fX) -
                       (pts[1].fY - pts[2].fY) * (pts[1].fX - pts[0].fX), kCloseSqd);
}

nearly_equal()

static bool nearly_equal ( double  x, double  y, double  tolerance = kNearlyZero, bool  xformToleranceToX = false  )

inlinestatic

Definition at line 179 of file GrDistanceFieldGenFromVector.cpp.

                                                                {
    SkASSERT(tolerance >= 0.0);
    if (xformToleranceToX) {
        tolerance = tolerance / sqrt(4.0 * y * y + 1.0);
    }
    return fabs(x - y) <= tolerance;
}

nearly_zero()

static bool nearly_zero ( double  x, double  tolerance = kNearlyZero  )

inlinestatic

Definition at line 174 of file GrDistanceFieldGenFromVector.cpp.

                                                                         {
    SkASSERT(tolerance >= 0.0);
    return fabs(x) <= tolerance;
}

pack_distance_field_val()

template<int distanceMagnitude>

static unsigned char pack_distance_field_val ( float  dist )

static

Definition at line 706 of file GrDistanceFieldGenFromVector.cpp.

                                                         {
    // The distance field is constructed as unsigned char values, so that the zero value is at 128,
    // Beside 128, we have 128 values in range [0, 128), but only 127 values in range (128, 255].
    // So we multiply distanceMagnitude by 127/128 at the latter range to avoid overflow.
    dist = SkTPin<float>(-dist, -distanceMagnitude, distanceMagnitude * 127.0f / 128.0f);
 
    // Scale into the positive range for unsigned distance.
    dist += distanceMagnitude;
 
    // Scale into unsigned char range.
    // Round to place negative and positive values as equally as possible around 128
    // (which represents zero).
    return (unsigned char)SkScalarRoundToInt(dist / (2 * distanceMagnitude) * 256.0f);
}

precomputation_for_row()

void precomputation_for_row	(	RowData *	rowData,
		const PathSegment &	segment,
		const SkPoint &	pointLeft,
		const SkPoint &	pointRight
	)

Definition at line 450 of file GrDistanceFieldGenFromVector.cpp.

                                                                                 {
    if (segment.fType != PathSegment::kQuad) {
        return;
    }
 
    const DPoint& xFormPtLeft = segment.fXformMatrix.mapPoint(pointLeft);
    const DPoint& xFormPtRight = segment.fXformMatrix.mapPoint(pointRight);
 
    rowData->fQuadXDirection = (int)sign_of(segment.fP2T.fX - segment.fP0T.fX);
    rowData->fScanlineXDirection = (int)sign_of(xFormPtRight.fX - xFormPtLeft.fX);
 
    const double x1 = xFormPtLeft.fX;
    const double y1 = xFormPtLeft.fY;
    const double x2 = xFormPtRight.fX;
    const double y2 = xFormPtRight.fY;
 
    if (nearly_equal(x1, x2, segment.fNearlyZeroScaled, true)) {
        rowData->fIntersectionType = RowData::kVerticalLine;
        rowData->fYAtIntersection = x1 * x1;
        rowData->fScanlineXDirection = 0;
        return;
    }
 
    // Line y = mx + b
    const double m = (y2 - y1) / (x2 - x1);
    const double b = -m * x1 + y1;
 
    const double m2 = m * m;
    const double c = m2 + 4.0 * b;
 
    const double tol = 4.0 * segment.fTangentTolScaledSqd / (m2 + 1.0);
 
    // Check if the scanline is the tangent line of the curve,
    // and the curve start or end at the same y-coordinate of the scanline
    if ((rowData->fScanlineXDirection == 1 &&
         (segment.fPts[0].fY == pointLeft.fY ||
         segment.fPts[2].fY == pointLeft.fY)) &&
         nearly_zero(c, tol)) {
        rowData->fIntersectionType = RowData::kTangentLine;
        rowData->fXAtIntersection1 = m / 2.0;
        rowData->fXAtIntersection2 = m / 2.0;
    } else if (c <= 0.0) {
        rowData->fIntersectionType = RowData::kNoIntersection;
        return;
    } else {
        rowData->fIntersectionType = RowData::kTwoPointsIntersect;
        const double d = sqrt(c);
        rowData->fXAtIntersection1 = (m + d) / 2.0;
        rowData->fXAtIntersection2 = (m - d) / 2.0;
    }
}

sign_of()

static double sign_of ( const double &  val )

inlinestatic

Definition at line 189 of file GrDistanceFieldGenFromVector.cpp.

                                                {
    return std::copysign(1, val);
}

Variable Documentation

kClose

const double kClose = (SK_Scalar1 / 16.0)

static

Definition at line 129 of file GrDistanceFieldGenFromVector.cpp.

kCloseSqd

const double kCloseSqd = kClose * kClose

static

Definition at line 130 of file GrDistanceFieldGenFromVector.cpp.

kConicTolerance

const float kConicTolerance = 0.25f

static

Definition at line 133 of file GrDistanceFieldGenFromVector.cpp.

kNearlyZero

const double kNearlyZero = (SK_Scalar1 / (1 << 18))

static

Definition at line 131 of file GrDistanceFieldGenFromVector.cpp.

kTangentTolerance

const double kTangentTolerance = (SK_Scalar1 / (1 << 11))

static

Definition at line 132 of file GrDistanceFieldGenFromVector.cpp.