SkCoincidentSpans Class Reference

#include <SkOpCoincidence.h>

Public Member Functions
const SkOpPtT *	coinPtTEnd () const
const SkOpPtT *	coinPtTStart () const
SkOpPtT *	coinPtTEndWritable () const
SkOpPtT *	coinPtTStartWritable () const
bool	collapsed (const SkOpPtT *) const
bool	contains (const SkOpPtT *s, const SkOpPtT *e) const
void	correctEnds ()
void	correctOneEnd (const SkOpPtT *(SkCoincidentSpans::*getEnd)() const, void(SkCoincidentSpans::*setEnd)(const SkOpPtT *ptT))
const char *	debugID () const
void	debugShow () const
void	dump () const
bool	expand ()
bool	extend (const SkOpPtT *coinPtTStart, const SkOpPtT *coinPtTEnd, const SkOpPtT *oppPtTStart, const SkOpPtT *oppPtTEnd)
bool	flipped () const
	SkDEBUGCODE (SkOpGlobalState *globalState() { return fGlobalState;}) void init(SkDEBUGCODE(SkOpGlobalState *globalState))
SkCoincidentSpans *	next ()
const SkCoincidentSpans *	next () const
SkCoincidentSpans **	nextPtr ()
const SkOpPtT *	oppPtTStart () const
const SkOpPtT *	oppPtTEnd () const
SkOpPtT *	oppPtTStartWritable () const
SkOpPtT *	oppPtTEndWritable () const
bool	ordered (bool *result) const
void	set (SkCoincidentSpans *next, const SkOpPtT *coinPtTStart, const SkOpPtT *coinPtTEnd, const SkOpPtT *oppPtTStart, const SkOpPtT *oppPtTEnd)
void	setCoinPtTEnd (const SkOpPtT *ptT)
void	setCoinPtTStart (const SkOpPtT *ptT)
void	setEnds (const SkOpPtT *coinPtTEnd, const SkOpPtT *oppPtTEnd)
void	setOppPtTEnd (const SkOpPtT *ptT)
void	setOppPtTStart (const SkOpPtT *ptT)
void	setStarts (const SkOpPtT *coinPtTStart, const SkOpPtT *oppPtTStart)
void	setNext (SkCoincidentSpans *next)

Detailed Description

Definition at line 22 of file SkOpCoincidence.h.

Member Function Documentation

coinPtTEnd()

const SkOpPtT * SkCoincidentSpans::coinPtTEnd

(

)

const

Definition at line 30 of file SkOpCoincidence.cpp.

                                                   {
    return fCoinPtTEnd;
}

coinPtTEndWritable()

SkOpPtT * SkCoincidentSpans::coinPtTEndWritable ( ) const

inline

Definition at line 29 of file SkOpCoincidence.h.

{ return const_cast<SkOpPtT*>(fCoinPtTEnd); }

coinPtTStart()

const SkOpPtT * SkCoincidentSpans::coinPtTStart

(

)

const

Definition at line 35 of file SkOpCoincidence.cpp.

                                                     {
    return fCoinPtTStart;
}

coinPtTStartWritable()

SkOpPtT * SkCoincidentSpans::coinPtTStartWritable ( ) const

inline

Definition at line 30 of file SkOpCoincidence.h.

{ return const_cast<SkOpPtT*>(fCoinPtTStart); }

collapsed()

bool SkCoincidentSpans::collapsed

(

const SkOpPtT *

test

)

const

Definition at line 22 of file SkOpCoincidence.cpp.

                                                           {
    return (fCoinPtTStart == test && fCoinPtTEnd->contains(test))
        || (fCoinPtTEnd == test && fCoinPtTStart->contains(test))
        || (fOppPtTStart == test && fOppPtTEnd->contains(test))
        || (fOppPtTEnd == test && fOppPtTStart->contains(test));
}

contains()

bool SkCoincidentSpans::contains	(	const SkOpPtT *	s,
		const SkOpPtT *	e
	)		const

Definition at line 131 of file SkOpCoincidence.cpp.

                                                                         {
    if (s->fT > e->fT) {
        using std::swap;
        swap(s, e);
    }
    if (s->segment() == fCoinPtTStart->segment()) {
        return fCoinPtTStart->fT <= s->fT && e->fT <= fCoinPtTEnd->fT;
    } else {
        SkASSERT(s->segment() == fOppPtTStart->segment());
        double oppTs = fOppPtTStart->fT;
        double oppTe = fOppPtTEnd->fT;
        if (oppTs > oppTe) {
            using std::swap;
            swap(oppTs, oppTe);
        }
        return oppTs <= s->fT && e->fT <= oppTe;
    }
}

