PathOpsTestCommon.h File Reference

#include "include/core/SkScalar.h"
#include "include/private/base/SkTArray.h"
#include "src/pathops/SkPathOpsPoint.h"

Go to the source code of this file.

Classes
struct	QuadPts
struct	ConicPts
struct	CubicPts

Functions
void	CubicPathToQuads (const SkPath &cubicPath, SkPath *quadPath)
void	CubicPathToSimple (const SkPath &cubicPath, SkPath *simplePath)
void	CubicToQuads (const SkDCubic &cubic, double precision, skia_private::TArray< SkDQuad, true > &quads)
bool	ValidBounds (const SkPathOpsBounds &)
bool	ValidConic (const SkDConic &cubic)
bool	ValidCubic (const SkDCubic &cubic)
bool	ValidLine (const SkDLine &line)
bool	ValidPoint (const SkDPoint &pt)
bool	ValidPoints (const SkPoint *pts, int count)
bool	ValidQuad (const SkDQuad &quad)
bool	ValidVector (const SkDVector &v)

Function Documentation

CubicPathToQuads()

void CubicPathToQuads	(	const SkPath &	cubicPath,
		SkPath *	quadPath
	)

Definition at line 178 of file PathOpsTestCommon.cpp.

                                                                 {
    quadPath->reset();
    SkDCubic cubic;
    TArray<SkDQuad, true> quads;
    for (auto [verb, pts, w] : SkPathPriv::Iterate(cubicPath)) {
        switch (verb) {
            case SkPathVerb::kMove:
                quadPath->moveTo(pts[0].fX, pts[0].fY);
                continue;
            case SkPathVerb::kLine:
                quadPath->lineTo(pts[1].fX, pts[1].fY);
                break;
            case SkPathVerb::kQuad:
                quadPath->quadTo(pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY);
                break;
            case SkPathVerb::kCubic:
                quads.clear();
                cubic.set(pts);
                CubicToQuads(cubic, cubic.calcPrecision(), quads);
                for (int index = 0; index < quads.size(); ++index) {
                    SkPoint qPts[2] = {
                        quads[index][1].asSkPoint(),
                        quads[index][2].asSkPoint()
                    };
                    quadPath->quadTo(qPts[0].fX, qPts[0].fY, qPts[1].fX, qPts[1].fY);
                }
                break;
            case SkPathVerb::kClose:
                 quadPath->close();
                break;
            default:
                SkDEBUGFAIL("bad verb");
                return;
        }
    }
}

CubicPathToSimple()

void CubicPathToSimple	(	const SkPath &	cubicPath,
		SkPath *	simplePath
	)

Definition at line 215 of file PathOpsTestCommon.cpp.

                                                                    {
    simplePath->reset();
    SkDCubic cubic;
    for (auto [verb, pts, w] : SkPathPriv::Iterate(cubicPath)) {
        switch (verb) {
            case SkPathVerb::kMove:
                simplePath->moveTo(pts[0].fX, pts[0].fY);
                continue;
            case SkPathVerb::kLine:
                simplePath->lineTo(pts[1].fX, pts[1].fY);
                break;
            case SkPathVerb::kQuad:
                simplePath->quadTo(pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY);
                break;
            case SkPathVerb::kCubic: {
                cubic.set(pts);
                double tInflects[2];
                int inflections = cubic.findInflections(tInflects);
                if (inflections > 1 && tInflects[0] > tInflects[1]) {
                    using std::swap;
                    swap(tInflects[0], tInflects[1]);
                }
                double lo = 0;
                for (int index = 0; index <= inflections; ++index) {
                    double hi = index < inflections ? tInflects[index] : 1;
                    SkDCubic part = cubic.subDivide(lo, hi);
                    SkPoint cPts[3];
                    cPts[0] = part[1].asSkPoint();
                    cPts[1] = part[2].asSkPoint();
                    cPts[2] = part[3].asSkPoint();
                    simplePath->cubicTo(cPts[0].fX, cPts[0].fY, cPts[1].fX, cPts[1].fY,
                            cPts[2].fX, cPts[2].fY);
                    lo = hi;
                }
                break;
            }
            case SkPathVerb::kClose:
                 simplePath->close();
                break;
            default:
                SkDEBUGFAIL("bad verb");
                return;
        }
    }
}

