ActiveEdge Struct Reference

Public Member Functions
	ActiveEdge ()
	ActiveEdge (const SkPoint &p0, const SkVector &v, uint16_t index0, uint16_t index1)
bool	aboveIfLeft (const ActiveEdge *that) const
bool	above (const ActiveEdge *that) const
bool	intersect (const SkPoint &q0, const SkVector &w, uint16_t index0, uint16_t index1) const
bool	intersect (const ActiveEdge *edge)
bool	lessThan (const ActiveEdge *that) const
bool	equals (uint16_t index0, uint16_t index1) const

Public Attributes
OffsetSegment	fSegment
uint16_t	fIndex0
uint16_t	fIndex1
ActiveEdge *	fChild [2]
ActiveEdge *	fAbove
ActiveEdge *	fBelow
int32_t	fRed

Detailed Description

Definition at line 554 of file SkPolyUtils.cpp.

Constructor & Destructor Documentation

ActiveEdge() [1/2]

ActiveEdge::ActiveEdge ( )

inline

Definition at line 555 of file SkPolyUtils.cpp.

: fChild{ nullptr, nullptr }, fAbove(nullptr), fBelow(nullptr), fRed(false) {}

ActiveEdge() [2/2]

ActiveEdge::ActiveEdge ( const SkPoint &  p0, const SkVector &  v, uint16_t  index0, uint16_t  index1  )

inline

Definition at line 556 of file SkPolyUtils.cpp.

        : fSegment({ p0, v })
        , fIndex0(index0)
        , fIndex1(index1)
        , fAbove(nullptr)
        , fBelow(nullptr)
        , fRed(true) {
        fChild[0] = nullptr;
        fChild[1] = nullptr;
    }

Member Function Documentation

above()

bool ActiveEdge::above ( const ActiveEdge *  that ) const

inline

Definition at line 624 of file SkPolyUtils.cpp.

                                             {
        const SkPoint& p0 = this->fSegment.fP0;
        const SkPoint& q0 = that->fSegment.fP0;
        if (right(p0, q0)) {
            return !that->aboveIfLeft(this);
        } else {
            return this->aboveIfLeft(that);
        }
    }

aboveIfLeft()

bool ActiveEdge::aboveIfLeft ( const ActiveEdge *  that ) const

inline

Definition at line 570 of file SkPolyUtils.cpp.

                                                   {
        const SkPoint& p0 = this->fSegment.fP0;
        const SkPoint& q0 = that->fSegment.fP0;
        SkASSERT(p0.fX <= q0.fX);
        SkVector d = q0 - p0;
        const SkVector& v = this->fSegment.fV;
        const SkVector& w = that->fSegment.fV;
        // The idea here is that if the vector between the origins of the two segments (d)
        // rotates counterclockwise up to the vector representing the "this" segment (v),
        // then we know that "this" is above "that". If the result is clockwise we say it's below.
        if (this->fIndex0 != that->fIndex0) {
            SkScalar cross = d.cross(v);
            if (cross > kCrossTolerance) {
                return true;
            } else if (cross < -kCrossTolerance) {
                return false;
            }
        } else if (this->fIndex1 == that->fIndex1) {
            return false;
        }
        // At this point either the two origins are nearly equal or the origin of "that"
        // lies on dv. So then we try the same for the vector from the tail of "this"
        // to the head of "that". Again, ccw means "this" is above "that".
        // d = that.P1 - this.P0
        //   = that.fP0 + that.fV - this.fP0
        //   = that.fP0 - this.fP0 + that.fV
        //   = old_d + that.fV
        d += w;
        SkScalar cross = d.cross(v);
        if (cross > kCrossTolerance) {
            return true;
        } else if (cross < -kCrossTolerance) {
            return false;
        }
        // If the previous check fails, the two segments are nearly collinear
        // First check y-coord of first endpoints
        if (p0.fX < q0.fX) {
            return (p0.fY >= q0.fY);
        } else if (p0.fY > q0.fY) {
            return true;
        } else if (p0.fY < q0.fY) {
            return false;
        }
        // The first endpoints are the same, so check the other endpoint
        SkPoint p1 = p0 + v;
        SkPoint q1 = q0 + w;
        if (p1.fX < q1.fX) {
            return (p1.fY >= q1.fY);
        } else {
            return (p1.fY > q1.fY);
        }
    }