correctEnds()

void SkCoincidentSpans::correctEnds

(

)

Definition at line 57 of file SkOpCoincidence.cpp.

                                    {
    this->correctOneEnd(&SkCoincidentSpans::coinPtTStart, &SkCoincidentSpans::setCoinPtTStart);
    this->correctOneEnd(&SkCoincidentSpans::coinPtTEnd, &SkCoincidentSpans::setCoinPtTEnd);
    this->correctOneEnd(&SkCoincidentSpans::oppPtTStart, &SkCoincidentSpans::setOppPtTStart);
    this->correctOneEnd(&SkCoincidentSpans::oppPtTEnd, &SkCoincidentSpans::setOppPtTEnd);
}

correctOneEnd()

void SkCoincidentSpans::correctOneEnd	(	const SkOpPtT *(SkCoincidentSpans::*)() const	getEnd,
		void(SkCoincidentSpans::*)(const SkOpPtT *ptT)	setEnd
	)

Definition at line 40 of file SkOpCoincidence.cpp.

                                                              {
    const SkOpPtT* origPtT = (this->*getEnd)();
    const SkOpSpanBase* origSpan = origPtT->span();
    const SkOpSpan* prev = origSpan->prev();
    const SkOpPtT* testPtT = prev ? prev->next()->ptT()
            : origSpan->upCast()->next()->prev()->ptT();
    if (origPtT != testPtT) {
        (this->*setEnd)(testPtT);
    }
}

debugID()

const char * SkCoincidentSpans::debugID ( ) const

inline

Definition at line 46 of file SkOpCoincidence.h.

                                {
#if DEBUG_COIN
        return fGlobalState->debugCoinDictEntry().fFunctionName;
#else
        return nullptr;
#endif
    }

debugShow()

void SkCoincidentSpans::debugShow

(

)

const

Definition at line 2083 of file SkPathOpsDebug.cpp.

                                        {
    SkDebugf("coinSpan - id=%d t=%1.9g tEnd=%1.9g\n", coinPtTStart()->segment()->debugID(),
            coinPtTStart()->fT, coinPtTEnd()->fT);
    SkDebugf("coinSpan + id=%d t=%1.9g tEnd=%1.9g\n", oppPtTStart()->segment()->debugID(),
            oppPtTStart()->fT, oppPtTEnd()->fT);
}

dump()

void SkCoincidentSpans::dump

(

)

const

Definition at line 924 of file PathOpsDebug.cpp.

                                   {
    SkDebugf("- seg=%d span=%d ptT=%d ", fCoinPtTStart->segment()->debugID(),
        fCoinPtTStart->span()->debugID(), fCoinPtTStart->debugID());
    fCoinPtTStart->dumpBase();
    SkDebugf(" span=%d ptT=%d ", fCoinPtTEnd->span()->debugID(), fCoinPtTEnd->debugID());
    fCoinPtTEnd->dumpBase();
    if (fCoinPtTStart->segment()->operand()) {
        SkDebugf(" operand");
    }
    if (fCoinPtTStart->segment()->isXor()) {
        SkDebugf(" xor");
    }
    SkDebugf("\n");
    SkDebugf("+ seg=%d span=%d ptT=%d ", fOppPtTStart->segment()->debugID(),
        fOppPtTStart->span()->debugID(), fOppPtTStart->debugID());
    fOppPtTStart->dumpBase();
    SkDebugf(" span=%d ptT=%d ", fOppPtTEnd->span()->debugID(), fOppPtTEnd->debugID());
    fOppPtTEnd->dumpBase();
    if (fOppPtTStart->segment()->operand()) {
        SkDebugf(" operand");
    }
    if (fOppPtTStart->segment()->isXor()) {
        SkDebugf(" xor");
    }
    SkDebugf("\n");
}

expand()

bool SkCoincidentSpans::expand

(

)

