SkPathOps.h File Reference

#include "include/core/SkPath.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTDArray.h"

Go to the source code of this file.

Classes
class	SkOpBuilder

Enumerations
enum	SkPathOp {   kDifference_SkPathOp , kIntersect_SkPathOp , kUnion_SkPathOp , kXOR_SkPathOp ,   kReverseDifference_SkPathOp }

Functions
bool SK_API	Op (const SkPath &one, const SkPath &two, SkPathOp op, SkPath *result)
bool SK_API	Simplify (const SkPath &path, SkPath *result)
bool SK_API	TightBounds (const SkPath &path, SkRect *result)
bool SK_API	AsWinding (const SkPath &path, SkPath *result)

Enumeration Type Documentation

SkPathOp

enum SkPathOp

The logical operations that can be performed when combining two paths.

Enumerator
kDifference_SkPathOp	subtract the op path from the first path
kIntersect_SkPathOp	intersect the two paths
kUnion_SkPathOp	union (inclusive-or) the two paths
kXOR_SkPathOp	exclusive-or the two paths
kReverseDifference_SkPathOp	subtract the first path from the op path

Definition at line 22 of file SkPathOps.h.

              {
    kDifference_SkPathOp,         //!< subtract the op path from the first path
    kIntersect_SkPathOp,          //!< intersect the two paths
    kUnion_SkPathOp,              //!< union (inclusive-or) the two paths
    kXOR_SkPathOp,                //!< exclusive-or the two paths
    kReverseDifference_SkPathOp,  //!< subtract the first path from the op path
};

Function Documentation

AsWinding()

bool SK_API AsWinding	(	const SkPath &	path,
		SkPath *	result
	)

Set the result with fill type winding to area equivalent to path. Returns true if successful. Does not detect if path contains contours which contain self-crossings or cross other contours; in these cases, may return true even though result does not fill same area as path.

Returns true if operation was able to produce a result; otherwise, result is unmodified. The result may be the input.

Parameters

path	The path typically with fill type set to even odd.
result	The equivalent path with fill type set to winding.

Returns

True if winding path was set.

Definition at line 408 of file SkPathOpsAsWinding.cpp.

                                                   {
    if (!path.isFinite()) {
        return false;
    }
    SkPathFillType fillType = path.getFillType();
    if (fillType == SkPathFillType::kWinding
            || fillType == SkPathFillType::kInverseWinding ) {
        return set_result_path(result, path, fillType);
    }
    fillType = path.isInverseFillType() ? SkPathFillType::kInverseWinding :
            SkPathFillType::kWinding;
    if (path.isEmpty() || path.isConvex()) {
        return set_result_path(result, path, fillType);
    }
    // count contours
    vector<Contour> contours;   // one per contour
    OpAsWinding winder(path);
    winder.contourBounds(&contours);
    if (contours.size() <= 1) {
        return set_result_path(result, path, fillType);
    }
    // create contour bounding box tree
    Contour sorted(SkRect(), 0, 0);
    for (auto& contour : contours) {
        winder.inParent(contour, sorted);
    }
    // if sorted has no grandchildren, no child has to fix its children's winding
    if (std::all_of(sorted.fChildren.begin(), sorted.fChildren.end(),
            [](const Contour* contour) -> bool { return contour->fChildren.empty(); } )) {
        return set_result_path(result, path, fillType);
    }
    // starting with outermost and moving inward, see if one path contains another
    for (auto contour : sorted.fChildren) {
        winder.nextEdge(*contour, OpAsWinding::Edge::kInitial);
        contour->fDirection = winder.getDirection(*contour);
        if (!winder.checkContainerChildren(nullptr, contour)) {
            return false;
        }
    }
    // starting with outermost and moving inward, mark paths to reverse
    bool reversed = false;
    for (auto contour : sorted.fChildren) {
        reversed |= winder.markReverse(nullptr, contour);
    }
    if (!reversed) {
        return set_result_path(result, path, fillType);
    }
    *result = winder.reverseMarkedContours(contours, fillType);
    return true;
}

Op()

bool SK_API Op	(	const SkPath &	one,
		const SkPath &	two,
		SkPathOp	op,
		SkPath *	result
	)

Set this path to the result of applying the Op to this path and the specified path: this = (this op operand). The resulting path will be constructed from non-overlapping contours. The curve order is reduced where possible so that cubics may be turned into quadratics, and quadratics maybe turned into lines.

Returns true if operation was able to produce a result; otherwise, result is unmodified.

Parameters