CubicToQuads()

void CubicToQuads	(	const SkDCubic &	cubic,
		double	precision,
		skia_private::TArray< SkDQuad, true > &	quads
	)

Definition at line 148 of file PathOpsTestCommon.cpp.

                                                                                         {
    TArray<double, true> ts;
    toQuadraticTs(&cubic, precision, &ts);
    if (ts.empty()) {
        SkDQuad quad = cubic.toQuad();
        quads.push_back(quad);
        return;
    }
    double tStart = 0;
    for (int i1 = 0; i1 <= ts.size(); ++i1) {
        const double tEnd = i1 < ts.size() ? ts[i1] : 1;
        SkDRect bounds;
        bounds.setBounds(cubic);
        SkDCubic part = cubic.subDivide(tStart, tEnd);
        SkDQuad quad = part.toQuad();
        if (quad[1].fX < bounds.fLeft) {
            quad[1].fX = bounds.fLeft;
        } else if (quad[1].fX > bounds.fRight) {
            quad[1].fX = bounds.fRight;
        }
        if (quad[1].fY < bounds.fTop) {
            quad[1].fY = bounds.fTop;
        } else if (quad[1].fY > bounds.fBottom) {
            quad[1].fY = bounds.fBottom;
        }
        quads.push_back(quad);
        tStart = tEnd;
    }
}

ValidBounds()

bool ValidBounds

(

const SkPathOpsBounds &

bounds

)

Definition at line 261 of file PathOpsTestCommon.cpp.

                                                {
    if (SkIsNaN(bounds.fLeft)) {
        return false;
    }
    if (SkIsNaN(bounds.fTop)) {
        return false;
    }
    if (SkIsNaN(bounds.fRight)) {
        return false;
    }
    return !SkIsNaN(bounds.fBottom);
}

ValidConic()

bool ValidConic

(

const SkDConic &

cubic

)

Definition at line 274 of file PathOpsTestCommon.cpp.

                                       {
    for (int index = 0; index < SkDConic::kPointCount; ++index) {
        if (!ValidPoint(conic[index])) {
            return false;
        }
    }
    if (SkDoubleIsNaN(conic.fWeight)) {
        return false;
    }
    return true;
}

ValidCubic()

bool ValidCubic

(

const SkDCubic &

cubic

)

Definition at line 286 of file PathOpsTestCommon.cpp.

                                       {
    for (int index = 0; index < 4; ++index) {
        if (!ValidPoint(cubic[index])) {
            return false;
        }
    }
    return true;
}

ValidLine()

bool ValidLine

(

const SkDLine &

line

)

Definition at line 295 of file PathOpsTestCommon.cpp.

                                    {
    for (int index = 0; index < 2; ++index) {
        if (!ValidPoint(line[index])) {
            return false;
        }
    }
    return true;
}

ValidPoint()

bool ValidPoint

(

const SkDPoint &

pt

)

Definition at line 304 of file PathOpsTestCommon.cpp.

                                    {
    if (SkDoubleIsNaN(pt.fX)) {
        return false;
    }
    return !SkDoubleIsNaN(pt.fY);
}

ValidPoints()

bool ValidPoints	(	const SkPoint *	pts,
		int	count
	)

Definition at line 311 of file PathOpsTestCommon.cpp.

                                                {
    for (int index = 0; index < count; ++index) {
        if (SkIsNaN(pts[index].fX)) {
            return false;
        }
        if (SkIsNaN(pts[index].fY)) {
            return false;
        }
    }
    return true;
}

ValidQuad()

bool ValidQuad

(

const SkDQuad &

quad

)

Definition at line 323 of file PathOpsTestCommon.cpp.

                                    {
    for (int index = 0; index < 3; ++index) {
        if (!ValidPoint(quad[index])) {
            return false;
        }
    }
    return true;
}

ValidVector()

bool ValidVector

(

const SkDVector &

v

)

Definition at line 332 of file PathOpsTestCommon.cpp.

                                     {
    if (SkDoubleIsNaN(v.fX)) {
        return false;
    }
    return !SkDoubleIsNaN(v.fY);
}