Definition at line 66 of file SkOpCoincidence.cpp.

                               {
    bool expanded = false;
    const SkOpSegment* segment = coinPtTStart()->segment();
    const SkOpSegment* oppSegment = oppPtTStart()->segment();
    do {
        const SkOpSpan* start = coinPtTStart()->span()->upCast();
        const SkOpSpan* prev = start->prev();
        const SkOpPtT* oppPtT;
        if (!prev || !(oppPtT = prev->contains(oppSegment))) {
            break;
        }
        double midT = (prev->t() + start->t()) / 2;
        if (!segment->isClose(midT, oppSegment)) {
            break;
        }
        setStarts(prev->ptT(), oppPtT);
        expanded = true;
    } while (true);
    do {
        const SkOpSpanBase* end = coinPtTEnd()->span();
        SkOpSpanBase* next = end->final() ? nullptr : end->upCast()->next();
        if (next && next->deleted()) {
            break;
        }
        const SkOpPtT* oppPtT;
        if (!next || !(oppPtT = next->contains(oppSegment))) {
            break;
        }
        double midT = (end->t() + next->t()) / 2;
        if (!segment->isClose(midT, oppSegment)) {
            break;
        }
        setEnds(next->ptT(), oppPtT);
        expanded = true;
    } while (true);
    return expanded;
}

extend()

bool SkCoincidentSpans::extend	(	const SkOpPtT *	coinPtTStart,
		const SkOpPtT *	coinPtTEnd,
		const SkOpPtT *	oppPtTStart,
		const SkOpPtT *	oppPtTEnd
	)

Definition at line 105 of file SkOpCoincidence.cpp.

                                                              {
    bool result = false;
    if (fCoinPtTStart->fT > coinPtTStart->fT || (this->flipped()
            ? fOppPtTStart->fT < oppPtTStart->fT : fOppPtTStart->fT > oppPtTStart->fT)) {
        this->setStarts(coinPtTStart, oppPtTStart);
        result = true;
    }
    if (fCoinPtTEnd->fT < coinPtTEnd->fT || (this->flipped()
            ? fOppPtTEnd->fT > oppPtTEnd->fT : fOppPtTEnd->fT < oppPtTEnd->fT)) {
        this->setEnds(coinPtTEnd, oppPtTEnd);
        result = true;
    }
    return result;
}

flipped()

bool SkCoincidentSpans::flipped ( ) const

inline

Definition at line 63 of file SkOpCoincidence.h.

{ return fOppPtTStart->fT > fOppPtTEnd->fT; }

next() [1/2]

SkCoincidentSpans * SkCoincidentSpans::next ( )

inline

Definition at line 71 of file SkOpCoincidence.h.

{ return fNext; }

next() [2/2]

const SkCoincidentSpans * SkCoincidentSpans::next ( ) const

inline

Definition at line 72 of file SkOpCoincidence.h.

{ return fNext; }

nextPtr()

SkCoincidentSpans ** SkCoincidentSpans::nextPtr ( )

inline

Definition at line 73 of file SkOpCoincidence.h.

{ return &fNext; }

oppPtTEnd()

const SkOpPtT * SkCoincidentSpans::oppPtTEnd

(

)

const

Definition at line 156 of file SkOpCoincidence.cpp.

                                                  {
    return fOppPtTEnd;
}

oppPtTEndWritable()

SkOpPtT * SkCoincidentSpans::oppPtTEndWritable ( ) const

inline

Definition at line 79 of file SkOpCoincidence.h.

{ return const_cast<SkOpPtT*>(fOppPtTEnd); }

oppPtTStart()

const SkOpPtT * SkCoincidentSpans::oppPtTStart

(

)

const

Definition at line 151 of file SkOpCoincidence.cpp.

                                                    {
    return fOppPtTStart;
}

oppPtTStartWritable()

SkOpPtT * SkCoincidentSpans::oppPtTStartWritable ( ) const

inline

Definition at line 78 of file SkOpCoincidence.h.

{ return const_cast<SkOpPtT*>(fOppPtTStart); }

ordered()

bool SkCoincidentSpans::ordered

(

bool *

result

)

const

Definition at line 163 of file SkOpCoincidence.cpp.

                                                  {
    const SkOpSpanBase* start = this->coinPtTStart()->span();
    const SkOpSpanBase* end = this->coinPtTEnd()->span();
    const SkOpSpanBase* next = start->upCast()->next();
    if (next == end) {
        *result = true;
        return true;
    }
    bool flipped = this->flipped();
    const SkOpSegment* oppSeg = this->oppPtTStart()->segment();
    double oppLastT = fOppPtTStart->fT;
    do {
        const SkOpPtT* opp = next->contains(oppSeg);
        if (!opp) {
//            SkOPOBJASSERT(start, 0);  // may assert if coincident span isn't fully processed
            return false;
        }
        if ((oppLastT > opp->fT) != flipped) {
            *result = false;
            return true;
        }
        oppLastT = opp->fT;
        if (next == end) {
            break;
        }
        if (!next->upCastable()) {
            *result = false;
            return true;
        }
        next = next->upCast()->next();
    } while (true);
    *result = true;
    return true;
}

