OpAsWinding Class Reference

Public Types
enum class	Edge { kInitial , kCompare }

Public Member Functions
	OpAsWinding (const SkPath &path)
void	contourBounds (vector< Contour > *containers)
Contour::Direction	getDirection (Contour &contour)
int	nextEdge (Contour &contour, Edge edge)
bool	containerContains (Contour &contour, Contour &test)
void	inParent (Contour &contour, Contour &parent)
bool	checkContainerChildren (Contour *parent, Contour *child)
bool	markReverse (Contour *parent, Contour *child)
SkPath	reverseMarkedContours (vector< Contour > &contours, SkPathFillType fillType)

Detailed Description

Definition at line 170 of file SkPathOpsAsWinding.cpp.

Member Enumeration Documentation

Edge

enum class OpAsWinding::Edge

strong

Enumerator
kInitial
kCompare

Definition at line 172 of file SkPathOpsAsWinding.cpp.

                    {
        kInitial,
        kCompare,
    };

Constructor & Destructor Documentation

OpAsWinding()

OpAsWinding::OpAsWinding ( const SkPath &  path )

inline

Definition at line 177 of file SkPathOpsAsWinding.cpp.

        : fPath(path) {
    }

Member Function Documentation

checkContainerChildren()

bool OpAsWinding::checkContainerChildren ( Contour *  parent, Contour *  child  )

inline

Definition at line 328 of file SkPathOpsAsWinding.cpp.

                                                                 {
        for (auto grandChild : child->fChildren) {
            if (!checkContainerChildren(child, grandChild)) {
                return false;
            }
        }
        if (parent) {
            if (!containerContains(*parent, *child)) {
                return false;
            }
        }
        return true;
    }

containerContains()

bool OpAsWinding::containerContains ( Contour &  contour, Contour &  test  )

inline

Definition at line 291 of file SkPathOpsAsWinding.cpp.

                                                            {
        // find outside point on lesser contour
        // arbitrarily, choose non-horizontal edge where point <= bounds left
        // note that if leftmost point is control point, may need tight bounds
        // to find edge with minimum-x
        if (SK_ScalarMax == test.fMinXY.fX) {
            this->nextEdge(test, Edge::kInitial);
        }
        // find all edges on greater equal or to the left of one on lesser
        contour.fMinXY = test.fMinXY;
        int winding = this->nextEdge(contour, Edge::kCompare);
        // if edge is up, mark contour cw, otherwise, ccw
        // sum of greater edges direction should be cw, 0, ccw
        test.fContained = winding != 0;
        return -1 <= winding && winding <= 1;
    }

contourBounds()

void OpAsWinding::contourBounds ( vector< Contour > *  containers )

inline

Definition at line 181 of file SkPathOpsAsWinding.cpp.

                                                    {
        SkRect bounds;
        bounds.setEmpty();
        int lastStart = 0;
        int verbStart = 0;
        for (auto [verb, pts, w] : SkPathPriv::Iterate(fPath)) {
            if (SkPathVerb::kMove == verb) {
                if (!bounds.isEmpty()) {
                    containers->emplace_back(bounds, lastStart, verbStart);
                    lastStart = verbStart;
               }
               bounds.setBounds(&pts[kPtIndex[SkPath::kMove_Verb]], kPtCount[SkPath::kMove_Verb]);
            }
            if (SkPathVerb::kLine <= verb && verb <= SkPathVerb::kCubic) {
                SkRect verbBounds;
                verbBounds.setBounds(&pts[kPtIndex[(int)verb]], kPtCount[(int)verb]);
                bounds.joinPossiblyEmptyRect(verbBounds);
            }
            ++verbStart;
        }
        if (!bounds.isEmpty()) {
            containers->emplace_back(bounds, lastStart, ++verbStart);
        }
    }

getDirection()

Contour::Direction OpAsWinding::getDirection ( Contour &  contour )

inline

Definition at line 206 of file SkPathOpsAsWinding.cpp.

                                                    {
        SkPath::Iter iter(fPath, true);
        int verbCount = -1;
        SkPath::Verb verb;
        SkPoint pts[4];
 
        SkScalar total_signed_area = 0;
        do {
            verb = iter.next(pts);
            if (++verbCount < contour.fVerbStart) {
                continue;
            }
            if (verbCount >= contour.fVerbEnd) {
                continue;
            }
            if (SkPath::kLine_Verb > verb || verb > SkPath::kCubic_Verb) {
                continue;
            }
 
            switch (verb)
            {
                case SkPath::kLine_Verb:
                    total_signed_area += (pts[0].fY - pts[1].fY) * (pts[0].fX + pts[1].fX);
                    break;
                case SkPath::kQuad_Verb:
                case SkPath::kConic_Verb:
                    total_signed_area += (pts[0].fY - pts[2].fY) * (pts[0].fX + pts[2].fX);
                    break;
                case SkPath::kCubic_Verb:
                    total_signed_area += (pts[0].fY - pts[3].fY) * (pts[0].fX + pts[3].fX);
                    break;
                default:
                    break;
            }
        } while (SkPath::kDone_Verb != verb);
 
        return total_signed_area < 0 ? Contour::Direction::kCCW: Contour::Direction::kCW;
    }

