add conics to path ops

src/pathops/SkOpCoincidence.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkOpCoincidence.h"
 #include "SkOpSegment.h"
 #include "SkPathOpsTSect.h"
 
 void SkOpCoincidence::add(SkOpPtT* coinPtTStart, SkOpPtT* coinPtTEnd, SkOpPtT* oppPtTStart,
         SkOpPtT* oppPtTEnd, SkChunkAlloc* allocator) {
     SkASSERT(coinPtTStart->fT < coinPtTEnd->fT);
     bool flipped = oppPtTStart->fT > oppPtTEnd->fT;
     SkCoincidentSpans* coinRec = SkOpTAllocator<SkCoincidentSpans>::Allocate(allocator);
     coinRec->fNext = this->fHead;
     coinRec->fCoinPtTStart = coinPtTStart;
     coinRec->fCoinPtTEnd = coinPtTEnd;
     coinRec->fOppPtTStart = oppPtTStart;
     coinRec->fOppPtTEnd = oppPtTEnd;
     coinRec->fFlipped = flipped;
     this->fHead = coinRec;
 }
 
-static void tRange(const SkOpPtT* overS, const SkOpPtT* overE, double tStart, double tEnd,
+static void t_range(const SkOpPtT* overS, const SkOpPtT* overE, double tStart, double tEnd,
         const SkOpPtT* coinPtTStart, const SkOpPtT* coinPtTEnd, double* coinTs, double* coinTe) {
     double denom = overE->fT - overS->fT;
     double start = 0 < denom ? tStart : tEnd;
     double end = 0 < denom ? tEnd : tStart;
     double sRatio = (start - overS->fT) / denom;
     double eRatio = (end - overS->fT) / denom;
     *coinTs = coinPtTStart->fT + (coinPtTEnd->fT - coinPtTStart->fT) * sRatio;
     *coinTe = coinPtTStart->fT + (coinPtTEnd->fT - coinPtTStart->fT) * eRatio;
 }
 
 bool SkOpCoincidence::addIfMissing(const SkOpPtT* over1s, const SkOpPtT* over1e,
                       const SkOpPtT* over2s, const SkOpPtT* over2e, double tStart, double tEnd,
         SkOpPtT* coinPtTStart, const SkOpPtT* coinPtTEnd,
         SkOpPtT* oppPtTStart, const SkOpPtT* oppPtTEnd, SkChunkAlloc* allocator) {
     double coinTs, coinTe, oppTs, oppTe;
-    tRange(over1s, over1e, tStart, tEnd, coinPtTStart, coinPtTEnd, &coinTs, &coinTe);
-    tRange(over2s, over2e, tStart, tEnd, oppPtTStart, oppPtTEnd, &oppTs, &oppTe);
+    t_range(over1s, over1e, tStart, tEnd, coinPtTStart, coinPtTEnd, &coinTs, &coinTe);
+    t_range(over2s, over2e, tStart, tEnd, oppPtTStart, oppPtTEnd, &oppTs, &oppTe);
     SkOpSegment* coinSeg = coinPtTStart->segment();
     SkOpSegment* oppSeg = oppPtTStart->segment();
     SkASSERT(coinSeg != oppSeg);
     SkCoincidentSpans* check = this->fHead;
     do {
         const SkOpSegment* checkCoinSeg = check->fCoinPtTStart->segment();
         if (checkCoinSeg != coinSeg && checkCoinSeg != oppSeg) {
             continue;
         }
         const SkOpSegment* checkOppSeg = check->fOppPtTStart->segment();
@@ skipping 43 matching lines @@
     SkCoincidentSpans* outer = this->fHead;
     if (!outer) {
         return true;
     }
     do {
         SkCoincidentSpans* inner = outer;
         while ((inner = inner->fNext)) {
             double overS, overE;
             if (this->overlap(outer->fCoinPtTStart, outer->fCoinPtTEnd,
                     inner->fCoinPtTStart, inner->fCoinPtTEnd, &overS, &overE)) {
-                if (!addIfMissing(outer->fCoinPtTStart, outer->fCoinPtTEnd,
+                if (!this->addIfMissing(outer->fCoinPtTStart, outer->fCoinPtTEnd,
                         inner->fCoinPtTStart, inner->fCoinPtTEnd, overS, overE,
                         outer->fOppPtTStart, outer->fOppPtTEnd,
                         inner->fOppPtTStart, inner->fOppPtTEnd, allocator)) {
                     return false;
                 }
             } else if (this->overlap(outer->fCoinPtTStart, outer->fCoinPtTEnd,
                     inner->fOppPtTStart, inner->fOppPtTEnd, &overS, &overE)) {
-                if (!addIfMissing(outer->fCoinPtTStart, outer->fCoinPtTEnd,
+                if (!this->addIfMissing(outer->fCoinPtTStart, outer->fCoinPtTEnd,
                         inner->fOppPtTStart, inner->fOppPtTEnd, overS, overE,
                         outer->fOppPtTStart, outer->fOppPtTEnd,
                         inner->fCoinPtTStart, inner->fCoinPtTEnd, allocator)) {
                     return false;
                 }
             } else if (this->overlap(outer->fOppPtTStart, outer->fOppPtTEnd,
                     inner->fCoinPtTStart, inner->fCoinPtTEnd, &overS, &overE)) {
-                if (!addIfMissing(outer->fOppPtTStart, outer->fOppPtTEnd,
+                if (!this->addIfMissing(outer->fOppPtTStart, outer->fOppPtTEnd,
                         inner->fCoinPtTStart, inner->fCoinPtTEnd, overS, overE,
                         outer->fCoinPtTStart, outer->fCoinPtTEnd,
                         inner->fOppPtTStart, inner->fOppPtTEnd, allocator)) {
                     return false;
                 }
             } else if (this->overlap(outer->fOppPtTStart, outer->fOppPtTEnd,
                     inner->fOppPtTStart, inner->fOppPtTEnd, &overS, &overE)) {
-                if (!addIfMissing(outer->fOppPtTStart, outer->fOppPtTEnd,
+                if (!this->addIfMissing(outer->fOppPtTStart, outer->fOppPtTEnd,
                         inner->fOppPtTStart, inner->fOppPtTEnd, overS, overE,
                         outer->fCoinPtTStart, outer->fCoinPtTEnd,
                         inner->fCoinPtTStart, inner->fCoinPtTEnd, allocator)) {
                     return false;
                 }
             }
         }
 
     } while ((outer = outer->fNext));
     return true;
 }
 
-
 bool SkOpCoincidence::contains(SkOpPtT* coinPtTStart, SkOpPtT* coinPtTEnd, SkOpPtT* oppPtTStart,
         SkOpPtT* oppPtTEnd, bool flipped) {
     SkCoincidentSpans* coin = fHead;
     if (!coin) {
         return false;
     }
     do {
         if (coin->fCoinPtTStart == coinPtTStart &&  coin->fCoinPtTEnd == coinPtTEnd
                 && coin->fOppPtTStart == oppPtTStart && coin->fOppPtTEnd == oppPtTEnd
                 && coin->fFlipped == flipped) {
@@ skipping 84 matching lines @@
             }
             if (!oWindValue && !oOppValue) {
                 oSegment->markDone(oStart);
             }
             SkOpSpanBase* next = start->next();
             SkOpSpanBase* oNext = flipped ? oStart->prev() : oStart->next();
             if (next == end) {
                 break;
             }
             start = next->upCast();
-            if (!oNext) {
-                return false;
-            }
-            if (!oNext->upCastable()) {
-                return false;
+            // if the opposite ran out too soon, just reuse the last span
+            if (!oNext || !oNext->upCastable()) {
+               oNext = oStart;
             }
             oStart = oNext->upCast();
         } while (true);
     } while ((coin = coin->fNext));
     return true;
 }
 
 void SkOpCoincidence::detach(SkCoincidentSpans* remove) {
     SkCoincidentSpans* coin = fHead;
     SkCoincidentSpans* prev = NULL;
@@ skipping 116 matching lines @@
 
 bool SkOpCoincidence::overlap(const SkOpPtT* coin1s, const SkOpPtT* coin1e, 
         const SkOpPtT* coin2s, const SkOpPtT* coin2e, double* overS, double* overE) const {
     if (coin1s->segment() != coin2s->segment()) {
         return false;
     }
     *overS = SkTMax(SkTMin(coin1s->fT, coin1e->fT), SkTMin(coin2s->fT, coin2e->fT));
     *overE = SkTMin(SkTMax(coin1s->fT, coin1e->fT), SkTMax(coin2s->fT, coin2e->fT));
     return *overS < *overE;
 }