set()

void SkCoincidentSpans::set	(	SkCoincidentSpans *	next,
		const SkOpPtT *	coinPtTStart,
		const SkOpPtT *	coinPtTEnd,
		const SkOpPtT *	oppPtTStart,
		const SkOpPtT *	oppPtTEnd
	)

Definition at line 122 of file SkOpCoincidence.cpp.

                                                                                         {
    SkASSERT(SkOpCoincidence::Ordered(coinPtTStart, oppPtTStart));
    fNext = next;
    this->setStarts(coinPtTStart, oppPtTStart);
    this->setEnds(coinPtTEnd, oppPtTEnd);
}

setCoinPtTEnd()

void SkCoincidentSpans::setCoinPtTEnd ( const SkOpPtT *  ptT )

inline

Definition at line 85 of file SkOpCoincidence.h.

                                           {
        SkOPASSERT(ptT == ptT->span()->ptT());
        SkOPASSERT(!fCoinPtTStart || ptT->fT != fCoinPtTStart->fT);
        SkASSERT(!fCoinPtTStart || fCoinPtTStart->segment() == ptT->segment());
        fCoinPtTEnd = ptT;
        ptT->setCoincident();
    }

setCoinPtTStart()

void SkCoincidentSpans::setCoinPtTStart ( const SkOpPtT *  ptT )

inline

Definition at line 93 of file SkOpCoincidence.h.

                                             {
        SkOPASSERT(ptT == ptT->span()->ptT());
        SkOPASSERT(!fCoinPtTEnd || ptT->fT != fCoinPtTEnd->fT);
        SkASSERT(!fCoinPtTEnd || fCoinPtTEnd->segment() == ptT->segment());
        fCoinPtTStart = ptT;
        ptT->setCoincident();
    }

setEnds()

void SkCoincidentSpans::setEnds ( const SkOpPtT *  coinPtTEnd, const SkOpPtT *  oppPtTEnd  )

inline

Definition at line 101 of file SkOpCoincidence.h.

                                                                      {
        this->setCoinPtTEnd(coinPtTEnd);
        this->setOppPtTEnd(oppPtTEnd);
    }

setNext()

void SkCoincidentSpans::setNext ( SkCoincidentSpans *  next )

inline

Definition at line 127 of file SkOpCoincidence.h.

{ fNext = next; }

setOppPtTEnd()

void SkCoincidentSpans::setOppPtTEnd ( const SkOpPtT *  ptT )

inline

Definition at line 106 of file SkOpCoincidence.h.

                                          {
        SkOPASSERT(ptT == ptT->span()->ptT());
        SkOPASSERT(!fOppPtTStart || ptT->fT != fOppPtTStart->fT);
        SkASSERT(!fOppPtTStart || fOppPtTStart->segment() == ptT->segment());
        fOppPtTEnd = ptT;
        ptT->setCoincident();
    }

setOppPtTStart()

void SkCoincidentSpans::setOppPtTStart ( const SkOpPtT *  ptT )

inline

Definition at line 114 of file SkOpCoincidence.h.

                                            {
        SkOPASSERT(ptT == ptT->span()->ptT());
        SkOPASSERT(!fOppPtTEnd || ptT->fT != fOppPtTEnd->fT);
        SkASSERT(!fOppPtTEnd || fOppPtTEnd->segment() == ptT->segment());
        fOppPtTStart = ptT;
        ptT->setCoincident();
    }

setStarts()

void SkCoincidentSpans::setStarts ( const SkOpPtT *  coinPtTStart, const SkOpPtT *  oppPtTStart  )

inline

Definition at line 122 of file SkOpCoincidence.h.

                                                                            {
        this->setCoinPtTStart(coinPtTStart);
        this->setOppPtTStart(oppPtTStart);
    }

SkDEBUGCODE()

SkCoincidentSpans::SkDEBUGCODE ( SkOpGlobalState *globalState() { return fGlobalState;}  )

inline

Definition at line 64 of file SkOpCoincidence.h.

                                               { return fGlobalState; })
 
    void init(SkDEBUGCODE(SkOpGlobalState* globalState)) {
        sk_bzero(this, sizeof(*this));
        SkDEBUGCODE(fGlobalState = globalState);
    }

---

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

• third_party/skia/src/pathops/SkOpCoincidence.h
• third_party/skia/src/pathops/SkOpCoincidence.cpp
• third_party/skia/src/pathops/SkPathOpsDebug.cpp
• third_party/skia/tests/PathOpsDebug.cpp