equals()

bool ActiveEdge::equals ( uint16_t  index0, uint16_t  index1  ) const

inline

Definition at line 684 of file SkPolyUtils.cpp.

                                                        {
        return (this->fIndex0 == index0 && this->fIndex1 == index1);
    }

intersect() [1/2]

bool ActiveEdge::intersect ( const ActiveEdge *  edge )

inline

Definition at line 673 of file SkPolyUtils.cpp.

                                           {
        return this->intersect(edge->fSegment.fP0, edge->fSegment.fV, edge->fIndex0, edge->fIndex1);
    }

intersect() [2/2]

bool ActiveEdge::intersect ( const SkPoint &  q0, const SkVector &  w, uint16_t  index0, uint16_t  index1  ) const

inline

Definition at line 634 of file SkPolyUtils.cpp.

                                                                                                 {
        // check first to see if these edges are neighbors in the polygon
        if (this->fIndex0 == index0 || this->fIndex1 == index0 ||
            this->fIndex0 == index1 || this->fIndex1 == index1) {
            return false;
        }
 
        // We don't need the exact intersection point so we can do a simpler test here.
        const SkPoint& p0 = this->fSegment.fP0;
        const SkVector& v = this->fSegment.fV;
        SkPoint p1 = p0 + v;
        SkPoint q1 = q0 + w;
 
        // We assume some x-overlap due to how the edgelist works
        // This allows us to simplify our test
        // We need some slop here because storing the vector and recomputing the second endpoint
        // doesn't necessary give us the original result in floating point.
        // TODO: Store vector as double? Store endpoint as well?
        SkASSERT(q0.fX <= p1.fX + SK_ScalarNearlyZero);
 
        // if each segment straddles the other (i.e., the endpoints have different sides)
        // then they intersect
        bool result;
        if (p0.fX < q0.fX) {
            if (q1.fX < p1.fX) {
                result = (compute_side(p0, v, q0)*compute_side(p0, v, q1) < 0);
            } else {
                result = (compute_side(p0, v, q0)*compute_side(q0, w, p1) > 0);
            }
        } else {
            if (p1.fX < q1.fX) {
                result = (compute_side(q0, w, p0)*compute_side(q0, w, p1) < 0);
            } else {
                result = (compute_side(q0, w, p0)*compute_side(p0, v, q1) > 0);
            }
        }
        return result;
    }

lessThan()

bool ActiveEdge::lessThan ( const ActiveEdge *  that ) const

inline

Definition at line 677 of file SkPolyUtils.cpp.

                                                {
        SkASSERT(!this->above(this));
        SkASSERT(!that->above(that));
        SkASSERT(!(this->above(that) && that->above(this)));
        return this->above(that);
    }

Member Data Documentation

fAbove

ActiveEdge* ActiveEdge::fAbove

Definition at line 692 of file SkPolyUtils.cpp.

fBelow

ActiveEdge* ActiveEdge::fBelow

Definition at line 693 of file SkPolyUtils.cpp.

fChild

ActiveEdge* ActiveEdge::fChild[2]

Definition at line 691 of file SkPolyUtils.cpp.

fIndex0

uint16_t ActiveEdge::fIndex0

Definition at line 689 of file SkPolyUtils.cpp.

fIndex1

uint16_t ActiveEdge::fIndex1

Definition at line 690 of file SkPolyUtils.cpp.

fRed

int32_t ActiveEdge::fRed

Definition at line 694 of file SkPolyUtils.cpp.

fSegment

OffsetSegment ActiveEdge::fSegment

Definition at line 688 of file SkPolyUtils.cpp.

---

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

• third_party/skia/src/utils/SkPolyUtils.cpp