one	The first operand (for difference, the minuend)
two	The second operand (for difference, the subtrahend)
op	The operator to apply.
result	The product of the operands. The result may be one of the inputs.

Returns

True if the operation succeeded.

Definition at line 383 of file SkPathOpsOp.cpp.

                                                                           {
#if DEBUG_DUMP_VERIFY
    if (SkPathOpsDebug::gVerifyOp) {
        if (!OpDebug(one, two, op, result  SkDEBUGPARAMS(false) SkDEBUGPARAMS(nullptr))) {
            ReportOpFail(one, two, op);
            return false;
        }
        VerifyOp(one, two, op, *result);
        return true;
    }
#endif
    return OpDebug(one, two, op, result  SkDEBUGPARAMS(true) SkDEBUGPARAMS(nullptr));
}

Simplify()

bool SK_API Simplify	(	const SkPath &	path,
		SkPath *	result
	)

Set this path to a set of non-overlapping contours that describe the same area as the original path. The curve order is reduced where possible so that cubics may be turned into quadratics, and quadratics maybe turned into lines.

Returns true if operation was able to produce a result; otherwise, result is unmodified.

Parameters

path	The path to simplify.
result	The simplified path. The result may be the input.

Returns

True if simplification succeeded.

Definition at line 283 of file SkPathOpsSimplify.cpp.

                                                  {
#if DEBUG_DUMP_VERIFY
    if (SkPathOpsDebug::gVerifyOp) {
        if (!SimplifyDebug(path, result  SkDEBUGPARAMS(false) SkDEBUGPARAMS(nullptr))) {
            ReportSimplifyFail(path);
            return false;
        }
        VerifySimplify(path, *result);
        return true;
    }
#endif
    return SimplifyDebug(path, result  SkDEBUGPARAMS(true) SkDEBUGPARAMS(nullptr));
}

TightBounds()

bool SK_API TightBounds	(	const SkPath &	path,
		SkRect *	result
	)

Set the resulting rectangle to the tight bounds of the path.

Parameters

path	The path measured.
result	The tight bounds of the path.

Returns

True if the bounds could be computed.

Definition at line 23 of file SkPathOpsTightBounds.cpp.

                                                     {
    SkRect moveBounds = { SK_ScalarMax, SK_ScalarMax, SK_ScalarMin, SK_ScalarMin };
    bool wellBehaved = true;
    for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
        switch (verb) {
            case SkPathVerb::kMove:
                moveBounds.fLeft = std::min(moveBounds.fLeft, pts[0].fX);
                moveBounds.fTop = std::min(moveBounds.fTop, pts[0].fY);
                moveBounds.fRight = std::max(moveBounds.fRight, pts[0].fX);
                moveBounds.fBottom = std::max(moveBounds.fBottom, pts[0].fY);
                break;
            case SkPathVerb::kQuad:
            case SkPathVerb::kConic:
                if (!wellBehaved) {
                    break;
                }
                wellBehaved &= between(pts[0].fX, pts[1].fX, pts[2].fX);
                wellBehaved &= between(pts[0].fY, pts[1].fY, pts[2].fY);
                break;
            case SkPathVerb::kCubic:
                if (!wellBehaved) {
                    break;
                }
                wellBehaved &= between(pts[0].fX, pts[1].fX, pts[3].fX);
                wellBehaved &= between(pts[0].fY, pts[1].fY, pts[3].fY);
                wellBehaved &= between(pts[0].fX, pts[2].fX, pts[3].fX);
                wellBehaved &= between(pts[0].fY, pts[2].fY, pts[3].fY);
                break;
            default:
                break;
        }
    }
    if (wellBehaved) {
        *result = path.getBounds();
        return true;
    }
    SkSTArenaAlloc<4096> allocator;  // FIXME: constant-ize, tune
    SkOpContour contour;
    SkOpContourHead* contourList = static_cast<SkOpContourHead*>(&contour);
    SkOpGlobalState globalState(contourList, &allocator  SkDEBUGPARAMS(false)
            SkDEBUGPARAMS(nullptr));
    // turn path into list of segments
    SkOpEdgeBuilder builder(path, contourList, &globalState);
    if (!builder.finish()) {
        return false;
    }
    if (!SortContourList(&contourList, false, false)) {
        *result = moveBounds;
        return true;
    }
    SkOpContour* current = contourList;
    SkPathOpsBounds bounds = current->bounds();
    while ((current = current->next())) {
        bounds.add(current->bounds());
    }
    *result = bounds;
    if (!moveBounds.isEmpty()) {
        result->join(moveBounds);
    }
    return true;
}