inParent()

void OpAsWinding::inParent ( Contour &  contour, Contour &  parent  )

inline

Definition at line 308 of file SkPathOpsAsWinding.cpp.

                                                     {
        // move contour into sibling list contained by parent
        for (auto test : parent.fChildren) {
            if (test->fBounds.contains(contour.fBounds)) {
                inParent(contour, *test);
                return;
            }
        }
        // move parent's children into contour's children if contained by contour
        for (auto iter = parent.fChildren.begin(); iter != parent.fChildren.end(); ) {
            if (contour.fBounds.contains((*iter)->fBounds)) {
                contour.fChildren.push_back(*iter);
                iter = parent.fChildren.erase(iter);
                continue;
            }
            ++iter;
        }
        parent.fChildren.push_back(&contour);
    }

markReverse()

bool OpAsWinding::markReverse ( Contour *  parent, Contour *  child  )

inline

Definition at line 342 of file SkPathOpsAsWinding.cpp.

                                                      {
        bool reversed = false;
        for (auto grandChild : child->fChildren) {
            reversed |= markReverse(grandChild->fContained ? child : parent, grandChild);
        }
 
        child->fDirection = getDirection(*child);
        if (parent && parent->fDirection == child->fDirection) {
            child->fReverse = true;
            child->fDirection = (Contour::Direction) -(int) child->fDirection;
            return true;
        }
        return reversed;
    }

nextEdge()

int OpAsWinding::nextEdge ( Contour &  contour, Edge  edge  )

inline

Definition at line 245 of file SkPathOpsAsWinding.cpp.

                                              {
        SkPath::Iter iter(fPath, true);
        SkPoint pts[4];
        SkPath::Verb verb;
        int verbCount = -1;
        int winding = 0;
        do {
            verb = iter.next(pts);
            if (++verbCount < contour.fVerbStart) {
                continue;
            }
            if (verbCount >= contour.fVerbEnd) {
                continue;
            }
            if (SkPath::kLine_Verb > verb || verb > SkPath::kCubic_Verb) {
                continue;
            }
            bool horizontal = true;
            for (int index = 1; index <= kPtCount[verb]; ++index) {
                if (pts[0].fY != pts[index].fY) {
                    horizontal = false;
                    break;
                }
            }
            if (horizontal) {
                continue;
            }
            if (edge == Edge::kCompare) {
                winding += contains_edge(pts, verb, conic_weight(iter, verb), contour.fMinXY);
                continue;
            }
            SkASSERT(edge == Edge::kInitial);
            SkPoint minXY = left_edge(pts, verb, conic_weight(iter, verb));
            if (minXY.fX > contour.fMinXY.fX) {
                continue;
            }
            if (minXY.fX == contour.fMinXY.fX) {
                if (minXY.fY != contour.fMinXY.fY) {
                    continue;
                }
            }
            contour.fMinXY = minXY;
        } while (SkPath::kDone_Verb != verb);
        return winding;
    }

reverseMarkedContours()

SkPath OpAsWinding::reverseMarkedContours ( vector< Contour > &  contours, SkPathFillType  fillType  )

inline

Definition at line 357 of file SkPathOpsAsWinding.cpp.

                                                                                     {
        SkPathPriv::Iterate iterate(fPath);
        auto iter = iterate.begin();
        int verbCount = 0;
 
        SkPathBuilder result;
        result.setFillType(fillType);
        for (const Contour& contour : contours) {
            SkPathBuilder reverse;
            SkPathBuilder* temp = contour.fReverse ? &reverse : &result;
            for (; iter != iterate.end() && verbCount < contour.fVerbEnd; ++iter, ++verbCount) {
                auto [verb, pts, w] = *iter;
                switch (verb) {
                    case SkPathVerb::kMove:
                        temp->moveTo(pts[0]);
                        break;
                    case SkPathVerb::kLine:
                        temp->lineTo(pts[1]);
                        break;
                    case SkPathVerb::kQuad:
                        temp->quadTo(pts[1], pts[2]);
                        break;
                    case SkPathVerb::kConic:
                        temp->conicTo(pts[1], pts[2], *w);
                        break;
                    case SkPathVerb::kCubic:
                        temp->cubicTo(pts[1], pts[2], pts[3]);
                        break;
                    case SkPathVerb::kClose:
                        temp->close();
                        break;
                }
            }
            if (contour.fReverse) {
                SkASSERT(temp == &reverse);
                SkPathPriv::ReverseAddPath(&result, reverse.detach());
            }
        }
        return result.detach();
    }

---

The documentation for this class was generated from the following file:

• third_party/skia/src/pathops/SkPathOpsAsWinding.cpp